CoAlloc: Moved CoAllocMeta to both Allocator and GlobalAlloc.

Author: peter-lyons-kehl

library/alloc/src/raw_vec.rs

@@ -1,6 +1,6 @@
 #![unstable(feature = "raw_vec_internals", reason = "unstable const warnings", issue = "none")]
 
-use core::alloc::{self, GlobalCoAllocMeta, LayoutError, PtrAndMeta};
+use core::alloc::{self, LayoutError, PtrAndMeta};
 use core::cmp;
 use core::intrinsics;
 use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
@@ -62,7 +62,7 @@ where
     //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::<A>()==core::any::TypeId::of::<Global>() {1} else {0}}],
     //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::<A::IsCoAllocator>()],
     pub(crate) metas:
-        [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREF)],
+        [A::CoAllocMeta; alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREF)],
 }
 
 impl<T, const COOP_PREF: bool> RawVec<T, Global, COOP_PREF>
@@ -136,11 +136,12 @@ where
     /// the returned `RawVec`.
     pub const fn new_in(alloc: A) -> Self {
         // `cap: 0` means "unallocated". zero-sized types are ignored.
+        #[allow(unreachable_code)] // @FIXME CoAlloc
         Self {
             ptr: Unique::dangling(),
             cap: 0,
             alloc,
-            metas: [GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/};
+            metas: [loop {}; // @FIXME CoAlloc
                 alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREF)],
         }
     }
@@ -215,11 +216,12 @@ where
             // Allocators currently return a `NonNull<[u8]>` whose length
             // matches the size requested. If that ever changes, the capacity
             // here should change to `ptr.len() / mem::size_of::<T>()`.
+            #[allow(unreachable_code)] // @FIXME CoAlloc
             Self {
                 ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) },
                 cap: capacity,
                 alloc,
-                metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/};
+                metas: [loop {}; // @FIXME CoAlloc
                     alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREF)],
             }
         }
@@ -237,11 +239,12 @@ where
     /// guaranteed.
     #[inline]
     pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, alloc: A) -> Self {
+        #[allow(unreachable_code)] //@FIXME CoAlloc
         Self {
             ptr: unsafe { Unique::new_unchecked(ptr) },
             cap: capacity,
             alloc,
-            metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/};
+            metas: [loop {}; //@FIXME CoAlloc
                 alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREF)],
         }
     }

library/core/src/alloc/global.rs

@@ -1,14 +1,13 @@
-use crate::alloc::GlobalCoAllocMeta;
 use crate::alloc::Layout;
 use crate::cmp;
 use crate::ptr;
 
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[allow(missing_debug_implementations)]
 /// Used for parameters and results (to/from `GlobalCoAllocator`'s functions, where applicable).
-pub struct RawAndMeta {
+pub struct RawAndMeta<M: Clone + Copy> {
     pub ptr: *mut u8,
-    pub meta: GlobalCoAllocMeta,
+    pub meta: M,
 }
 
 /// A memory allocator that can be registered as the standard library’s default
@@ -130,6 +129,11 @@ pub struct RawAndMeta {
 ///   having side effects.
 #[stable(feature = "global_alloc", since = "1.28.0")]
 pub unsafe trait GlobalAlloc {
+    /// @FIXME Validate (preferrable at compile time, otherwise as a test) that this type's
+    /// alignment <= `usize` alignment.
+    #[unstable(feature = "global_co_alloc_meta", issue = "none")]
+    type CoAllocMeta: Clone + Copy = ();
+
     /// Allocate memory as described by the given `layout`.
     ///
     /// Returns a pointer to newly-allocated memory,
@@ -166,7 +170,7 @@ pub unsafe trait GlobalAlloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8;
 
     #[unstable(feature = "global_co_alloc", issue = "none")]
-    unsafe fn co_alloc(&self, _layout: Layout, mut _result: &mut RawAndMeta) {
+    unsafe fn co_alloc(&self, _layout: Layout, mut _result: &mut RawAndMeta<Self::CoAllocMeta>) {
         panic!("@FIXME")
     }
 
@@ -186,7 +190,7 @@ pub unsafe trait GlobalAlloc {
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
 
     #[unstable(feature = "global_co_alloc", issue = "none")]
-    unsafe fn co_dealloc(&self, _ptr_and_meta: RawAndMeta, _layout: Layout) {
+    unsafe fn co_dealloc(&self, _ptr_and_meta: RawAndMeta<Self::CoAllocMeta>, _layout: Layout) {
         panic!("@FIXME")
     }
 
@@ -223,7 +227,11 @@ pub unsafe trait GlobalAlloc {
     }
 
     #[unstable(feature = "global_co_alloc", issue = "none")]
-    unsafe fn co_alloc_zeroed(&self, layout: Layout, mut result: &mut RawAndMeta) {
+    unsafe fn co_alloc_zeroed(
+        &self,
+        layout: Layout,
+        mut result: &mut RawAndMeta<Self::CoAllocMeta>,
+    ) {
         let size = layout.size();
         // SAFETY: the safety contract for `alloc` must be upheld by the caller.
         unsafe { self.co_alloc(layout, &mut result) };
@@ -310,10 +318,10 @@ pub unsafe trait GlobalAlloc {
     #[unstable(feature = "global_co_alloc", issue = "none")]
     unsafe fn co_realloc(
         &self,
-        ptr_and_meta: RawAndMeta,
+        ptr_and_meta: RawAndMeta<Self::CoAllocMeta>,
         layout: Layout,
         new_size: usize,
-        mut result: &mut RawAndMeta,
+        mut result: &mut RawAndMeta<Self::CoAllocMeta>,
     ) {
         // SAFETY: the caller must ensure that the `new_size` does not overflow.
         // `layout.align()` comes from a `Layout` and is thus guaranteed to be valid.

library/core/src/alloc/mod.rs

@@ -25,23 +25,6 @@ use crate::error::Error;
 use crate::fmt;
 use crate::ptr::{self, NonNull};
 
-// @FIXME Make this target-specific
-/// Metadata for `Vec/VecDeque/RawVec` to assist the allocator. Make sure its
-/// alignment is not bigger than alignment of `usize`. Otherwise, even if (a
-/// particular) `Vec/VecDeque/RawVec` generic instance doesn't use cooperation,
-/// it would increase size of that `Vec/VecDeque/RawVec` because of alignment
-/// rules! @FIXME compile time test that `GlobalCoAllocMeta` alignment <=
-/// `usize` alignment.
-#[unstable(feature = "global_co_alloc_meta", issue = "none")]
-#[allow(missing_debug_implementations)]
-#[derive(Clone, Copy)]
-pub struct GlobalCoAllocMeta {
-    //pub one: usize,
-    /*pub two: usize,
-    pub three: usize,
-    pub four: usize,*/
-}
-
 /// The `AllocError` error indicates an allocation failure
 /// that may be due to resource exhaustion or to
 /// something wrong when combining the given input arguments with this
@@ -68,18 +51,20 @@ impl fmt::Display for AllocError {
 /// (Non-Null) Pointer and coallocation metadata.
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[allow(missing_debug_implementations)]
-pub struct PtrAndMeta {
+#[derive(Clone, Copy)]
+pub struct PtrAndMeta<M: Clone + Copy> {
     pub ptr: NonNull<u8>,
-    pub meta: GlobalCoAllocMeta,
+    pub meta: M,
 }
 
 /// (NonNull) Slice and coallocation metadata.
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[allow(missing_debug_implementations)]
+#[derive(Clone, Copy)]
 /// Used for results (from `CoAllocator`'s functions, where applicable).
-pub struct SliceAndMeta {
+pub struct SliceAndMeta<M: Clone + Copy> {
     pub slice: NonNull<[u8]>,
-    pub meta: GlobalCoAllocMeta,
+    pub meta: M,
 }
 
 #[unstable(feature = "global_co_alloc_short_term_pref", issue = "none")]
@@ -94,8 +79,9 @@ macro_rules! SHORT_TERM_VEC_PREFERS_COOP {
 /// `Result` of `SliceAndMeta` or `AllocError`.
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[allow(missing_debug_implementations)]
-pub type SliceAndMetaResult = Result<SliceAndMeta, AllocError>;
+pub type SliceAndMetaResult<M> = Result<SliceAndMeta<M>, AllocError>;
 
+// @FIXME REMOVE
 /// Return 0 or 1, indicating whether to use coallocation metadata or not.
 /// Param `coop_preferred` - if false, then this returns `0`, regardless of
 /// whether allocator `A` is cooperative.
@@ -172,6 +158,8 @@ pub unsafe trait Allocator {
     // It applies to the global (default) allocator only. And/or System allocator?! @FIXME
     const CO_ALLOCATES_WITH_META: bool = false;
 
+    /// @FIXME Validate (preferrable at compile time, otherwise as a test) that this type's
+    /// alignment <= `usize` alignment.
     type CoAllocMeta: Clone + Copy = ();
 
     /// Attempts to allocate a block of memory.
@@ -196,7 +184,7 @@ pub unsafe trait Allocator {
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
 
-    fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {
+    fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult<Self::CoAllocMeta>) {
         panic!("FIXME")
     }
 
@@ -222,7 +210,11 @@ pub unsafe trait Allocator {
         Ok(ptr)
     }
 
-    fn co_allocate_zeroed(&self, layout: Layout, mut result: &mut SliceAndMetaResult) {
+    fn co_allocate_zeroed(
+        &self,
+        layout: Layout,
+        mut result: &mut SliceAndMetaResult<Self::CoAllocMeta>,
+    ) {
         self.co_allocate(layout, &mut result);
         if let Ok(SliceAndMeta { slice, .. }) = result {
             // SAFETY: `alloc` returns a valid memory block
@@ -241,7 +233,7 @@ pub unsafe trait Allocator {
     /// [*fit*]: #memory-fitting
     unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
 
-    unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {
+    unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta<Self::CoAllocMeta>, _layout: Layout) {
         panic!("FIXME")
     }
 
@@ -311,10 +303,10 @@ pub unsafe trait Allocator {
 
     unsafe fn co_grow(
         &self,
-        ptr_and_meta: PtrAndMeta,
+        ptr_and_meta: PtrAndMeta<Self::CoAllocMeta>,
         old_layout: Layout,
         new_layout: Layout,
-        mut result: &mut SliceAndMetaResult,
+        mut result: &mut SliceAndMetaResult<Self::CoAllocMeta>,
     ) {
         debug_assert!(
             new_layout.size() >= old_layout.size(),
@@ -405,10 +397,10 @@ pub unsafe trait Allocator {
 
     unsafe fn co_grow_zeroed(
         &self,
-        ptr_and_meta: PtrAndMeta,
+        ptr_and_meta: PtrAndMeta<Self::CoAllocMeta>,
         old_layout: Layout,
         new_layout: Layout,
-        mut result: &mut SliceAndMetaResult,
+        mut result: &mut SliceAndMetaResult<Self::CoAllocMeta>,
     ) {
         debug_assert!(
             new_layout.size() >= old_layout.size(),
@@ -500,10 +492,10 @@ pub unsafe trait Allocator {
 
     unsafe fn co_shrink(
         &self,
-        ptr_and_meta: PtrAndMeta,
+        ptr_and_meta: PtrAndMeta<Self::CoAllocMeta>,
         old_layout: Layout,
         new_layout: Layout,
-        mut result: &mut SliceAndMetaResult,
+        mut result: &mut SliceAndMetaResult<Self::CoAllocMeta>,
     ) {
         debug_assert!(
             new_layout.size() <= old_layout.size(),