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
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

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

#[test]
fn write() {
    const WRITERS: usize = 2;

    loom::model(|| {
        let lock = Arc::new(RwLock::<usize>::new(0));
        let threads = (0..WRITERS)
            .map(|_| {
                let lock = lock.clone();
                thread::spawn(writer(lock))
            })
            .collect::<Vec<_>>();

        for thread in threads {
            thread.join().expect("writer thread mustn't panic");
        }

        let guard = future::block_on(lock.read());
        assert_eq!(*guard, WRITERS, "final state must equal number of writers");
    });
}

#[test]
fn read_write() {
    const WRITERS: usize = 2;

    loom::model(|| {
        let lock = Arc::new(RwLock::<usize>::new(0));
        let w_threads = (0..WRITERS)
            .map(|_| {
                let lock = lock.clone();
                thread::spawn(writer(lock))
            })
            .collect::<Vec<_>>();

        {
            let guard = future::block_on(lock.read());
            assert!(*guard == 0 || *guard == 1 || *guard == 2);
        }

        for thread in w_threads {
            thread.join().expect("writer thread mustn't panic")
        }

        let guard = future::block_on(lock.read());
        assert_eq!(*guard, WRITERS, "final state must equal number of writers");
    });
}

fn writer(lock: Arc<RwLock<usize>>) -> impl FnOnce() {
    move || {
        future::block_on(async {
            let mut guard = lock.write().await;
            *guard += 1;
        })
    }
}

#[test]
#[cfg(feature = "alloc")]
fn write_owned() {
    const WRITERS: usize = 2;

    loom::model(|| {
        let lock = alloc::sync::Arc::new(RwLock::<usize>::new(0));
        let threads = (0..WRITERS)
            .map(|_| {
                let lock = lock.clone();
                thread::spawn(owned_writer(lock))
            })
            .collect::<Vec<_>>();

        for thread in threads {
            thread.join().expect("writer thread mustn't panic");
        }

        let guard = future::block_on(lock.read());
        assert_eq!(*guard, WRITERS, "final state must equal number of writers");
    });
}

#[test]
#[cfg(feature = "alloc")]
fn read_write_owned() {
    const WRITERS: usize = 2;

    loom::model(|| {
        let lock = alloc::sync::Arc::new(RwLock::<usize>::new(0));
        let w_threads = (0..WRITERS)
            .map(|_| {
                let lock = lock.clone();
                thread::spawn(owned_writer(lock))
            })
            .collect::<Vec<_>>();

        {
            let guard = future::block_on(lock.read_owned());
            assert!(*guard == 0 || *guard == 1 || *guard == 2);
        }

        for thread in w_threads {
            thread.join().expect("writer thread mustn't panic")
        }

        let guard = future::block_on(lock.read_owned());
        assert_eq!(*guard, WRITERS, "final state must equal number of writers");
    });
}

#[cfg(feature = "alloc")]
fn owned_writer(lock: alloc::sync::Arc<RwLock<usize>>) -> impl FnOnce() {
    move || {
        future::block_on(async {
            let mut guard = lock.write_owned().await;
            *guard += 1;
        })
    }
}