diff --git a/docs/tutorial/code/mygc_semispace/gc_work.rs b/docs/tutorial/code/mygc_semispace/gc_work.rs
index 733eabe5eb..aa338ae55e 100644
--- a/docs/tutorial/code/mygc_semispace/gc_work.rs
+++ b/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
\ No newline at end of file
+// 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
diff --git a/docs/tutorial/code/mygc_semispace/global.rs b/docs/tutorial/code/mygc_semispace/global.rs
index 129a945bb3..dcb234d4a2 100644
--- a/docs/tutorial/code/mygc_semispace/global.rs
+++ b/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
 
diff --git a/docs/tutorial/src/mygc/ss/collection.md b/docs/tutorial/src/mygc/ss/collection.md
index d1cb56fba3..a819043624 100644
--- a/docs/tutorial/src/mygc/ss/collection.md
+++ b/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, `GCWorkScheduler` provides a
+method `schedule_common_work()` that will add common work packets for you.
+
+To use `schedule_common_work()`, 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_work()`.
+
 ```rust
 {{#include ../../../code/mygc_semispace/global.rs:schedule_collection}}
 ```
diff --git a/src/plan/generational/copying/gc_work.rs b/src/plan/generational/copying/gc_work.rs
index df586f05ed..c8e0b6c3e9 100644
--- a/src/plan/generational/copying/gc_work.rs
+++ b/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>;
+}
diff --git a/src/plan/generational/copying/global.rs b/src/plan/generational/copying/global.rs
index 67ef671589..213e2d1efe 100644
--- a/src/plan/generational/copying/global.rs
+++ b/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);
         }
     }
 
diff --git a/src/plan/generational/gc_work.rs b/src/plan/generational/gc_work.rs
index 6819cc22eb..b0639bda53 100644
--- a/src/plan/generational/gc_work.rs
+++ b/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
     }
diff --git a/src/plan/generational/immix/gc_work.rs b/src/plan/generational/immix/gc_work.rs
index 5ec06f3431..1d08b5425f 100644
--- a/src/plan/generational/immix/gc_work.rs
+++ b/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>;
+}
diff --git a/src/plan/generational/immix/global.rs b/src/plan/generational/immix/global.rs
index d9e2d83628..a3c10e8756 100644
--- a/src/plan/generational/immix/global.rs
+++ b/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);
         }
     }
 
diff --git a/src/plan/global.rs b/src/plan/global.rs
index dee9b05a34..4e5c5bd8c7 100644
--- a/src/plan/global.rs
+++ b/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")]
@@ -952,61 +951,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()
     }
diff --git a/src/plan/immix/gc_work.rs b/src/plan/immix/gc_work.rs
index 1471aa1204..696821272e 100644
--- a/src/plan/immix/gc_work.rs
+++ b/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>;
+}
diff --git a/src/plan/immix/global.rs b/src/plan/immix/global.rs
index 5eb635f843..ed2b00ab5a 100644
--- a/src/plan/immix/global.rs
+++ b/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);
         }
     }
 
diff --git a/src/plan/marksweep/gc_work.rs b/src/plan/marksweep/gc_work.rs
index 4fce9cbdda..d3aed1e7c2 100644
--- a/src/plan/marksweep/gc_work.rs
+++ b/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>;
+}
diff --git a/src/plan/marksweep/global.rs b/src/plan/marksweep/global.rs
index bb4c5b7699..9791715da3 100644
--- a/src/plan/marksweep/global.rs
+++ b/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));
     }
 
diff --git a/src/plan/pageprotect/gc_work.rs b/src/plan/pageprotect/gc_work.rs
index 66ff15d5bf..b519893b6b 100644
--- a/src/plan/pageprotect/gc_work.rs
+++ b/src/plan/pageprotect/gc_work.rs
@@ -18,6 +18,7 @@ pub struct PPProcessEdges<VM: VMBinding> {
 impl<VM: VMBinding> ProcessEdgesWork for PPProcessEdges<VM> {
     const OVERWRITE_REFERENCE: bool = false;
     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::<PageProtect<VM>>().unwrap();
@@ -56,3 +57,11 @@ impl<VM: VMBinding> DerefMut for PPProcessEdges<VM> {
         &mut self.base
     }
 }
+
+pub struct PPGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for PPGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = PageProtect<VM>;
+    type CopyContextType = NoCopy<VM>;
+    type ProcessEdgesWorkType = PPProcessEdges<VM>;
+}
diff --git a/src/plan/pageprotect/global.rs b/src/plan/pageprotect/global.rs
index 295c8a040a..692b83c243 100644
--- a/src/plan/pageprotect/global.rs
+++ b/src/plan/pageprotect/global.rs
@@ -1,4 +1,4 @@
-use super::gc_work::PPProcessEdges;
+use super::gc_work::PPGCWorkContext;
 use super::mutator::ALLOCATOR_MAPPING;
 use crate::mmtk::MMTK;
 use crate::plan::global::GcStatus;
@@ -75,8 +75,7 @@ impl<VM: VMBinding> Plan for PageProtect<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, PPProcessEdges<VM>, NoCopy<VM>>(self, &CONSTRAINTS, scheduler);
+        scheduler.schedule_common_work::<PPGCWorkContext<VM>>(self);
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
diff --git a/src/plan/semispace/gc_work.rs b/src/plan/semispace/gc_work.rs
index 9c444d47ff..c57aaa90dd 100644
--- a/src/plan/semispace/gc_work.rs
+++ b/src/plan/semispace/gc_work.rs
@@ -139,3 +139,11 @@ impl<VM: VMBinding> DerefMut for SSProcessEdges<VM> {
         &mut self.base
     }
 }
+
+pub struct SSGCWorkContext<VM: VMBinding>(std::marker::PhantomData<VM>);
+impl<VM: VMBinding> crate::scheduler::GCWorkContext for SSGCWorkContext<VM> {
+    type VM = VM;
+    type PlanType = SemiSpace<VM>;
+    type CopyContextType = SSCopyContext<VM>;
+    type ProcessEdgesWorkType = SSProcessEdges<VM>;
+}
diff --git a/src/plan/semispace/global.rs b/src/plan/semispace/global.rs
index 6c8f464d59..f95a4ce5d0 100644
--- a/src/plan/semispace/global.rs
+++ b/src/plan/semispace/global.rs
@@ -1,4 +1,4 @@
-use super::gc_work::{SSCopyContext, SSProcessEdges};
+use super::gc_work::{SSCopyContext, SSGCWorkContext};
 use crate::mmtk::MMTK;
 use crate::plan::global::CommonPlan;
 use crate::plan::global::GcStatus;
@@ -75,12 +75,7 @@ impl<VM: VMBinding> Plan for SemiSpace<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, SSProcessEdges<VM>, SSCopyContext<VM>>(
-                self,
-                &SS_CONSTRAINTS,
-                scheduler,
-            );
+        scheduler.schedule_common_work::<SSGCWorkContext<VM>>(self);
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
diff --git a/src/scheduler/gc_work.rs b/src/scheduler/gc_work.rs
index e85122355a..24fa7f09a3 100644
--- a/src/scheduler/gc_work.rs
+++ b/src/scheduler/gc_work.rs
@@ -27,34 +27,31 @@ impl<VM: VMBinding> CoordinatorWork<VM> for ScheduleCollection {}
 /// We assume this work packet is the only running work packet that accesses plan, and there should
 /// be no other concurrent work packet that accesses plan (read or write). Otherwise, there may
 /// be a race condition.
-pub struct Prepare<P: Plan, W: CopyContext + GCWorkerLocal> {
-    pub plan: &'static P,
-    _p: PhantomData<W>,
+pub struct Prepare<C: GCWorkContext> {
+    pub plan: &'static C::PlanType,
 }
 
-impl<P: Plan, W: CopyContext + GCWorkerLocal> Prepare<P, W> {
-    pub fn new(plan: &'static P) -> Self {
-        Self {
-            plan,
-            _p: PhantomData,
-        }
+impl<C: GCWorkContext> Prepare<C> {
+    pub fn new(plan: &'static C::PlanType) -> Self {
+        Self { plan }
     }
 }
 
-impl<P: Plan, W: CopyContext + GCWorkerLocal> GCWork<P::VM> for Prepare<P, W> {
-    fn do_work(&mut self, worker: &mut GCWorker<P::VM>, mmtk: &'static MMTK<P::VM>) {
+impl<C: GCWorkContext + 'static> GCWork<C::VM> for Prepare<C> {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
         trace!("Prepare Global");
         // We assume this is the only running work packet that accesses plan at the point of execution
         #[allow(clippy::cast_ref_to_mut)]
-        let plan_mut: &mut P = unsafe { &mut *(self.plan as *const _ as *mut _) };
+        let plan_mut: &mut C::PlanType = unsafe { &mut *(self.plan as *const _ as *mut _) };
         plan_mut.prepare(worker.tls);
 
-        for mutator in <P::VM as VMBinding>::VMActivePlan::mutators() {
+        for mutator in <C::VM as VMBinding>::VMActivePlan::mutators() {
             mmtk.scheduler.work_buckets[WorkBucketStage::Prepare]
-                .add(PrepareMutator::<P::VM>::new(mutator));
+                .add(PrepareMutator::<C::VM>::new(mutator));
         }
         for w in &mmtk.scheduler.worker_group().workers {
-            w.local_work_bucket.add(PrepareCollector::<W>::new());
+            w.local_work_bucket
+                .add(PrepareCollector::<C::CopyContextType>::new());
         }
     }
 }
@@ -103,35 +100,32 @@ impl<VM: VMBinding, W: CopyContext + GCWorkerLocal> GCWork<VM> for PrepareCollec
 /// We assume this work packet is the only running work packet that accesses plan, and there should
 /// be no other concurrent work packet that accesses plan (read or write). Otherwise, there may
 /// be a race condition.
-pub struct Release<P: Plan, W: CopyContext + GCWorkerLocal> {
-    pub plan: &'static P,
-    _p: PhantomData<W>,
+pub struct Release<C: GCWorkContext> {
+    pub plan: &'static C::PlanType,
 }
 
-impl<P: Plan, W: CopyContext + GCWorkerLocal> Release<P, W> {
-    pub fn new(plan: &'static P) -> Self {
-        Self {
-            plan,
-            _p: PhantomData,
-        }
+impl<C: GCWorkContext> Release<C> {
+    pub fn new(plan: &'static C::PlanType) -> Self {
+        Self { plan }
     }
 }
 
-impl<P: Plan, W: CopyContext + GCWorkerLocal> GCWork<P::VM> for Release<P, W> {
-    fn do_work(&mut self, worker: &mut GCWorker<P::VM>, mmtk: &'static MMTK<P::VM>) {
+impl<C: GCWorkContext + 'static> GCWork<C::VM> for Release<C> {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
         trace!("Release Global");
-        <P::VM as VMBinding>::VMCollection::vm_release();
+        <C::VM as VMBinding>::VMCollection::vm_release();
         // We assume this is the only running work packet that accesses plan at the point of execution
         #[allow(clippy::cast_ref_to_mut)]
-        let plan_mut: &mut P = unsafe { &mut *(self.plan as *const _ as *mut _) };
+        let plan_mut: &mut C::PlanType = unsafe { &mut *(self.plan as *const _ as *mut _) };
         plan_mut.release(worker.tls);
 
-        for mutator in <P::VM as VMBinding>::VMActivePlan::mutators() {
+        for mutator in <C::VM as VMBinding>::VMActivePlan::mutators() {
             mmtk.scheduler.work_buckets[WorkBucketStage::Release]
-                .add(ReleaseMutator::<P::VM>::new(mutator));
+                .add(ReleaseMutator::<C::VM>::new(mutator));
         }
         for w in &mmtk.scheduler.worker_group().workers {
-            w.local_work_bucket.add(ReleaseCollector::<W>::new());
+            w.local_work_bucket
+                .add(ReleaseCollector::<C::CopyContextType>::new());
         }
         // TODO: Process weak references properly
         mmtk.reference_processors.clear();
@@ -406,6 +400,7 @@ pub trait ProcessEdgesWork:
     Send + 'static + Sized + DerefMut + Deref<Target = ProcessEdgesBase<Self>>
 {
     type VM: VMBinding;
+
     const CAPACITY: usize = 4096;
     const OVERWRITE_REFERENCE: bool = true;
     const SCAN_OBJECTS_IMMEDIATELY: bool = true;
diff --git a/src/scheduler/mod.rs b/src/scheduler/mod.rs
index 516e62383d..672f400450 100644
--- a/src/scheduler/mod.rs
+++ b/src/scheduler/mod.rs
@@ -11,6 +11,7 @@ pub(self) mod work_counter;
 mod work;
 pub use work::CoordinatorWork;
 pub use work::GCWork;
+pub(crate) use work::GCWorkContext;
 
 mod work_bucket;
 pub use work_bucket::WorkBucketStage;
diff --git a/src/scheduler/scheduler.rs b/src/scheduler/scheduler.rs
index d79e20b6e5..b290099eb8 100644
--- a/src/scheduler/scheduler.rs
+++ b/src/scheduler/scheduler.rs
@@ -145,6 +145,61 @@ impl<VM: VMBinding> GCWorkScheduler<VM> {
         }
     }
 
+    /// Schedule all the common work packets
+    pub fn schedule_common_work<C: GCWorkContext<VM = VM> + 'static>(
+        &self,
+        plan: &'static C::PlanType,
+    ) {
+        use crate::plan::Plan;
+        use crate::scheduler::gc_work::*;
+        // Stop & scan mutators (mutator scanning can happen before STW)
+        self.work_buckets[WorkBucketStage::Unconstrained]
+            .add(StopMutators::<C::ProcessEdgesWorkType>::new());
+
+        // Prepare global/collectors/mutators
+        self.work_buckets[WorkBucketStage::Prepare].add(Prepare::<C>::new(plan));
+
+        // VM-specific weak ref processing
+        self.work_buckets[WorkBucketStage::RefClosure]
+            .add(ProcessWeakRefs::<C::ProcessEdgesWorkType>::new());
+
+        // Release global/collectors/mutators
+        self.work_buckets[WorkBucketStage::Release].add(Release::<C>::new(plan));
+
+        // Analysis GC work
+        #[cfg(feature = "analysis")]
+        {
+            use crate::util::analysis::GcHookWork;
+            self.work_buckets[WorkBucketStage::Unconstrained].add(GcHookWork);
+        }
+
+        // Sanity
+        #[cfg(feature = "sanity")]
+        {
+            use crate::util::sanity::sanity_checker::ScheduleSanityGC;
+            self.work_buckets[WorkBucketStage::Final]
+                .add(ScheduleSanityGC::<C::PlanType, C::CopyContextType>::new(
+                    plan,
+                ));
+        }
+
+        // Finalization
+        if !plan.base().options.no_finalizer {
+            use crate::util::finalizable_processor::{Finalization, ForwardFinalization};
+            // finalization
+            self.work_buckets[WorkBucketStage::RefClosure]
+                .add(Finalization::<C::ProcessEdgesWorkType>::new());
+            // forward refs
+            if plan.constraints().needs_forward_after_liveness {
+                self.work_buckets[WorkBucketStage::RefForwarding]
+                    .add(ForwardFinalization::<C::ProcessEdgesWorkType>::new());
+            }
+        }
+
+        // Set EndOfGC to run at the end
+        self.set_finalizer(Some(EndOfGC));
+    }
+
     fn are_buckets_drained(&self, buckets: &[WorkBucketStage]) -> bool {
         buckets.iter().all(|&b| self.work_buckets[b].is_drained())
     }
diff --git a/src/scheduler/work.rs b/src/scheduler/work.rs
index 2026cfdcdf..2deeea2641 100644
--- a/src/scheduler/work.rs
+++ b/src/scheduler/work.rs
@@ -22,3 +22,19 @@ pub trait GCWork<VM: VMBinding>: 'static + Send {
         stat.end_of_work(&mut worker.stat);
     }
 }
+
+use super::gc_work::ProcessEdgesWork;
+use crate::plan::CopyContext;
+use crate::plan::Plan;
+
+/// This trait provides a group of associated types that are needed to
+/// create GC work packets for a certain plan. For example, `GCWorkScheduler.schedule_common_work()`
+/// needs this trait to schedule different work packets. For certain plans,
+/// they may need to provide several types that implement this trait, e.g. one for
+/// nursery GC, one for mature GC.
+pub trait GCWorkContext {
+    type VM: VMBinding;
+    type PlanType: Plan<VM = Self::VM>;
+    type CopyContextType: CopyContext<VM = Self::VM> + GCWorkerLocal;
+    type ProcessEdgesWorkType: ProcessEdgesWork<VM = Self::VM>;
+}
diff --git a/src/util/sanity/sanity_checker.rs b/src/util/sanity/sanity_checker.rs
index a52a8817e7..a797c90765 100644
--- a/src/util/sanity/sanity_checker.rs
+++ b/src/util/sanity/sanity_checker.rs
@@ -176,6 +176,7 @@ impl<VM: VMBinding> DerefMut for SanityGCProcessEdges<VM> {
 
 impl<VM: VMBinding> ProcessEdgesWork for SanityGCProcessEdges<VM> {
     type VM = VM;
+
     const OVERWRITE_REFERENCE: bool = false;
     fn new(edges: Vec<Address>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
         Self {