Fix Heap construction from Vec of ZST, enforce exact capacity for Hea…

…p::new, bump version

Cargo.toml

@@ -7,14 +7,14 @@ readme = "README.md"
 license = "MIT/Apache-2.0"
 
 [workspace.dependencies]
-ringbuf = { path = ".", version = "0.4.4" }
+ringbuf = { path = ".", version = "0.4.5" }
 
 [workspace]
 members = ["async", "blocking"]
 
 [package]
 name = "ringbuf"
-version = "0.4.4"
+version = "0.4.5"
 edition.workspace = true
 authors.workspace = true
 description = "Lock-free SPSC FIFO ring buffer with direct access to inner data"

src/rb/local.rs

@@ -19,13 +19,13 @@ use core::{
  ptr,
 };
 
-struct End {
+struct Endpoint {
  index: Cell<usize>,
  held: Cell<bool>,
 }
 
-impl End {
- fn new(index: usize) -> Self {
+impl Endpoint {
+ const fn new(index: usize) -> Self {
  Self {
  index: Cell::new(index),
  held: Cell::new(false),
@@ -37,8 +37,8 @@ impl End {
 ///
 /// Slightly faster than multi-threaded version because it doesn't synchronize cache.
 pub struct LocalRb<S: Storage + ?Sized> {
- read: End,
- write: End,
+ read: Endpoint,
+ write: Endpoint,
  storage: S,
 }
 
@@ -53,8 +53,8 @@ impl<S: Storage> LocalRb<S> {
  assert!(!storage.is_empty());
  Self {
  storage,
- read: End::new(read),
- write: End::new(write),
+ read: Endpoint::new(read),
+ write: Endpoint::new(write),
  }
  }
  /// Destructures ring buffer into underlying storage and `read` and `write` indices.

src/rb/macros.rs

@@ -19,15 +19,16 @@ macro_rules! rb_impl_init {
  ///
  /// *Panics if allocation failed or `capacity` is zero.*
  pub fn new(capacity: usize) -> Self {
- Self::try_new(capacity).unwrap()
+ unsafe { Self::from_raw_parts(crate::storage::Heap::<T>::new(capacity), usize::default(), usize::default()) }
  }
  /// Creates a new instance of a ring buffer returning an error if allocation failed.
  ///
  /// *Panics if `capacity` is zero.*
  pub fn try_new(capacity: usize) -> Result<Self, alloc::collections::TryReserveError> {
- let mut vec = alloc::vec::Vec::new();
+ let mut vec = alloc::vec::Vec::<core::mem::MaybeUninit<T>>::new();
  vec.try_reserve_exact(capacity)?;
- Ok(unsafe { Self::from_raw_parts(vec.into(), usize::default(), usize::default()) })
+ unsafe { vec.set_len(capacity) };
+ Ok(unsafe { Self::from_raw_parts(vec.into_boxed_slice().into(), usize::default(), usize::default()) })
  }
  }
 

src/storage.rs

@@ -2,7 +2,7 @@
 use alloc::{boxed::Box, vec::Vec};
 use core::{cell::UnsafeCell, marker::PhantomData, mem::MaybeUninit, ops::Range, ptr::NonNull, slice};
 #[cfg(feature = "alloc")]
-use core::{mem::forget, ptr};
+use core::{mem::ManuallyDrop, ptr};
 
 /// Abstract storage for the ring buffer.
 ///
@@ -104,7 +104,7 @@ unsafe impl<T, const N: usize> Storage for Array<T, N> {
  type Item = T;
  #[inline]
  fn as_mut_ptr(&self) -> *mut MaybeUninit<T> {
- self.data.get() as *mut _
+ self.data.get().cast()
  }
  #[inline]
  fn len(&self) -> usize {
@@ -122,7 +122,7 @@ unsafe impl<T> Storage for Slice<T> {
  type Item = T;
  #[inline]
  fn as_mut_ptr(&self) -> *mut MaybeUninit<T> {
- self.data.get() as *mut _
+ self.data.get().cast()
  }
  #[inline]
  fn len(&self) -> usize {
@@ -153,34 +153,40 @@ unsafe impl<T> Storage for Heap<T> {
 }
 #[cfg(feature = "alloc")]
 impl<T> Heap<T> {
+ /// Create a new heap storage with exact capacity.
  pub fn new(capacity: usize) -> Self {
- Self {
- ptr: Vec::<T>::with_capacity(capacity).leak() as *mut _ as *mut MaybeUninit<T>,
- len: capacity,
- }
+ let mut data = Vec::<MaybeUninit<T>>::with_capacity(capacity);
+ // `data.capacity()` is not guaranteed to be equal to `capacity`.
+ // We enforce that by `set_len` and converting to boxed slice.
+ unsafe { data.set_len(capacity) };
+ Self::from(data.into_boxed_slice())
  }
 }
 #[cfg(feature = "alloc")]
 impl<T> From<Vec<MaybeUninit<T>>> for Heap<T> {
  fn from(mut value: Vec<MaybeUninit<T>>) -> Self {
- let len = value.capacity();
- let ptr = value.as_mut_ptr();
- forget(value);
- Self { ptr, len }
+ // Convert `value` to boxed slice of length equals to `value.capacity()`
+ // except for zero-sized types - for them length will be `value.len()` because `Vec::capacity` for ZST is undefined
+ // (see <https://doc.rust-lang.org/std/vec/struct.Vec.html#guarantees>).
+ if size_of::<T>() != 0 {
+ unsafe { value.set_len(value.capacity()) };
+ }
+ Self::from(value.into_boxed_slice())
  }
 }
 #[cfg(feature = "alloc")]
 impl<T> From<Box<[MaybeUninit<T>]>> for Heap<T> {
  fn from(value: Box<[MaybeUninit<T>]>) -> Self {
  Self {
  len: value.len(),
- ptr: Box::into_raw(value) as *mut MaybeUninit<T>,
+ ptr: Box::into_raw(value).cast(),
  }
  }
 }
 #[cfg(feature = "alloc")]
 impl<T> From<Heap<T>> for Box<[MaybeUninit<T>]> {
  fn from(value: Heap<T>) -> Self {
+ let value = ManuallyDrop::new(value);
  unsafe { Box::from_raw(ptr::slice_from_raw_parts_mut(value.ptr, value.len)) }
  }
 }

src/tests/mod.rs

@@ -22,3 +22,4 @@ mod shared;
 mod skip;
 mod slice;
 mod unsized_;
+mod zero_sized;

src/tests/zero_sized.rs

@@ -0,0 +1,49 @@
+use crate::{
+ producer::Producer,
+ traits::{Consumer, Observer, Split},
+ HeapRb,
+};
+
+#[test]
+fn basic() {
+ let (mut prod, mut cons) = HeapRb::<()>::new(2).split();
+ let obs = prod.observe();
+ assert_eq!(obs.capacity().get(), 2);
+
+ assert_eq!(obs.occupied_len(), 0);
+ assert_eq!(obs.vacant_len(), 2);
+ assert!(obs.is_empty());
+
+ assert!(cons.try_pop().is_none());
+
+ prod.try_push(()).unwrap();
+ assert_eq!(obs.occupied_len(), 1);
+ assert_eq!(obs.vacant_len(), 1);
+
+ prod.try_push(()).unwrap();
+ assert_eq!(obs.occupied_len(), 2);
+ assert_eq!(obs.vacant_len(), 0);
+ assert!(obs.is_full());
+
+ assert!(prod.try_push(()).is_err());
+
+ cons.try_pop().unwrap();
+ assert_eq!(obs.occupied_len(), 1);
+ assert_eq!(obs.vacant_len(), 1);
+
+ prod.try_push(()).unwrap();
+ assert_eq!(obs.occupied_len(), 2);
+ assert_eq!(obs.vacant_len(), 0);
+ assert!(obs.is_full());
+
+ cons.try_pop().unwrap();
+ assert_eq!(obs.occupied_len(), 1);
+ assert_eq!(obs.vacant_len(), 1);
+
+ cons.try_pop().unwrap();
+ assert_eq!(obs.occupied_len(), 0);
+ assert_eq!(obs.vacant_len(), 2);
+ assert!(obs.is_empty());
+
+ assert!(cons.try_pop().is_none());
+}