Add PolicyProcessEdges

src/plan/generational/immix/gc_work.rs

@@ -1,87 +1,30 @@
 use super::global::GenImmix;
 use crate::plan::generational::gc_work::GenNurseryProcessEdges;
-use crate::policy::space::Space;
-use crate::scheduler::gc_work::*;
-use crate::util::{Address, ObjectReference};
-use crate::vm::*;
-use crate::MMTK;
-use std::ops::{Deref, DerefMut};
-
-use crate::plan::immix::gc_work::{TraceKind, TRACE_KIND_FAST};
-
-/// ProcessEdges for a full heap GC for generational immix. The const type parameter
-/// defines whether there is copying in the GC.
-/// Note that even with TraceKind::Fast, there is no defragmentation, we are still
-/// copying from nursery to immix space. So we always need to write new object
-/// references in process_edge() (i.e. we do not need to overwrite the default implementation
-/// of process_edge() as the immix plan does).
-pub(super) struct GenImmixMatureProcessEdges<VM: VMBinding, const KIND: TraceKind> {
-    plan: &'static GenImmix<VM>,
-    base: ProcessEdgesBase<VM>,
-}
-
-impl<VM: VMBinding, const KIND: TraceKind> ProcessEdgesWork
-    for GenImmixMatureProcessEdges<VM, KIND>
-{
-    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::<GenImmix<VM>>().unwrap();
-        Self { plan, base }
-    }
-
-    #[cold]
-    fn flush(&mut self) {
-        if self.nodes.is_empty() {
-            return;
-        }
-
-        let scan_objects_work = crate::policy::immix::ScanObjectsAndMarkLines::<Self>::new(
-            self.pop_nodes(),
-            false,
-            &self.plan.immix,
-        );
-        self.new_scan_work(scan_objects_work);
-    }
-
-    #[inline]
-    fn trace_object(&mut self, object: ObjectReference) -> ObjectReference {
-        if object.is_null() {
-            return object;
-        }
-
-        if self.plan.immix.in_space(object) {
-            if KIND == TRACE_KIND_FAST {
-                return self.plan.immix.fast_trace_object(self, object);
-            } else {
-                return self.plan.immix.trace_object(
-                    self,
-                    object,
-                    crate::util::copy::CopySemantics::Mature,
-                    self.worker(),
-                );
-            }
-        }
-
-        self.plan
-            .gen
-            .trace_object_full_heap::<Self>(self, object, self.worker())
+use crate::plan::TransitiveClosure;
+use crate::policy::gc_work::{PolicyProcessEdges, TraceKind};
+use crate::policy::immix::ImmixSpace;
+use crate::scheduler::GCWorker;
+use crate::util::copy::CopySemantics;
+use crate::util::ObjectReference;
+use crate::vm::VMBinding;
+
+impl<VM: VMBinding> crate::policy::gc_work::UsePolicyProcessEdges<VM> for GenImmix<VM> {
+    type TargetPolicy = ImmixSpace<VM>;
+    const COPY: CopySemantics = CopySemantics::Mature;
+
+    #[inline(always)]
+    fn get_target_space(&self) -> &Self::TargetPolicy {
+        &self.immix
     }
-}
-
-impl<VM: VMBinding, const KIND: TraceKind> Deref for GenImmixMatureProcessEdges<VM, KIND> {
-    type Target = ProcessEdgesBase<VM>;
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.base
-    }
-}
 
-impl<VM: VMBinding, const KIND: TraceKind> DerefMut for GenImmixMatureProcessEdges<VM, KIND> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.base
+    #[inline(always)]
+    fn fallback_trace<T: TransitiveClosure>(
+        &self,
+        trace: &mut T,
+        object: ObjectReference,
+        worker: &mut GCWorker<VM>,
+    ) -> ObjectReference {
+        self.gen.trace_object_full_heap::<T>(trace, object, worker)
     }
 }
 
@@ -100,5 +43,5 @@ impl<VM: VMBinding, const KIND: TraceKind> crate::scheduler::GCWorkContext
 {
     type VM = VM;
     type PlanType = GenImmix<VM>;
-    type ProcessEdgesWorkType = GenImmixMatureProcessEdges<VM, KIND>;
+    type ProcessEdgesWorkType = PolicyProcessEdges<VM, GenImmix<VM>, KIND>;
 }

src/plan/generational/immix/global.rs

@@ -4,11 +4,11 @@ use crate::plan::generational::global::Gen;
 use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
 use crate::plan::global::GcStatus;
-use crate::plan::immix::gc_work::{TRACE_KIND_DEFRAG, TRACE_KIND_FAST};
 use crate::plan::AllocationSemantics;
 use crate::plan::Plan;
 use crate::plan::PlanConstraints;
 use crate::policy::immix::ImmixSpace;
+use crate::policy::immix::{TRACE_KIND_DEFRAG, TRACE_KIND_FAST};
 use crate::policy::space::Space;
 use crate::scheduler::GCWorkScheduler;
 use crate::util::alloc::allocators::AllocatorSelector;

src/plan/immix/gc_work.rs

@@ -1,106 +1,29 @@
 use super::global::Immix;
-use crate::policy::space::Space;
-use crate::scheduler::gc_work::*;
+use crate::plan::TransitiveClosure;
+use crate::policy::gc_work::{PolicyProcessEdges, TraceKind};
+use crate::policy::immix::ImmixSpace;
+use crate::scheduler::GCWorker;
 use crate::util::copy::CopySemantics;
-use crate::util::{Address, ObjectReference};
+use crate::util::ObjectReference;
 use crate::vm::VMBinding;
-use crate::MMTK;
-use std::ops::{Deref, DerefMut};
 
-// It would be better if we use an enum for this. However, we use this as
-// a constant type parameter, and Rust only accepts integer and bool for
-// constant type parameters for now. We need to wait until `adt_const_params` is
-// stablized.
-pub(in crate::plan) type TraceKind = u8;
-pub(in crate::plan) const TRACE_KIND_FAST: TraceKind = 0;
-pub(in crate::plan) const TRACE_KIND_DEFRAG: TraceKind = 1;
+impl<VM: VMBinding> crate::policy::gc_work::UsePolicyProcessEdges<VM> for Immix<VM> {
+    type TargetPolicy = ImmixSpace<VM>;
+    const COPY: CopySemantics = CopySemantics::DefaultCopy;
 
-/// Object tracing for Immix.
-/// Note that it is possible to use [`SFTProcessEdges`](mmtk/scheduler/gc_work/SFTProcessEdges) for immix.
-/// We need to: 1. add a plan-specific method to create scan work packets, as most plans use `ScanObjects` while
-/// immix uses `ScanObjectsAndMarkLines`, 2. use `ImmixSpace.trace_object()` which has an overhead of checking
-/// which trace method to use (with ImmixProcessEdges, we can know which trace method to use by statically checking `TraceKind`).
-pub(super) struct ImmixProcessEdges<VM: VMBinding, const KIND: TraceKind> {
-    // Use a static ref to the specific plan to avoid overhead from dynamic dispatch or
-    // downcast for each traced object.
-    plan: &'static Immix<VM>,
-    base: ProcessEdgesBase<VM>,
-}
-
-impl<VM: VMBinding, const KIND: TraceKind> ImmixProcessEdges<VM, KIND> {
-    fn immix(&self) -> &'static Immix<VM> {
-        self.plan
-    }
-}
-
-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 {
-        let base = ProcessEdgesBase::new(edges, roots, mmtk);
-        let plan = base.plan().downcast_ref::<Immix<VM>>().unwrap();
-        Self { plan, base }
-    }
-
-    #[cold]
-    fn flush(&mut self) {
-        if self.nodes.is_empty() {
-            return;
-        }
-        let scan_objects_work = crate::policy::immix::ScanObjectsAndMarkLines::<Self>::new(
-            self.pop_nodes(),
-            false,
-            &self.immix().immix_space,
-        );
-        self.new_scan_work(scan_objects_work);
-    }
-
-    /// Trace  and evacuate objects.
     #[inline(always)]
-    fn trace_object(&mut self, object: ObjectReference) -> ObjectReference {
-        if object.is_null() {
-            return object;
-        }
-        if self.immix().immix_space.in_space(object) {
-            if KIND == TRACE_KIND_FAST {
-                self.immix().immix_space.fast_trace_object(self, object)
-            } else {
-                self.immix().immix_space.trace_object(
-                    self,
-                    object,
-                    CopySemantics::DefaultCopy,
-                    self.worker(),
-                )
-            }
-        } else {
-            self.immix().common.trace_object::<Self>(self, object)
-        }
+    fn get_target_space(&self) -> &Self::TargetPolicy {
+        &self.immix_space
     }
 
-    #[inline]
-    fn process_edge(&mut self, slot: Address) {
-        let object = unsafe { slot.load::<ObjectReference>() };
-        let new_object = self.trace_object(object);
-        if KIND == TRACE_KIND_DEFRAG && Self::OVERWRITE_REFERENCE {
-            unsafe { slot.store(new_object) };
-        }
-    }
-}
-
-impl<VM: VMBinding, const KIND: TraceKind> Deref for ImmixProcessEdges<VM, KIND> {
-    type Target = ProcessEdgesBase<VM>;
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.base
-    }
-}
-
-impl<VM: VMBinding, const KIND: TraceKind> DerefMut for ImmixProcessEdges<VM, KIND> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.base
+    #[inline(always)]
+    fn fallback_trace<T: TransitiveClosure>(
+        &self,
+        trace: &mut T,
+        object: ObjectReference,
+        _worker: &mut GCWorker<VM>,
+    ) -> ObjectReference {
+        self.common.trace_object::<T>(trace, object)
     }
 }
 
@@ -112,5 +35,5 @@ impl<VM: VMBinding, const KIND: TraceKind> crate::scheduler::GCWorkContext
 {
     type VM = VM;
     type PlanType = Immix<VM>;
-    type ProcessEdgesWorkType = ImmixProcessEdges<VM, KIND>;
+    type ProcessEdgesWorkType = PolicyProcessEdges<VM, Immix<VM>, KIND>;
 }

src/plan/immix/global.rs

@@ -1,12 +1,12 @@
 use super::gc_work::ImmixGCWorkContext;
-use super::gc_work::{TRACE_KIND_DEFRAG, TRACE_KIND_FAST};
 use super::mutator::ALLOCATOR_MAPPING;
 use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
 use crate::plan::global::GcStatus;
 use crate::plan::AllocationSemantics;
 use crate::plan::Plan;
 use crate::plan::PlanConstraints;
+use crate::policy::immix::{TRACE_KIND_DEFRAG, TRACE_KIND_FAST};
 use crate::policy::space::Space;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;