CoAlloc: meta_num_slots... macros- WIP..

Author: peter-lyons-kehl

library/alloc/src/macros.rs

@@ -155,7 +155,7 @@ macro_rules! DEFAULT_COOP_PREF {
 #[macro_export]
 macro_rules! meta_num_slots {
     ($alloc:ty, $coop_pref:expr) => {
-        if ($alloc::CO_ALLOCATES_WITH_META) && ($coop_pref) { 1 } else { 0 }
+        if ($alloc::CO_ALLOC_META_NUM_SLOTS) && ($coop_pref) { 1 } else { 0 }
     };
 }
 // -\---> replace with something like:
@@ -164,7 +164,7 @@ macro_rules! meta_num_slots {
 pub const fn meta_num_slots<A: Allocator>(
     COOP_PREF: bool,
 ) -> usize {
-    if A::CO_ALLOCATES_WITH_META && COOP_PREF { 1 } else { 0 }
+    if A::CO_ALLOC_META_NUM_SLOTS && COOP_PREF { 1 } else { 0 }
 }
 */
 
@@ -180,8 +180,10 @@ pub const fn meta_num_slots<A: Allocator>(
 #[unstable(feature = "global_co_alloc", issue = "none")]
 #[macro_export]
 macro_rules! meta_num_slots_default {
+    // Can't generate if ... {1} else {0}
+    // because it's "overly complex generic constant".
     ($alloc:ty) => {
-        if ($alloc::CO_ALLOCATES_WITH_META) && (DEFAULT_COOP_PREF!()) { 1 } else { 0 }
+        if (<$alloc>::CO_ALLOC_META_NUM_SLOTS) && (DEFAULT_COOP_PREF!()) { 1 } else { 0 }
     };
 }
 
@@ -191,7 +193,7 @@ macro_rules! meta_num_slots_default {
 #[macro_export]
 macro_rules! meta_num_slots_global {
     ($coop_pref:expr) => {
-        if ::alloc::alloc::Global::CO_ALLOCATES_WITH_META && ($coop_pref) { 1 } else { 0 }
+        if ::alloc::alloc::Global::CO_ALLOC_META_NUM_SLOTS && ($coop_pref) { 1 } else { 0 }
     };
 }
 
@@ -205,6 +207,6 @@ macro_rules! meta_num_slots_global {
 #[macro_export]
 macro_rules! meta_num_slots_default_global {
     () => {
-        if ::alloc::alloc::Global::CO_ALLOCATES_WITH_META && (DEFAULT_COOP_PREF!()) { 1 } else { 0 }
+        if ::alloc::alloc::Global::CO_ALLOC_META_NUM_SLOTS && (DEFAULT_COOP_PREF!()) { 1 } else { 0 }
     };
 }

library/alloc/src/raw_vec.rs

@@ -1,5 +1,6 @@
 #![unstable(feature = "raw_vec_internals", reason = "unstable const warnings", issue = "none")]
 
+use crate::meta_num_slots_default;
 use core::alloc::{self, LayoutError, PtrAndMeta};
 use core::cmp;
 use core::intrinsics;
@@ -120,6 +121,10 @@ impl<T, A: Allocator, const COOP_PREF: bool> RawVec<T, A, COOP_PREF>
 where
     [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREF)]:,
 {
+    const fn new_plain_metas() -> [A::CoAllocMeta; {meta_num_slots_default!(A)}] {
+        loop {}
+    }
+
     // 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.

library/core/src/alloc/mod.rs

@@ -48,6 +48,75 @@ impl fmt::Display for AllocError {
     }
 }
 
+/// `CoAllocPref` values indicate a type's preference for coallocation (in either user space, or
+/// `std` space). Used as a `const` generic parameter type (usually called `CO_ALLOC_PREF`).
+///
+/// The actual value may be overriden by the allocator. See also `CoAllocMetaNumSlotsPref` and
+/// `co_alloc_pref` macro .
+///
+/// This type  WILL CHANGE (once ``#![feature(generic_const_exprs)]` and
+/// `#![feature(adt_const_params)]` are stable) to a dedicated struct/enum. Hence:
+/// - DO NOT construct instances, but use `co_alloc_pref` macro together with constants
+/// `CO_ALLOC_PREF_YES` and `CO_ALLOC_PREF_NO`;
+/// - DO NOT hard code any values; and
+/// - DO NOT mix this/cast this with/to `usize` (nor any other integers).
+///
+/// @FIXME CO_ALLOC_PREF_DEFAULT - as a separate constant, or a "keyword" recognized by
+/// `co_alloc_pref`  macro?
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+pub type CoAllocPref = usize;
+
+/// `CoAllocMetaNumSlotsPref` values indicate a type prefers to coallocate by carrying metadata, or
+/// not. (In either user space, or `std` space). Used as an argument to macro call of
+/// `co_alloc_pref`, which generates a `CoAllocPref` value.
+///
+/// Currently this indicates only the (preferred) number of `CoAllocMetaBase` slots being used
+/// (either 1 = coallocation, or 0 = no coallocation). However, in the future this type may have
+/// other properties (serving as extra hints to the allocator).
+///
+/// The actual value may be overriden by the allocator. For example, if the allocator doesn't
+/// support coallocation, then whether this value prefers to coallocate or not makes no difference.
+///
+/// This type  WILL CHANGE (once ``#![feature(generic_const_exprs)]` and
+/// `#![feature(adt_const_params)]` are stable) to a dedicated struct/enum. Hence:
+/// - DO NOT mix this/cast this with/to `isize` (nor any other integers); and
+/// - DO NOT hard code any values, but use `CO_ALLOC_PREF_YES` and `CO_ALLOC_PREF_NO`.
+///
+/// Currently this type is intentionally not `usize`. Why? This helps to prevent mistakes when one
+/// would use `CO_ALLOC_PREF_YES` or `CO_ALLOC_PREF_NO` in place of `CoAllocPref` vales.
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+pub type CoAllocMetaNumSlotsPref = isize;
+
+/// "Yes" as a type's preference for coallocation (in either user space, or `std` space).
+///
+/// It may be overriden by the allocator. For example, if the allocator doesn't support
+/// coallocation, then this value makes no difference.
+///
+/// This constant and its type WILL CHANGE (once ``#![feature(generic_const_exprs)]` and
+/// `#![feature(adt_const_params)]` are stable) to a dedicated struct/enum. Hence DO NOT hard
+/// code/replace/mix this any other values/parameters.
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+pub const CO_ALLOC_PREF_YES: CoAllocMetaNumSlotsPref = 1;
+
+/// "No" as a type's preference for coallocation (in either user space, or `std` space).
+///
+/// Any allocator is required to respect this. Even if the allocator does support coallocation, it
+/// will not coallocate types that use this value.
+///
+/// This constant and its type WILL CHANGE (once ``#![feature(generic_const_exprs)]` and
+/// `#![feature(adt_const_params)]` are stable) to a dedicated struct/enum. Hence DO NOT hard
+/// code/replace/mix this any other values/parameters.
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+pub const CO_ALLOC_PREF_NO: CoAllocMetaNumSlotsPref = 0;
+
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[macro_export]
+macro_rules! co_alloc_pref {
+    ($coop_pref:expr) => {
+        if ::alloc::alloc::Global::CO_ALLOC_META_NUM_SLOTS && ($coop_pref) { 1 } else { 0 }
+    };
+}
+
 /// (Non-Null) Pointer and coallocation metadata.
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[derive(Clone, Copy, Debug)]
@@ -79,14 +148,13 @@ macro_rules! SHORT_TERM_VEC_PREFERS_COOP {
 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.
+/// 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.
 #[unstable(feature = "global_co_alloc", issue = "none")]
 pub const fn co_alloc_metadata_num_slots_with_preference<A: Allocator>(
     coop_preferred: bool,
 ) -> usize {
-    if A::CO_ALLOCATES_WITH_META && coop_preferred { 1 } else { 0 }
+    if coop_preferred { A::CO_ALLOC_META_NUM_SLOTS } else { 0 }
 }
 
 /// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of
@@ -148,15 +216,18 @@ pub const fn co_alloc_metadata_num_slots_with_preference<A: Allocator>(
 #[unstable(feature = "allocator_api", issue = "32838")]
 #[const_trait]
 pub unsafe trait Allocator {
-    //const fn is_co_allocator() -> bool {false}
-    // Can't have: const type Xyz;
-    /// If this is any type with non-zero size, then the actual `Allocator` implementation supports cooperative functions (`co_*`) as first class citizens.
-    //type IsCoAllocator = ();
-    // It applies to the global (default) allocator only. And/or System allocator?! @FIXME
-    const CO_ALLOCATES_WITH_META: bool = false;
+    //const fn is_co_allocator() -> bool {false} Can't have: const type Xyz;
+    /// If this is any type with non-zero size, then the actual `Allocator` implementation supports
+    /// cooperative functions (`co_*`) as first class citizens.
+    //type IsCoAllocator = (); It applies to the global (default) allocator only. And/or System
+    // allocator?! @FIXME
+    /// NOT for public use. MAY CHANGE.
+    ///
+    /// Either 0 or 1.
+    const CO_ALLOC_META_NUM_SLOTS: usize = 0;
 
     /// NOT for public use. The default value MAY be REMOVED or CHANGED.
-    /// 
+    ///
     /// @FIXME Validate (preferrable at compile time, otherwise as a test) that this type's
     /// alignment <= `usize` alignment.
     type CoAllocMeta: CoAllocMetaBase = CoAllocMetaPlain;
@@ -591,7 +662,13 @@ where
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 pub trait CoAllocMetaBase: Clone + Copy {
     /// NOT for public use. This MAY BE REMOVED or CHANGED.
-    /// 
+    ///
+    /// For EXPERIMENTATION only.
+    const ZERO_METAS: [Self; 0];
+    const ONE_METAS: [Self; 1];
+
+    /// NOT for public use. This MAY BE REMOVED or CHANGED.
+    ///
     /// For EXPERIMENTATION only.
     fn new_plain() -> Self;
 }
@@ -600,11 +677,14 @@ pub trait CoAllocMetaBase: Clone + Copy {
 #[derive(Clone, Copy, Debug)]
 pub struct CoAllocMetaPlain {}
 
-static CO_ALLOC_META_PLAIN: CoAllocMetaPlain = CoAllocMetaPlain {};
+const CO_ALLOC_META_PLAIN: CoAllocMetaPlain = CoAllocMetaPlain {};
 
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 impl CoAllocMetaBase for CoAllocMetaPlain {
+    const ZERO_METAS: [Self; 0] = [];
+    const ONE_METAS: [Self; 1] = [CO_ALLOC_META_PLAIN];
+
     fn new_plain() -> Self {
         CO_ALLOC_META_PLAIN
     }
-}
+}