Merge pull request #382 from Pivot-Studio/feat/gc_bench

feat: add gc benchmark code

Author: Chronostasys

immix/src/collector.rs

@@ -245,6 +245,7 @@ impl Collector {
             || (unsafe { self.thread_local_allocator.as_mut().unwrap().should_gc() })
         {
             self.collect_fast_unwind(sp);
+            return;
         }
         let status = self.status.borrow();
         if status.collect_threshold < status.bytes_allocated_since_last_gc {
@@ -263,6 +264,9 @@ impl Collector {
             return std::ptr::null_mut();
         }
         unsafe {
+            let mut status = self.status.borrow_mut();
+            status.bytes_allocated_since_last_gc += ((size - 1) / LINE_SIZE + 1) * LINE_SIZE;
+            drop(status);
             let ptr = self
                 .thread_local_allocator
                 .as_mut()

immix/src/consts.rs

@@ -12,7 +12,7 @@ pub const EVA_BLOCK_PROPORTION: f64 = 0.025;
 
 pub const ALIGN: usize = 4096;
 
-pub const THRESHOLD_PROPORTION: f64 = 1000.75;
+pub const THRESHOLD_PROPORTION: f64 = 10.75;
 
 pub const LLVM_GC_STRATEGY_NAME: &str = "plimmix";
 

planglib/core/gc.pi

@@ -8,6 +8,8 @@ pub fn DioGC__disable_auto_collect() void;
 
 pub fn DioGC__enable_auto_collect() void;
 
+pub fn DioGC__get_stw_num() i64;
+
 fn DioGC__stuck_begin(sp:i64) void;
 
 fn DioGC__stuck_end() void;

src/ast/builder/llvmbuilder.rs

@@ -1637,10 +1637,11 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> {
         // }
         // self.module.strip_debug_info();
         // self.module.strip_debug_info(); // FIXME
-        self.module.verify().unwrap_or_else(|_| {
+        self.module.verify().unwrap_or_else(|e| {
             panic!(
-                "module {} is not valid",
-                self.module.get_name().to_str().unwrap()
+                "module {} is not valid, err msg: {}",
+                self.module.get_name().to_str().unwrap(),
+                e
             )
         });
         let used = self.used.borrow();

src/ast/node/macro_nodes.rs

@@ -237,6 +237,10 @@ impl Node for MacroCallNode {
         ctx: &'b mut Ctx<'a>,
         builder: &'b BuilderEnum<'a, '_>,
     ) -> NodeResult {
+        let ctx = &mut ctx.new_child(self.range.start, builder);
+        ctx.macro_loop_idx = Default::default();
+        ctx.macro_loop_len = Default::default();
+        ctx.macro_loop = false;
         match &*self.callee {
             NodeEnum::ExternIdNode(ex_node) => {
                 for ns in &ex_node.namespace {

test/gcbench/Kagari.toml

@@ -0,0 +1,2 @@
+entry = "main.pi"
+project = "gcbench"

test/gcbench/README.md

@@ -0,0 +1,3 @@
+# GC Benchmark
+
+This is a simple benchmark for testing our gc performance.

test/gcbench/main.pi

@@ -0,0 +1,109 @@
+pub fn main() i64 {
+    // bench();
+    for let i = 0; i < 3; i = i + 1 {
+        bench();
+    }
+    let start = millitime();
+    for let i = 0; i < 30; i = i + 1 {
+        bench();
+    }
+    let end = millitime();
+    println!("time: ", (end - start)/30);
+
+    let stw = gc::DioGC__get_stw_num();
+    println!("gc stw: ", stw);
+    return 0;
+}
+
+
+fn millitime() i64;
+
+fn bench() void {
+    let root =  &GCTestObj{};
+    populate(*K_LONG_LIVED_TREE_DEPTH, root);
+    let d = *K_MIN_TREE_DEPTH;
+    while d <= *K_MAX_TREE_DEPTH {
+        time_construct(d);
+        d = d + 2;
+    }
+
+    keep_on_stack(root);
+    return;
+}
+
+fn keep_on_stack(p:*GCTestObj) void;
+
+fn time_construct(depth: i64) void {
+    let i_num_iters = num_iters(depth);
+    // println!(i_num_iters);
+    for let i = 0; i < i_num_iters; i = i + 1 {
+        let temp_tree = make_tree(depth);
+        populate(depth, temp_tree);
+    }
+    for let i = 0; i < i_num_iters; i = i + 1 {
+        make_tree(depth);
+    }
+    return;
+}
+
+
+
+
+fn tree_size(i: i64) i64 {
+    
+    return (1<<(i+1)) -1;
+}
+
+
+var K_STRETCH_TREE_DEPTH = &18;
+var K_LONG_LIVED_TREE_DEPTH = & 16;
+var K_MIN_TREE_DEPTH = & 4;
+var K_MAX_TREE_DEPTH = & 16;
+
+
+fn num_iters(i:i64) i64 {
+    
+    return 2 * tree_size(*K_STRETCH_TREE_DEPTH) / tree_size(i);
+}
+
+struct GCTestObj {
+    b:* GCTestObj;
+    d:u64;
+    e:*GCTestObj;
+    d0:u64;
+    d1:u64;
+    d2:u64;
+    d3:u64;
+    d4:u64;
+    d5:u64;
+    d6:u64;
+    d7:u64;
+    d8:u64;
+    d9:u64;
+    d10:u64;
+    d11:u64;
+
+
+}
+
+fn populate(idepth: i64, thisnode: * GCTestObj) void {
+    if idepth <= 0 {
+        return;
+    }
+    thisnode.b =  &GCTestObj{};
+    thisnode.e =  &GCTestObj{};
+    populate(idepth-1, thisnode.b);
+    populate(idepth-1, thisnode.e);
+    return;
+}
+
+
+fn make_tree(idepth: i64) * GCTestObj {
+    if idepth <= 0 {
+        return  &GCTestObj{};
+    }
+    let left = make_tree(idepth-1);
+    let right = make_tree(idepth-1);
+    let thisnode =  &GCTestObj{b: left, e: right};
+    return thisnode;
+}

vm/src/lib.rs

@@ -288,3 +288,13 @@ thread_local! {
 fn exit_now(code: i64) {
     std::process::exit(code as _);
 }
+
+#[is_runtime]
+fn millitime() -> i64 {
+    let now = std::time::SystemTime::now();
+    let duration = now.duration_since(std::time::UNIX_EPOCH).unwrap();
+    duration.as_millis() as _
+}
+
+#[is_runtime]
+fn keep_on_stack(_p: i64) {}

vm/src/libcwrap/mod.rs

@@ -120,9 +120,9 @@ fn getrandom_inner(
 ) -> libc::ssize_t {
     unsafe {
         if getentropy(buf as *mut u8, buflen) == 0 {
-            return buflen as libc::ssize_t;
+            buflen as libc::ssize_t
         } else {
-            return -1;
+            -1
         }
     }
 }