Refactor ProcessControlBlock to acquire mutable access to heap via locks

- Refactor CloneIntoProcess to better support cloning into processes,
heaps and heap fragments
- Update term types with necessary changes

NOTE: There are some definite weaknesses to this initial approach, but
it will have to do for now

Author: bitwalker

liblumen_alloc/src/borrow/clone_to_process.rs

@@ -1,4 +1,8 @@
-use crate::erts::{AllocInProcess, Term};
+use core::alloc::{AllocErr, Layout};
+use core::mem;
+use core::ptr::NonNull;
+
+use crate::erts::{self, HeapAlloc, HeapFragment, ProcessControlBlock, Term};
 
 /// This trait represents cloning, like `Clone`, but specifically
 /// in the context of terms which need to be cloned into the heap
@@ -15,7 +19,44 @@ use crate::erts::{AllocInProcess, Term};
 /// just be aware that any uses of `Clone` will allocate on the global heap
 pub trait CloneToProcess {
     /// Returns boxed copy of this value, performing any heap allocations
-    /// using the process heap of `process`, or using heap fragments if
+    /// using the process heap of `process`, possibly using heap fragments if
     /// there is not enough space for the cloned value
-    fn clone_to_process<A: AllocInProcess>(&self, process: &mut A) -> Term;
+    fn clone_to_process(&self, process: &ProcessControlBlock) -> Term {
+        let mut heap = process.acquire_heap();
+        match self.clone_to_heap(&mut heap) {
+            Ok(term) => term,
+            Err(_) => {
+                drop(heap);
+                let (term, mut frag) = self.clone_to_fragment().unwrap();
+                process.attach_fragment(unsafe { frag.as_mut() });
+                term
+            }
+        }
+    }
+
+    /// Returns boxed copy of this value, performing any heap allocations
+    /// using the given heap. If cloning requires allocation that exceeds
+    /// the amount of memory available, this returns `Err(AllocErr)`, otherwise
+    /// it returns `Ok(Term)`
+    fn clone_to_heap<A: HeapAlloc>(&self, heap: &mut A) -> Result<Term, AllocErr>;
+
+    /// Returns boxed copy of this value and the heap fragment it was allocated into
+    ///
+    /// If unable to allocate a heap fragment that fits this value, `Err(AllocErr)` is returned
+    fn clone_to_fragment(&self) -> Result<(Term, NonNull<HeapFragment>), AllocErr> {
+        let need = self.size_in_words();
+        let layout = unsafe {
+            let size = need * mem::size_of::<usize>();
+            Layout::from_size_align_unchecked(size, mem::align_of::<Term>())
+        };
+        let mut frag = unsafe { HeapFragment::new(layout)? };
+        let frag_ref = unsafe { frag.as_mut() };
+        let term = self.clone_to_heap(frag_ref)?;
+        Ok((term, frag))
+    }
+
+    /// Returns the size in words needed to allocate this value
+    fn size_in_words(&self) -> usize {
+        erts::to_word_size(mem::size_of_val(self))
+    }
 }

liblumen_alloc/src/erts/fragment.rs

@@ -3,10 +3,11 @@ use core::ptr::{self, NonNull};
 
 use intrusive_collections::intrusive_adapter;
 use intrusive_collections::{LinkedListLink, UnsafeRef};
+use liblumen_core::util::pointer::{distance_absolute, in_area};
 
 use crate::std_alloc;
 
-use super::Term;
+use super::{HeapAlloc, Term};
 
 // This adapter is used to track a list of heap fragments, attached to a process
 intrusive_adapter!(pub HeapFragmentAdapter = UnsafeRef<HeapFragment>: HeapFragment { link: LinkedListLink });
@@ -52,6 +53,8 @@ pub struct HeapFragment {
     pub link: LinkedListLink,
     // The memory region allocated for this fragment
     raw: RawFragment,
+    // The amount of used memory in this fragment
+    top: *mut u8,
 }
 impl HeapFragment {
     /// Returns the size (in bytes) of the fragment
@@ -80,11 +83,13 @@ impl HeapFragment {
         let align = layout.align();
         let ptr = std_alloc::alloc(full_layout)?.as_ptr() as *mut Self;
         let data = (ptr as *mut u8).offset(offset as isize);
+        let top = data;
         ptr::write(
             ptr,
             Self {
                 link: LinkedListLink::new(),
                 raw: RawFragment { size, align, data },
+                top,
             },
         );
         Ok(NonNull::new_unchecked(ptr))
@@ -105,3 +110,28 @@ impl Drop for HeapFragment {
         }
     }
 }
+impl HeapAlloc for HeapFragment {
+    /// Perform a heap allocation.
+    ///
+    /// If space on the process heap is not immediately available, then the allocation
+    /// will be pushed into a heap fragment which will then be later moved on to the
+    /// process heap during garbage collection
+    unsafe fn alloc(&mut self, need: usize) -> Result<NonNull<Term>, AllocErr> {
+        let base = self.raw.data as *mut Term;
+        let top = self.top as *mut Term;
+        let available = distance_absolute(top, base);
+        if need > available {
+            return Err(AllocErr);
+        }
+
+        let new_top = base.offset(need as isize);
+        debug_assert!(new_top <= self.raw.data.offset(self.raw.size as isize) as *mut Term);
+        self.top = new_top as *mut u8;
+        Ok(NonNull::new_unchecked(new_top))
+    }
+
+    /// Returns true if the given pointer is owned by this process/heap
+    fn is_owner<T>(&mut self, ptr: *const T) -> bool {
+        in_area(ptr, self.raw.data, self.top)
+    }
+}