ptab 0.1.7

Lock-free concurrent table optimized 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

use core::ops::Deref;
use core::ops::DerefMut;

/// Pads and aligns a value to the length of a cache line.
///
/// Alignment varies by architecture; see [`CACHE_LINE`] for the effective size.
///
/// Based on [`crossbeam-utils`].
///
/// [`CACHE_LINE`]: crate::params::CACHE_LINE
/// [`crossbeam-utils`]: https://crates.io/crates/crossbeam-utils
#[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(crate) struct CachePadded<T> {
  value: T,
}

// SAFETY: Transparent wrapper; inherits `Send` from `T`.
unsafe impl<T: Send> Send for CachePadded<T> {}

// SAFETY: Transparent wrapper; inherits `Sync` from `T`.
unsafe impl<T: Sync> Sync for CachePadded<T> {}

impl<T> CachePadded<T> {
  #[inline]
  pub(crate) const fn new(value: T) -> Self {
    Self { value }
  }
}

impl<T> Deref for CachePadded<T> {
  type Target = T;

  #[inline]
  fn deref(&self) -> &T {
    &self.value
  }
}

impl<T> DerefMut for CachePadded<T> {
  #[inline]
  fn deref_mut(&mut self) -> &mut T {
    &mut self.value
  }
}

// -----------------------------------------------------------------------------
// Tests
// -----------------------------------------------------------------------------

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
  use crate::padded::CachePadded;

  #[test]
  fn works() {
    let mut value: CachePadded<u8> = CachePadded::new(123);

    assert_eq!(&*value, &123);
    assert_eq!(&mut *value, &123);
  }
}