papaya 0.2.4

A fast and ergonomic concurrent hash-table for read-heavy workloads.
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
114
115
116
117

mod counter;
mod parker;
mod stack;
mod tagged;

pub use counter::Counter;
pub use parker::Parker;
pub use stack::Stack;
pub use tagged::{untagged, AtomicPtrFetchOps, StrictProvenance, Tagged, Unpack};

/// A `seize::Guard` that has been verified to belong to a given map.
pub trait VerifiedGuard: seize::Guard {}

#[repr(transparent)]
pub struct MapGuard<G>(G);

impl<G> MapGuard<G> {
    /// Create a new `MapGuard`.
    ///
    /// # Safety
    ///
    /// The guard must be valid to use with the given map.
    pub unsafe fn new(guard: G) -> MapGuard<G> {
        MapGuard(guard)
    }

    /// Create a new `MapGuard` from a reference.
    ///
    /// # Safety
    ///
    /// The guard must be valid to use with the given map.
    pub unsafe fn from_ref(guard: &G) -> &MapGuard<G> {
        // Safety: `VerifiedGuard` is `repr(transparent)` over `G`.
        unsafe { &*(guard as *const G as *const MapGuard<G>) }
    }
}

impl<G> VerifiedGuard for MapGuard<G> where G: seize::Guard {}

impl<G> seize::Guard for MapGuard<G>
where
    G: seize::Guard,
{
    #[inline]
    fn refresh(&mut self) {
        self.0.refresh();
    }

    #[inline]
    fn flush(&self) {
        self.0.flush();
    }

    #[inline]
    fn collector(&self) -> &seize::Collector {
        self.0.collector()
    }

    #[inline]
    fn thread_id(&self) -> usize {
        self.0.thread_id()
    }

    #[inline]
    unsafe fn defer_retire<T>(&self, ptr: *mut T, reclaim: unsafe fn(*mut T, &seize::Collector)) {
        unsafe { self.0.defer_retire(ptr, reclaim) };
    }
}

/// Pads and aligns a value to the length of a cache line.
///
// Source: https://github.com/crossbeam-rs/crossbeam/blob/0f81a6957588ddca9973e32e92e7e94abdad801e/crossbeam-utils/src/cache_padded.rs#L63.
#[derive(Clone, Copy, Default, Hash, PartialEq, Eq)]
#[cfg_attr(
    any(
        target_arch = "x86_64",
        target_arch = "aarch64",
        target_arch = "arm64ec",
        target_arch = "powerpc64",
    ),
    repr(align(128))
)]
#[cfg_attr(
    any(
        target_arch = "arm",
        target_arch = "mips",
        target_arch = "mips32r6",
        target_arch = "mips64",
        target_arch = "mips64r6",
        target_arch = "sparc",
        target_arch = "hexagon",
    ),
    repr(align(32))
)]
#[cfg_attr(target_arch = "m68k", repr(align(16)))]
#[cfg_attr(target_arch = "s390x", repr(align(256)))]
#[cfg_attr(
    not(any(
        target_arch = "x86_64",
        target_arch = "aarch64",
        target_arch = "arm64ec",
        target_arch = "powerpc64",
        target_arch = "arm",
        target_arch = "mips",
        target_arch = "mips32r6",
        target_arch = "mips64",
        target_arch = "mips64r6",
        target_arch = "sparc",
        target_arch = "hexagon",
        target_arch = "m68k",
        target_arch = "s390x",
    )),
    repr(align(64))
)]
pub struct CachePadded<T> {
    value: T,
}