gil 0.8.0

A collection of high-performance, lock-free concurrent queues (SPSC, MPSC, MPMC, SPMC) with sync and async support
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

use core::{mem::MaybeUninit, ptr::NonNull};

use crate::atomic::AtomicUsize;

#[repr(align(64))]
#[cfg_attr(all(target_arch = "aarch64", target_os = "macos"), repr(align(128)))]
pub(crate) struct Cell<T> {
    pub(crate) epoch: AtomicUsize,
    pub(crate) data: MaybeUninit<T>,
}

pub(crate) struct CellPtr<T> {
    ptr: NonNull<Cell<T>>,
}

impl<T> CellPtr<T> {
    /// # Safety
    /// The value must be initialised correctly at this `index`
    #[inline(always)]
    pub(crate) unsafe fn get(&self) -> T {
        unsafe { _field!(Cell<T>, self.ptr, data, T).read() }
    }

    #[inline(always)]
    pub(crate) fn set(&self, value: T) {
        unsafe { _field!(Cell<T>, self.ptr, data, T).write(value) }
    }

    #[inline(always)]
    pub(crate) fn epoch(&self) -> &AtomicUsize {
        unsafe { _field!(Cell<T>, self.ptr, epoch, AtomicUsize).as_ref() }
    }

    #[inline(always)]
    pub(crate) unsafe fn drop_in_place(&self) {
        if core::mem::needs_drop::<T>() {
            unsafe {
                core::ptr::drop_in_place(_field!(Cell<T>, self.ptr, data, T).as_ptr());
            }
        }
    }
}

impl<T> From<NonNull<Cell<T>>> for CellPtr<T> {
    fn from(value: NonNull<Cell<T>>) -> Self {
        Self { ptr: value }
    }
}