Complete new storage

agerasev · Jan 20, 2024 · c6250bd · c6250bd
1 parent c8078f9
commit c6250bd
Show file tree

Hide file tree

Showing 9 changed files with 40 additions and 25 deletions.
diff --git a/async/src/alias.rs b/async/src/alias.rs
@@ -4,9 +4,9 @@ use crate::{
 };
 #[cfg(feature = "alloc")]
 use alloc::sync::Arc;
+use ringbuf::{storage::Array, SharedRb};
 #[cfg(feature = "alloc")]
 use ringbuf::{storage::Heap, HeapRb};
-use ringbuf::{storage::Static, SharedRb};
 
 #[cfg(feature = "alloc")]
 pub type AsyncHeapRb<T> = AsyncRb<Heap<T>>;
@@ -22,11 +22,11 @@ impl<T> AsyncHeapRb<T> {
  }
 }
 
-pub type AsyncStaticRb<T, const N: usize> = AsyncRb<Static<T, N>>;
+pub type AsyncStaticRb<T, const N: usize> = AsyncRb<Array<T, N>>;
 pub type AsyncStaticProd<'a, T, const N: usize> = AsyncProd<&'a AsyncStaticRb<T, N>>;
 pub type AsyncStaticCons<'a, T, const N: usize> = AsyncCons<&'a AsyncStaticRb<T, N>>;
 
-impl<T, const N: usize> Default for AsyncRb<Static<T, N>> {
+impl<T, const N: usize> Default for AsyncRb<Array<T, N>> {
  fn default() -> Self {
  AsyncRb::from(SharedRb::default())
  }

diff --git a/async/src/rb.rs b/async/src/rb.rs
@@ -54,9 +54,12 @@ impl<S: Storage> Observer for AsyncRb<S> {
  self.base.write_index()
  }
 
- unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<S::Item>], &mut [MaybeUninit<S::Item>]) {
+ unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&[MaybeUninit<S::Item>], &[MaybeUninit<S::Item>]) {
  self.base.unsafe_slices(start, end)
  }
+ unsafe fn unsafe_slices_mut(&self, start: usize, end: usize) -> (&mut [MaybeUninit<S::Item>], &mut [MaybeUninit<S::Item>]) {
+ self.base.unsafe_slices_mut(start, end)
+ }
 
  #[inline]
  fn read_is_held(&self) -> bool {

diff --git a/async/src/traits/consumer.rs b/async/src/traits/consumer.rs
@@ -96,7 +96,7 @@ pub trait AsyncConsumer: Consumer {
  }
 }
 
-pub struct PopFuture<'a, A: AsyncConsumer> {
+pub struct PopFuture<'a, A: AsyncConsumer + ?Sized> {
  owner: &'a mut A,
  done: bool,
 }
@@ -130,7 +130,7 @@ impl<'a, A: AsyncConsumer> Future for PopFuture<'a, A> {
  }
 }
 
-pub struct PopSliceFuture<'a, 'b, A: AsyncConsumer>
+pub struct PopSliceFuture<'a, 'b, A: AsyncConsumer + ?Sized>
 where
  A::Item: Copy,
 {
@@ -177,7 +177,7 @@ where
  }
 }
 
-pub struct WaitOccupiedFuture<'a, A: AsyncConsumer> {
+pub struct WaitOccupiedFuture<'a, A: AsyncConsumer + ?Sized> {
  owner: &'a A,
  count: usize,
  done: bool,

diff --git a/async/src/traits/producer.rs b/async/src/traits/producer.rs
@@ -110,7 +110,7 @@ pub trait AsyncProducer: Producer {
  }
 }
 
-pub struct PushFuture<'a, A: AsyncProducer> {
+pub struct PushFuture<'a, A: AsyncProducer + ?Sized> {
  owner: &'a mut A,
  item: Option<A::Item>,
 }
@@ -144,7 +144,7 @@ impl<'a, A: AsyncProducer> Future for PushFuture<'a, A> {
  }
 }
 
-pub struct PushSliceFuture<'a, 'b, A: AsyncProducer>
+pub struct PushSliceFuture<'a, 'b, A: AsyncProducer + ?Sized>
 where
  A::Item: Copy,
 {
@@ -190,7 +190,7 @@ where
  }
 }
 
-pub struct PushIterFuture<'a, A: AsyncProducer, I: Iterator<Item = A::Item>> {
+pub struct PushIterFuture<'a, A: AsyncProducer + ?Sized, I: Iterator<Item = A::Item>> {
  owner: &'a mut A,
  iter: Option<Peekable<I>>,
 }
@@ -224,7 +224,7 @@ impl<'a, A: AsyncProducer, I: Iterator<Item = A::Item>> Future for PushIterFutur
  }
 }
 
-pub struct WaitVacantFuture<'a, A: AsyncProducer> {
+pub struct WaitVacantFuture<'a, A: AsyncProducer + ?Sized> {
  owner: &'a A,
  count: usize,
  done: bool,

diff --git a/blocking/src/alias.rs b/blocking/src/alias.rs
@@ -1,9 +1,9 @@
 #[cfg(feature = "std")]
 use crate::sync::StdSemaphore;
 use crate::{rb::BlockingRb, sync::Semaphore};
+use ringbuf::{storage::Array, SharedRb};
 #[cfg(feature = "alloc")]
 use ringbuf::{storage::Heap, HeapRb};
-use ringbuf::{storage::Static, SharedRb};
 
 #[cfg(feature = "std")]
 pub type BlockingHeapRb<T, X = StdSemaphore> = BlockingRb<Heap<T>, X>;
@@ -18,11 +18,11 @@ impl<T, X: Semaphore> BlockingHeapRb<T, X> {
 }
 
 #[cfg(feature = "std")]
-pub type BlockingStaticRb<T, const N: usize, X = StdSemaphore> = BlockingRb<Static<T, N>, X>;
+pub type BlockingStaticRb<T, const N: usize, X = StdSemaphore> = BlockingRb<Array<T, N>, X>;
 #[cfg(all(feature = "alloc", not(feature = "std")))]
-pub type BlockingStaticRb<T, const N: usize, X> = BlockingRb<Static<T, N>, X>;
+pub type BlockingStaticRb<T, const N: usize, X> = BlockingRb<Array<T, N>, X>;
 
-impl<T, const N: usize, X: Semaphore> Default for BlockingRb<Static<T, N>, X> {
+impl<T, const N: usize, X: Semaphore> Default for BlockingRb<Array<T, N>, X> {
  fn default() -> Self {
  BlockingRb::from(SharedRb::default())
  }

diff --git a/blocking/src/rb.rs b/blocking/src/rb.rs
@@ -53,9 +53,12 @@ impl<S: Storage, X: Semaphore> Observer for BlockingRb<S, X> {
  self.base.write_index()
  }
 
- unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<S::Item>], &mut [MaybeUninit<S::Item>]) {
+ unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&[MaybeUninit<S::Item>], &[MaybeUninit<S::Item>]) {
  self.base.unsafe_slices(start, end)
  }
+ unsafe fn unsafe_slices_mut(&self, start: usize, end: usize) -> (&mut [MaybeUninit<S::Item>], &mut [MaybeUninit<S::Item>]) {
+ self.base.unsafe_slices_mut(start, end)
+ }
 
  #[inline]
  fn read_is_held(&self) -> bool {

diff --git a/src/benchmarks/base.rs b/src/benchmarks/base.rs
@@ -1,12 +1,12 @@
-use crate::{storage::Static, traits::*, LocalRb, SharedRb};
+use crate::{storage::Array, traits::*, LocalRb, SharedRb};
 use test::{black_box, Bencher};
 
 const RB_SIZE: usize = 256;
 const BATCH_SIZE: usize = 100;
 
 #[bench]
 fn push_pop_shared(b: &mut Bencher) {
- let buf = SharedRb::<Static<u64, RB_SIZE>>::default();
+ let buf = SharedRb::<Array<u64, RB_SIZE>>::default();
  let (mut prod, mut cons) = buf.split();
  prod.push_slice(&[1; RB_SIZE / 2]);
  b.iter(|| {
@@ -17,7 +17,7 @@ fn push_pop_shared(b: &mut Bencher) {
 
 #[bench]
 fn push_pop_local(b: &mut Bencher) {
- let buf = LocalRb::<Static<u64, RB_SIZE>>::default();
+ let buf = LocalRb::<Array<u64, RB_SIZE>>::default();
  let (mut prod, mut cons) = buf.split();
  prod.push_slice(&[1; RB_SIZE / 2]);
  b.iter(|| {
@@ -28,7 +28,7 @@ fn push_pop_local(b: &mut Bencher) {
 
 #[bench]
 fn push_pop_x100(b: &mut Bencher) {
- let buf = SharedRb::<Static<u64, RB_SIZE>>::default();
+ let buf = SharedRb::<Array<u64, RB_SIZE>>::default();
  let (mut prod, mut cons) = buf.split();
  prod.push_slice(&[1; RB_SIZE / 2]);
  b.iter(|| {

diff --git a/src/benchmarks/parts.rs b/src/benchmarks/parts.rs
@@ -1,11 +1,11 @@
-use crate::{storage::Static, traits::*, SharedRb};
+use crate::{storage::Array, traits::*, SharedRb};
 use test::{black_box, Bencher};
 
 const RB_SIZE: usize = 256;
 
 #[bench]
 fn advance(b: &mut Bencher) {
- let buf = SharedRb::<Static<u64, RB_SIZE>>::default();
+ let buf = SharedRb::<Array<u64, RB_SIZE>>::default();
  let (mut prod, cons) = buf.split();
  prod.push_slice(&[1; RB_SIZE / 2]);
  b.iter(|| {
@@ -16,7 +16,7 @@ fn advance(b: &mut Bencher) {
 
 #[bench]
 fn get_occupied_slices(b: &mut Bencher) {
- let buf = SharedRb::<Static<u64, RB_SIZE>>::default();
+ let buf = SharedRb::<Array<u64, RB_SIZE>>::default();
  let (mut prod, mut cons) = buf.split();
  prod.push_slice(&[0; 3 * RB_SIZE / 4]);
  cons.skip(RB_SIZE);
@@ -29,7 +29,7 @@ fn get_occupied_slices(b: &mut Bencher) {
 
 #[bench]
 fn get_vacant_slices(b: &mut Bencher) {
- let buf = SharedRb::<Static<u64, RB_SIZE>>::default();
+ let buf = SharedRb::<Array<u64, RB_SIZE>>::default();
  let (mut prod, mut cons) = buf.split();
  prod.push_slice(&[0; 1 * RB_SIZE / 4]);
  cons.skip(RB_SIZE);

diff --git a/src/storage.rs b/src/storage.rs
@@ -1,6 +1,8 @@
 #[cfg(feature = "alloc")]
 use alloc::{boxed::Box, vec::Vec};
-use core::{cell::UnsafeCell, marker::PhantomData, mem::MaybeUninit, ops::Range, ptr, ptr::NonNull, slice};
+#[cfg(feature = "alloc")]
+use core::ptr;
+use core::{cell::UnsafeCell, marker::PhantomData, mem::MaybeUninit, ops::Range, ptr::NonNull, slice};
 
 /// Abstract storage for the ring buffer.
 ///
@@ -128,12 +130,16 @@ unsafe impl<T> Storage for Slice<T> {
  }
 }
 
+#[cfg(feature = "alloc")]
 pub struct Heap<T> {
  ptr: *mut MaybeUninit<T>,
  len: usize,
 }
+#[cfg(feature = "alloc")]
 unsafe impl<T> Send for Heap<T> where T: Send {}
+#[cfg(feature = "alloc")]
 unsafe impl<T> Sync for Heap<T> where T: Sync {}
+#[cfg(feature = "alloc")]
 unsafe impl<T> Storage for Heap<T> {
  type Item = T;
  #[inline]
@@ -154,6 +160,7 @@ impl<T> Heap<T> {
  }
  }
 }
+#[cfg(feature = "alloc")]
 impl<T> From<Box<[MaybeUninit<T>]>> for Heap<T> {
  fn from(value: Box<[MaybeUninit<T>]>) -> Self {
  Self {
@@ -162,11 +169,13 @@ impl<T> From<Box<[MaybeUninit<T>]>> for Heap<T> {
  }
  }
 }
+#[cfg(feature = "alloc")]
 impl<T> From<Heap<T>> for Box<[MaybeUninit<T>]> {
  fn from(value: Heap<T>) -> Self {
  unsafe { Box::from_raw(ptr::slice_from_raw_parts_mut(value.ptr, value.len)) }
  }
 }
+#[cfg(feature = "alloc")]
 impl<T> Drop for Heap<T> {
  fn drop(&mut self) {
  drop(unsafe { Box::from_raw(ptr::slice_from_raw_parts_mut(self.ptr, self.len)) });