Change Region to require [MaybeUninit<u8>] rather than [u8]

Closes #11

Author: TimDiekmann

CHANGELOG.md

@@ -1,7 +1,9 @@
 ## [v0.5](https://timdiekmann.github.io/alloc-compose/alloc_compose/index.html) (Unreleased)
 
-- **Breaking Change** Add `AllocAll` trait and move some methods from `Region` into that trait
-- **Breaking Change** Remove `MemoryMarker`
+**Breaking Changes:** 
+- Add `AllocAll` trait and move some methods from `Region` into that trait
+- Change `Region` to require `[MaybeUninit<u8>]` rather than `[u8]`
+- Remove `MemoryMarker`
 
 ## [v0.4](https://docs.rs/alloc-compose/0.4)
 

src/affix.rs

@@ -546,7 +546,7 @@ mod tests {
                 Affix::<System, Prefix, Suffix>::prefix(memory.ptr, layout).as_ref(),
                 &prefix
             );
-            assert_eq!(memory.as_slice(), &vec![0_u8; memory.size][..]);
+            assert_eq!(MaybeUninit::slice_get_ref(memory.as_slice()), &vec![0_u8; memory.size][..]);
             assert_eq!(
                 Affix::<System, Prefix, Suffix>::suffix(memory.ptr, layout).as_ref(),
                 &suffix
@@ -569,7 +569,7 @@ mod tests {
                 &prefix
             );
             assert_eq!(
-                growed_memory.as_slice(),
+                MaybeUninit::slice_get_ref(growed_memory.as_slice()),
                 &vec![0_u8; growed_memory.size][..]
             );
             assert_eq!(
@@ -590,7 +590,7 @@ mod tests {
                 Affix::<System, Prefix, Suffix>::prefix(memory.ptr, layout).as_ref(),
                 &prefix
             );
-            assert_eq!(memory.as_slice(), &vec![0_u8; memory.size][..]);
+            assert_eq!(MaybeUninit::slice_get_ref(memory.as_slice()), &vec![0_u8; memory.size][..]);
             assert_eq!(
                 Affix::<System, Prefix, Suffix>::suffix(memory.ptr, layout).as_ref(),
                 &suffix

src/fallback.rs

@@ -23,8 +23,9 @@ use core::{
 ///
 /// use alloc_compose::{Fallback, Owns, Region};
 /// use std::alloc::{AllocInit, AllocRef, Layout, System};
+/// use std::mem::MaybeUninit;
 ///
-/// let mut data = [0; 32];
+/// let mut data = [MaybeUninit::new(0); 32];
 /// let mut alloc = Fallback {
 ///     primary: Region::new(&mut data),
 ///     secondary: System,
@@ -137,10 +138,11 @@ mod tests {
     use super::Fallback;
     use crate::{helper, Owns, Region};
     use std::alloc::{AllocInit, AllocRef, Layout, ReallocPlacement, System};
+    use std::mem::MaybeUninit;
 
     #[test]
     fn alloc() {
-        let mut data = [0; 32];
+        let mut data = [MaybeUninit::new(0); 32];
         let mut alloc = Fallback {
             primary: helper::tracker(Region::new(&mut data)),
             secondary: helper::tracker(System),
@@ -163,7 +165,7 @@ mod tests {
 
     #[test]
     fn grow() {
-        let mut data = [0; 80];
+        let mut data = [MaybeUninit::new(0); 80];
         let mut alloc = Fallback {
             primary: helper::tracker(Region::new(&mut data)),
             secondary: helper::tracker(System),
@@ -226,7 +228,7 @@ mod tests {
 
     #[test]
     fn shrink() {
-        let mut data = [0; 80];
+        let mut data = [MaybeUninit::new(0); 80];
         let mut alloc = Fallback {
             primary: helper::tracker(Region::new(&mut data)),
             secondary: helper::tracker(System),
@@ -275,8 +277,8 @@ mod tests {
 
     #[test]
     fn owns() {
-        let mut data_1 = [0; 32];
-        let mut data_2 = [0; 64];
+        let mut data_1 = [MaybeUninit::new(0); 32];
+        let mut data_2 = [MaybeUninit::new(0); 64];
         let mut alloc = Fallback {
             primary: Region::new(&mut data_1),
             secondary: Region::new(&mut data_2),

src/lib.rs

@@ -1,6 +1,7 @@
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(doc, feature(doc_cfg, external_doc))]
 #![cfg_attr(feature = "intrinsics", feature(core_intrinsics))]
+#![cfg_attr(test, feature(maybe_uninit_slice_assume_init))]
 #![cfg_attr(doc, doc(include = "../README.md"))]
 #![feature(
     allocator_api,
@@ -157,6 +158,7 @@ pub(crate) mod helper {
     use std::{
         alloc::{AllocErr, AllocInit, AllocRef, Layout, MemoryBlock, ReallocPlacement, System},
         collections::HashMap,
+        mem::MaybeUninit,
         ptr::NonNull,
         slice,
         sync::{Mutex, PoisonError},
@@ -320,16 +322,16 @@ pub(crate) mod helper {
     }
 
     pub trait AsSlice {
-        unsafe fn as_slice<'a>(self) -> &'a [u8];
-        unsafe fn as_slice_mut<'a>(self) -> &'a mut [u8];
+        unsafe fn as_slice<'a>(self) -> &'a [MaybeUninit<u8>];
+        unsafe fn as_slice_mut<'a>(self) -> &'a mut [MaybeUninit<u8>];
     }
 
     impl AsSlice for MemoryBlock {
-        unsafe fn as_slice<'a>(self) -> &'a [u8] {
-            slice::from_raw_parts(self.ptr.as_ptr(), self.size)
+        unsafe fn as_slice<'a>(self) -> &'a [MaybeUninit<u8>] {
+            slice::from_raw_parts(self.ptr.cast().as_ptr(), self.size)
         }
-        unsafe fn as_slice_mut<'a>(self) -> &'a mut [u8] {
-            slice::from_raw_parts_mut(self.ptr.as_ptr(), self.size)
+        unsafe fn as_slice_mut<'a>(self) -> &'a mut [MaybeUninit<u8>] {
+            slice::from_raw_parts_mut(self.ptr.cast().as_ptr(), self.size)
         }
     }
 

src/proxy.rs

@@ -44,9 +44,10 @@ use core::{
 ///     stats::{AllocInitFilter, ResultFilter},
 ///     Region,
 /// };
+/// use core::mem::MaybeUninit;
 ///
 /// let counter = stats::FilteredCounter::default();
-/// let mut data = [0; 32];
+/// let mut data = [MaybeUninit::new(0); 32];
 /// let mut alloc = Proxy {
 ///     alloc: Region::new(&mut data),
 ///     callbacks: counter.by_ref(),

src/region.rs

@@ -2,6 +2,7 @@ use crate::{unlikely, AllocAll, Owns};
 use core::{
     alloc::{AllocErr, AllocInit, AllocRef, Layout, MemoryBlock, ReallocPlacement},
     fmt,
+    mem::MaybeUninit,
     ptr::{self, NonNull},
 };
 
@@ -14,8 +15,9 @@ use core::{
 ///
 /// use alloc_compose::{Owns, Region};
 /// use core::alloc::{AllocInit, AllocRef, Layout};
+/// use core::mem::MaybeUninit;
 ///
-/// let mut data = [0; 64];
+/// let mut data = [MaybeUninit::new(0); 64];
 /// let mut region = Region::new(&mut data);
 ///
 /// let memory = region.alloc(Layout::new::<u32>(), AllocInit::Uninitialized)?;
@@ -27,22 +29,22 @@ use core::{
 /// ```rust
 /// # #![feature(allocator_api)]
 /// # use alloc_compose::{Owns, Region};
-/// # use core::alloc::{AllocInit, AllocRef, Layout};
-/// # let mut data = [0; 64];
+/// # use core::{alloc::{AllocInit, AllocRef, Layout}, mem::MaybeUninit};
+/// # let mut data = [MaybeUninit::new(0); 64];
 /// # let mut region = Region::new(&mut data);
 /// # let memory = region.alloc(Layout::new::<u32>(), AllocInit::Uninitialized)?;
 /// unsafe { region.dealloc(memory.ptr, Layout::new::<u32>()) };
 /// assert!(!region.owns(memory));
 /// # Ok::<(), core::alloc::AllocErr>(())
 /// ```
 pub struct Region<'a> {
-    data: &'a mut [u8],
+    data: &'a mut [MaybeUninit<u8>],
     ptr: usize,
 }
 
 impl<'a> Region<'a> {
     #[inline]
-    pub fn new(data: &'a mut [u8]) -> Self {
+    pub fn new(data: &'a mut [MaybeUninit<u8>]) -> Self {
         let ptr = data.as_ptr() as usize + data.len();
         let region = Self { data, ptr };
         debug_assert!(region.is_empty());
@@ -252,23 +254,43 @@ mod tests {
 
     #[test]
     fn alloc_zero() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
 
         assert_eq!(region.capacity(), 32);
         assert!(region.is_empty());
 
         region
-            .alloc(Layout::new::<[u8; 0]>(), AllocInit::Zeroed)
+            .alloc(Layout::new::<[u8; 0]>(), AllocInit::Uninitialized)
             .expect("Could not allocated 0 bytes");
         assert!(region.is_empty());
 
-        assert_eq!(data, [1; 32]);
+        unsafe {
+            assert_eq!(MaybeUninit::slice_get_ref(&data), &[1; 32][..]);
+        }
+    }
+
+    #[test]
+    fn alloc_zeroed() {
+        let mut data = [MaybeUninit::new(1); 32];
+        let mut region = Region::new(&mut data);
+
+        assert_eq!(region.capacity(), 32);
+        assert!(region.is_empty());
+
+        region
+            .alloc(Layout::new::<[u8; 32]>(), AllocInit::Zeroed)
+            .expect("Could not allocated 32 bytes");
+        assert!(!region.is_empty());
+
+        unsafe {
+            assert_eq!(MaybeUninit::slice_get_ref(&data), &[0; 32][..]);
+        }
     }
 
     #[test]
     fn alloc_all() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
 
         assert_eq!(region.capacity(), 32);
@@ -299,7 +321,7 @@ mod tests {
 
     #[test]
     fn alloc_small() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
 
         assert_eq!(region.capacity(), 32);
@@ -310,39 +332,30 @@ mod tests {
             .expect("Could not allocated 16 bytes");
         assert_eq!(region.capacity_left(), 16);
 
-        assert_eq!(&data[0..16], &[1; 16][..]);
-        assert_eq!(&data[16..], &[0; 16][..]);
-    }
-
-    #[test]
-    fn alloc_full() {
-        let mut data = [1; 32];
-        let mut region = Region::new(&mut data);
-
-        region
-            .alloc(Layout::new::<[u8; 32]>(), AllocInit::Zeroed)
-            .expect("Could not allocated 32 bytes");
-        assert_eq!(region.capacity_left(), 0);
-
-        assert_eq!(data, [0; 32]);
+        unsafe {
+            assert_eq!(MaybeUninit::slice_get_ref(&data[0..16]), &[1; 16][..]);
+            assert_eq!(MaybeUninit::slice_get_ref(&data[16..]), &[0; 16][..]);
+        }
     }
 
     #[test]
     fn alloc_uninitialzed() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
 
         region
             .alloc(Layout::new::<[u8; 32]>(), AllocInit::Uninitialized)
             .expect("Could not allocated 32 bytes");
         assert_eq!(region.capacity_left(), 0);
 
-        assert_eq!(data, [1; 32]);
+        unsafe {
+            assert_eq!(MaybeUninit::slice_get_ref(&data), &[1; 32][..]);
+        }
     }
 
     #[test]
     fn alloc_fail() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
 
         region
@@ -380,7 +393,7 @@ mod tests {
 
     #[test]
     fn dealloc() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
         let layout = Layout::from_size_align(8, 1).expect("Invalid layout");
 
@@ -417,7 +430,7 @@ mod tests {
 
     #[test]
     fn realloc() {
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
         let layout = Layout::from_size_align(8, 1).expect("Invalid layout");
 
@@ -479,7 +492,7 @@ mod tests {
             )
         };
 
-        let mut data = [1; 32];
+        let mut data = [MaybeUninit::new(1); 32];
         let mut region = Region::new(&mut data);
         test_output(&region);
 

src/stats.rs

@@ -626,10 +626,11 @@ mod tests {
     use super::{AtomicCounter, Counter, FilteredAtomicCounter, FilteredCounter};
     use crate::{helper, CallbackRef, Owns, Proxy, Region};
     use std::alloc::{AllocInit, AllocRef, Layout, ReallocPlacement};
+    use std::mem::MaybeUninit;
 
     #[allow(clippy::too_many_lines)]
     fn run_suite(callbacks: &impl CallbackRef) {
-        let mut region = [0; 32];
+        let mut region = [MaybeUninit::new(0); 32];
         let mut alloc = Proxy {
             alloc: helper::tracker(Region::new(&mut region)),
             callbacks,