genswap 0.1.0

Generation-tracked ArcSwap wrapper for 5-1600x faster cached reads in read-heavy workloads
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

use genswap::GenSwap;
use std::sync::Arc;
use std::thread;
use std::time::Duration;

/// Example configuration struct that might be used in a real application
#[derive(Debug, Clone)]
struct Config {
    feature_flags: Vec<String>,
    rate_limit: u32,
    timeout_ms: u64,
}

fn main() {
    println!("=== GenSwap Example ===\n");

    // Create shared config that gets updated periodically
    let config = Arc::new(GenSwap::new(Config {
        feature_flags: vec!["feature_a".into()],
        rate_limit: 100,
        timeout_ms: 1000,
    }));

    println!("Initial config:");
    println!("  Generation: {}", config.generation());
    println!("  Rate limit: {}\n", config.load_full().rate_limit);

    // Spawn consumer threads
    let handles: Vec<_> = (0..4)
        .map(|id| {
            let config = Arc::clone(&config);
            thread::spawn(move || {
                let mut reader = config.reader();
                let mut reads = 0;
                let mut refreshes = 0;

                for _ in 0..1000 {
                    let cfg = reader.get();
                    reads += 1;

                    // Simulate using the config
                    if cfg.rate_limit > 0 && cfg.timeout_ms > 0 {
                        // Process request with rate limit and timeout
                    }

                    // Track how many times we refreshed from source
                    if reader.is_stale() {
                        refreshes += 1;
                    }

                    thread::sleep(Duration::from_micros(100));
                }

                println!(
                    "Thread {}: {} reads, {} cache refreshes ({:.2}% hit rate)",
                    id,
                    reads,
                    refreshes,
                    100.0 * (reads - refreshes) as f64 / reads as f64
                );
            })
        })
        .collect();

    // Producer thread updates config periodically
    let producer_config = Arc::clone(&config);
    let producer = thread::spawn(move || {
        thread::sleep(Duration::from_millis(10));

        println!("\nUpdating config (generation 1)...");
        producer_config.update(Config {
            feature_flags: vec!["feature_a".into(), "feature_b".into()],
            rate_limit: 200,
            timeout_ms: 1000,
        });

        thread::sleep(Duration::from_millis(30));

        println!("Updating config (generation 2)...");
        producer_config.update(Config {
            feature_flags: vec!["feature_a".into(), "feature_b".into(), "feature_c".into()],
            rate_limit: 300,
            timeout_ms: 2000,
        });

        thread::sleep(Duration::from_millis(30));

        println!("Updating config (generation 3)...\n");
        producer_config.update(Config {
            feature_flags: vec!["feature_a".into(), "feature_b".into()],
            rate_limit: 250,
            timeout_ms: 1500,
        });
    });

    producer.join().unwrap();
    for handle in handles {
        handle.join().unwrap();
    }

    // Show final state
    println!("\nFinal config:");
    println!("  Generation: {}", config.generation());
    println!("  Rate limit: {}", config.load_full().rate_limit);
    println!("  Features: {:?}", config.load_full().feature_flags);

    println!("\n=== Performance Benefits ===");
    println!("Each reader thread performed ~1000 reads with only 3-4 cache refreshes.");
    println!("Cache hit rate: >99%");
    println!("\nWithout caching, each read would require:");
    println!("  - Arc::load_full() -> atomic refcount increment");
    println!("  - Drop on return -> atomic refcount decrement");
    println!("\nWith GenSwap:");
    println!("  - Cache hit: single atomic load (generation check) + return reference");
    println!("  - Cache miss: reload + update cached Arc");
    println!("\nResult: ~10-100x faster reads in read-heavy workloads!");
}