CoAlloc: Allocator + Global API

Author: peter-lyons-kehl

library/core/src/alloc/global.rs

@@ -1,6 +1,15 @@
 use crate::alloc::Layout;
 use crate::cmp;
 use crate::ptr;
+use crate::alloc::GlobalCoAllocMeta;
+
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+/// Used for parameters and results (to/from `GlobalCoAllocator`'s functions, where applicable).
+pub struct RawAndMeta {
+    pub ptr: *mut u8,
+    pub meta: GlobalCoAllocMeta,
+}
 
 /// A memory allocator that can be registered as the standard library’s default
 /// through the `#[global_allocator]` attribute.
@@ -156,6 +165,9 @@ pub unsafe trait GlobalAlloc {
     #[stable(feature = "global_alloc", since = "1.28.0")]
     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")}
+
     /// Deallocate the block of memory at the given `ptr` pointer with the given `layout`.
     ///
     /// # Safety
@@ -171,6 +183,9 @@ pub unsafe trait GlobalAlloc {
     #[stable(feature = "global_alloc", since = "1.28.0")]
     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")}
+
     /// Behaves like `alloc`, but also ensures that the contents
     /// are set to zero before being returned.
     ///
@@ -198,11 +213,23 @@ pub unsafe trait GlobalAlloc {
         if !ptr.is_null() {
             // SAFETY: as allocation succeeded, the region from `ptr`
             // of size `size` is guaranteed to be valid for writes.
-            unsafe { ptr::write_bytes(ptr, 0, size) };
+            unsafe { ptr::write_bytes(ptr, 0u8, size) };
         }
         ptr
     }
 
+    #[unstable(feature = "global_co_alloc", issue = "none")]
+    unsafe fn co_alloc_zeroed(&self, layout: Layout, mut result: &mut RawAndMeta) {
+        let size = layout.size();
+        // SAFETY: the safety contract for `alloc` must be upheld by the caller.
+        unsafe { self.co_alloc(layout, &mut result) };
+        if !result.ptr.is_null() {
+            // SAFETY: as allocation succeeded, the region from `ptr_and_meta.ptr` of size `size` is
+            // guaranteed to be valid for writes.
+            unsafe { ptr::write_bytes(result.ptr, 0u8, size) };
+        }
+    }
+
     /// Shrink or grow a block of memory to the given `new_size` in bytes.
     /// The block is described by the given `ptr` pointer and `layout`.
     ///
@@ -275,4 +302,31 @@ pub unsafe trait GlobalAlloc {
         }
         new_ptr
     }
+
+    #[unstable(feature = "global_co_alloc", issue = "none")]
+    unsafe fn co_realloc(
+        &self,
+        ptr_and_meta: RawAndMeta,
+        layout: Layout,
+        new_size: usize,
+        mut result: &mut RawAndMeta
+    ) {
+        // SAFETY: the caller must ensure that the `new_size` does not overflow.
+        // `layout.align()` comes from a `Layout` and is thus guaranteed to be valid.
+        let new_layout = unsafe { Layout::from_size_align_unchecked(new_size, layout.align()) };
+        // SAFETY: the caller must ensure that `new_layout` is greater than zero.
+        unsafe { self.co_alloc(new_layout, &mut result) };
+        if !result.ptr.is_null() {
+            // SAFETY: the previously allocated block cannot overlap the newly allocated block.
+            // The safety contract for `dealloc` must be upheld by the caller.
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    ptr_and_meta.ptr,
+                    result.ptr,
+                    cmp::min(layout.size(), new_size),
+                );
+                self.co_dealloc(ptr_and_meta, layout);
+            }
+        }
+    }
 }

library/core/src/alloc/mod.rs

@@ -25,6 +25,16 @@ use crate::error::Error;
 use crate::fmt;
 use crate::ptr::{self, NonNull};
 
+// @TODO Make this target-specific
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+pub struct GlobalCoAllocMeta {
+    //pub one: usize,
+    /*pub two: usize,
+    pub three: usize,
+    pub four: usize,*/
+}
+
 /// The `AllocError` error indicates an allocation failure
 /// that may be due to resource exhaustion or to
 /// something wrong when combining the given input arguments with this
@@ -48,6 +58,30 @@ impl fmt::Display for AllocError {
     }
 }
 
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+pub struct PtrAndMeta {
+    pub ptr: NonNull<u8>,
+    pub meta: GlobalCoAllocMeta,
+}
+
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+/// Used for results (from `CoAllocator`'s functions, where applicable).
+pub struct SliceAndMeta {
+    pub slice: NonNull<[u8]>,
+    pub meta: GlobalCoAllocMeta,
+}
+
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+pub type SliceAndMetaResult = Result<SliceAndMeta, AllocError>;
+
+#[unstable(feature = "global_co_alloc", issue = "none")]
+pub const fn co_alloc_metadata_num_slots<A: Allocator>() -> usize {
+    if A::IS_CO_ALLOCATOR { 1 } else { 0 }
+}
+
 /// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of
 /// data described via [`Layout`][].
 ///
@@ -107,6 +141,13 @@ impl fmt::Display for AllocError {
 #[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?! TODO
+    const IS_CO_ALLOCATOR: bool = true;
+
     /// Attempts to allocate a block of memory.
     ///
     /// On success, returns a [`NonNull<[u8]>`][NonNull] meeting the size and alignment guarantees of `layout`.
@@ -129,6 +170,8 @@ 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")}
+
     /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized.
     ///
     /// # Errors
@@ -151,6 +194,19 @@ pub unsafe trait Allocator {
         Ok(ptr)
     }
 
+    fn co_allocate_zeroed(&self, layout: Layout, mut result: &mut SliceAndMetaResult) {
+        self.co_allocate(layout, &mut result);
+        if let Ok(SliceAndMeta{slice, ..}) = result {
+            // SAFETY: `alloc` returns a valid memory block
+            unsafe {
+                    slice
+                    .as_non_null_ptr()
+                    .as_ptr()
+                    .write_bytes(0, slice.len())
+            }
+        }
+    }
+
     /// Deallocates the memory referenced by `ptr`.
     ///
     /// # Safety
@@ -162,6 +218,8 @@ 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")}
+
     /// Attempts to extend the memory block.
     ///
     /// Returns a new [`NonNull<[u8]>`][NonNull] containing a pointer and the actual size of the allocated
@@ -226,6 +284,37 @@ pub unsafe trait Allocator {
         Ok(new_ptr)
     }
 
+    unsafe fn co_grow(
+        &self,
+        ptr_and_meta: PtrAndMeta,
+        old_layout: Layout,
+        new_layout: Layout,
+        mut result: &mut SliceAndMetaResult
+    ) {
+        debug_assert!(
+            new_layout.size() >= old_layout.size(),
+            "`new_layout.size()` must be greater than or equal to `old_layout.size()`"
+        );
+
+        self.co_allocate(new_layout, &mut result);
+
+        if let Ok(SliceAndMeta {slice, ..}) = result {
+            // SAFETY: because `new_layout.size()` must be greater than or equal to
+            // `old_layout.size()`, both the old and new memory allocation are valid for reads and
+            // writes for `old_layout.size()` bytes. Also, because the old allocation wasn't yet
+            // deallocated, it cannot overlap `new_slice_and_meta.slice`. Thus, the call to `copy_nonoverlapping` is
+            // safe. The safety contract for `dealloc` must be upheld by the caller.
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    ptr_and_meta.ptr.as_ptr(),
+                    slice.as_mut_ptr(),
+                    old_layout.size(),
+                );
+                self.co_deallocate(ptr_and_meta, old_layout);
+            }
+        }
+    }
+
     /// Behaves like `grow`, but also ensures that the new contents are set to zero before being
     /// returned.
     ///
@@ -289,6 +378,37 @@ pub unsafe trait Allocator {
         Ok(new_ptr)
     }
 
+    unsafe fn co_grow_zeroed(
+        &self,
+        ptr_and_meta: PtrAndMeta,
+        old_layout: Layout,
+        new_layout: Layout,
+        mut result: &mut SliceAndMetaResult
+    ) {
+        debug_assert!(
+            new_layout.size() >= old_layout.size(),
+            "`new_layout.size()` must be greater than or equal to `old_layout.size()`"
+        );
+
+        self.co_allocate_zeroed(new_layout, &mut result);
+
+        if let Ok(SliceAndMeta{ slice, ..}) = result {
+            // SAFETY: because `new_layout.size()` must be greater than or equal to
+            // `old_layout.size()`, both the old and new memory allocation are valid for reads and
+            // writes for `old_layout.size()` bytes. Also, because the old allocation wasn't yet
+            // deallocated, it cannot overlap `new_slice_and_meta.slice`. Thus, the call to `copy_nonoverlapping` is
+            // safe. The safety contract for `dealloc` must be upheld by the caller.
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    ptr_and_meta.ptr.as_ptr(),
+                    slice.as_mut_ptr(),
+                    old_layout.size(),
+                );
+                self.co_deallocate(ptr_and_meta, old_layout);
+            }
+        }
+    }
+
     /// Attempts to shrink the memory block.
     ///
     /// Returns a new [`NonNull<[u8]>`][NonNull] containing a pointer and the actual size of the allocated
@@ -353,6 +473,37 @@ pub unsafe trait Allocator {
         Ok(new_ptr)
     }
 
+    unsafe fn co_shrink(
+        &self,
+        ptr_and_meta: PtrAndMeta,
+        old_layout: Layout,
+        new_layout: Layout,
+        mut result: &mut SliceAndMetaResult
+    ) {
+        debug_assert!(
+            new_layout.size() <= old_layout.size(),
+            "`new_layout.size()` must be smaller than or equal to `old_layout.size()`"
+        );
+
+        self.co_allocate(new_layout, &mut result);
+
+        if let Ok(SliceAndMeta{ slice, ..}) = result {
+            // SAFETY: because `new_layout.size()` must be lower than or equal to
+            // `old_layout.size()`, both the old and new memory allocation are valid for reads and
+            // writes for `new_layout.size()` bytes. Also, because the old allocation wasn't yet
+            // deallocated, it cannot overlap `new_slice_and_meta.slice`. Thus, the call to `copy_nonoverlapping` is
+            // safe. The safety contract for `dealloc` must be upheld by the caller.
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    ptr_and_meta.ptr.as_ptr(),
+                    slice.as_mut_ptr(),
+                    new_layout.size(),
+                );
+                self.co_deallocate(ptr_and_meta, old_layout);
+            }
+        }
+    }
+
     /// Creates a "by reference" adapter for this instance of `Allocator`.
     ///
     /// The returned adapter also implements `Allocator` and will simply borrow this.
@@ -365,6 +516,7 @@ pub unsafe trait Allocator {
     }
 }
 
+// @TODO
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl<A> Allocator for &A
 where

library/core/src/lib.rs

@@ -98,6 +98,7 @@
 #![cfg_attr(not(bootstrap), warn(multiple_supertrait_upcastable))]
 //
 // Library features:
+#![feature(associated_type_defaults)]
 #![feature(const_align_offset)]
 #![feature(const_align_of_val)]
 #![feature(const_align_of_val_raw)]

library/std/src/alloc.rs

@@ -197,10 +197,13 @@ impl System {
     }
 }
 
+// @TODO
 // 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")]
 unsafe impl Allocator for System {
+    const IS_CO_ALLOCATOR: bool = false;
+
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         self.alloc_impl(layout, false)