noxu-txn 4.1.0

Transaction management and locking for Noxu DB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Lock statistics definitions.
//!

/// Lock statistics counters.
///
/// Tracks lock manager performance and usage metrics.
///
#[derive(Debug, Default, Clone)]
pub struct LockStats {
    /// Total number of lock requests.
    pub lock_requests: u64,

    /// Number of lock requests that had to wait.
    pub lock_waits: u64,

    /// Current number of lock owners across all locks.
    pub n_owners: u64,

    /// Current number of lock waiters across all locks.
    pub n_waiters: u64,

    /// Total number of locks currently held.
    pub n_total_locks: u64,

    /// Number of read locks currently held.
    pub n_read_locks: u64,

    /// Number of write locks currently held.
    pub n_write_locks: u64,

    /// Number of lock requests that timed out (LockTimeout errors returned).
    pub n_lock_timeouts: u64,
}

impl LockStats {
    /// Creates a new LockStats with all counters at zero.
    pub fn new() -> Self {
        Self::default()
    }

    /// Resets all statistics to zero.
    pub fn reset(&mut self) {
        *self = Self::default();
    }

    /// Returns the percentage of lock requests that had to wait.
    pub fn wait_percentage(&self) -> f64 {
        if self.lock_requests == 0 {
            0.0
        } else {
            (self.lock_waits as f64 / self.lock_requests as f64) * 100.0
        }
    }

    /// Adds the counts from another LockStats to this one.
    pub fn add(&mut self, other: &LockStats) {
        self.lock_requests += other.lock_requests;
        self.lock_waits += other.lock_waits;
        self.n_owners += other.n_owners;
        self.n_waiters += other.n_waiters;
        self.n_total_locks += other.n_total_locks;
        self.n_read_locks += other.n_read_locks;
        self.n_write_locks += other.n_write_locks;
        self.n_lock_timeouts += other.n_lock_timeouts;
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new() {
        let stats = LockStats::new();
        assert_eq!(stats.lock_requests, 0);
        assert_eq!(stats.lock_waits, 0);
        assert_eq!(stats.n_owners, 0);
        assert_eq!(stats.n_waiters, 0);
        assert_eq!(stats.n_total_locks, 0);
        assert_eq!(stats.n_read_locks, 0);
        assert_eq!(stats.n_write_locks, 0);
    }

    #[test]
    fn test_reset() {
        let mut stats = LockStats::new();
        stats.lock_requests = 100;
        stats.lock_waits = 10;
        stats.n_owners = 5;

        stats.reset();
        assert_eq!(stats.lock_requests, 0);
        assert_eq!(stats.lock_waits, 0);
        assert_eq!(stats.n_owners, 0);
    }

    #[test]
    fn test_wait_percentage() {
        let mut stats = LockStats::new();
        assert_eq!(stats.wait_percentage(), 0.0);

        stats.lock_requests = 100;
        stats.lock_waits = 10;
        assert_eq!(stats.wait_percentage(), 10.0);

        stats.lock_requests = 200;
        stats.lock_waits = 50;
        assert_eq!(stats.wait_percentage(), 25.0);
    }

    #[test]
    fn test_add() {
        let mut stats1 = LockStats::new();
        stats1.lock_requests = 100;
        stats1.lock_waits = 10;
        stats1.n_owners = 5;
        stats1.n_waiters = 2;
        stats1.n_total_locks = 50;
        stats1.n_read_locks = 30;
        stats1.n_write_locks = 20;
        stats1.n_lock_timeouts = 3;

        let mut stats2 = LockStats::new();
        stats2.lock_requests = 50;
        stats2.lock_waits = 5;
        stats2.n_owners = 3;
        stats2.n_waiters = 1;
        stats2.n_total_locks = 25;
        stats2.n_read_locks = 15;
        stats2.n_write_locks = 10;
        stats2.n_lock_timeouts = 2;

        stats1.add(&stats2);
        assert_eq!(stats1.lock_requests, 150);
        assert_eq!(stats1.lock_waits, 15);
        assert_eq!(stats1.n_owners, 8);
        assert_eq!(stats1.n_waiters, 3);
        assert_eq!(stats1.n_total_locks, 75);
        assert_eq!(stats1.n_read_locks, 45);
        assert_eq!(stats1.n_write_locks, 30);
        assert_eq!(stats1.n_lock_timeouts, 5);
    }

    #[test]
    fn test_lock_timeout_counter() {
        let mut stats = LockStats::new();
        assert_eq!(stats.n_lock_timeouts, 0);
        stats.n_lock_timeouts = 7;
        assert_eq!(stats.n_lock_timeouts, 7);
        stats.reset();
        assert_eq!(stats.n_lock_timeouts, 0);
    }
}