atomption 0.1.0

A simple AtomicOption implementation with no safety issue.
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

use std::marker::PhantomData;
use std::ptr::null_mut;
use std::sync::atomic::{AtomicPtr, Ordering};

type PhantomUnsync<T> = PhantomData<*mut T>;

pub struct AtomicOption<T> {
    inner: AtomicPtr<T>,
    _phantom: PhantomUnsync<T>,
}

impl<T> AtomicOption<T> {
    #[inline(always)]
    pub fn new(data: Option<Box<T>>) -> AtomicOption<T> {
        let empty = AtomicOption {
            inner: AtomicPtr::new(null_mut()),
            _phantom: PhantomData,
        };
        empty.store(data);
        empty
    }

    #[inline(always)]
    pub fn swap(&self, new: Option<Box<T>>) -> Option<Box<T>> {
        let addr = if let Some(new) = new {
            Box::into_raw(new)
        } else {
            null_mut()
        };

        let addr = self.inner.swap(addr, Ordering::AcqRel);
        if addr.is_null() {
            None
        } else {
            Some(unsafe { Box::from_raw(addr) })
        }
    }

    #[inline(always)]
    pub fn take(&self) -> Option<Box<T>> {
        self.swap(None)
    }

    #[inline(always)]
    pub fn store(&self, new: Option<Box<T>>) {
        drop(self.swap(new))
    }
}

unsafe impl<T> Sync for AtomicOption<T> where T: Send {}
unsafe impl<T> Send for AtomicOption<T> where T: Send {}

impl<T> Drop for AtomicOption<T> {
    fn drop(&mut self) {
        let _ = self.take();
    }
}

#[cfg(test)]
mod tests {
    use std::{mem::transmute, thread};

    use super::AtomicOption;

    #[test]
    fn test_simple() {
        let opt = AtomicOption::new(None);
        assert_eq!(opt.take(), None);
        assert_eq!(opt.swap(Some(Box::new(0))), None);
        assert_eq!(opt.take(), Some(Box::new(0)));
        opt.store(Some(Box::new(1)));
        opt.store(Some(Box::new(2)));
        assert_eq!(opt.swap(Some(Box::new(3))), Some(Box::new(2)));
    }

    #[test]
    fn test_two_threads() {
        for _ in 0..100 {
            let opt = AtomicOption::<i64>::new(None);
            let opt: &'static AtomicOption<i64> = unsafe { transmute(&opt) };
            let func1 = move || {
                let mut remain = 100;
                loop {
                    let a = opt.swap(Some(Box::new(remain)));
                    if a.is_none() {
                        remain -= 1;
                    }
                    if remain == 0 {
                        break;
                    }
                }
            };

            let func2 = move || {
                let mut remain = 100;
                loop {
                    let a = opt.swap(None);
                    if a.is_some() {
                        remain -= 1;
                    }
                    if remain == 0 {
                        break;
                    }
                }
            };

            for h in [thread::spawn(func1), thread::spawn(func2)] {
                h.join().unwrap();
            }
            assert_eq!(opt.take(), None);
        }
    }
}