petgraph-live 0.3.1

Generic generation-keyed graph cache, disk snapshot, and graph algorithms for petgraph 0.8
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

use petgraph_live::cache::GenerationCache;
use std::sync::Arc;

#[test]
fn test_cache_miss_calls_build() {
    let cache: GenerationCache<Vec<i32>> = GenerationCache::new();
    let call_count = std::cell::Cell::new(0u32);
    let _graph = cache
        .get_or_build::<_, ()>(1, || {
            call_count.set(call_count.get() + 1);
            Ok(vec![1, 2, 3])
        })
        .unwrap();
    assert_eq!(call_count.get(), 1);
    // Same generation: build NOT called.
    let _graph2 = cache
        .get_or_build::<_, ()>(1, || {
            call_count.set(call_count.get() + 1);
            Ok(vec![4, 5, 6])
        })
        .unwrap();
    assert_eq!(call_count.get(), 1);
}

#[test]
fn test_cache_hit_returns_same_arc() {
    let cache: GenerationCache<Vec<i32>> = GenerationCache::new();
    let a1 = cache.get_or_build::<_, ()>(42, || Ok(vec![1])).unwrap();
    let a2 = cache.get_or_build::<_, ()>(42, || Ok(vec![2])).unwrap();
    assert!(Arc::ptr_eq(&a1, &a2));
}

#[test]
fn test_generation_change_triggers_rebuild() {
    let cache: GenerationCache<u64> = GenerationCache::new();
    let a1 = cache.get_or_build::<_, ()>(1, || Ok(100)).unwrap();
    assert_eq!(*a1, 100);
    let a2 = cache.get_or_build::<_, ()>(2, || Ok(200)).unwrap();
    assert_eq!(*a2, 200);
    assert!(!Arc::ptr_eq(&a1, &a2));
    assert_eq!(cache.current_generation(), Some(2));
}

#[test]
fn test_invalidate_forces_rebuild() {
    let cache: GenerationCache<u32> = GenerationCache::new();
    let a1 = cache.get_or_build::<_, ()>(1, || Ok(10)).unwrap();
    cache.invalidate();
    assert_eq!(cache.current_generation(), None);
    let a2 = cache.get_or_build::<_, ()>(1, || Ok(20)).unwrap();
    assert_eq!(*a2, 20);
    assert!(!Arc::ptr_eq(&a1, &a2));
}

#[test]
fn test_concurrent_reads() {
    use std::thread;

    let cache: Arc<GenerationCache<Vec<u8>>> = Arc::new(GenerationCache::new());
    cache
        .get_or_build::<_, ()>(1, || Ok(vec![0u8; 1024]))
        .unwrap();

    let handles: Vec<_> = (0..8)
        .map(|_| {
            let c = Arc::clone(&cache);
            thread::spawn(move || {
                for _ in 0..100 {
                    let g = c.get_or_build::<_, ()>(1, || Ok(vec![1u8; 1024])).unwrap();
                    assert_eq!(g.len(), 1024);
                }
            })
        })
        .collect();

    for h in handles {
        h.join().unwrap();
    }
}