CoAlloc: library/alloc now uses macros, and no ICE. But meta_num_slots macro is hardcoded - TO FIX.

Author: peter-lyons-kehl

library/alloc/src/boxed.rs

@@ -643,7 +643,7 @@ impl<T> Box<[T]> {
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        unsafe { RawVec::<T, Global, false>::with_capacity(len).into_box(len) }
+        unsafe { RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::with_capacity(len).into_box(len) }
     }
 
     /// Constructs a new boxed slice with uninitialized contents, with the memory
@@ -669,7 +669,7 @@ impl<T> Box<[T]> {
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        unsafe { RawVec::<T, Global, false>::with_capacity_zeroed(len).into_box(len) }
+        unsafe { RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::with_capacity_zeroed(len).into_box(len) }
     }
 
     /// Constructs a new boxed slice with uninitialized contents. Returns an error if
@@ -701,7 +701,7 @@ impl<T> Box<[T]> {
                 Err(_) => return Err(AllocError),
             };
             let ptr = Global.allocate(layout)?;
-            Ok(RawVec::<T, Global, false>::from_raw_parts_in(
+            Ok(RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::from_raw_parts_in(
                 ptr.as_mut_ptr() as *mut _,
                 len,
                 Global,
@@ -738,7 +738,7 @@ impl<T> Box<[T]> {
                 Err(_) => return Err(AllocError),
             };
             let ptr = Global.allocate_zeroed(layout)?;
-            Ok(RawVec::<T, Global, false>::from_raw_parts_in(
+            Ok(RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::from_raw_parts_in(
                 ptr.as_mut_ptr() as *mut _,
                 len,
                 Global,
@@ -781,7 +781,7 @@ where
     #[must_use]
     #[allow(unused_braces)]
     pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
-        unsafe { RawVec::<T, A, false>::with_capacity_in(len, alloc).into_box(len) }
+        unsafe { RawVec::<T, A, {CO_ALLOC_PREF_META_NO!()}>::with_capacity_in(len, alloc).into_box(len) }
     }
 
     /// Constructs a new boxed slice with uninitialized contents in the provided allocator,
@@ -810,7 +810,7 @@ where
     #[must_use]
     #[allow(unused_braces)]
     pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
-        unsafe { RawVec::<T, A, false>::with_capacity_zeroed_in(len, alloc).into_box(len) }
+        unsafe { RawVec::<T, A, {CO_ALLOC_PREF_META_NO!()}>::with_capacity_zeroed_in(len, alloc).into_box(len) }
     }
 }
 
@@ -1516,7 +1516,7 @@ impl<T: Copy> From<&[T]> for Box<[T]> {
     fn from(slice: &[T]) -> Box<[T]> {
         let len = slice.len();
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        let buf = RawVec::<T, Global, false>::with_capacity(len);
+        let buf = RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::with_capacity(len);
         unsafe {
             ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
             buf.into_box(slice.len()).assume_init()
@@ -2051,7 +2051,7 @@ where
     fn clone(&self) -> Self {
         let alloc = Box::allocator(self).clone();
         // false = no need for co-alloc metadata, since it would get lost once converted to the boxed slice.
-        self.to_vec_in::<A, false>(alloc).into_boxed_slice()
+        self.to_vec_in::<A, {CO_ALLOC_PREF_META_NO!()}>(alloc).into_boxed_slice()
     }
 
     fn clone_from(&mut self, other: &Self) {

library/alloc/src/macros.rs

@@ -127,7 +127,7 @@ macro_rules! __rust_force_expr {
 
 // ----- CoAlloc constant-like macros:
 
-// @FIXME Docs
+/// Coallocation option/parameter about using metadata that does prefer to use meta data. This is of type [::alloc::co_alloc::CoAllocMetaNumSlotsPref] (but not a whole []::alloc::co_alloc::CoAllocPref]).
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[macro_export]
 macro_rules! CO_ALLOC_PREF_NUM_META_SLOTS_ONE {
@@ -136,7 +136,7 @@ macro_rules! CO_ALLOC_PREF_NUM_META_SLOTS_ONE {
     };
 }
 
-// @FIXME Docs
+/// Coallocation option/parameter about using metadata that prefers NOT to use meta data. This is of type [::alloc::co_alloc::CoAllocMetaNumSlotsPref] (but not a whole []::alloc::co_alloc::CoAllocPref]).
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[macro_export]
 macro_rules! CO_ALLOC_PREF_NUM_META_SLOTS_ZERO {
@@ -145,7 +145,7 @@ macro_rules! CO_ALLOC_PREF_NUM_META_SLOTS_ZERO {
     };
 }
 
-// @FIXME Docs
+/// Default coallocation option/parameter about using metadata (whether to use meta data, or not). This is of type [::alloc::co_alloc::CoAllocMetaNumSlotsPref] (but not a whole []::alloc::co_alloc::CoAllocPref]).
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[macro_export]
 macro_rules! CO_ALLOC_PREF_NUM_META_SLOTS_DEFAULT {
@@ -213,7 +213,7 @@ macro_rules! CO_ALLOC_PREF_DEFAULT {
     () => { $crate::CO_ALLOC_PREF_META_DEFAULT!() };
 }
 
-// @FIXME Move to library/alloc - if possible:
+/// Coallocation preference for (internal) short term vectors.
 #[unstable(feature = "global_co_alloc", issue = "none")]
 //pub const SHORT_TERM_VEC_CO_ALLOC_PREF: bool = true;
 #[macro_export]

library/alloc/src/raw_vec.rs

@@ -127,6 +127,7 @@ impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> RawVec<T, A, CO_ALLOC_PR
 where
     [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
+    #[allow(dead_code)]
     const fn new_plain_metas() -> [A::CoAllocMeta; { meta_num_slots_default!(A) }] {
         loop {}
     }
@@ -531,7 +532,9 @@ where
     /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
     default fn drop(&mut self) {
         if let Some((ptr, layout)) = self.current_memory() {
-            if A::CO_ALLOCATES_WITH_META && CO_ALLOC_PREF {
+            let meta_num_slots = crate::meta_num_slots!(A, CO_ALLOC_PREF);
+            if  meta_num_slots!=0 {
+                debug_assert!(meta_num_slots==1, "Number of coallocation meta slots can be only 0 or 1, but it is {}!", meta_num_slots);
                 let meta = self.metas[0];
                 unsafe { self.alloc.co_deallocate(PtrAndMeta { ptr, meta }, layout) }
             } else {

library/alloc/src/vec/in_place_drop.rs

@@ -36,6 +36,6 @@ impl<T> Drop for InPlaceDstBufDrop<T> {
     #[inline]
     fn drop(&mut self) {
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        unsafe { super::Vec::<T, Global, false>::from_raw_parts(self.ptr, self.len, self.cap) };
+        unsafe { super::Vec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::from_raw_parts(self.ptr, self.len, self.cap) };
     }
 }

library/alloc/src/vec/into_iter.rs

@@ -134,14 +134,16 @@ where
         // this creates less assembly
         self.cap = 0;
         self.buf = unsafe {
-            // @FIXME The below if CO_ALLOC_PREF {..} else {..}
-            // branching exists, because the following fails. Otherwise we'd have a snowball effect of wide spread of where...Global...
+            // @FIXME The below if .. {..} else {..}
+            // branching exists, because the following fails. Otherwise we'd have a snowball effect of wide spread of where...Global... bounds.
             //
-            // NonNull::new_unchecked(RawVec::<T, Global, CO_ALLOC_PREF>::NEW.ptr())
-            if CO_ALLOC_PREF {
-                NonNull::new_unchecked(RawVec::<T, Global, true>::NEW.ptr())
+            //NonNull::new_unchecked(RawVec::<T, Global, CO_ALLOC_PREF>::NEW.ptr());
+            let meta_num_slots = crate::meta_num_slots!(A, CO_ALLOC_PREF);
+            if  meta_num_slots>0 {
+                debug_assert!(meta_num_slots==1, "Number of coallocation meta slots can be only 0 or 1, but it is {}!", meta_num_slots);
+                NonNull::new_unchecked(RawVec::<T, Global, {CO_ALLOC_PREF_META_YES!()}>::NEW.ptr())
             } else {
-                NonNull::new_unchecked(RawVec::<T, Global, false>::NEW.ptr())
+                NonNull::new_unchecked(RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::NEW.ptr())
             }
         };
         self.ptr = self.buf.as_ptr();

library/core/src/alloc/mod.rs

@@ -51,7 +51,7 @@ impl fmt::Display for AllocError {
 /// (Non-Null) Pointer and coallocation metadata.
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[derive(Clone, Copy, Debug)]
-pub struct PtrAndMeta<M: CoAllocMetaBase> {
+pub struct PtrAndMeta<M: ~const CoAllocMetaBase> {
     pub ptr: NonNull<u8>,
     pub meta: M,
 }
@@ -60,7 +60,7 @@ pub struct PtrAndMeta<M: CoAllocMetaBase> {
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[derive(Clone, Copy, Debug)]
 /// Used for results (from `CoAllocator`'s functions, where applicable).
-pub struct SliceAndMeta<M: CoAllocMetaBase> {
+pub struct SliceAndMeta<M: ~const CoAllocMetaBase> {
     pub slice: NonNull<[u8]>,
     pub meta: M,
 }
@@ -70,6 +70,7 @@ pub struct SliceAndMeta<M: CoAllocMetaBase> {
 pub type SliceAndMetaResult<M> = Result<SliceAndMeta<M>, AllocError>;
 
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[const_trait]
 pub trait CoAllocMetaBase: Clone + Copy {
     /// NOT for public use. This MAY BE REMOVED or CHANGED.
     ///
@@ -90,7 +91,7 @@ pub struct CoAllocMetaPlain {}
 const CO_ALLOC_META_PLAIN: CoAllocMetaPlain = CoAllocMetaPlain {};
 
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
-impl CoAllocMetaBase for CoAllocMetaPlain {
+impl const CoAllocMetaBase for CoAllocMetaPlain {
     const ZERO_METAS: [Self; 0] = [];
     const ONE_METAS: [Self; 1] = [CO_ALLOC_META_PLAIN];
 
@@ -188,7 +189,7 @@ pub unsafe trait Allocator {
     ///
     /// @FIXME Validate (preferrable at compile time, otherwise as a test) that this type's
     /// alignment <= `usize` alignment.
-    type CoAllocMeta: CoAllocMetaBase = CoAllocMetaPlain;
+    type CoAllocMeta: ~const CoAllocMetaBase = CoAllocMetaPlain;
 
     /// Attempts to allocate a block of memory.
     ///