Enable copying GC

Author: wks

mmtk/src/abi.rs

@@ -273,6 +273,7 @@ pub struct RubyBindingOptions {
 pub struct RubyUpcalls {
     pub init_gc_worker_thread: extern "C" fn(gc_worker_tls: *mut GCThreadTLS),
     pub get_gc_thread_tls: extern "C" fn() -> *mut GCThreadTLS,
+    pub is_mutator: extern "C" fn() -> bool,
     pub stop_the_world: extern "C" fn(tls: VMWorkerThread),
     pub resume_mutators: extern "C" fn(tls: VMWorkerThread),
     pub block_for_gc: extern "C" fn(tls: VMMutatorThread),

mmtk/src/active_plan.rs

@@ -18,8 +18,7 @@ impl ActivePlan<Ruby> for VMActivePlan {
     }
 
     fn is_mutator(_tls: VMThread) -> bool {
-        // FIXME
-        true
+        (upcalls().is_mutator)()
     }
 
     fn mutator(_tls: VMMutatorThread) -> &'static mut Mutator<Ruby> {

mmtk/src/binding.rs

@@ -1,7 +1,8 @@
 use std::ffi::CString;
 use std::sync::Mutex;
 
-use mmtk::MMTK;
+use mmtk::util::ObjectReference;
+use mmtk::{memory_manager, MMTK};
 
 use crate::abi;
 use crate::abi::RubyBindingOptions;
@@ -27,6 +28,7 @@ pub struct RubyBinding {
     pub plan_name: Mutex<Option<CString>>,
     pub weak_proc: WeakProcessor,
     pub ppp_registry: PPPRegistry,
+    pub(crate) pinned_roots: Mutex<Vec<ObjectReference>>,
 }
 
 unsafe impl Sync for RubyBinding {}
@@ -48,6 +50,7 @@ impl RubyBinding {
             plan_name: Mutex::new(None),
             weak_proc: WeakProcessor::new(),
             ppp_registry: PPPRegistry::new(),
+            pinned_roots: Default::default(),
         }
     }
 
@@ -65,4 +68,16 @@ impl RubyBinding {
         }
         plan_name.as_deref().unwrap().as_ptr()
     }
+
+    pub(crate) fn unpin_pinned_roots(&self) {
+        let mut pinned_roots = self
+            .pinned_roots
+            .try_lock()
+            .expect("It is accessed during weak ref processing. Should have no race.");
+
+        for object in pinned_roots.drain(..) {
+            let result = memory_manager::unpin_object::<Ruby>(object);
+            debug_assert!(result);
+        }
+    }
 }

mmtk/src/scanning.rs

@@ -4,7 +4,7 @@ use crate::{upcalls, Ruby, RubyEdge};
 use mmtk::scheduler::GCWorker;
 use mmtk::util::{ObjectReference, VMWorkerThread};
 use mmtk::vm::{EdgeVisitor, ObjectTracer, RootsWorkFactory, Scanning};
-use mmtk::{Mutator, MutatorContext};
+use mmtk::{memory_manager, Mutator, MutatorContext};
 
 pub struct VMScanning {}
 
@@ -33,8 +33,13 @@ impl Scanning<Ruby> for VMScanning {
             "Not an MMTk object: {object}",
         );
         let gc_tls = unsafe { GCThreadTLS::from_vwt_check(tls) };
-        let visit_object = |_worker, target_object: ObjectReference, _pin| {
-            trace!("Tracing object: {} -> {}", object, target_object);
+        let visit_object = |_worker, target_object: ObjectReference, pin| {
+            trace!(
+                "Tracing object: {} -> {}{}",
+                object,
+                target_object,
+                if pin { " pin" } else { "" }
+            );
             debug_assert!(
                 mmtk::memory_manager::is_mmtk_object(target_object.to_raw_address()),
                 "Destination is not an MMTk object. Src: {object} dst: {target_object}"
@@ -90,6 +95,7 @@ impl Scanning<Ruby> for VMScanning {
             .weak_proc
             .process_weak_stuff(worker, tracer_context);
         crate::binding().ppp_registry.cleanup_ppps();
+        crate::binding().unpin_pinned_roots();
         false
     }
 
@@ -111,8 +117,21 @@ impl VMScanning {
         callback: F,
     ) {
         let mut buffer: Vec<ObjectReference> = Vec::new();
-        let visit_object = |_, object: ObjectReference, _pin| {
-            debug!("[{}] Scanning object: {}", root_scan_kind, object);
+        let mut my_pinned_roots = vec![];
+        let visit_object = |_, object: ObjectReference, pin| {
+            debug!(
+                "[{}] Visiting object: {}{}",
+                root_scan_kind,
+                object,
+                if pin {
+                    "(unmovable root)"
+                } else {
+                    "(movable, but we pin it anyway)"
+                }
+            );
+            if memory_manager::pin_object::<Ruby>(object) {
+                my_pinned_roots.push(object);
+            }
             buffer.push(object);
             if buffer.len() >= Self::OBJECT_BUFFER_SIZE {
                 factory.create_process_node_roots_work(std::mem::take(&mut buffer));
@@ -122,8 +141,20 @@ impl VMScanning {
         gc_tls
             .object_closure
             .set_temporarily_and_run_code(visit_object, callback);
+
         if !buffer.is_empty() {
             factory.create_process_node_roots_work(buffer);
         }
+
+        info!(
+            "Pinned {} node roots during {}",
+            my_pinned_roots.len(),
+            root_scan_kind
+        );
+
+        {
+            let mut pinned_roots = crate::binding().pinned_roots.lock().unwrap();
+            pinned_roots.append(&mut my_pinned_roots);
+        }
     }
 }