tiered-cache 0.1.6

A high-performance multi-tiered cache with automatic sizing
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

use tiered_cache::{CacheConfig, TierConfig, TieredCache};

const MB: usize = 1024 * 1024; // 1 megabyte

fn main() {
    // Configure a 1GB cache with three tiers:
    // - Small tier: 200MB for items 0-64KB
    // - Medium tier: 300MB for items 64KB-1MB
    // - Large tier: 500MB for items 1MB-10MB
    let config = CacheConfig {
        tiers: vec![
            TierConfig {
                total_capacity: 200 * MB,
                size_range: (0, 64 * 1024),  // 0-64KB
            },
            TierConfig {
                total_capacity: 300 * MB,
                size_range: (64 * 1024, MB), // 64KB-1MB
            },
            TierConfig {
                total_capacity: 500 * MB,
                size_range: (MB, 10 * MB),   // 1MB-10MB
            },
        ],
        update_channel_size: None,
    };

    let cache = TieredCache::<Vec<u8>, Vec<u8>>::new(config);

    // Example usage
    let key = b"example".to_vec();
    let value = vec![0u8; 500 * 1024]; // 500KB value
    
    cache.put(key.clone(), value);
    
    if let Some(retrieved) = cache.get(&key) {
        println!("Retrieved value of size: {} bytes", retrieved.len());
    }

    // Print cache statistics
    let stats = cache.stats();
    println!("Cache statistics:");
    println!("Total items: {}", stats.total_items);
    println!("Total size: {} MB", stats.total_size / MB);
    
    for (i, tier) in stats.tier_stats.iter().enumerate() {
        println!("\nTier {}:", i);
        println!("  Items: {}", tier.items);
        println!("  Size: {} MB", tier.size / MB);
        println!("  Capacity: {} MB", tier.capacity / MB);
    }
}