plain-cache 0.2.2

Highly performant thread-safe cache with a focus on simplicity
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

use std::sync::atomic::{AtomicU8, Ordering};

#[derive(Debug)]
pub(crate) enum EntryPointer {
    MainQueue(usize),
    SmallQueue(usize),
}

#[derive(Debug)]
pub(crate) struct Entry<K, V> {
    pub(crate) key: K,
    pub(crate) value: V,
    num_accessed: AtomicU8,
}

impl<K, V> Entry<K, V> {}

impl<K, V> Entry<K, V> {
    pub(crate) fn new(key: K, value: V) -> Self {
        Self {
            key,
            value,
            num_accessed: AtomicU8::new(0),
        }
    }

    pub(crate) fn set_num_accessed(&self, val: u8) {
        self.num_accessed.store(val, Ordering::Release);
    }

    pub(crate) fn get_num_accessed(&self) -> u8 {
        self.num_accessed.load(Ordering::Acquire)
    }

    pub(crate) fn increment_num_accessed(&self, mut current_val: u8) {
        loop {
            match self.num_accessed.compare_exchange(
                current_val,
                current_val + 1,
                Ordering::AcqRel,
                Ordering::Acquire,
            ) {
                Ok(_) => break,
                Err(new_val) => {
                    current_val = new_val;
                }
            }
        }
    }
}