Simplify type parameters for schedule_common()

docs/tutorial/code/mygc_semispace/gc_work.rs

@@ -149,4 +149,14 @@ impl<VM: VMBinding> DerefMut for MyGCProcessEdges<VM> {
         &mut self.base
     }
 }
-// ANCHOR_END: deref
+// ANCHOR_END: deref
+
+// ANCHOR: workcontext
+pub struct MyGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for MyGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = MyGC<VM>;
+    type CopyContextType = MyGCCopyContext<VM>;
+    type ProcessEdgesWorkType = MyGCProcessEdges<VM>;
+}
+// ANCHOR_END: workcontext

docs/tutorial/code/mygc_semispace/global.rs

@@ -4,6 +4,7 @@ use crate::plan::global::BasePlan; //Modify
 use crate::plan::global::CommonPlan; // Add
 use crate::plan::global::GcStatus; // Add
 use crate::plan::mygc::mutator::ALLOCATOR_MAPPING;
+use crate::plan::mygc::gc_work::MyGCWorkContext;
 use crate::plan::AllocationSemantics;
 use crate::plan::Plan;
 use crate::plan::PlanConstraints;
@@ -96,13 +97,7 @@ impl<VM: VMBinding> Plan for MyGC<VM> {
     fn schedule_collection(&'static self, scheduler: &GCWorkScheduler<VM>) {
         self.base().set_collection_kind::<Self>(self);
         self.base().set_gc_status(GcStatus::GcPrepare);
-        scheduler.work_buckets[WorkBucketStage::Unconstrained]
-            .add(StopMutators::<MyGCProcessEdges<VM>>::new());
-        scheduler.work_buckets[WorkBucketStage::Prepare]
-            .add(Prepare::<Self, MyGCCopyContext<VM>>::new(self));
-        scheduler.work_buckets[WorkBucketStage::Release]
-            .add(Release::<Self, MyGCCopyContext<VM>>::new(self));
-        scheduler.set_finalizer(Some(EndOfGC));
+        scheduler.schedule_common_work::<MyGCWorkContext<VM>>(self);
     }
     // ANCHOR_END: schedule_collection
 

docs/tutorial/src/mygc/ss/collection.md

@@ -132,6 +132,17 @@ scheduler's prepare stage and resumes the mutators. The `StopMutators` work
 will invoke code from the bindings to scan threads and other roots, and those 
 scanning work will further push work for a transitive closure.
 
+Though you can add those work packets by yourself, `CommonPlan` provides a
+method `schedule_common()` that will add common work packets for you.
+
+To use `schedule_common()`, first we need to create a type `MyGCWorkContext`
+and implement the trait `GCWorkContext` for it. We create this type in `gc_work.rs`.
+
+```rust
+{{#include ../../../code/mygc_semispace/gc_work.rs:workcontext}}
+
+Then we implement `schedule_collection()` using `MyGCWorkContext` and `schedule_common()`.
+
 ```rust
 {{#include ../../../code/mygc_semispace/global.rs:schedule_collection}}
 ```

src/plan/generational/copying/gc_work.rs

@@ -1,4 +1,5 @@
 use super::global::GenCopy;
+use crate::plan::generational::gc_work::GenNurseryProcessEdges;
 use crate::plan::CopyContext;
 use crate::plan::PlanConstraints;
 use crate::policy::space::Space;
@@ -85,6 +86,7 @@ impl<VM: VMBinding> GenCopyMatureProcessEdges<VM> {
 
 impl<VM: VMBinding> ProcessEdgesWork for GenCopyMatureProcessEdges<VM> {
     type VM = VM;
+
     fn new(edges: Vec<Address>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
         let base = ProcessEdgesBase::new(edges, roots, mmtk);
         let plan = base.plan().downcast_ref::<GenCopy<VM>>().unwrap();
@@ -130,3 +132,19 @@ impl<VM: VMBinding> DerefMut for GenCopyMatureProcessEdges<VM> {
         &mut self.base
     }
 }
+
+pub struct GenCopyNurseryGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for GenCopyNurseryGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = GenCopy<VM>;
+    type CopyContextType = GenCopyCopyContext<VM>;
+    type ProcessEdgesWorkType = GenNurseryProcessEdges<VM, Self::CopyContextType>;
+}
+
+pub(super) struct GenCopyMatureGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for GenCopyMatureGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = GenCopy<VM>;
+    type CopyContextType = GenCopyCopyContext<VM>;
+    type ProcessEdgesWorkType = GenCopyMatureProcessEdges<VM>;
+}

src/plan/generational/copying/global.rs

@@ -1,7 +1,6 @@
-use super::gc_work::{GenCopyCopyContext, GenCopyMatureProcessEdges};
+use super::gc_work::{GenCopyCopyContext, GenCopyMatureGCWorkContext, GenCopyNurseryGCWorkContext};
 use super::mutator::ALLOCATOR_MAPPING;
 use crate::mmtk::MMTK;
-use crate::plan::generational::gc_work::GenNurseryProcessEdges;
 use crate::plan::generational::global::Gen;
 use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
@@ -86,20 +85,10 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {
         self.base().set_gc_status(GcStatus::GcPrepare);
         if !is_full_heap {
             debug!("Nursery GC");
-            self.common()
-                .schedule_common::<Self, GenNurseryProcessEdges<VM, GenCopyCopyContext<VM>>, GenCopyCopyContext<VM>>(
-                    self,
-                    &GENCOPY_CONSTRAINTS,
-                    scheduler,
-                );
+            scheduler.schedule_common_work::<GenCopyNurseryGCWorkContext<VM>>(self);
         } else {
             debug!("Full heap GC");
-            self.common()
-                .schedule_common::<Self, GenCopyMatureProcessEdges<VM>, GenCopyCopyContext<VM>>(
-                    self,
-                    &GENCOPY_CONSTRAINTS,
-                    scheduler,
-                );
+            scheduler.schedule_common_work::<GenCopyMatureGCWorkContext<VM>>(self);
         }
     }
 

src/plan/generational/gc_work.rs

@@ -9,15 +9,16 @@ use crate::MMTK;
 use std::ops::{Deref, DerefMut};
 
 /// Process edges for a nursery GC. A generatinoal plan should use this type for a nursery GC.
-pub struct GenNurseryProcessEdges<VM: VMBinding, C: CopyContext + GCWorkerLocal> {
+pub struct GenNurseryProcessEdges<VM: VMBinding, C: CopyContext<VM = VM> + GCWorkerLocal> {
     gen: &'static Gen<VM>,
     base: ProcessEdgesBase<GenNurseryProcessEdges<VM, C>>,
 }
 
-impl<VM: VMBinding, C: CopyContext + GCWorkerLocal> ProcessEdgesWork
+impl<VM: VMBinding, C: CopyContext<VM = VM> + GCWorkerLocal> ProcessEdgesWork
     for GenNurseryProcessEdges<VM, C>
 {
     type VM = VM;
+
     fn new(edges: Vec<Address>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
         let base = ProcessEdgesBase::new(edges, roots, mmtk);
         let gen = base.plan().generational();
@@ -40,14 +41,18 @@ impl<VM: VMBinding, C: CopyContext + GCWorkerLocal> ProcessEdgesWork
     }
 }
 
-impl<VM: VMBinding, C: CopyContext + GCWorkerLocal> Deref for GenNurseryProcessEdges<VM, C> {
+impl<VM: VMBinding, C: CopyContext<VM = VM> + GCWorkerLocal> Deref
+    for GenNurseryProcessEdges<VM, C>
+{
     type Target = ProcessEdgesBase<Self>;
     fn deref(&self) -> &Self::Target {
         &self.base
     }
 }
 
-impl<VM: VMBinding, C: CopyContext + GCWorkerLocal> DerefMut for GenNurseryProcessEdges<VM, C> {
+impl<VM: VMBinding, C: CopyContext<VM = VM> + GCWorkerLocal> DerefMut
+    for GenNurseryProcessEdges<VM, C>
+{
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.base
     }

src/plan/generational/immix/gc_work.rs

@@ -1,4 +1,5 @@
 use super::global::GenImmix;
+use crate::plan::generational::gc_work::GenNurseryProcessEdges;
 use crate::plan::CopyContext;
 use crate::plan::PlanConstraints;
 use crate::policy::space::Space;
@@ -187,3 +188,23 @@ impl<VM: VMBinding, const KIND: TraceKind> DerefMut for GenImmixMatureProcessEdg
         &mut self.base
     }
 }
+
+pub struct GenImmixNurseryGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for GenImmixNurseryGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = GenImmix<VM>;
+    type CopyContextType = GenImmixCopyContext<VM>;
+    type ProcessEdgesWorkType = GenNurseryProcessEdges<VM, Self::CopyContextType>;
+}
+
+pub(super) struct GenImmixMatureGCWorkContext<VM: VMBinding, const KIND: TraceKind>(
+    std::marker::PhantomData<VM>,
+);
+impl<VM: VMBinding, const KIND: TraceKind> crate::scheduler::GCWorkContext
+    for GenImmixMatureGCWorkContext<VM, KIND>
+{
+    type VM = VM;
+    type PlanType = GenImmix<VM>;
+    type CopyContextType = GenImmixCopyContext<VM>;
+    type ProcessEdgesWorkType = GenImmixMatureProcessEdges<VM, KIND>;
+}

src/plan/generational/immix/global.rs

@@ -1,5 +1,6 @@
-use super::gc_work::{GenImmixCopyContext, GenImmixMatureProcessEdges};
-use crate::plan::generational::gc_work::GenNurseryProcessEdges;
+use super::gc_work::{
+    GenImmixCopyContext, GenImmixMatureGCWorkContext, GenImmixNurseryGCWorkContext,
+};
 use crate::plan::generational::global::Gen;
 use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
@@ -127,28 +128,17 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
 
         if !is_full_heap {
             debug!("Nursery GC");
-            self.common()
-                .schedule_common::<Self, GenNurseryProcessEdges<VM, GenImmixCopyContext<VM>>, GenImmixCopyContext<VM>>(
-                    self,
-                    &GENIMMIX_CONSTRAINTS,
-                    scheduler,
-                );
+            scheduler.schedule_common_work::<GenImmixNurseryGCWorkContext<VM>>(self);
         } else if defrag {
             debug!("Full heap GC Defrag");
-            self.common()
-                .schedule_common::<Self, GenImmixMatureProcessEdges<VM, { TraceKind::Defrag }>, GenImmixCopyContext<VM>>(
+            scheduler
+                .schedule_common_work::<GenImmixMatureGCWorkContext<VM, { TraceKind::Defrag }>>(
                     self,
-                    &GENIMMIX_CONSTRAINTS,
-                    scheduler,
                 );
         } else {
             debug!("Full heap GC Fast");
-            self.common()
-                .schedule_common::<Self, GenImmixMatureProcessEdges<VM, { TraceKind::Fast }>, GenImmixCopyContext<VM>>(
-                    self,
-                    &GENIMMIX_CONSTRAINTS,
-                    scheduler,
-                );
+            scheduler
+                .schedule_common_work::<GenImmixMatureGCWorkContext<VM, { TraceKind::Fast }>>(self);
         }
     }
 

src/plan/global.rs

@@ -9,7 +9,6 @@ use crate::plan::Mutator;
 use crate::policy::immortalspace::ImmortalSpace;
 use crate::policy::largeobjectspace::LargeObjectSpace;
 use crate::policy::space::Space;
-use crate::scheduler::gc_work::ProcessEdgesWork;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 #[cfg(feature = "analysis")]
@@ -918,61 +917,6 @@ impl<VM: VMBinding> CommonPlan<VM> {
         self.base.release(tls, full_heap)
     }
 
-    /// Schedule all the common work packets
-    pub fn schedule_common<
-        P: Plan<VM = VM>,
-        E: ProcessEdgesWork<VM = VM>,
-        C: CopyContext<VM = VM> + GCWorkerLocal,
-    >(
-        &self,
-        plan: &'static P,
-        constraints: &'static PlanConstraints,
-        scheduler: &GCWorkScheduler<VM>,
-    ) {
-        use crate::scheduler::gc_work::*;
-
-        // Stop & scan mutators (mutator scanning can happen before STW)
-        scheduler.work_buckets[WorkBucketStage::Unconstrained].add(StopMutators::<E>::new());
-
-        // Prepare global/collectors/mutators
-        scheduler.work_buckets[WorkBucketStage::Prepare].add(Prepare::<P, C>::new(plan));
-
-        // VM-specific weak ref processing
-        scheduler.work_buckets[WorkBucketStage::RefClosure].add(ProcessWeakRefs::<E>::new());
-
-        // Release global/collectors/mutators
-        scheduler.work_buckets[WorkBucketStage::Release].add(Release::<P, C>::new(plan));
-
-        // Analysis GC work
-        #[cfg(feature = "analysis")]
-        {
-            use crate::util::analysis::GcHookWork;
-            scheduler.work_buckets[WorkBucketStage::Unconstrained].add(GcHookWork);
-        }
-
-        // Sanity
-        #[cfg(feature = "sanity")]
-        {
-            use crate::util::sanity::sanity_checker::ScheduleSanityGC;
-            scheduler.work_buckets[WorkBucketStage::Final].add(ScheduleSanityGC::<P, C>::new(plan));
-        }
-
-        // Finalization
-        if !self.base.options.no_finalizer {
-            use crate::util::finalizable_processor::{Finalization, ForwardFinalization};
-            // finalization
-            scheduler.work_buckets[WorkBucketStage::RefClosure].add(Finalization::<E>::new());
-            // forward refs
-            if constraints.needs_forward_after_liveness {
-                scheduler.work_buckets[WorkBucketStage::RefForwarding]
-                    .add(ForwardFinalization::<E>::new());
-            }
-        }
-
-        // Set EndOfGC to run at the end
-        scheduler.set_finalizer(Some(EndOfGC));
-    }
-
     pub fn stacks_prepared(&self) -> bool {
         self.base.stacks_prepared()
     }

src/plan/immix/gc_work.rs

@@ -97,6 +97,7 @@ impl<VM: VMBinding, const KIND: TraceKind> ImmixProcessEdges<VM, KIND> {
 
 impl<VM: VMBinding, const KIND: TraceKind> ProcessEdgesWork for ImmixProcessEdges<VM, KIND> {
     type VM = VM;
+
     const OVERWRITE_REFERENCE: bool = crate::policy::immix::DEFRAG;
 
     fn new(edges: Vec<Address>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
@@ -166,3 +167,15 @@ impl<VM: VMBinding, const KIND: TraceKind> DerefMut for ImmixProcessEdges<VM, KI
         &mut self.base
     }
 }
+
+pub(super) struct ImmixGCWorkContext<VM: VMBinding, const KIND: TraceKind>(
+    std::marker::PhantomData<VM>,
+);
+impl<VM: VMBinding, const KIND: TraceKind> crate::scheduler::GCWorkContext
+    for ImmixGCWorkContext<VM, KIND>
+{
+    type VM = VM;
+    type PlanType = Immix<VM>;
+    type CopyContextType = ImmixCopyContext<VM>;
+    type ProcessEdgesWorkType = ImmixProcessEdges<VM, KIND>;
+}

src/plan/immix/global.rs

@@ -1,4 +1,4 @@
-use super::gc_work::{ImmixCopyContext, ImmixProcessEdges, TraceKind};
+use super::gc_work::{ImmixCopyContext, ImmixGCWorkContext, TraceKind};
 use super::mutator::ALLOCATOR_MAPPING;
 use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
@@ -91,11 +91,9 @@ impl<VM: VMBinding> Plan for Immix<VM> {
         // The blocks are not identical, clippy is wrong. Probably it does not recognize the constant type parameter.
         #[allow(clippy::if_same_then_else)]
         if in_defrag {
-            self.common()
-                .schedule_common::<Self, ImmixProcessEdges<VM, { TraceKind::Defrag }>, ImmixCopyContext<VM>>(self, &IMMIX_CONSTRAINTS, scheduler);
+            scheduler.schedule_common_work::<ImmixGCWorkContext<VM, { TraceKind::Defrag }>>(self);
         } else {
-            self.common()
-                .schedule_common::<Self, ImmixProcessEdges<VM, { TraceKind::Fast }>, ImmixCopyContext<VM>>(self, &IMMIX_CONSTRAINTS, scheduler);
+            scheduler.schedule_common_work::<ImmixGCWorkContext<VM, { TraceKind::Fast }>>(self);
         }
     }
 

src/plan/marksweep/gc_work.rs

@@ -23,6 +23,7 @@ pub struct MSProcessEdges<VM: VMBinding> {
 
 impl<VM: VMBinding> ProcessEdgesWork for MSProcessEdges<VM> {
     type VM = VM;
+
     const OVERWRITE_REFERENCE: bool = false;
     fn new(edges: Vec<Address>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
         let base = ProcessEdgesBase::new(edges, roots, mmtk);
@@ -118,3 +119,11 @@ impl<VM: VMBinding> GCWork<VM> for MSSweepChunks<VM> {
         mmtk.scheduler.work_buckets[WorkBucketStage::Release].bulk_add(work_packets);
     }
 }
+
+pub struct MSGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for MSGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = MarkSweep<VM>;
+    type CopyContextType = NoCopy<VM>;
+    type ProcessEdgesWorkType = MSProcessEdges<VM>;
+}

src/plan/marksweep/global.rs

@@ -3,7 +3,7 @@ use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
 use crate::plan::global::GcStatus;
 use crate::plan::global::NoCopy;
-use crate::plan::marksweep::gc_work::{MSProcessEdges, MSSweepChunks};
+use crate::plan::marksweep::gc_work::{MSGCWorkContext, MSSweepChunks};
 use crate::plan::marksweep::mutator::ALLOCATOR_MAPPING;
 use crate::plan::AllocationSemantics;
 use crate::plan::Plan;
@@ -56,12 +56,7 @@ impl<VM: VMBinding> Plan for MarkSweep<VM> {
     fn schedule_collection(&'static self, scheduler: &GCWorkScheduler<VM>) {
         self.base().set_collection_kind::<Self>(self);
         self.base().set_gc_status(GcStatus::GcPrepare);
-        self.common()
-            .schedule_common::<Self, MSProcessEdges<VM>, NoCopy<VM>>(
-                self,
-                &MS_CONSTRAINTS,
-                scheduler,
-            );
+        scheduler.schedule_common_work::<MSGCWorkContext<VM>>(self);
         scheduler.work_buckets[WorkBucketStage::Prepare].add(MSSweepChunks::<VM>::new(self));
     }