swym 0.1.0-preview

Transactional memory for rust
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

use crate::{
    internal::epoch::QuiesceEpoch,
    tcell::TCell,
    tx::{Error, Ordering, Read},
};
use std::{
    marker::PhantomData,
    mem::{self, ManuallyDrop},
    sync::atomic::Ordering::Acquire,
};

/// A read only transaction.
pub struct ReadTx<'tcell>(PhantomData<fn(&'tcell ())>);
impl<'tcell> !Send for ReadTx<'tcell> {}
impl<'tcell> !Sync for ReadTx<'tcell> {}

impl<'tcell> ReadTx<'tcell> {
    #[inline]
    pub(crate) fn new<'a>(pin_epoch: QuiesceEpoch) -> &'a Self {
        unsafe { mem::transmute(pin_epoch) }
    }

    #[inline]
    fn pin_epoch(&self) -> QuiesceEpoch {
        unsafe { mem::transmute(self) }
    }

    #[inline]
    unsafe fn get_impl<T>(&self, tcell: &TCell<T>) -> Result<ManuallyDrop<T>, Error> {
        let value = tcell.erased.read_acquire::<T>();
        if likely!(self
            .pin_epoch()
            .read_write_valid_lockable(&tcell.erased.current_epoch, Acquire))
        {
            Ok(value)
        } else {
            Err(Error::RETRY)
        }
    }
}

unsafe impl<'tcell> Read<'tcell> for ReadTx<'tcell> {
    #[inline]
    unsafe fn _get_unchecked<T>(
        &self,
        tcell: &TCell<T>,
        ordering: Ordering,
    ) -> Result<ManuallyDrop<T>, Error> {
        match ordering {
            Ordering::ReadWrite | Ordering::Read => self.get_impl(tcell),
        }
    }
}