syncmap 0.1.3

syncmap is a fast, concurrent cache library built with a focus on performance and correctness. The motivation to build syncmap comes from the sync.Map in Golang.
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

use std::marker::PhantomData;
use std::ptr;
use std::sync::atomic::Ordering;
use seize::{AtomicPtr, Guard};
use crate::reclaim::{Atomic, Shared};

#[derive(Clone)]
pub struct Entry<V> {
    pub(crate) p: Atomic<V>,
    pub(crate) expunged: Atomic<V>,
}


impl<V> Entry<V>

{
    pub(crate) fn new(e: Shared<V>) -> Self {
        Self {
            p: Atomic::from(e),
            expunged: Atomic::null(),
        }
    }
    pub fn remove<'g>(&'g self, guard: &'g Guard<'_>) -> Option<&'g V> {
        let item = self.p.load(Ordering::SeqCst, guard);
        if item.is_null() /*TODO || self.p == self.EXPUNGED*/ {
            return None;
        }
        if let Ok(v) = self.p.compare_exchange(item, Shared::null(), Ordering::AcqRel, Ordering::Acquire, guard) {
            if let Some(v) = unsafe { item.as_ref() } {
                let v = &**v;

                return Some(v);
            }
        }

        return None;
    }
    pub fn load<'g>(&'g self, guard: &'g Guard<'_>) -> Option<&'g V> {
        let item = self.p.load(Ordering::SeqCst, guard);
        if item.is_null() /*TODO || self.p == self.EXPUNGED*/ {
            return None;
        }
        if let Some(v) = unsafe { item.as_ref() } {
            let v = &**v;

            return Some(v);
        }
        return None;
    }

    //todo check later
    pub(crate) fn try_store<'g>(&'g self, value: Shared<V>, guard: &'g Guard<'_>) -> bool {
        loop {
            let load = self.p.load(Ordering::SeqCst, guard);

            if load == self.expunged.load(Ordering::SeqCst, guard) {
                return false;
            }
            if self.p.compare_exchange(load, value, Ordering::AcqRel, Ordering::Acquire, guard).is_ok() {
                return true;
            }
        }
    }

    pub fn unexpunge_locked<'g>(&'g self, guard: &'g Guard<'_>) -> bool {
        let exp = self.expunged.load(Ordering::SeqCst, guard);
        self.expunged.compare_exchange(exp, Shared::null(), Ordering::AcqRel, Ordering::Acquire, guard).is_ok()
    }

    pub fn try_unexpunge_locked<'g>(&'g self, guard: &'g Guard<'_>) -> bool {
        let mut p = self.p.load(Ordering::SeqCst, guard);
        while p.is_null() {
            if self.p.compare_exchange(p,self.expunged.load(Ordering::SeqCst,guard),Ordering::AcqRel,Ordering::Acquire,guard).is_ok() {
                return true;
            }
            p = self.p.load(Ordering::SeqCst, guard);
        }
        return p == self.expunged.load(Ordering::SeqCst,guard)
    }


    pub(crate) fn store_locked<'g>(&'g self, value: Shared<V>, guard: &'g Guard<'_>) {

        self.p.swap(value, Ordering::SeqCst,guard);
    }
}


impl<V> Drop for Entry<V> {
    fn drop(&mut self) {
        unsafe {
            //let _ = Box::into_raw(self.p.load())
        }
    }
}