urcu2 0.1.3

Safe API to liburcu
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use crate::collections::hashmap::container::RcuHashMap;
use crate::rcu::context::RcuReadContext;
use crate::rcu::default::RcuDefaultFlavor;
use crate::rcu::flavor::RcuFlavor;
use crate::rcu::reference::RcuRef;

macro_rules! assert_sorted_eq {
    ($left:expr, $right:expr) => {
        let mut left = $left;
        left.sort();

        let mut right = $right;
        right.sort();

        assert_eq!(left, right);
    };
}

#[test]
fn get() {
    let context = RcuDefaultFlavor::rcu_context_builder()
        .with_read_context()
        .register_thread()
        .unwrap();

    let hashmap = RcuHashMap::<u32, u32>::new().unwrap();
    let guard = context.rcu_read_lock();

    assert_eq!(hashmap.get(&2367, &guard), None);
    assert_eq!(hashmap.get(&6068, &guard), None);
    assert_eq!(hashmap.get(&9823, &guard), None);
    assert_eq!(hashmap.get(&7038, &guard), None);
    assert_eq!(hashmap.get(&7321, &guard), None);
    assert_eq!(hashmap.get(&9810, &guard), None);

    hashmap.insert(2367, 9848, &guard).call_cleanup(&context);
    hashmap.insert(6068, 4733, &guard).call_cleanup(&context);
    hashmap.insert(9823, 4944, &guard).call_cleanup(&context);
    assert_eq!(hashmap.get(&2367, &guard), Some(&9848));
    assert_eq!(hashmap.get(&6068, &guard), Some(&4733));
    assert_eq!(hashmap.get(&9823, &guard), Some(&4944));
    assert_eq!(hashmap.get(&7038, &guard), None);
    assert_eq!(hashmap.get(&7321, &guard), None);
    assert_eq!(hashmap.get(&9810, &guard), None);

    hashmap.insert(7038, 6341, &guard).call_cleanup(&context);
    hashmap.insert(7321, 2556, &guard).call_cleanup(&context);
    hashmap.remove(&9823, &guard).call_cleanup(&context);
    assert_eq!(hashmap.get(&2367, &guard), Some(&9848));
    assert_eq!(hashmap.get(&6068, &guard), Some(&4733));
    assert_eq!(hashmap.get(&9823, &guard), None);
    assert_eq!(hashmap.get(&7038, &guard), Some(&6341));
    assert_eq!(hashmap.get(&7321, &guard), Some(&2556));
    assert_eq!(hashmap.get(&9810, &guard), None);

    hashmap.remove(&2367, &guard).call_cleanup(&context);
    hashmap.remove(&7038, &guard).call_cleanup(&context);
    hashmap.remove(&7321, &guard).call_cleanup(&context);
    hashmap.remove(&9823, &guard).call_cleanup(&context);
    hashmap.insert(9810, 7691, &guard).call_cleanup(&context);
    assert_eq!(hashmap.get(&2367, &guard), None);
    assert_eq!(hashmap.get(&6068, &guard), Some(&4733));
    assert_eq!(hashmap.get(&9823, &guard), None);
    assert_eq!(hashmap.get(&7038, &guard), None);
    assert_eq!(hashmap.get(&7321, &guard), None);
    assert_eq!(hashmap.get(&9810, &guard), Some(&7691));

    hashmap.remove(&7038, &guard).call_cleanup(&context);
    hashmap.remove(&6068, &guard).call_cleanup(&context);
    hashmap.remove(&9810, &guard).call_cleanup(&context);
    hashmap.remove(&9823, &guard).call_cleanup(&context);
    assert_eq!(hashmap.get(&2367, &guard), None);
    assert_eq!(hashmap.get(&6068, &guard), None);
    assert_eq!(hashmap.get(&9823, &guard), None);
    assert_eq!(hashmap.get(&7038, &guard), None);
    assert_eq!(hashmap.get(&7321, &guard), None);
    assert_eq!(hashmap.get(&9810, &guard), None);
}

#[test]
fn contains() {
    let context = RcuDefaultFlavor::rcu_context_builder()
        .with_read_context()
        .register_thread()
        .unwrap();

    let hashmap = RcuHashMap::<u32, u32>::new().unwrap();
    let guard = context.rcu_read_lock();

    assert!(!hashmap.contains(&6847, &guard));
    assert!(!hashmap.contains(&6614, &guard));
    assert!(!hashmap.contains(&1330, &guard));
    assert!(!hashmap.contains(&5154, &guard));
    assert!(!hashmap.contains(&8996, &guard));

    hashmap.insert(6847, 6228, &guard).call_cleanup(&context);
    assert!(hashmap.contains(&6847, &guard));
    assert!(!hashmap.contains(&6614, &guard));
    assert!(!hashmap.contains(&1330, &guard));
    assert!(!hashmap.contains(&5154, &guard));
    assert!(!hashmap.contains(&8996, &guard));

    hashmap.insert(6614, 1920, &guard).call_cleanup(&context);
    hashmap.insert(1330, 2524, &guard).call_cleanup(&context);
    assert!(hashmap.contains(&6847, &guard));
    assert!(hashmap.contains(&6614, &guard));
    assert!(hashmap.contains(&1330, &guard));
    assert!(!hashmap.contains(&5154, &guard));
    assert!(!hashmap.contains(&8996, &guard));

    hashmap.insert(5154, 7117, &guard).call_cleanup(&context);
    hashmap.insert(8996, 5158, &guard).call_cleanup(&context);
    hashmap.remove(&6614, &guard).call_cleanup(&context);
    hashmap.remove(&6614, &guard).call_cleanup(&context);
    assert!(hashmap.contains(&6847, &guard));
    assert!(!hashmap.contains(&6614, &guard));
    assert!(hashmap.contains(&1330, &guard));
    assert!(hashmap.contains(&5154, &guard));
    assert!(hashmap.contains(&8996, &guard));

    hashmap.remove(&6847, &guard).call_cleanup(&context);
    hashmap.remove(&1330, &guard).call_cleanup(&context);
    hashmap.remove(&5154, &guard).call_cleanup(&context);
    hashmap.remove(&5154, &guard).call_cleanup(&context);
    hashmap.remove(&6847, &guard).call_cleanup(&context);
    hashmap.remove(&8996, &guard).call_cleanup(&context);
    assert!(!hashmap.contains(&6847, &guard));
    assert!(!hashmap.contains(&6614, &guard));
    assert!(!hashmap.contains(&1330, &guard));
    assert!(!hashmap.contains(&5154, &guard));
    assert!(!hashmap.contains(&8996, &guard));
}

#[test]
fn iter() {
    let context = RcuDefaultFlavor::rcu_context_builder()
        .with_read_context()
        .register_thread()
        .unwrap();

    let hashmap = RcuHashMap::<u32, u32>::new().unwrap();
    let guard = context.rcu_read_lock();

    assert_sorted_eq!(hashmap.iter(&guard).collect::<Vec<_>>(), vec![]);

    hashmap.insert(5837, 4209, &guard).call_cleanup(&context);
    assert_sorted_eq!(
        hashmap.iter(&guard).collect::<Vec<_>>(),
        vec![(&5837, &4209)]
    );

    hashmap.insert(6030, 9028, &guard).call_cleanup(&context);
    hashmap.insert(8423, 3333, &guard).call_cleanup(&context);
    assert_sorted_eq!(
        hashmap.iter(&guard).collect::<Vec<_>>(),
        vec![(&5837, &4209), (&6030, &9028), (&8423, &3333)]
    );

    hashmap.remove(&99, &guard).call_cleanup(&context);
    assert_sorted_eq!(
        hashmap.iter(&guard).collect::<Vec<_>>(),
        vec![(&5837, &4209), (&6030, &9028), (&8423, &3333)]
    );

    hashmap.remove(&6030, &guard).call_cleanup(&context);
    assert_sorted_eq!(
        hashmap.iter(&guard).collect::<Vec<_>>(),
        vec![(&5837, &4209), (&8423, &3333)]
    );

    hashmap.insert(8423, 3333, &guard).call_cleanup(&context);
    hashmap.insert(8423, 3333, &guard).call_cleanup(&context);
    assert_sorted_eq!(
        hashmap.iter(&guard).collect::<Vec<_>>(),
        vec![(&5837, &4209), (&8423, &3333)]
    );

    hashmap.remove(&5837, &guard).call_cleanup(&context);
    hashmap.remove(&8423, &guard).call_cleanup(&context);
    hashmap.remove(&8423, &guard).call_cleanup(&context);
    hashmap.remove(&8423, &guard).call_cleanup(&context);
    hashmap.remove(&5837, &guard).call_cleanup(&context);
    assert_sorted_eq!(hashmap.iter(&guard).collect::<Vec<_>>(), vec![]);
}