faa_array_queue 0.1.2

Fetch-And-Add Array Queue implementation for Rust.
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

use crate::FaaArrayQueue;

#[test]
pub fn test_hazard_vector() {
    use std::sync::Arc;
    use std::thread;

    let thread_count = 128;
    let loop_count = 53;
    let queue1 = Arc::new(FaaArrayQueue::<usize>::default());
    let queue2 = Arc::new(FaaArrayQueue::<usize>::default());

    let handles: Vec<_> = (0..thread_count)
        .into_iter()
        .map(|idx| {
            let cpy1 = queue1.clone();
            let cpy2 = queue2.clone();
            thread::spawn(move || {
                thread::park();
                let start = idx * loop_count;
                for idx in start..start + loop_count {
                    cpy1.enqueue(idx);
                }
                for _ in 0..loop_count {
                    let val;
                    loop {
                        if let Some(x) = cpy1.dequeue() {
                            val = x;
                            break;
                        }
                    }
                    cpy2.enqueue(val);
                }
            })
        })
        .collect();

    for child in handles.iter() {
        child.thread().unpark();
    }

    for child in handles.into_iter() {
        child.join().unwrap();
    }

    let none = queue1.dequeue();
    assert!(none.is_none(), "expected vec1 to be empty");
    let mut vec2 = Vec::new();
    loop {
        if let Some(x) = queue2.dequeue() {
            vec2.push(x);
        } else {
            break;
        }
    }

    vec2.sort();

    for i in 0..(thread_count * loop_count) {
        assert!(vec2[i] == i, "unexpected vec2 value");
    }
}