Basic GC Support

mmtk/src/api.rs

@@ -3,24 +3,53 @@ use libc::c_void;
 use mmtk::memory_manager;
 use mmtk::scheduler::GCWorker;
 use mmtk::util::opaque_pointer::*;
+use mmtk::util::options::PlanSelector;
 use mmtk::util::{Address, ObjectReference};
 use mmtk::AllocationSemantics;
 use mmtk::Mutator;
 use mmtk::MMTK;
+use mmtk::policy::space::Space;
 use std::ffi::CStr;
 
 use V8_Upcalls;
 use UPCALLS;
 use V8;
 
+/// Release an address buffer
+#[no_mangle]
+pub unsafe extern "C" fn mmtk_release_buffer(ptr: *mut Address, length: usize, capacity: usize) {
+    let _vec = Vec::<Address>::from_raw_parts(ptr, length, capacity);
+}
+
+/// Check whether an object is movable.
+#[no_mangle]
+pub unsafe extern "C" fn mmtk_is_movable(object: ObjectReference) -> i32 {
+    let object = {
+        let untagged_word = object.to_address().as_usize() & !0b11usize;
+        Address::from_usize(untagged_word).to_object_reference()
+    };
+    if object.is_movable() { 1 } else { 0 }
+}
+
+/// Get the forwarding pointer, or NULL if the object is not forwarded
+#[no_mangle]
+pub unsafe extern "C" fn mmtk_get_forwarded_object(object: ObjectReference) -> *mut c_void {
+    let tag = object.to_address().as_usize() & 0b11usize;
+    let object = {
+        let untagged_word = object.to_address().as_usize() & !0b11usize;
+        Address::from_usize(untagged_word).to_object_reference()
+    };
+    object.get_forwarded_object().map(|x| (x.to_address().as_usize() | tag) as *mut c_void).unwrap_or(0 as _)
+}
+
 #[no_mangle]
 pub extern "C" fn v8_new_heap(calls: *const V8_Upcalls, heap_size: usize) -> *mut c_void {
     unsafe {
         UPCALLS = calls;
     };
-    let mmtk: Box<MMTK<V8>> = Box::new(MMTK::new());
-    let mmtk: *mut MMTK<V8> = Box::into_raw(mmtk);
-    memory_manager::gc_init(unsafe { &mut *mmtk }, heap_size);
+    let mmtk: *const MMTK<V8> = &*crate::SINGLETON;
+    memory_manager::gc_init(unsafe { &mut *(mmtk as *mut MMTK<V8>) }, heap_size);
+    initialize_collection(unsafe { &mut *(mmtk as *mut MMTK<V8>) }, VMThread::UNINITIALIZED);
 
     mmtk as *mut c_void
 }
@@ -38,6 +67,25 @@ pub extern "C" fn bind_mutator(
     Box::into_raw(memory_manager::bind_mutator(mmtk, tls))
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn mmtk_in_space(mmtk: &'static MMTK<V8>, object: ObjectReference, space: AllocationSemantics) -> i32 {
+    match space {
+        AllocationSemantics::Default => {
+            (object.is_mapped()
+                && mmtk_in_space(mmtk, object, AllocationSemantics::ReadOnly) == 0
+                && mmtk_in_space(mmtk, object, AllocationSemantics::Immortal) == 0
+                && mmtk_in_space(mmtk, object, AllocationSemantics::Los) == 0
+                && mmtk_in_space(mmtk, object, AllocationSemantics::Code) == 0
+                && mmtk_in_space(mmtk, object, AllocationSemantics::LargeCode) == 0) as _
+        },
+        AllocationSemantics::ReadOnly => mmtk.plan.base().ro_space.in_space(object) as _,
+        AllocationSemantics::Immortal => mmtk.plan.common().immortal.in_space(object) as _,
+        AllocationSemantics::Los => mmtk.plan.common().los.in_space(object) as _,
+        AllocationSemantics::Code => mmtk.plan.base().code_space.in_space(object) as _,
+        AllocationSemantics::LargeCode => mmtk.plan.base().code_lo_space.in_space(object) as _,
+    }
+}
+
 #[no_mangle]
 // It is fine we turn the pointer back to box, as we turned a boxed value to the raw pointer in bind_mutator()
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
@@ -53,7 +101,18 @@ pub extern "C" fn alloc(
     offset: isize,
     semantics: AllocationSemantics,
 ) -> Address {
-    memory_manager::alloc::<V8>(mutator, size, align, offset, semantics)
+    let a = memory_manager::alloc::<V8>(mutator, size, align, offset, semantics);
+    unsafe { memory_manager::post_alloc::<V8>(mutator, a.to_object_reference(), size, semantics); }
+    if PlanSelector::PageProtect == mutator.plan.options().plan && AllocationSemantics::Default == semantics {
+        // Possible `array_header_size` values that can be passed to [AllocateUninitializedJSArrayWithElements](https://source.chromium.org/chromium/chromium/src/+/main:v8/src/codegen/code-stub-assembler.h;l=1884).
+        let array_header_sizes = [0x20, 0x50, 0x58];
+        for array_header_size in array_header_sizes {
+            unsafe {
+                memory_manager::post_alloc::<V8>(mutator, a.add(array_header_size).to_object_reference(), 0, semantics);
+            }
+        }
+    }
+    a
 }
 
 #[no_mangle]
@@ -107,8 +166,12 @@ pub extern "C" fn scan_region(mmtk: &mut MMTK<V8>) {
 }
 
 #[no_mangle]
-pub extern "C" fn is_live_object(object: ObjectReference) -> bool {
-    object.is_live()
+pub extern "C" fn mmtk_object_is_live(object: ObjectReference) -> usize {
+    debug_assert_eq!(object.to_address().as_usize() & 0b11, 0);
+    if crate::SINGLETON.plan.base().ro_space.in_space(object) {
+        return 1;
+    }
+    if object.is_reachable() { 1 } else { 0 }
 }
 
 #[no_mangle]

mmtk/src/collection.rs

@@ -1,12 +1,17 @@
 use mmtk::scheduler::GCWorker;
+use mmtk::util::*;
 use mmtk::scheduler::ProcessEdgesWork;
-use mmtk::util::opaque_pointer::*;
 use mmtk::vm::Collection;
-use mmtk::MutatorContext;
+use mmtk::{MutatorContext, MMTK};
 
 use UPCALLS;
 use V8;
 
+use crate::object_archive::global_object_archive;
+use crate::scanning::ROOT_OBJECTS;
+use crate::scanning::flush_roots;
+use crate::scanning::trace_root;
+
 pub struct VMCollection {}
 
 impl Collection<V8> for VMCollection {
@@ -28,15 +33,20 @@ impl Collection<V8> for VMCollection {
         }
     }
 
-    fn spawn_worker_thread(tls: VMThread, ctx: Option<&GCWorker<V8>>) {
+    fn spawn_worker_thread(_tls: VMThread, ctx: Option<&GCWorker<V8>>) {
         let ctx_ptr = if let Some(r) = ctx {
             r as *const GCWorker<V8> as *mut GCWorker<V8>
         } else {
             std::ptr::null_mut()
-        };
-        unsafe {
-            ((*UPCALLS).spawn_worker_thread)(tls, ctx_ptr as usize as _);
-        }
+        } as usize;
+        std::thread::spawn(move || {
+            let mmtk: *mut MMTK<V8> = &*crate::SINGLETON as *const MMTK<V8> as *mut MMTK<V8>;
+            if ctx_ptr == 0 {
+                crate::api::start_control_collector(unsafe { &mut *mmtk }, VMWorkerThread(VMThread::UNINITIALIZED));
+            } else {
+                crate::api::start_worker(unsafe { &mut *mmtk }, VMWorkerThread(VMThread::UNINITIALIZED), unsafe { &mut *(ctx_ptr as *mut GCWorker<V8>) });
+            }
+        });
     }
 
     fn prepare_mutator<T: MutatorContext<V8>>(
@@ -46,4 +56,19 @@ impl Collection<V8> for VMCollection {
     ) {
         unimplemented!()
     }
+
+    fn vm_release() {
+        global_object_archive().update();
+    }
+
+    fn process_weak_refs<E: ProcessEdgesWork<VM = V8>>(worker: &mut GCWorker<V8>) {
+        unsafe {
+            debug_assert!(ROOT_OBJECTS.is_empty());
+            ((*UPCALLS).process_weak_refs)(trace_root::<E> as _, worker as *mut _ as _);
+            if !ROOT_OBJECTS.is_empty() {
+                flush_roots::<E>(worker);
+            }
+            debug_assert!(ROOT_OBJECTS.is_empty());
+        }
+    }
 }

mmtk/src/lib.rs

@@ -1,3 +1,7 @@
+#![feature(vec_into_raw_parts)]
+#![feature(thread_local)]
+#![feature(const_option)]
+
 extern crate libc;
 extern crate mmtk;
 #[macro_use]
@@ -6,6 +10,7 @@ extern crate lazy_static;
 #[macro_use]
 extern crate log;
 
+use std::env;
 use std::ptr::null_mut;
 
 use libc::c_void;
@@ -22,6 +27,17 @@ mod object_archive;
 pub mod object_model;
 pub mod reference_glue;
 pub mod scanning;
+use mmtk::util::{Address};
+
+#[repr(C)]
+pub struct NewBuffer {
+    pub ptr: *mut Address,
+    pub capacity: usize,
+}
+
+type ProcessEdgesFn = *const extern "C" fn(buf: *mut Address, size: usize, cap: usize) -> NewBuffer;
+type TraceRootFn = *const extern "C" fn(slot: Address, ctx: &'static mut GCWorker<V8>) -> Address;
+type TraceFieldFn = *const extern "C" fn(slot: Address, ctx: &'static mut GCWorker<V8>) -> Address;
 
 #[repr(C)]
 pub struct V8_Upcalls {
@@ -39,6 +55,11 @@ pub struct V8_Upcalls {
     pub get_object_size: extern "C" fn(object: ObjectReference) -> usize,
     pub get_mmtk_mutator: extern "C" fn(tls: VMMutatorThread) -> *mut Mutator<V8>,
     pub is_mutator: extern "C" fn(tls: VMThread) -> bool,
+    pub scan_roots: extern "C" fn(trace_root: TraceRootFn, context: *mut c_void, task_id: usize),
+    pub scan_objects: extern "C" fn(objects: *const ObjectReference, count: usize, process_edges: ProcessEdgesFn, trace_field: TraceFieldFn, context: *mut c_void, task_id: usize),
+    pub process_weak_refs: extern "C" fn(trace_root: TraceRootFn, context: *mut c_void),
+    pub on_move_event: extern "C" fn(from: ObjectReference, to: ObjectReference, size: usize),
+    pub process_ephemerons: extern "C" fn(trace_root: TraceRootFn, context: *mut c_void, task_id: usize),
 }
 
 pub static mut UPCALLS: *const V8_Upcalls = null_mut();
@@ -58,9 +79,15 @@ impl VMBinding for V8 {
 
 lazy_static! {
     pub static ref SINGLETON: MMTK<V8> = {
-        #[cfg(feature = "nogc")]
-        std::env::set_var("MMTK_PLAN", "NoGC");
-
+        // V8 can only support up to 8 worker threads.
+        // Set MMTK_THREADS = 7 here to exclude the main thread -- it undertakes part of the worker's job.
+        if let Ok(threads) = env::var("MMTK_THREADS").map(|x| x.parse::<usize>().unwrap()) {
+            if threads > 7 {
+                env::set_var("MMTK_THREADS", "7");
+            }
+        } else {
+            env::set_var("MMTK_THREADS", "7");
+        }
         MMTK::new()
     };
 }