cleaner-core 0.1.0

Fast, reusable disk scanning, sizing, and cleaning engine
Documentation
//! Atomic statistics tracking for multi-threaded operations

use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};

/// Thread-safe statistics using atomic operations
/// Uses Relaxed ordering for maximum performance since we only need eventual consistency
#[derive(Debug, Default)]
pub struct Stats {
    pub directories_deleted: AtomicUsize,
    pub files_deleted: AtomicUsize,
    pub bytes_freed: AtomicU64,
    pub errors: AtomicUsize,
}

impl Stats {
    pub fn new() -> Self {
        Self::default()
    }

    #[cfg(test)]
    #[inline]
    pub fn add_directory(&self) {
        self.add_directories(1);
    }

    #[inline]
    pub fn add_directories(&self, count: usize) {
        let _ =
            self.directories_deleted
                .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
                    Some(value.saturating_add(count))
                });
    }

    #[cfg(test)]
    #[inline]
    pub fn add_file(&self) {
        self.add_files(1);
    }

    #[inline]
    pub fn add_files(&self, count: usize) {
        let _ = self
            .files_deleted
            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
                Some(value.saturating_add(count))
            });
    }

    #[inline]
    pub fn add_bytes(&self, bytes: u64) {
        let _ = self
            .bytes_freed
            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
                Some(value.saturating_add(bytes))
            });
    }

    #[cfg(test)]
    #[inline]
    pub fn add_error(&self) {
        self.add_errors(1);
    }

    #[inline]
    pub fn add_errors(&self, count: usize) {
        let _ = self
            .errors
            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
                Some(value.saturating_add(count))
            });
    }

    pub fn add_batch(&self, directories: usize, files: usize, bytes: u64, errors: usize) {
        self.add_directories(directories);
        self.add_files(files);
        self.add_bytes(bytes);
        self.add_errors(errors);
    }

    pub fn directories(&self) -> usize {
        self.directories_deleted.load(Ordering::Relaxed)
    }

    pub fn files(&self) -> usize {
        self.files_deleted.load(Ordering::Relaxed)
    }

    pub fn bytes(&self) -> u64 {
        self.bytes_freed.load(Ordering::Relaxed)
    }

    pub fn error_count(&self) -> usize {
        self.errors.load(Ordering::Relaxed)
    }
}

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

    #[test]
    fn counters_start_at_zero_and_accumulate() {
        let stats = Stats::new();
        assert_eq!(
            (
                stats.directories(),
                stats.files(),
                stats.bytes(),
                stats.error_count()
            ),
            (0, 0, 0, 0)
        );
        stats.add_directory();
        stats.add_file();
        stats.add_files(3);
        stats.add_bytes(42);
        stats.add_bytes(8);
        stats.add_error();
        assert_eq!(
            (
                stats.directories(),
                stats.files(),
                stats.bytes(),
                stats.error_count()
            ),
            (1, 4, 50, 1)
        );
    }

    #[test]
    fn counters_are_thread_safe() {
        let stats = Arc::new(Stats::new());
        let threads: Vec<_> = (0..8)
            .map(|_| {
                let stats = Arc::clone(&stats);
                std::thread::spawn(move || {
                    for _ in 0..100 {
                        stats.add_file();
                        stats.add_bytes(2);
                    }
                })
            })
            .collect();
        for thread in threads {
            thread.join().unwrap();
        }
        assert_eq!(stats.files(), 800);
        assert_eq!(stats.bytes(), 1600);
    }
}