Add $vm_shrink_heap() host function to stress test the GC.

Author: maximecb

src/alloc.rs

@@ -40,13 +40,28 @@ impl Alloc
         self.mem_size
     }
 
+    pub fn bytes_used(&self) -> usize
+    {
+        self.next_idx
+    }
+
     pub fn bytes_free(&self) -> usize
     {
         assert!(self.next_idx <= self.mem_size);
         self.mem_size - self.next_idx
     }
 
-    // Allocate a block of a given size
+    /// Shrink the available memory to a smaller size
+    /// This is primarily used to test the GC
+    pub fn shrink_to(&mut self, new_size: usize)
+    {
+        assert!(self.next_idx <= new_size);
+        self.mem_size = new_size;
+
+        // TODO: try to realloc to a smaller size?
+    }
+
+    /// Allocate a block of a given size
     fn alloc_bytes(&mut self, size_bytes: usize) -> Result<*mut u8, ()>
     {
         let align_bytes = 8;
@@ -64,7 +79,7 @@ impl Alloc
         Ok(unsafe { self.mem_block.add(obj_pos) })
     }
 
-    // Allocate a variable-sized table of elements of a given type
+    /// Allocate a variable-sized table of elements of a given type
     pub fn alloc_table<T>(&mut self, num_elems: usize) -> Result<*mut [T], ()>
     {
         let num_bytes = num_elems * std::mem::size_of::<T>();
@@ -74,7 +89,7 @@ impl Alloc
         Ok(std::ptr::slice_from_raw_parts_mut(p, num_elems))
     }
 
-    // Allocate a new object of a given type
+    /// Allocate a new object of a given type
     pub fn alloc<T>(&mut self, obj: T) -> Result<*mut T, ()>
     {
         let num_bytes = std::mem::size_of::<T>();
@@ -88,7 +103,7 @@ impl Alloc
         Ok(p)
     }
 
-    // Allocate a new object with a given number of slots
+    /// Allocate a new object with a given number of slots
     pub fn new_object(&mut self, class_id: ClassId, num_slots: usize) -> Result<Value, ()>
     {
         // Allocate the slots for the object

src/host.rs

@@ -78,6 +78,7 @@ pub fn get_host_const(name: &str, fun: &Function, prog: &Program) -> Expr
     static READ_FILE: HostFn = HostFn { name: "read_file", f: Fn1(read_file) };
     static READ_FILE_UTF8: HostFn = HostFn { name: "read_file", f: Fn1(read_file_utf8) };
     static WRITE_FILE: HostFn = HostFn { name: "write_file", f: Fn2(write_file) };
+    static VM_SHRINK_HEAP: HostFn = HostFn { name: "vm_shrink_heap", f: Fn1(vm_shrink_heap) };
     static ACTOR_ID: HostFn = HostFn { name: "actor_id", f: Fn0(actor_id) };
     static ACTOR_PARENT: HostFn = HostFn { name: "actor_parent", f: Fn0(actor_parent) };
     static ACTOR_SLEEP: HostFn = HostFn { name: "actor_sleep", f: Fn1(actor_sleep) };
@@ -109,6 +110,7 @@ pub fn get_host_const(name: &str, fun: &Function, prog: &Program) -> Expr
         "read_file_utf8" => &READ_FILE_UTF8,
         "write_file" => &WRITE_FILE,
 
+        "vm_shrink_heap" => &VM_SHRINK_HEAP,
         "actor_id" => &ACTOR_ID,
         "actor_parent" => &ACTOR_PARENT,
         "actor_sleep" => &ACTOR_SLEEP,
@@ -419,6 +421,20 @@ fn write_file(actor: &mut Actor, file_path: Value, mut bytes: Value) -> Result<V
     }
 }
 
+/// Shrink the heap to a smaller size
+fn vm_shrink_heap(actor: &mut Actor, new_size: Value) -> Result<Value, String>
+{
+    let new_size = unwrap_usize!(new_size);
+
+    if actor.alloc.bytes_used() > new_size {
+        return Err("requested heap size is smaller than bytes currently allocated".into());
+    }
+
+    actor.alloc.shrink_to(new_size);
+
+    Ok(Value::Nil)
+}
+
 /// Get the id of the current actor
 fn actor_id(actor: &mut Actor) -> Result<Value, String>
 {

tests/gc_alloc_arrays.psh

@@ -1,4 +1,6 @@
-for (let var i = 0; i < 1_000_000; ++i)
+$vm_shrink_heap(256_000);
+
+for (let var i = 0; i < 200_000; ++i)
 {
     let a = [0, 1, 2, 3, 4];
     assert(a.len == 5);

tests/gc_alloc_random.psh

@@ -21,7 +21,9 @@ class Foo
     }
 }
 
-for (let var i = 0; i < 6_000_000; ++i)
+$vm_shrink_heap(256_000);
+
+for (let var i = 0; i < 4_000_000; ++i)
 {
     let r = rand_int(1, 5);
 

tests/gc_grow_array.psh

@@ -1,3 +1,5 @@
+$vm_shrink_heap(256_000);
+
 let a = [];
 
 for (let var i = 0; i < 3_000_000; ++i)

tests/gc_linked_list.psh

@@ -7,6 +7,8 @@ class Node
     }
 }
 
+$vm_shrink_heap(256_000);
+
 let var list = nil;
 
 for (let var n = 0; n < 1_000; ++n)

tests/gc_list_extend.psh

@@ -7,6 +7,8 @@ class Node
     }
 }
 
+$vm_shrink_heap(256_000);
+
 let var list = nil;
 let num_nodes = 1_000_000;
 

tests/gc_str_concat.psh

@@ -1,3 +1,5 @@
+$vm_shrink_heap(256_000);
+
 let var str = nil;
 
 for (let var n = 0; n < 500; ++n)