CoAlloc: Vec + its use cases. ICE

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/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,14 +1,16 @@
 #![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 core::alloc::PlVec;
 use crate::mem;
 
 #[thread_local]
-static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
+static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new();
 
 pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     let list = &mut DTORS;

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

@@ -1,17 +1,19 @@
 #![cfg(target_thread_local)]
-#![unstable(feature = "thread_local_internals", issue = "none")]
+#![unstable(feature = "thread_local_internals", issue = "none")]#![feature(global_co_alloc_plvec)]
+#![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::mem;
+use core::alloc::PlVec;
 
 #[thread_local]
 static REGISTERED: Cell<bool> = Cell::new(false);
 
 #[thread_local]
-static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
+static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new();
 
 pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     if !REGISTERED.get() {

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

@@ -1,5 +1,8 @@
 #![cfg(target_thread_local)]
 #![unstable(feature = "thread_local_internals", issue = "none")]
+#![feature(global_co_alloc_plvec)]
+
+use core::alloc::PlVec;
 
 //! Provides thread-local destructors without an associated "key", which
 //! can be more efficient.
@@ -64,7 +67,7 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     static REGISTERED: Cell<bool> = Cell::new(false);
 
     #[thread_local]
-    static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
+    static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new();
 
     if !REGISTERED.get() {
         _tlv_atexit(run_dtors, ptr::null_mut());

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

@@ -3,10 +3,13 @@
 
 #![unstable(feature = "thread_local_internals", issue = "none")]
 #![cfg(target_thread_local)]
+#![feature(global_co_alloc_plvec)]
+
+use core::alloc::PlVec;
 
 // Using a per-thread list avoids the problems in synchronizing global state.
 #[thread_local]
-static mut DESTRUCTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
+static mut DESTRUCTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
 
 // Ensure this can never be inlined because otherwise this may break in dylibs.
 // See #44391.