Co-allocating functions for GlobalAlloc

Author: peter-lyons-kehl

library/core/src/alloc/global.rs

@@ -6,7 +6,7 @@ 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 PtrAndMeta {
+pub struct RawAndMeta {
     pub ptr: *mut u8,
     pub meta: GlobalCoAllocMeta,
 }
@@ -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 PtrAndMeta) {panic!("TODO")}
+    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`.
     ///
@@ -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: PtrAndMeta, _layout: Layout) {panic!("TODO")}
+    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.
@@ -219,7 +219,7 @@ pub unsafe trait GlobalAlloc {
     }
 
     #[unstable(feature = "global_co_alloc", issue = "none")]
-    unsafe fn co_alloc_zeroed(&self, layout: Layout, mut result: &mut PtrAndMeta) {
+    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) };
@@ -305,10 +305,10 @@ pub unsafe trait GlobalAlloc {
     #[unstable(feature = "global_co_alloc", issue = "none")]
     unsafe fn co_realloc(
         &self,
-        ptr_and_meta: PtrAndMeta,
+        ptr_and_meta: RawAndMeta,
         layout: Layout,
         new_size: usize,
-        mut result: &mut PtrAndMeta
+        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.

library/core/src/alloc/mod.rs

@@ -59,6 +59,25 @@ 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>;
+
 /// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of
 /// data described via [`Layout`][].
 ///
@@ -140,6 +159,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
@@ -162,6 +183,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
@@ -173,6 +207,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
@@ -237,6 +273,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.
     ///
@@ -300,6 +367,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
@@ -364,6 +462,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.