Skip to main content

cleaner_core/
stats.rs

1//! Atomic statistics tracking for multi-threaded operations
2
3use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
4
5/// Thread-safe statistics using atomic operations
6/// Uses Relaxed ordering for maximum performance since we only need eventual consistency
7#[derive(Debug, Default)]
8pub struct Stats {
9    pub directories_deleted: AtomicUsize,
10    pub files_deleted: AtomicUsize,
11    pub bytes_freed: AtomicU64,
12    pub errors: AtomicUsize,
13}
14
15impl Stats {
16    pub fn new() -> Self {
17        Self::default()
18    }
19
20    #[cfg(test)]
21    #[inline]
22    pub fn add_directory(&self) {
23        self.add_directories(1);
24    }
25
26    #[inline]
27    pub fn add_directories(&self, count: usize) {
28        let _ =
29            self.directories_deleted
30                .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
31                    Some(value.saturating_add(count))
32                });
33    }
34
35    #[cfg(test)]
36    #[inline]
37    pub fn add_file(&self) {
38        self.add_files(1);
39    }
40
41    #[inline]
42    pub fn add_files(&self, count: usize) {
43        let _ = self
44            .files_deleted
45            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
46                Some(value.saturating_add(count))
47            });
48    }
49
50    #[inline]
51    pub fn add_bytes(&self, bytes: u64) {
52        let _ = self
53            .bytes_freed
54            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
55                Some(value.saturating_add(bytes))
56            });
57    }
58
59    #[cfg(test)]
60    #[inline]
61    pub fn add_error(&self) {
62        self.add_errors(1);
63    }
64
65    #[inline]
66    pub fn add_errors(&self, count: usize) {
67        let _ = self
68            .errors
69            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
70                Some(value.saturating_add(count))
71            });
72    }
73
74    pub fn add_batch(&self, directories: usize, files: usize, bytes: u64, errors: usize) {
75        self.add_directories(directories);
76        self.add_files(files);
77        self.add_bytes(bytes);
78        self.add_errors(errors);
79    }
80
81    pub fn directories(&self) -> usize {
82        self.directories_deleted.load(Ordering::Relaxed)
83    }
84
85    pub fn files(&self) -> usize {
86        self.files_deleted.load(Ordering::Relaxed)
87    }
88
89    pub fn bytes(&self) -> u64 {
90        self.bytes_freed.load(Ordering::Relaxed)
91    }
92
93    pub fn error_count(&self) -> usize {
94        self.errors.load(Ordering::Relaxed)
95    }
96}
97
98#[cfg(test)]
99mod tests {
100    use super::*;
101    use std::sync::Arc;
102
103    #[test]
104    fn counters_start_at_zero_and_accumulate() {
105        let stats = Stats::new();
106        assert_eq!(
107            (
108                stats.directories(),
109                stats.files(),
110                stats.bytes(),
111                stats.error_count()
112            ),
113            (0, 0, 0, 0)
114        );
115        stats.add_directory();
116        stats.add_file();
117        stats.add_files(3);
118        stats.add_bytes(42);
119        stats.add_bytes(8);
120        stats.add_error();
121        assert_eq!(
122            (
123                stats.directories(),
124                stats.files(),
125                stats.bytes(),
126                stats.error_count()
127            ),
128            (1, 4, 50, 1)
129        );
130    }
131
132    #[test]
133    fn counters_are_thread_safe() {
134        let stats = Arc::new(Stats::new());
135        let threads: Vec<_> = (0..8)
136            .map(|_| {
137                let stats = Arc::clone(&stats);
138                std::thread::spawn(move || {
139                    for _ in 0..100 {
140                        stats.add_file();
141                        stats.add_bytes(2);
142                    }
143                })
144            })
145            .collect();
146        for thread in threads {
147            thread.join().unwrap();
148        }
149        assert_eq!(stats.files(), 800);
150        assert_eq!(stats.bytes(), 1600);
151    }
152}