maitake-sync 0.2.2

No-std async synchronization primitives from Maitake
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

use super::*;
use crate::loom::{self, future, sync::Arc, thread};

#[test]
fn wake_one() {
    loom::model(|| {
        let q = Arc::new(WaitMap::<usize, usize>::new());
        let thread = thread::spawn({
            let q = q.clone();
            move || {
                future::block_on(async {
                    let _val = q.wait(123).await;
                });
            }
        });

        loom::thread::yield_now();
        let _result = q.wake(&123, 666);
        q.close();

        thread.join().unwrap();
    });
}

#[test]
fn wake_two_sequential() {
    loom::model(|| {
        let q = Arc::new(WaitMap::<usize, usize>::new());
        let q2 = q.clone();

        let thread_a = thread::spawn(move || {
            let wait1 = q2.wait(123);
            let wait2 = q2.wait(456);
            future::block_on(async move {
                let _ = wait1.await;
                let _ = wait2.await;
            });
        });

        let thread_b = thread::spawn(move || {
            loom::thread::yield_now();
            let _result = q.wake(&123, 321);
            let _result = q.wake(&456, 654);
            q.close();
        });

        thread_a.join().unwrap();
        thread_b.join().unwrap();
    });
}

#[test]
#[cfg(feature = "alloc")]
fn wake_close() {
    use ::alloc::sync::Arc;

    loom::model(|| {
        let q = Arc::new(WaitMap::<usize, usize>::new());
        let wait1 = q.wait_owned(123);
        let wait2 = q.wait_owned(456);

        let thread1 =
            thread::spawn(move || future::block_on(wait1).expect_err("wait1 must be canceled"));
        let thread2 =
            thread::spawn(move || future::block_on(wait2).expect_err("wait2 must be canceled"));

        q.close();

        thread1.join().unwrap();
        thread2.join().unwrap();
    });
}

#[test]
fn wake_and_drop() {
    use futures::FutureExt;
    loom::model(|| {
        // use `Arc`s as the value type to ensure their destructors are run.
        let q = Arc::new(WaitMap::<usize, Arc<()>>::new());

        let thread = thread::spawn({
            let q = q.clone();
            move || {
                dbg!(q.wait(1).now_or_never());
            }
        });

        thread::yield_now();
        dbg!(q.wake(&1, Arc::new(())));

        thread.join().unwrap();
    });
}