Reduce default heap size to 16MB. Start GC refactoring for ByteArray.

Author: maximecb

src/alloc.rs

@@ -15,7 +15,7 @@ impl Alloc
 {
     pub fn new() -> Self
     {
-        Self::with_size(32 * 1024 * 1024)
+        Self::with_size(16 * 1024 * 1024)
     }
 
     pub fn with_size(mem_size_bytes: usize) -> Self

src/bytearray.rs

@@ -169,18 +169,16 @@ fn blit_bgra32(
     }
 }
 
-/// Create a new ByteArray instance
-pub fn ba_new(actor: &mut Actor, _self: Value) -> Result<Value, String>
-{
-    let ba = ByteArray::default();
-    let new_arr = actor.alloc.alloc(ba).unwrap();
-    Ok(Value::ByteArray(new_arr))
-}
-
 /// Create a new ByteArray instance
 pub fn ba_with_size(actor: &mut Actor, _self: Value, num_bytes: Value) -> Result<Value, String>
 {
     let num_bytes = num_bytes.unwrap_usize();
+
+    actor.gc_check(
+        size_of::<ByteArray>() + num_bytes,
+        &mut []
+    );
+
     let mut bytes = Vec::with_capacity(num_bytes);
     bytes.resize(num_bytes, 0);
     let ba = ByteArray { bytes };

src/host.rs

@@ -166,7 +166,8 @@ pub fn cmd_get_arg(actor: &mut Actor, idx: Value) -> Result<Value, String>
         return Ok(Value::Nil);
     }
 
-    Ok(actor.alloc.str_val(&args[idx]).unwrap())
+    let arg_str = &args[idx];
+    Ok(actor.alloc.str_val(arg_str).unwrap())
 }
 
 /// Print a value to stdout

src/runtime.rs

@@ -365,7 +365,6 @@ pub fn get_method(val: Value, method_name: &str) -> Value
     static ARRAY_INSERT: HostFn = HostFn { name: "insert", f: Fn3(array_insert) };
     static ARRAY_APPEND: HostFn = HostFn { name: "append", f: Fn2(array_append) };
 
-    static BA_NEW: HostFn = HostFn { name: "new", f: Fn1(ba_new) };
     static BA_WITH_SIZE: HostFn = HostFn { name: "with_size", f: Fn2(ba_with_size) };
     static BA_FILL_U32: HostFn = HostFn { name: "fill_u32", f: Fn4(ba_fill_u32) };
     static BA_READ_U32: HostFn = HostFn { name: "load_u32", f: Fn2(ba_load_u32) };
@@ -422,7 +421,6 @@ pub fn get_method(val: Value, method_name: &str) -> Value
         (Value::Array(_), "insert") => &ARRAY_INSERT,
         (Value::Array(_), "append") => &ARRAY_APPEND,
 
-        (Value::Class(BYTEARRAY_ID), "new") => &BA_NEW,
         (Value::Class(BYTEARRAY_ID), "with_size") => &BA_WITH_SIZE,
         (Value::ByteArray(_), "fill_u32") => &BA_FILL_U32,
         (Value::ByteArray(_), "load_u32") => &BA_READ_U32,

src/vm.rs

@@ -1792,7 +1792,7 @@ impl Actor
                     self.gc_check(
                         std::mem::size_of::<Object>() +
                         std::mem::size_of::<Value>() * num_slots,
-                        &mut vec![],
+                        &mut [],
                     );
 
                     let obj_val = self.alloc.new_object(class_id, num_slots).unwrap();
@@ -1828,7 +1828,7 @@ impl Actor
                     self.gc_check(
                         std::mem::size_of::<Object>() +
                         std::mem::size_of::<Value>() * num_slots,
-                        &mut vec![],
+                        &mut [],
                     );
 
                     // Allocate the object
@@ -1993,7 +1993,7 @@ impl Actor
 
                     self.gc_check(
                         size_of::<Array>() + size_of::<Value>() * capacity,
-                        &mut vec![],
+                        &mut [],
                     );
 
                     let new_arr = Array::with_capacity(capacity, &mut self.alloc).unwrap();
@@ -2755,7 +2755,7 @@ mod tests
     #[test]
     fn bytearray()
     {
-        eval("let a = ByteArray.new();");
+        eval("let a = ByteArray.with_size(0);");
         eval("let a = ByteArray.with_size(1024); assert(a.len == 1024);");
         eval("let a = ByteArray.with_size(32); a.store_u32(0, 0xFF_FF_FF_FF);");
         eval("let a = ByteArray.with_size(32); a.store_u32(0, 0xFF_00_00_00); assert(a[0] == 0 && a[3] == 255);");