Introduce a context object for GC controller thread (#533)

* Introduce context for the GC controller thread

This commit introduces the `GCController` struct.  It is owned by the GC
controller thread.  It owns the `GCWorker` for the controller, and has
references to objects that it needs to communicate with other threads.

Previously, those dependencies were scattered in
`ControllerCollectorContext` and `GCWorkScheduler`, which complicated
the initialization of the MMTk instance and the GC controller thread.

* Move controller functions to GCController

Move the GCWorkScheduler::wait_for_completion method to the GCController
type.  This allows us to move controller-specific fields away from
GCWorkScheduler, too.

* Miscellaneous fixes.

-   Renamed ControllerCollectorContext to GCRequester
-   Removed initializer and finalizer functions from GCWorkScheduler
-   The embedded GCController is no longer boxed.
-   Added comments
-   Minor adjustment to API functions.
-   Other minor fixes.

Author: wks

docs/tutorial/code/mygc_semispace/global.rs

@@ -79,9 +79,8 @@ impl<VM: VMBinding> Plan for MyGC<VM> {
         &mut self,
         heap_size: usize,
         vm_map: &'static VMMap,
-        scheduler: &Arc<GCWorkScheduler<VM>>,
     ) {
-        self.common.gc_init(heap_size, vm_map, scheduler);
+        self.common.gc_init(heap_size, vm_map);
         self.copyspace0.init(&vm_map);
         self.copyspace1.init(&vm_map);
     }

examples/mmtk.h

@@ -86,7 +86,7 @@ extern void mmtk_scan_region();
 extern void mmtk_handle_user_collection_request(void* tls);
 
 // Run the main loop for the GC controller thread. Does not return
-extern void mmtk_start_control_collector(void* tls);
+extern void mmtk_start_control_collector(void* tls, void* worker);
 
 // Run the main loop for a GC worker. Does not return
 extern void mmtk_start_worker(void* tls, void* worker);

src/memory_manager.rs

@@ -15,26 +15,16 @@ use crate::mmtk::MMTK;
 use crate::plan::AllocationSemantics;
 use crate::plan::{Mutator, MutatorContext};
 use crate::scheduler::WorkBucketStage;
-use crate::scheduler::{GCWork, GCWorker};
+use crate::scheduler::{GCController, GCWork, GCWorker};
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::constants::{LOG_BYTES_IN_PAGE, MIN_OBJECT_SIZE};
 use crate::util::heap::layout::vm_layout_constants::HEAP_END;
 use crate::util::heap::layout::vm_layout_constants::HEAP_START;
 use crate::util::opaque_pointer::*;
 use crate::util::{Address, ObjectReference};
-use crate::vm::Collection;
 use crate::vm::VMBinding;
 use std::sync::atomic::Ordering;
 
-/// Run the main loop for the GC controller thread. This method does not return.
-///
-/// Arguments:
-/// * `mmtk`: A reference to an MMTk instance.
-/// * `tls`: The thread that will be used as the GC controller.
-pub fn start_control_collector<VM: VMBinding>(mmtk: &MMTK<VM>, tls: VMWorkerThread) {
-    mmtk.plan.base().control_collector_context.run(tls);
-}
-
 /// Initialize an MMTk instance. A VM should call this method after creating an [MMTK](../mmtk/struct.MMTK.html)
 /// instance but before using any of the methods provided in MMTk. This method will attempt to initialize a
 /// logger. If the VM would like to use its own logger, it should initialize the logger before calling this method.
@@ -69,8 +59,7 @@ pub fn gc_init<VM: VMBinding>(mmtk: &'static mut MMTK<VM>, heap_size: usize) {
         }
     }
     assert!(heap_size > 0, "Invalid heap size");
-    mmtk.plan
-        .gc_init(heap_size, &crate::VM_MAP, &mmtk.scheduler);
+    mmtk.plan.gc_init(heap_size, &crate::VM_MAP);
     info!("Initialized MMTk with {:?}", *mmtk.options.plan);
     #[cfg(feature = "extreme_assertions")]
     warn!("The feature 'extreme_assertions' is enabled. MMTk will run expensive run-time checks. Slow performance should be expected.");
@@ -163,36 +152,51 @@ pub fn get_allocator_mapping<VM: VMBinding>(
     mmtk.plan.get_allocator_mapping()[semantics]
 }
 
+/// Run the main loop for the GC controller thread. This method does not return.
+///
+/// Arguments:
+/// * `tls`: The thread that will be used as the GC controller.
+/// * `gc_controller`: The execution context of the GC controller threa.
+///   It is the `GCController` passed to `Collection::spawn_gc_thread`.
+/// * `mmtk`: A reference to an MMTk instance.
+pub fn start_control_collector<VM: VMBinding>(
+    _mmtk: &'static MMTK<VM>,
+    tls: VMWorkerThread,
+    gc_controller: &mut GCController<VM>,
+) {
+    gc_controller.run(tls);
+}
+
 /// Run the main loop of a GC worker. This method does not return.
 ///
 /// Arguments:
 /// * `tls`: The thread that will be used as the GC worker.
-/// * `worker`: A reference to the GC worker.
+/// * `worker`: The execution context of the GC worker thread.
+///   It is the `GCWorker` passed to `Collection::spawn_gc_thread`.
 /// * `mmtk`: A reference to an MMTk instance.
 pub fn start_worker<VM: VMBinding>(
+    mmtk: &'static MMTK<VM>,
     tls: VMWorkerThread,
     worker: &mut GCWorker<VM>,
-    mmtk: &'static MMTK<VM>,
 ) {
     worker.run(tls, mmtk);
 }
 
 /// Initialize the scheduler and GC workers that are required for doing garbage collections.
 /// This is a mandatory call for a VM during its boot process once its thread system
-/// is ready. This should only be called once. This call will invoke Collection::spawn_worker_thread()
+/// is ready. This should only be called once. This call will invoke Collection::spawn_gc_thread()
 /// to create GC threads.
 ///
 /// Arguments:
 /// * `mmtk`: A reference to an MMTk instance.
 /// * `tls`: The thread that wants to enable the collection. This value will be passed back to the VM in
-///   Collection::spawn_worker_thread() so that the VM knows the context.
+///   Collection::spawn_gc_thread() so that the VM knows the context.
 pub fn initialize_collection<VM: VMBinding>(mmtk: &'static MMTK<VM>, tls: VMThread) {
     assert!(
         !mmtk.plan.is_initialized(),
         "MMTk collection has been initialized (was initialize_collection() already called before?)"
     );
     mmtk.scheduler.initialize(*mmtk.options.threads, mmtk, tls);
-    VM::VMCollection::spawn_worker_thread(tls, None); // spawn controller thread
     mmtk.plan.base().initialized.store(true, Ordering::SeqCst);
 }
 

src/plan/controller_collector_context.rs

@@ -0,0 +1,66 @@
+use crate::vm::VMBinding;
+use std::marker::PhantomData;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Condvar, Mutex};
+
+struct RequestSync {
+    request_count: isize,
+    last_request_count: isize,
+}
+
+/// GC requester.  This object allows other threads to request (trigger) GC,
+/// and the GC coordinator thread waits for GC requests using this object.
+pub struct GCRequester<VM: VMBinding> {
+    request_sync: Mutex<RequestSync>,
+    request_condvar: Condvar,
+    request_flag: AtomicBool,
+    phantom: PhantomData<VM>,
+}
+
+// Clippy says we need this...
+impl<VM: VMBinding> Default for GCRequester<VM> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<VM: VMBinding> GCRequester<VM> {
+    pub fn new() -> Self {
+        GCRequester {
+            request_sync: Mutex::new(RequestSync {
+                request_count: 0,
+                last_request_count: -1,
+            }),
+            request_condvar: Condvar::new(),
+            request_flag: AtomicBool::new(false),
+            phantom: PhantomData,
+        }
+    }
+
+    pub fn request(&self) {
+        if self.request_flag.load(Ordering::Relaxed) {
+            return;
+        }
+
+        let mut guard = self.request_sync.lock().unwrap();
+        if !self.request_flag.load(Ordering::Relaxed) {
+            self.request_flag.store(true, Ordering::Relaxed);
+            guard.request_count += 1;
+            self.request_condvar.notify_all();
+        }
+    }
+
+    pub fn clear_request(&self) {
+        let guard = self.request_sync.lock().unwrap();
+        self.request_flag.store(false, Ordering::Relaxed);
+        drop(guard);
+    }
+
+    pub fn wait_for_request(&self) {
+        let mut guard = self.request_sync.lock().unwrap();
+        guard.last_request_count += 1;
+        while guard.last_request_count == guard.request_count {
+            guard = self.request_condvar.wait(guard).unwrap();
+        }
+    }
+}

src/plan/gc_requester.rs

@@ -72,13 +72,8 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {
         self.gen.last_collection_full_heap()
     }
 
-    fn gc_init(
-        &mut self,
-        heap_size: usize,
-        vm_map: &'static VMMap,
-        scheduler: &Arc<GCWorkScheduler<VM>>,
-    ) {
-        self.gen.gc_init(heap_size, vm_map, scheduler);
+    fn gc_init(&mut self, heap_size: usize, vm_map: &'static VMMap) {
+        self.gen.gc_init(heap_size, vm_map);
         self.copyspace0.init(vm_map);
         self.copyspace1.init(vm_map);
     }

src/plan/generational/copying/global.rs

@@ -74,13 +74,8 @@ impl<VM: VMBinding> Gen<VM> {
     }
 
     /// Initialize Gen. This should be called by the gc_init() API call.
-    pub fn gc_init(
-        &mut self,
-        heap_size: usize,
-        vm_map: &'static VMMap,
-        scheduler: &Arc<GCWorkScheduler<VM>>,
-    ) {
-        self.common.gc_init(heap_size, vm_map, scheduler);
+    pub fn gc_init(&mut self, heap_size: usize, vm_map: &'static VMMap) {
+        self.common.gc_init(heap_size, vm_map);
         self.nursery.init(vm_map);
     }
 

src/plan/generational/global.rs

@@ -97,13 +97,8 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
         self.gen.collection_required(self, space_full, space)
     }
 
-    fn gc_init(
-        &mut self,
-        heap_size: usize,
-        vm_map: &'static VMMap,
-        scheduler: &Arc<GCWorkScheduler<VM>>,
-    ) {
-        self.gen.gc_init(heap_size, vm_map, scheduler);
+    fn gc_init(&mut self, heap_size: usize, vm_map: &'static VMMap) {
+        self.gen.gc_init(heap_size, vm_map);
         self.immix.init(vm_map);
     }