Get a new arena when this one is full

Author: Avi-D-coder

src/arena.rs

@@ -170,8 +170,8 @@ const fn header_size<T>() -> usize {
     header + ((align - (header % align)) % align)
 }
 
-/// Returns `header` and `next`.
-fn alloc_arena<T>() -> *mut T {
+/// Returns `next`.
+pub fn alloc_arena<T>() -> *mut T {
     // Get more memory from system allocator
     let mem_ptr = unsafe { System.alloc(Layout::new::<Mem>()) };
     let mem_addr = mem_ptr as usize;
@@ -180,13 +180,16 @@ fn alloc_arena<T>() -> *mut T {
             < unsafe { &std::mem::transmute::<_, &Mem>(mem_ptr)._mem[16383] } as *const _ as usize
     );
 
+    // FIXME animalizes Header
+
+    // FIXME this seems wrong! Make sure it's in sync with ArenaUntyped
     let capacity = (16384 - header_size::<T>()) / size_of::<T>();
     (mem_addr + (capacity * size_of::<T>())) as *mut T
 }
 
 impl<T: Trace> Arena<T> for ArenaInternals<T> {
     fn new() -> ArenaInternals<T> {
-        // if !T::PRE_CONDTION {
+        // if !T::PRE_CONDITION {
 
         // };
         let bus = GC_BUS.with(|tm| {

src/gc_logic.rs

@@ -13,7 +13,7 @@ use std::{
 
 pub(crate) static mut REGISTER: Option<Sender<RegMsg>> = None;
 
-const ARENA_SIZE: usize = 16384;
+pub const ARENA_SIZE: usize = 16384;
 
 #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub(crate) struct TypeInfo {
@@ -60,7 +60,7 @@ impl Default for Parents {
 }
 
 /// Keep in sync with Header<T>
-struct HeaderUnTyped {
+pub(crate) struct HeaderUnTyped {
     // TODO private
     pub evacuated: Mutex<HashMap<u16, *const u8>>,
     // roots: HashMap<u16, *const Box<UnsafeCell<*const T>>>,
@@ -71,13 +71,13 @@ struct HeaderUnTyped {
 
 impl HeaderUnTyped {
     /// last is closest to Header, since we bump down.
-    fn last_offset(align: u16) -> u16 {
+    pub(crate) fn last_offset(align: u16) -> u16 {
         let header = mem::size_of::<HeaderUnTyped>() as u16;
         header + ((align - (header % align)) % align)
     }
 
     // TODO is this right?
-    fn first_offset(align: u16, size: u16) -> u16 {
+    pub(crate) fn first_offset(align: u16, size: u16) -> u16 {
         let cap = (ARENA_SIZE as u16 - HeaderUnTyped::last_offset(align)) / size;
         HeaderUnTyped::last_offset(align) + (cap * size)
     }

src/mark.rs

@@ -1,8 +1,13 @@
 use super::gc::*;
-use crate::{auto_traits::HasGc, trace::GcTypeInfo};
+use crate::{
+    arena::alloc_arena,
+    auto_traits::HasGc,
+    gc_logic::{HeaderUnTyped, ARENA_SIZE},
+    trace::GcTypeInfo,
+};
 use smallvec::SmallVec;
 use std::ops::Range;
-use std::{mem, ptr};
+use std::{cmp::min, mem, ptr};
 
 /// This will be sound once GAT or const Eq &str lands.
 /// The former will allow transmuting only lifetimes.
@@ -21,6 +26,7 @@ pub struct Handlers {
     nexts: SmallVec<[*mut u8; 4]>,
     /// forward(old, new) -> already evacuated
     forward: fn(*const u8, *const u8) -> Option<*const u8>,
+    filled: SmallVec<[SmallVec<[*mut HeaderUnTyped; 1]>; 4]>,
 }
 
 pub unsafe trait Condemned {
@@ -72,6 +78,15 @@ unsafe impl<'r, T> Condemned for Gc<'r, T> {
         if region.contains(&addr) {
             let i = handlers.translation[OFFSET as usize];
             if let Some(next) = handlers.nexts.get_mut(i as usize) {
+                let next_addr = *next as usize;
+                let header_addr = next_addr - next_addr % ARENA_SIZE;
+
+                // Get a new Arena if this ones full
+                if HeaderUnTyped::last_offset(mem::align_of::<T>() as u16) as usize > next_addr {
+                    handlers.filled[i as usize].push(header_addr as *mut HeaderUnTyped);
+                    *next = alloc_arena::<T>() as *mut u8;
+                };
+
                 unsafe { ptr::copy_nonoverlapping(ptr, *next as *mut T, 1) }
                 let forward = handlers.forward;
                 if let Some(pre_evac) = forward(ptr as *const u8, *next as *const u8) {
@@ -84,7 +99,8 @@ unsafe impl<'r, T> Condemned for Gc<'r, T> {
                     unsafe {
                         *r = *next as *const T;
                     }
-                    *next = (addr + mem::size_of::<T>()) as *mut u8;
+                    // TODO fix overwrite when size_of<T> > size_of<Header> via min in other places
+                    *next = min(addr - mem::size_of::<T>(), header_addr) as *mut u8;
                 }
             }
         }