syncmap 0.1.3

syncmap is a fast, concurrent cache library built with a focus on performance and correctness. The motivation to build syncmap comes from the sync.Map in Golang.
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
118

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::thread;
    use std::time::Duration;
    use rayon;
    use rayon::prelude::*;
    use syncmap::map::Map;


    const ITER: u64 = 32 * 1024;
    const ITERREMOVE: u64 = 32 * 1024;


    #[test]
    #[cfg_attr(miri, ignore)]
    fn concurrent_insert() {
        let map = Arc::new(Map::<u64, u64>::new());


        let handles: Vec<_> = (0..10).map(|_| {
            let map1 = map.clone();
            thread::spawn(move || {
                let guard = map1.guard();
                for i in 0..ITER {
                    map1.insert(i, i, &guard);
                }
            })
        }).collect();


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


        thread::sleep(Duration::from_micros(500));
        let mut missed = 0;
        let guard = map.guard();
        for i in 0..ITER {
            let v = map.get(&i, &guard);
            if v.is_some() {
                assert!(v == Some(&i));
            } else {
                missed += 1;
            }

            // let kv = map.get_key_value(&i, &guard).unwrap();
            // assert!(kv == (&i, &0) || kv == (&i, &1));
        }

        println!("missed {}", missed);

        println!("cpu {}", num_cpus::get())
    }

    #[test]
    fn concurrent_remove() {
        let map = Arc::new(Map::<u64, u64>::new());


        let handles: Vec<_> = (0..5).map(|_| {
            let map1 = map.clone();
            thread::spawn(move || {
                let guard = map1.guard();
                for i in 0..ITERREMOVE {
                    map1.insert(i, i, &guard);
                }
            })
        }).collect();


        for h in handles {
            h.join().unwrap()
        }
        thread::sleep(Duration::from_millis(500));
        let map1 = map.clone();
        let miss_remove = Arc::new(AtomicUsize::new(0));
       let  missr = Arc::clone(&miss_remove);
        let t1 = std::thread::spawn(move || {
            let guard = map1.guard();
            for i in 0..ITERREMOVE {
                if let Some(v) = map1.remove(&i, &guard) {
                    missr.fetch_add(1,Ordering::SeqCst);
                }
            }
        });
        let map2 = map.clone();
        let  missr2 = Arc::clone(&miss_remove);
        let t2 = std::thread::spawn(move || {
            let guard = map2.guard();
            for i in 0..ITERREMOVE {
                if let Some(v) = map2.remove(&i, &guard) {
                    missr2.fetch_add(1,Ordering::SeqCst);
                }
            }
        });

        t1.join().unwrap();
        t2.join().unwrap();

        println!("size of {}", map.len());
        // after joining the threads, the map should be empty
        let mut missedget:usize = 0;
        let guard = map.guard();
        for i in 0..ITERREMOVE {
            let v = map.get(&i, &guard);
            if v.is_none() {
                missedget += 1;
            }
        }
        assert_eq!(missedget,miss_remove.load(Ordering::SeqCst));


    }
}