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
|
#![deny(warnings, rust_2018_idioms)]
use loom::cell::UnsafeCell;
use loom::sync::atomic::AtomicUsize;
use loom::sync::Mutex;
use loom::thread;
use std::rc::Rc;
use std::sync::atomic::Ordering::SeqCst;
#[test]
fn mutex_enforces_mutal_exclusion() {
loom::model(|| {
let data = Rc::new((Mutex::new(0), AtomicUsize::new(0)));
let ths: Vec<_> = (0..2)
.map(|_| {
let data = data.clone();
thread::spawn(move || {
let mut locked = data.0.lock().unwrap();
let prev = data.1.fetch_add(1, SeqCst);
assert_eq!(prev, *locked);
*locked += 1;
})
})
.collect();
for th in ths {
th.join().unwrap();
}
let locked = data.0.lock().unwrap();
assert_eq!(*locked, data.1.load(SeqCst));
});
}
#[test]
fn mutex_establishes_seq_cst() {
loom::model(|| {
struct Data {
cell: UnsafeCell<usize>,
flag: Mutex<bool>,
}
let data = Rc::new(Data {
cell: UnsafeCell::new(0),
flag: Mutex::new(false),
});
{
let data = data.clone();
thread::spawn(move || {
unsafe { data.cell.with_mut(|v| *v = 1) };
*data.flag.lock().unwrap() = true;
});
}
let flag = *data.flag.lock().unwrap();
if flag {
let v = unsafe { data.cell.with(|v| *v) };
assert_eq!(v, 1);
}
});
}
#[test]
fn mutex_into_inner() {
loom::model(|| {
let lock = Rc::new(Mutex::new(0));
let ths: Vec<_> = (0..2)
.map(|_| {
let lock = lock.clone();
thread::spawn(move || {
*lock.lock().unwrap() += 1;
})
})
.collect();
for th in ths {
th.join().unwrap();
}
let lock = Rc::try_unwrap(lock).unwrap().into_inner().unwrap();
assert_eq!(lock, 2);
})
}
|
