flashmap 0.2.0

A lock-free eventually consistent concurrent hash map.
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

//! These tests focus on creating interesting interleavings of borrows and lifetimes.

mod util;

use flashmap::Evicted;
use std::{ops::Deref, thread};

#[test]
pub fn nested_readers() {
    let (mut write, read) = flashmap::new::<Box<u32>, Box<u32>>();

    let t1 = thread::spawn(move || {
        write.guard().insert(Box::new(10), Box::new(20));
        write.guard().insert(Box::new(20), Box::new(40));
    });

    let t2 = thread::spawn(move || {
        let outer = read.guard();
        let forty = outer.get(&20);
        let middle = read.guard();
        assert!(matches!(forty.map(Deref::deref), Some(40) | None));
        let inner = read.guard();
        let twenty = middle.get(&10);
        assert!(matches!(forty.map(Deref::deref), Some(40) | None));
        drop(outer);
        assert!(matches!(twenty.map(Deref::deref), Some(20) | None));
        assert_eq!(inner.get(&10), twenty);
        drop(inner);
        assert!(matches!(twenty.map(Deref::deref), Some(20) | None));
        drop(middle);
    });

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

#[test]
pub fn reclamation() {
    let (mut write, read) = flashmap::new::<Box<u32>, Box<u32>>();

    let mut guard = write.guard();
    guard.insert(Box::new(10), Box::new(20));
    guard.insert(Box::new(20), Box::new(40));
    guard.insert(Box::new(40), Box::new(80));
    drop(guard);

    let mut guard = write.guard();
    let twenty = guard.remove(Box::new(10)).unwrap();
    let forty = guard.replace(Box::new(20), |_| Box::new(50)).unwrap();

    let leaked_twenty = Evicted::leak(twenty);
    let leaked_forty = Evicted::leak(forty);

    let eighty = guard.insert(Box::new(40), Box::new(90)).unwrap();
    let leaked_eighty = Evicted::leak(eighty);
    drop(guard);

    let reclaimer = write.reclaimer();
    let twenty = reclaimer(leaked_twenty);
    let forty = reclaimer(leaked_forty);
    drop(reclaimer);

    assert_eq!(*twenty * 2, *forty);
    assert_eq!(**leaked_eighty, 80);

    write.guard().drop_lazily(leaked_eighty);

    drop(write);

    let guard = read.guard();
    assert!(guard.get(&10).is_none());
    assert_eq!(**guard.get(&20).unwrap(), 50);
    assert_eq!(**guard.get(&40).unwrap(), 90);

    drop(guard);
    drop(read);
}