Vec & VecDeque use cases have COOP_PREFERRED. NOT COMPILABLE.

Author: peter-lyons-kehl

library/alloc/src/collections/vec_deque/mod.rs

@@ -9,6 +9,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 use core::alloc::{self, GlobalAlloc};
+use crate::vec::DEFAULT_COOP_PREFERRED;
 use core::cmp::{self, Ordering};
 use core::fmt;
 use core::hash::{Hash, Hasher};
@@ -93,11 +94,10 @@ mod tests;
 #[cfg_attr(not(test), rustc_diagnostic_item = "VecDeque")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_insignificant_dtor]
-// @TODO
 pub struct VecDeque<
     T,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-    const COOP_PREFERRED: bool = true
+    const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED
 >
 where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
@@ -2906,7 +2906,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
             if other.head != 0 {
                 ptr::copy(buf.add(other.head), buf, len);
             }
-            // @TODO:
+            // @FIXME: COOP
             Vec::from_raw_parts_in(buf, len, cap, alloc)
         }
     }

library/alloc/src/raw_vec.rs

@@ -14,6 +14,7 @@ use crate::alloc::{Allocator, Global, Layout};
 use crate::boxed::Box;
 use crate::collections::TryReserveError;
 use crate::collections::TryReserveErrorKind::*;
+use crate::vec::DEFAULT_COOP_PREFERRED;
 
 #[cfg(test)]
 mod tests;
@@ -49,8 +50,7 @@ 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)]
-// @TODO apply `_coop` with logical && to `A::IsCoAllocator`
-pub(crate) struct RawVec<T, A: Allocator = Global, const COOP_PREFERRED: bool = true>
+pub(crate) struct RawVec<T, A: Allocator = Global, const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED>
 where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     ptr: Unique<T>,
@@ -506,12 +506,12 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
     }
 }
 
-// @TODO Custom
+// @FIXME Custom
 unsafe impl<#[may_dangle] T, const COOP_PREFERRED: bool> Drop for RawVec<T, Global, COOP_PREFERRED>
 where [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]: {
     /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
     fn drop(&mut self) {
-        // @TODO
+        // @TOFIXMEDO
         if let Some((ptr, layout)) = self.current_memory() {
             unsafe { self.alloc.deallocate(ptr, layout) }
         }

library/alloc/src/vec/mod.rs

@@ -397,24 +397,34 @@ mod spec_extend;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")]
 #[rustc_insignificant_dtor]
-// @TODO _coop
-pub struct Vec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, const COOP_PREFERRED: bool = true>
+pub struct Vec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED>
 where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     buf: RawVec<T, A, COOP_PREFERRED>,
     len: usize,
 }
 
-#[unstable(feature = "global_co_alloc_vec", issue = "none")]
-pub type CoVec<T> = Vec<T, Global, true>;
+#[unstable(feature = "global_co_alloc_covec", issue = "none")]
+pub type CoVec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> = Vec<T, A, true>;
+
+/// "Plain" Vec. Not "cooperative" - not carrying extra data to assist the allocator.
+#[unstable(feature = "global_co_alloc_plvec", issue = "none")]
+pub type PlVec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> = Vec<T, A, false>;
+
+/// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter.
+#[unstable(feature = "global_co_alloc_def", issue = "none")]
+pub const DEFAULT_COOP_PREFERRED: bool = true;
+
+/// "Default" Vec. Either "cooperative" or not - as specified by `DEFAULT_COOP_PREFERRED`. The
+/// difference to `Vec` (used without specifying `COOP_PREFERRED`): `DefVec` indicates that the
+/// author considered using `CoVec` or `PlVec`, but left it to default instead.
+#[unstable(feature = "global_co_alloc_defvec", issue = "none")]
+pub type DefVec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> = Vec<T, A, DEFAULT_COOP_PREFERRED>;
 
-/// "Plain" Vec.
-#[unstable(feature = "global_co_alloc_vec", issue = "none")]
-pub type PlVec<T> = Vec<T, Global, false>;
 
-/// "Weighted" Vec.
-/// weight means how much it wants to cooperate. 0 = always pack; u8::MAX = always coop (if `Global` supports it).
-/// @TODO Weighing on the side of Allocator - const fn.
+/// "Weighted cooperative" Vec. Weight means how much it wants to cooperate (with the allocator). 0
+/// = always pack; u8::MAX = always cooperate (if `Global` supports it).
+/// @FIXME A `pub const` threshold.
 #[unstable(feature = "global_co_alloc_vec", issue = "none")]
 pub type WeVec<T, const weight: u8> = Vec<T, Global, {weight>1}>;
 

library/core/src/alloc/global.rs

@@ -166,7 +166,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) {panic!("TODO")}
+    unsafe fn co_alloc(&self, _layout: Layout, mut _result: &mut RawAndMeta) {panic!("@FIXME")}
 
     /// Deallocate the block of memory at the given `ptr` pointer with the given `layout`.
     ///
@@ -184,7 +184,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) {panic!("TODO")}
+    unsafe fn co_dealloc(&self, _ptr_and_meta: RawAndMeta, _layout: Layout) {panic!("@FIXME")}
 
     /// Behaves like `alloc`, but also ensures that the contents
     /// are set to zero before being returned.

library/core/src/alloc/mod.rs

@@ -26,7 +26,7 @@ use crate::error::Error;
 use crate::fmt;
 use crate::ptr::{self, NonNull};
 
-// @TODO Make this target-specific
+// @FIXME Make this target-specific
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
 #[allow(missing_debug_implementations)]
 #[derive(Clone, Copy)]
@@ -157,7 +157,8 @@ pub unsafe trait Allocator {
     // 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?! TODO
+    // It applies to the global (default) allocator only. And/or System allocator?! @FIXME
+    // @FIXME make false by default
     const IS_CO_ALLOCATOR: bool = true;
 
     /// Attempts to allocate a block of memory.
@@ -182,7 +183,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) {panic!("TODO")}
+    fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {panic!("FIXME")}
 
     /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized.
     ///
@@ -230,7 +231,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) {panic!("TODO")}
+    unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {panic!("FIXME")}
 
     /// Attempts to extend the memory block.
     ///
@@ -528,7 +529,7 @@ pub unsafe trait Allocator {
     }
 }
 
-// @TODO
+// @FIXME
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl<A> Allocator for &A
 where

library/std/src/alloc.rs

@@ -197,7 +197,7 @@ impl System {
     }
 }
 
-// @TODO
+// @FIXME
 // The Allocator impl checks the layout size to be non-zero and forwards to the GlobalAlloc impl,
 // which is in `std::sys::*::alloc`.
 #[unstable(feature = "allocator_api", issue = "32838")]

library/std/src/io/cursor.rs

@@ -6,6 +6,7 @@ use crate::io::prelude::*;
 use crate::alloc::Allocator;
 use crate::cmp;
 use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut, SeekFrom};
+use core::alloc;
 
 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`Seek`] implementation.
@@ -397,11 +398,12 @@ fn slice_write_vectored(
 }
 
 /// Reserves the required space, and pads the vec with 0s if necessary.
-fn reserve_and_pad<A: Allocator>(
+fn reserve_and_pad<A: Allocator, const COOP_PREFERRED: bool>(
     pos_mut: &mut u64,
-    vec: &mut Vec<u8, A>,
+    vec: &mut Vec<u8, A, COOP_PREFERRED>,
     buf_len: usize,
-) -> io::Result<usize> {
+) -> io::Result<usize>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
     let pos: usize = (*pos_mut).try_into().map_err(|_| {
         io::const_io_error!(
             ErrorKind::InvalidInput,
@@ -440,9 +442,10 @@ fn reserve_and_pad<A: Allocator>(
 
 /// Writes the slice to the vec without allocating
 /// # Safety: vec must have buf.len() spare capacity
-unsafe fn vec_write_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
+unsafe fn vec_write_unchecked<A, const COOP_PREFERRED: bool>(pos: usize, vec: &mut Vec<u8, A, COOP_PREFERRED>, buf: &[u8]) -> usize
 where
     A: Allocator,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     debug_assert!(vec.capacity() >= pos + buf.len());
     vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len());
@@ -458,9 +461,10 @@ where
 /// This also allows for the vec body to be empty, but with a position of N.
 /// This means that [`Write`] will pad the vec with 0 initially,
 /// before writing anything from that point
-fn vec_write<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
+fn vec_write<A, const COOP_PREFERRED: bool>(pos_mut: &mut u64, vec: &mut Vec<u8, A, COOP_PREFERRED>, buf: &[u8]) -> io::Result<usize>
 where
     A: Allocator,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     let buf_len = buf.len();
     let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
@@ -489,13 +493,14 @@ where
 /// This also allows for the vec body to be empty, but with a position of N.
 /// This means that [`Write`] will pad the vec with 0 initially,
 /// before writing anything from that point
-fn vec_write_vectored<A>(
+fn vec_write_vectored<A, const COOP_PREFERRED: bool>(
     pos_mut: &mut u64,
-    vec: &mut Vec<u8, A>,
+    vec: &mut Vec<u8, A, COOP_PREFERRED>,
     bufs: &[IoSlice<'_>],
 ) -> io::Result<usize>
 where
     A: Allocator,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     // For safety reasons, we don't want this sum to overflow ever.
     // If this saturates, the reserve should panic to avoid any unsound writing.
@@ -543,9 +548,10 @@ impl Write for Cursor<&mut [u8]> {
 }
 
 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
-impl<A> Write for Cursor<&mut Vec<u8, A>>
+impl<A, const COOP_PREFERRED: bool> Write for Cursor<&mut Vec<u8, A, COOP_PREFERRED>>
 where
     A: Allocator,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         vec_write(&mut self.pos, self.inner, buf)
@@ -567,9 +573,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Write for Cursor<Vec<u8, A>>
+impl<A, const COOP_PREFERRED: bool> Write for Cursor<Vec<u8, A, COOP_PREFERRED>>
 where
     A: Allocator,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         vec_write(&mut self.pos, &mut self.inner, buf)

library/std/src/io/impls.rs

@@ -378,7 +378,8 @@ impl Write for &mut [u8] {
 /// Write is implemented for `Vec<u8>` by appending to the vector.
 /// The vector will grow as needed.
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Allocator> Write for Vec<u8, A> {
+impl<A: Allocator, const COOP_PREFERRED: bool> Write for Vec<u8, A, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.extend_from_slice(buf);

library/std/src/sys/hermit/thread_local_dtor.rs

@@ -1,17 +1,19 @@
 #![cfg(target_thread_local)]
 #![unstable(feature = "thread_local_internals", issue = "none")]
+#![feature(global_co_alloc_plvec)]
 
 // Simplify dtor registration by using a list of destructors.
 // The this solution works like the implementation of macOS and
 // doesn't additional OS support
 
 use crate::cell::Cell;
 use crate::ptr;
+use core::alloc::PlVec;
 
 #[thread_local]
 static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
 
-type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
 
 pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     if DTORS.get().is_null() {

library/std/src/sys/solid/thread_local_dtor.rs

@@ -1,16 +1,18 @@
 #![cfg(target_thread_local)]
 #![unstable(feature = "thread_local_internals", issue = "none")]
+#![feature(global_co_alloc_plvec)]
 
 // Simplify dtor registration by using a list of destructors.
 
 use super::{abi, itron::task};
 use crate::cell::Cell;
 use crate::ptr;
+use core::alloc::PlVec;
 
 #[thread_local]
 static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
 
-type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
 
 pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     if DTORS.get().is_null() {