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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
#![cfg(crossbeam_loom)]
use crossbeam_epoch as epoch;
use loom_crate as loom;
use epoch::*;
use epoch::{Atomic, Owned};
use loom::sync::atomic::Ordering::{self, Acquire, Relaxed, Release};
use loom::sync::Arc;
use loom::thread::spawn;
use std::mem::ManuallyDrop;
use std::ptr;
#[test]
fn it_works() {
loom::model(|| {
let collector = Collector::new();
let item: Atomic<String> = Atomic::from(Owned::new(String::from("boom")));
let item2 = item.clone();
let collector2 = collector.clone();
let guard = collector.register().pin();
let jh = loom::thread::spawn(move || {
let guard = collector2.register().pin();
guard.defer(move || {
// this isn't really safe, since other threads may still have pointers to the
// value, but in this limited test scenario it's okay, since we know the test won't
// access item after all the pins are released.
let mut item = unsafe { item2.into_owned() };
// mutate it as a second measure to make sure the assert_eq below would fail
item.retain(|c| c == 'o');
drop(item);
});
});
let item = item.load(Ordering::SeqCst, &guard);
// we pinned strictly before the call to defer_destroy,
// so item cannot have been dropped yet
assert_eq!(*unsafe { item.deref() }, "boom");
drop(guard);
jh.join().unwrap();
drop(collector);
})
}
#[test]
fn treiber_stack() {
/// Treiber's lock-free stack.
///
/// Usable with any number of producers and consumers.
#[derive(Debug)]
pub struct TreiberStack<T> {
head: Atomic<Node<T>>,
}
#[derive(Debug)]
struct Node<T> {
data: ManuallyDrop<T>,
next: Atomic<Node<T>>,
}
impl<T> TreiberStack<T> {
/// Creates a new, empty stack.
pub fn new() -> TreiberStack<T> {
TreiberStack {
head: Atomic::null(),
}
}
/// Pushes a value on top of the stack.
pub fn push(&self, t: T) {
let mut n = Owned::new(Node {
data: ManuallyDrop::new(t),
next: Atomic::null(),
});
let guard = epoch::pin();
loop {
let head = self.head.load(Relaxed, &guard);
n.next.store(head, Relaxed);
match self
.head
.compare_exchange(head, n, Release, Relaxed, &guard)
{
Ok(_) => break,
Err(e) => n = e.new,
}
}
}
/// Attempts to pop the top element from the stack.
///
/// Returns `None` if the stack is empty.
pub fn pop(&self) -> Option<T> {
let guard = epoch::pin();
loop {
let head = self.head.load(Acquire, &guard);
match unsafe { head.as_ref() } {
Some(h) => {
let next = h.next.load(Relaxed, &guard);
if self
.head
.compare_exchange(head, next, Relaxed, Relaxed, &guard)
.is_ok()
{
unsafe {
guard.defer_destroy(head);
return Some(ManuallyDrop::into_inner(ptr::read(&(*h).data)));
}
}
}
None => return None,
}
}
}
/// Returns `true` if the stack is empty.
pub fn is_empty(&self) -> bool {
let guard = epoch::pin();
self.head.load(Acquire, &guard).is_null()
}
}
impl<T> Drop for TreiberStack<T> {
fn drop(&mut self) {
while self.pop().is_some() {}
}
}
loom::model(|| {
let stack1 = Arc::new(TreiberStack::new());
let stack2 = Arc::clone(&stack1);
// use 5 since it's greater than the 4 used for the sanitize feature
let jh = spawn(move || {
for i in 0..5 {
stack2.push(i);
assert!(stack2.pop().is_some());
}
});
for i in 0..5 {
stack1.push(i);
assert!(stack1.pop().is_some());
}
jh.join().unwrap();
assert!(stack1.pop().is_none());
assert!(stack1.is_empty());
});
}
|
