Merge branch 'frame'

Author: sisshiki1969

src/alloc.rs

@@ -1,6 +1,26 @@
 use crate::*;
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::cell::RefCell;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+struct MyAllocator;
+
+unsafe impl GlobalAlloc for MyAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        MALLOC_AMOUNT.fetch_add(layout.size(), Ordering::SeqCst);
+        System.alloc(layout)
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        MALLOC_AMOUNT.fetch_sub(layout.size(), Ordering::SeqCst);
+        System.dealloc(ptr, layout)
+    }
+}
+
+#[global_allocator]
+static GLOBAL: MyAllocator = MyAllocator;
+
+pub static MALLOC_AMOUNT: AtomicUsize = AtomicUsize::new(0);
 
 thread_local!(
     pub static ALLOC: RefCell<Allocator> = RefCell::new(Allocator::new());
@@ -17,14 +37,12 @@ pub trait GC {
     fn mark(&self, alloc: &mut Allocator);
 }
 
-///-----------------------------------------------------------------------------------------------------------------
 ///
 /// Heap page struct.
 ///
 /// Single page occupies `ALLOC_SIZE` bytes in memory.
 /// This struct contains 64 * (`SIZE` - 1) `GCBox` cells, and bitmap (`SIZE` - 1 bytes each) for marking phase.
 ///
-///-----------------------------------------------------------------------------------------------------------------
 struct Page {
     data: [GCBox<RValue>; DATA_LEN],
     mark_bits: [u64; SIZE - 1],

src/coroutine/stack.rs

@@ -1,10 +1,8 @@
 use super::*;
 use once_cell::sync::Lazy;
 use region::{protect, Protection};
-use std::{
-    alloc::{alloc, Layout, LayoutError},
-    sync::Mutex,
-};
+use std::alloc::{GlobalAlloc, Layout, LayoutError, System};
+use std::sync::Mutex;
 
 const DEFAULT_STACK_SIZE: usize = 1024 * 512;
 const STACK_LAYOUT: Result<Layout, LayoutError> =
@@ -41,7 +39,7 @@ impl Stack {
     pub(crate) fn allocate() -> Self {
         match STACK_STORE.lock().unwrap().pop() {
             None => unsafe {
-                let stack = alloc(STACK_LAYOUT.unwrap());
+                let stack = System.alloc(STACK_LAYOUT.unwrap());
                 protect(stack, DEFAULT_STACK_SIZE, Protection::READ_WRITE)
                     .expect("Mprotect failed.");
                 Stack(stack)

src/vm/executor.rs

@@ -469,23 +469,23 @@ impl VM {
 
 impl VM {
     fn gc(&mut self) {
-        //let malloced = MALLOC_AMOUNT.with(|x| x.borrow().clone());
+        let malloced = MALLOC_AMOUNT.load(std::sync::atomic::Ordering::SeqCst);
         let (object_trigger, malloc_trigger) = ALLOC.with(|m| {
             let m = m.borrow();
-            (m.is_allocated(), false)
+            (m.is_allocated(), m.malloc_threshold < malloced)
         });
         if !object_trigger && !malloc_trigger {
             return;
         }
         #[cfg(feature = "perf")]
         self.globals.perf.get_perf(Perf::GC);
         self.globals.gc();
-        /*if malloc_trigger {
-            let malloced = MALLOC_AMOUNT.with(|x| x.borrow().clone());
+        if malloc_trigger {
+            let malloced = MALLOC_AMOUNT.load(std::sync::atomic::Ordering::SeqCst);
             if malloced > 0 {
                 ALLOC.with(|m| m.borrow_mut().malloc_threshold = (malloced * 2) as usize);
             }
-        }*/
+        }
     }
 
     fn jmp_cond(&mut self, cond: bool, inst_offset: usize, dest_offset: usize) {