Zero-Cost Abstractions & Memory Safety in Ultra-Low Latency Rust Engines

1use std::sync::atomic::{AtomicUsize, Ordering};
2use std::cell::UnsafeCell;
3use std::mem::MaybeUninit;
4
5pub struct SpscRingBuffer<T, const N: usize> {
6    buffer: [UnsafeCell<MaybeUninit<T>>; N],
7    head: AtomicUsize,
8    tail: AtomicUsize,
9}
10
11unsafe impl<T: Send, const N: usize> Sync for SpscRingBuffer<T, N> {}
12
13impl<T, const N: usize> SpscRingBuffer<T, N> {
14    pub fn new() -> Self {
15        Self {
16            buffer: std::array::from_fn(|_| UnsafeCell::new(MaybeUninit::uninit())),
17            head: AtomicUsize::new(0),
18            tail: AtomicUsize::new(0),
19        }
20    }
21
22    pub fn push(&self, item: T) -> Result<(), T> {
23        let head = self.head.load(Ordering::Relaxed);
24        let tail = self.tail.load(Ordering::Acquire);
25
26        if head.wrapping_sub(tail) >= N {
27            return Err(item); // Buffer full
28        }
29
30        let slot = head % N;
31        unsafe {
32            (*self.buffer[slot].get()).write(item);
33        }
34
35        self.head.store(head.wrapping_add(1), Ordering::Release);
36        Ok(())
37    }
38
39    pub fn pop(&self) -> Option<T> {
40        let tail = self.tail.load(Ordering::Relaxed);
41        let head = self.head.load(Ordering::Acquire);
42
43        if tail == head {
44            return None; // Buffer empty
45        }
46
47        let slot = tail % N;
48        let item = unsafe {
49            (*self.buffer[slot].get()).assume_init_read()
50        };
51
52        self.tail.store(tail.wrapping_add(1), Ordering::Release);
53        Some(item)
54    }
55}