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
extern crate crossbeam_epoch; use crossbeam_epoch::{Atomic, Owned}; use std::sync::atomic::Ordering; use std::ops::Deref; use std::fmt; pub struct Stm<T: 'static + Send> { inner: Atomic<T>, } impl<T: 'static + Send> Stm<T> { pub fn new(data: T) -> Stm<T> { Stm { inner: Atomic::new(data), } } pub fn update<F>(&self, f: F) where F: Fn(&T) -> T, { let guard = crossbeam_epoch::pin(); guard.flush(); loop { let shared = self.inner.load(Ordering::Acquire, &guard); let data = unsafe { shared.as_ref().unwrap() }; let t = f(data); let r = self.inner .compare_and_set(shared, Owned::new(t), Ordering::AcqRel, &guard); if let Ok(r) = r { unsafe { guard.defer(move || r.into_owned()) } break; } } } pub fn load(&self) -> StmGuard<T> { StmGuard { parent: self, inner: crossbeam_epoch::pin(), } } } impl<T: 'static + Send + fmt::Debug> fmt::Debug for Stm<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("StmGuard") .field("data", self.load().deref()) .finish() } } impl<T: 'static + Send + fmt::Display> fmt::Display for Stm<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.load().deref().fmt(f) } } pub struct StmGuard<'a, T: 'static + Send> { parent: &'a Stm<T>, inner: crossbeam_epoch::Guard, } impl<'a, T: 'static + Send> Deref for StmGuard<'a, T> { type Target = T; fn deref(&self) -> &T { let shared = self.parent.inner.load(Ordering::Acquire, &self.inner); unsafe { shared.as_ref().unwrap() } } } impl<'a, T: 'static + Send + fmt::Debug> fmt::Debug for StmGuard<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("StmGuard") .field("data", &self.deref()) .finish() } } impl<'a, T: 'static + Send + fmt::Display> fmt::Display for StmGuard<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.deref().fmt(f) } } #[cfg(test)] mod tests { use super::*; #[test] fn stm_test() { let stm = Stm::new(vec![1, 2, 3]); { let data = stm.load(); println!("{:?}", data); } stm.update(|v| { let mut v = v.clone(); v.push(4); v }); { let data = stm.load(); println!("{:?}", data); } stm.update(|_| vec![1]); { let data = stm.load(); println!("{:?}", data); } } }