(Experimental) Join GC threads on the binding side.

mmtk/Cargo.toml

@@ -36,11 +36,11 @@ probe = "0.5"
 features = ["is_mmtk_object", "object_pinning"]
 
 # Uncomment the following lines to use mmtk-core from the official repository.
-git = "https://github.com/mmtk/mmtk-core.git"
-rev = "42754a5f23fdb513039d7f07e52014ded42c98bf"
+#git = "https://github.com/wks/mmtk-core.git"
+#rev = "7cb0b2c12be341c084e03f2cd943fad8ac088f83"
 
 # Uncomment the following line to use mmtk-core from a local repository.
-#path = "../../mmtk-core"
+path = "../../mmtk-core"
 
 [features]
 default = []

mmtk/src/abi.rs

@@ -1,13 +1,12 @@
 use crate::api::RubyMutator;
 use crate::{upcalls, Ruby};
-use mmtk::scheduler::{GCController, GCWorker};
+use mmtk::scheduler::GCWorker;
 use mmtk::util::{Address, ObjectReference, VMMutatorThread, VMWorkerThread};
 
 // For the C binding
 pub const OBJREF_OFFSET: usize = 8;
 pub const MIN_OBJ_ALIGN: usize = 8; // Even on 32-bit machine.  A Ruby object is at least 40 bytes large.
 
-pub const GC_THREAD_KIND_CONTROLLER: libc::c_int = 0;
 pub const GC_THREAD_KIND_WORKER: libc::c_int = 1;
 
 const HAS_MOVED_GIVTBL: usize = 1 << 63;
@@ -244,10 +243,6 @@ impl GCThreadTLS {
         }
     }
 
-    pub fn for_controller(gc_context: *mut GCController<Ruby>) -> Self {
-        Self::new(GC_THREAD_KIND_CONTROLLER, gc_context as *mut libc::c_void)
-    }
-
     pub fn for_worker(gc_context: *mut GCWorker<Ruby>) -> Self {
         Self::new(GC_THREAD_KIND_WORKER, gc_context as *mut libc::c_void)
     }
@@ -266,7 +261,7 @@ impl GCThreadTLS {
         let result = &mut *ptr;
         debug_assert!({
             let kind = result.kind;
-            kind == GC_THREAD_KIND_CONTROLLER || kind == GC_THREAD_KIND_WORKER
+            kind == GC_THREAD_KIND_WORKER
         });
         result
     }

mmtk/src/api.rs

@@ -154,6 +154,17 @@ pub extern "C" fn mmtk_initialize_collection(tls: VMThread) {
     memory_manager::initialize_collection(mmtk(), tls)
 }
 
+#[no_mangle]
+pub extern "C" fn mmtk_prepare_to_fork() {
+    mmtk().prepare_to_fork();
+    binding().join_all_gc_threads();
+}
+
+#[no_mangle]
+pub extern "C" fn mmtk_after_fork(tls: VMThread) {
+    mmtk().after_fork(tls);
+}
+
 #[no_mangle]
 pub extern "C" fn mmtk_enable_collection() {
     memory_manager::enable_collection(mmtk())

mmtk/src/binding.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::ffi::CString;
 use std::sync::Mutex;
+use std::thread::JoinHandle;
 
 use libc::c_void;
 use mmtk::util::ObjectReference;
@@ -36,6 +37,7 @@ pub struct RubyBinding {
     pub weak_proc: WeakProcessor,
     pub ppp_registry: PPPRegistry,
     pub(crate) moved_givtbl: Mutex<HashMap<ObjectReference, MovedGIVTblEntry>>,
+    pub gc_thread_join_handles: Mutex<Vec<JoinHandle<()>>>
 }
 
 unsafe impl Sync for RubyBinding {}
@@ -58,6 +60,7 @@ impl RubyBinding {
             weak_proc: WeakProcessor::new(),
             ppp_registry: PPPRegistry::new(),
             moved_givtbl: Default::default(),
+            gc_thread_join_handles: Default::default(),
         }
     }
 
@@ -75,4 +78,20 @@ impl RubyBinding {
         }
         plan_name.as_deref().unwrap().as_ptr()
     }
+
+    pub fn join_all_gc_threads(&self) {
+        let handles = {
+            let mut guard = self.gc_thread_join_handles.lock().unwrap();
+            std::mem::take(&mut *guard)
+        };
+
+        debug!("Joining GC threads...");
+        let total = handles.len();
+        let mut joined = 0;
+        for handle in handles {
+            handle.join().unwrap();
+            joined += 1;
+            debug!("{joined}/{total} GC threads joined.");
+        }
+    }
 }