use crate::slot::Slot;
use core::sync::atomic::{AtomicU64, Ordering};
#[repr(align(128))]
pub(crate) struct PaddedCounter(pub(crate) AtomicU64);
pub(crate) struct Ring<T, const N: usize> {
slots: Box<[Slot<T>]>,
pub(crate) progress: PaddedCounter,
pub(crate) producer_final: PaddedCounter,
}
unsafe impl<T: Send, const N: usize> Send for Ring<T, N> {}
unsafe impl<T: Send, const N: usize> Sync for Ring<T, N> {}
impl<T, const N: usize> Ring<T, N> {
pub(crate) const MASK: u64 = N as u64 - 1;
pub(crate) fn new(base: u64) -> Self {
const {
assert!(N >= 2, "ring capacity must be at least 2");
assert!(N.is_power_of_two(), "ring capacity must be a power of two");
}
debug_assert!(base & Self::MASK == 0);
let slots = (0..N as u64)
.map(|i| Slot::empty(base.wrapping_add(i)))
.collect();
Ring {
slots,
progress: PaddedCounter(AtomicU64::new(base)),
producer_final: PaddedCounter(AtomicU64::new(base)),
}
}
#[inline(always)]
pub(crate) fn slot(&self, pos: u64) -> &Slot<T> {
unsafe { self.slots.get_unchecked((pos & Self::MASK) as usize) }
}
pub(crate) fn slots_ptr(&self) -> core::ptr::NonNull<Slot<T>> {
unsafe { core::ptr::NonNull::new_unchecked(self.slots.as_ptr().cast_mut()) }
}
}
impl<T, const N: usize> Drop for Ring<T, N> {
fn drop(&mut self) {
if core::mem::needs_drop::<T>() {
let consumed = self.progress.0.load(Ordering::Acquire);
let produced = self.producer_final.0.load(Ordering::Acquire);
let mut pos = consumed;
while pos != produced {
unsafe { (*self.slot(pos).payload.get()).assume_init_drop() };
pos = pos.wrapping_add(1);
}
}
}
}