CoAlloc: RawVec includes GlobalCoAllocMeta based on allocator; related bounds - NOT COMPILING (no ICE, but standard compiler error)

Author: peter-lyons-kehl

library/alloc/src/lib.rs

@@ -86,6 +86,7 @@
 #![warn(deprecated_in_future)]
 #![warn(missing_debug_implementations)]
 #![warn(missing_docs)]
+#![allow(incomplete_features)]
 #![allow(explicit_outlives_requirements)]
 #![cfg_attr(not(bootstrap), warn(multiple_supertrait_upcastable))]
 //
@@ -124,6 +125,7 @@
 #![feature(extend_one)]
 #![feature(fmt_internals)]
 #![feature(fn_traits)]
+#![feature(generic_const_exprs)]
 #![feature(global_co_alloc_meta)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(inline_const)]

library/alloc/src/raw_vec.rs

@@ -1,6 +1,6 @@
 #![unstable(feature = "raw_vec_internals", reason = "unstable const warnings", issue = "none")]
 
-use core::alloc::{LayoutError, GlobalCoAllocMeta};
+use core::alloc::{self, LayoutError, GlobalCoAllocMeta};
 use core::cmp;
 use core::intrinsics;
 use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
@@ -49,12 +49,19 @@ enum AllocInit {
 /// `usize::MAX`. This means that you need to be careful when round-tripping this type with a
 /// `Box<[T]>`, since `capacity()` won't yield the length.
 #[allow(missing_debug_implementations)]
-pub(crate) struct RawVec<T, A: Allocator = Global> {
+// @TODO
+// 1. make const generic _coop come from the target specification
+// 2. apply `_coop` with logical && to `A::IsCoAllocator`
+pub(crate) struct RawVec<T, A: Allocator = Global, const _coop: bool = true>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     ptr: Unique<T>,
     cap: usize,
     alloc: A,
-    #[allow(dead_code)]
-    pub(crate) meta: GlobalCoAllocMeta,
+    // As of v1.67.0, `cmp` for `TypeId` is not `const`, unfortunately:
+    //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) meta: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots::<A>()],
 }
 
 impl<T> RawVec<T, Global> {
@@ -104,7 +111,9 @@ impl<T> RawVec<T, Global> {
     }
 }
 
-impl<T, A: Allocator> RawVec<T, A> {
+impl<T, A: Allocator> RawVec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     // Tiny Vecs are dumb. Skip to:
     // - 8 if the element size is 1, because any heap allocators is likely
     //   to round up a request of less than 8 bytes to at least 8 bytes.
@@ -284,7 +293,9 @@ impl<T, A: Allocator> RawVec<T, A> {
             slf: &mut RawVec<T, A>,
             len: usize,
             additional: usize,
-        ) {
+        )
+        where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+        {
             handle_reserve(slf.grow_amortized(len, additional));
         }
 
@@ -357,14 +368,18 @@ impl<T, A: Allocator> RawVec<T, A> {
     }
 }
 
-impl<T, A: Allocator> RawVec<T, A> {
+impl<T, A: Allocator> RawVec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     /// Returns if the buffer needs to grow to fulfill the needed extra capacity.
     /// Mainly used to make inlining reserve-calls possible without inlining `grow`.
-    fn needs_to_grow(&self, len: usize, additional: usize) -> bool {
+    fn needs_to_grow(&self, len: usize, additional: usize) -> bool
+     {
         additional > self.capacity().wrapping_sub(len)
     }
 
-    fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) {
+    fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize)
+    {
         // 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>()`.
@@ -475,24 +490,27 @@ where
     memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into())
 }
 
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A> {
+unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     /// 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() {
-            unsafe { self.alloc.deallocate(ptr, layout) }
+            unsafe { self.alloc.co_deallocate(ptr, layout) }
         }
     }
 }
 
-unsafe impl<#[may_dangle] T> Drop for RawVec<T, Global> {
+// @TODO Custom
+/*unsafe impl<#[may_dangle] T> Drop for RawVec<T, Global> {
     /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
     fn drop(&mut self) {
         // @TODO
         if let Some((ptr, layout)) = self.current_memory() {
             unsafe { self.alloc.deallocate(ptr, layout) }
         }
     }
-}
+}*/
 
 // Central function for reserve error handling.
 #[cfg(not(no_global_oom_handling))]

library/alloc/src/slice.rs

@@ -97,7 +97,8 @@ pub(crate) mod hack {
     // We shouldn't add inline attribute to this since this is used in
     // `vec!` macro mostly and causes perf regression. See #71204 for
     // discussion and perf results.
-    pub fn into_vec<T, A: Allocator>(b: Box<[T], A>) -> Vec<T, A> {
+    pub fn into_vec<T, A: Allocator>(b: Box<[T], A>) -> Vec<T, A>
+    where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
         unsafe {
             let len = b.len();
             let (b, alloc) = Box::into_raw_with_allocator(b);
@@ -107,21 +108,24 @@ pub(crate) mod hack {
 
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    pub fn to_vec<T: ConvertVec, A: Allocator>(s: &[T], alloc: A) -> Vec<T, A> {
+    pub fn to_vec<T: ConvertVec, A: Allocator>(s: &[T], alloc: A) -> Vec<T, A>
+    where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
         T::to_vec(s, alloc)
     }
 
     #[cfg(not(no_global_oom_handling))]
     pub trait ConvertVec {
         fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
         where
-            Self: Sized;
+            Self: Sized,
+            [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:;
     }
 
     #[cfg(not(no_global_oom_handling))]
     impl<T: Clone> ConvertVec for T {
         #[inline]
-        default fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A> {
+        default fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
+        where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
             struct DropGuard<'a, T, A: Allocator> {
                 vec: &'a mut Vec<T, A>,
                 num_init: usize,
@@ -158,7 +162,8 @@ pub(crate) mod hack {
     #[cfg(not(no_global_oom_handling))]
     impl<T: Copy> ConvertVec for T {
         #[inline]
-        fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A> {
+        fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
+        where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
             let mut v = Vec::with_capacity_in(s.len(), alloc);
             // SAFETY:
             // allocated above with the capacity of `s`, and initialize to `s.len()` in
@@ -436,6 +441,7 @@ impl<T> [T] {
     pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A>
     where
         T: Clone,
+        [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:
     {
         // N.B., see the `hack` module in this file for more details.
         hack::to_vec(self, alloc)
@@ -458,7 +464,8 @@ impl<T> [T] {
     #[rustc_allow_incoherent_impl]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
+    pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A>
+    where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
         // N.B., see the `hack` module in this file for more details.
         hack::into_vec(self)
     }
@@ -769,14 +776,16 @@ impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V] {
 ////////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Borrow<[T]> for Vec<T, A> {
+impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>
+where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn borrow(&self) -> &[T] {
         &self[..]
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A> {
+impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>
+where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn borrow_mut(&mut self) -> &mut [T] {
         &mut self[..]
     }