tokio 0.2.22

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.
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

use crate::util::slab::TransferStack;

use loom::cell::UnsafeCell;
use loom::sync::Arc;
use loom::thread;

#[test]
fn transfer_stack() {
    loom::model(|| {
        let causalities = [UnsafeCell::new(None), UnsafeCell::new(None)];
        let shared = Arc::new((causalities, TransferStack::new()));
        let shared1 = shared.clone();
        let shared2 = shared.clone();

        // Spawn two threads that both try to push to the stack.
        let t1 = thread::spawn(move || {
            let (causalities, stack) = &*shared1;
            stack.push(0, |prev| {
                causalities[0].with_mut(|c| unsafe {
                    *c = Some(prev);
                });
            });
        });

        let t2 = thread::spawn(move || {
            let (causalities, stack) = &*shared2;
            stack.push(1, |prev| {
                causalities[1].with_mut(|c| unsafe {
                    *c = Some(prev);
                });
            });
        });

        let (causalities, stack) = &*shared;

        // Try to pop from the stack...
        let mut idx = stack.pop_all();
        while idx == None {
            idx = stack.pop_all();
            thread::yield_now();
        }
        let idx = idx.unwrap();

        let saw_both = causalities[idx].with(|val| {
            let val = unsafe { *val };
            assert!(
                val.is_some(),
                "UnsafeCell write must happen-before index is pushed to the stack!",
            );
            // were there two entries in the stack? if so, check that
            // both saw a write.
            if let Some(c) = causalities.get(val.unwrap()) {
                c.with(|val| {
                    let val = unsafe { *val };
                    assert!(
                        val.is_some(),
                        "UnsafeCell write must happen-before index is pushed to the stack!",
                    );
                });
                true
            } else {
                false
            }
        });

        // We only saw one push. Ensure that the other push happens too.
        if !saw_both {
            // Try to pop from the stack...
            let mut idx = stack.pop_all();
            while idx == None {
                idx = stack.pop_all();
                thread::yield_now();
            }
            let idx = idx.unwrap();

            causalities[idx].with(|val| {
                let val = unsafe { *val };
                assert!(
                    val.is_some(),
                    "UnsafeCell write must happen-before index is pushed to the stack!",
                );
            });
        }

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