Benchmark arc + bool + atomic bool + option

main.rs

// Arc<AtomicBool> access: 4.3390258s
// Arc<bool> access: 3.3204702s
// Option<Arc<AtomicBool>> access: 4.1391463s
// Option<Arc<bool>> access: 3.3405671s
// Weak<AtomicBool> access after drop: 6.6603574s
// Weak<bool> access after drop: 6.5926837s

use std::sync::{Arc, Weak};
use std::sync::atomic::AtomicBool;
use std::time::Instant;

fn benchmark<F: Fn()>(name: &str, iterations: usize, func: F) {
    let start = Instant::now();
    for _ in 0..iterations {
        func();
    }
    let duration = start.elapsed();
    println!("{}: {:?}", name, duration);
}

fn main() {
    let iterations = 10_000_000_000;

    // Benchmark Arc<AtomicBool>
    let atomic_flag = Arc::new(AtomicBool::new(true));
    benchmark("Arc<AtomicBool> access", iterations, || {
        let value = atomic_flag.load(std::sync::atomic::Ordering::SeqCst);
        std::hint::black_box(value);
    });

    // Benchmark Arc<bool>
    let bool_flag = Arc::new(true);
    benchmark("Arc<bool> access", iterations, || {
        let value = *bool_flag;
        std::hint::black_box(value);
    });

    // Benchmark Option<Arc<AtomicBool>>
    let option_atomic_flag = Some(Arc::new(AtomicBool::new(true)));
    benchmark("Option<Arc<AtomicBool>> access", iterations, || {
        if let Some(ref flag) = option_atomic_flag {
            let value = flag.load(std::sync::atomic::Ordering::SeqCst);
            std::hint::black_box(value);
        }
    });

    // Benchmark Option<Arc<bool>>
    let option_bool_flag = Some(Arc::new(true));
    benchmark("Option<Arc<bool>> access", iterations, || {
        if let Some(ref flag) = option_bool_flag {
            let value = **flag;
            std::hint::black_box(value);
        }
    });

    // Simulate drop scenarios
    let weak_atomic_flag: Weak<AtomicBool> = Arc::downgrade(&atomic_flag);
    let weak_bool_flag: Weak<bool> = Arc::downgrade(&bool_flag);

    drop(atomic_flag);
    drop(bool_flag);

    benchmark("Weak<AtomicBool> access after drop", iterations, || {
        if let Some(flag) = weak_atomic_flag.upgrade() {
            let value = flag.load(std::sync::atomic::Ordering::SeqCst);
            std::hint::black_box(value);
        }
    });

    benchmark("Weak<bool> access after drop", iterations, || {
        if let Some(flag) = weak_bool_flag.upgrade() {
            let value = *flag;
            std::hint::black_box(value);
        }
    });
}