Complete new storage

Author: agerasev

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())
     }

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 {

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,

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,

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())
     }

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 {

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(|| {

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);

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)) });