Return join handles when spawning GC threads

Author: wks

mmtk/src/collection.rs

@@ -1,6 +1,7 @@
 use crate::abi::GCThreadTLS;
 
 use crate::api::RubyMutator;
+use crate::gc_thread::RubyGCThreadJoinHandle;
 use crate::{mmtk, upcalls, Ruby};
 use mmtk::memory_manager;
 use mmtk::scheduler::*;
@@ -31,36 +32,36 @@ impl Collection<Ruby> for VMCollection {
         (upcalls().block_for_gc)(tls);
     }
 
-    fn spawn_gc_thread(_tls: VMThread, ctx: GCThreadContext<Ruby>) {
-        match ctx {
-            GCThreadContext::Worker(mut worker) => {
-                thread::Builder::new()
-                    .name("MMTk Worker Thread".to_string())
-                    .spawn(move || {
-                        let ordinal = worker.ordinal;
-                        debug!(
-                            "Hello! This is MMTk Worker Thread running! ordinal: {}",
-                            ordinal
-                        );
-                        crate::register_gc_thread(thread::current().id());
-                        let ptr_worker = &mut *worker as *mut GCWorker<Ruby>;
-                        let gc_thread_tls =
-                            Box::into_raw(Box::new(GCThreadTLS::for_worker(ptr_worker)));
-                        (upcalls().init_gc_worker_thread)(gc_thread_tls);
-                        memory_manager::start_worker(
-                            mmtk(),
-                            GCThreadTLS::to_vwt(gc_thread_tls),
-                            worker,
-                        );
-                        debug!(
-                            "An MMTk Worker Thread is quitting. Good bye! ordinal: {}",
-                            ordinal
-                        );
-                        crate::unregister_gc_thread(thread::current().id());
-                    })
-                    .unwrap();
-            }
-        }
+    fn spawn_gc_thread(_tls: VMThread, ctx: GCThreadContext<Ruby>) -> RubyGCThreadJoinHandle {
+        let rust_join_handle = match ctx {
+            GCThreadContext::Worker(mut worker) => thread::Builder::new()
+                .name("MMTk Worker Thread".to_string())
+                .spawn(move || {
+                    let ordinal = worker.ordinal;
+                    debug!(
+                        "Hello! This is MMTk Worker Thread running! ordinal: {}",
+                        ordinal
+                    );
+                    crate::register_gc_thread(thread::current().id());
+                    let ptr_worker = &mut *worker as *mut GCWorker<Ruby>;
+                    let gc_thread_tls =
+                        Box::into_raw(Box::new(GCThreadTLS::for_worker(ptr_worker)));
+                    (upcalls().init_gc_worker_thread)(gc_thread_tls);
+                    memory_manager::start_worker(
+                        mmtk(),
+                        GCThreadTLS::to_vwt(gc_thread_tls),
+                        worker,
+                    );
+                    debug!(
+                        "An MMTk Worker Thread is quitting. Good bye! ordinal: {}",
+                        ordinal
+                    );
+                    crate::unregister_gc_thread(thread::current().id());
+                })
+                .unwrap(),
+        };
+
+        RubyGCThreadJoinHandle::new(rust_join_handle)
     }
 
     fn vm_live_bytes() -> usize {

mmtk/src/gc_thread.rs

@@ -0,0 +1,20 @@
+use mmtk::vm::gc_thread::GCThreadJoinHandle;
+use std::thread::JoinHandle;
+
+/// We implement `GCThreadJoinHandle` using Rust's own `JoinHandle` because we create GC worker
+/// threads directly using the thread support in Rust's standard library.
+pub struct RubyGCThreadJoinHandle {
+    rust_join_handle: JoinHandle<()>,
+}
+
+impl RubyGCThreadJoinHandle {
+    pub fn new(rust_join_handle: JoinHandle<()>) -> Self {
+        Self { rust_join_handle }
+    }
+}
+
+impl GCThreadJoinHandle for RubyGCThreadJoinHandle {
+    fn join_native_thread(self) {
+        self.rust_join_handle.join().unwrap();
+    }
+}

mmtk/src/lib.rs

@@ -12,6 +12,7 @@ use std::thread::ThreadId;
 
 use abi::RubyUpcalls;
 use binding::{RubyBinding, RubyBindingFast};
+use gc_thread::RubyGCThreadJoinHandle;
 use mmtk::vm::edge_shape::{SimpleEdge, UnimplementedMemorySlice};
 use mmtk::vm::VMBinding;
 use mmtk::MMTK;
@@ -22,6 +23,7 @@ pub mod active_plan;
 pub mod api;
 pub mod binding;
 pub mod collection;
+pub mod gc_thread;
 pub mod object_model;
 pub mod ppp;
 pub mod reference_glue;
@@ -50,6 +52,8 @@ impl VMBinding for Ruby {
 
     type VMEdge = RubyEdge;
     type VMMemorySlice = RubyMemorySlice;
+
+    type VMGCThreadJoinHandle = RubyGCThreadJoinHandle;
 }
 
 /// The singleton object for the Ruby binding itself.