Adding support for red/black roots

src/plan/generational/gc_work.rs

@@ -25,8 +25,13 @@ impl<VM: VMBinding, P: GenerationalPlanExt<VM> + PlanTraceObject<VM>> ProcessEdg
     type VM = VM;
     type ScanObjectsWorkType = PlanScanObjects<Self, P>;
 
-    fn new(edges: Vec<EdgeOf<Self>>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
-        let base = ProcessEdgesBase::new(edges, roots, mmtk);
+    fn new(
+        edges: Vec<EdgeOf<Self>>,
+        roots: bool,
+        mmtk: &'static MMTK<VM>,
+        is_immovable: bool,
+    ) -> Self {
+        let base = ProcessEdgesBase::new(edges, roots, mmtk, is_immovable);
         let plan = base.plan().downcast_ref().unwrap();
         Self { plan, base }
     }
@@ -50,8 +55,9 @@ impl<VM: VMBinding, P: GenerationalPlanExt<VM> + PlanTraceObject<VM>> ProcessEdg
         &self,
         nodes: Vec<ObjectReference>,
         roots: bool,
+        is_immovable: bool
     ) -> Self::ScanObjectsWorkType {
-        PlanScanObjects::new(self.plan, nodes, false, roots)
+        PlanScanObjects::new(self.plan, nodes, false, roots, is_immovable)
     }
 }
 
@@ -106,7 +112,7 @@ impl<E: ProcessEdgesWork> GCWork<E::VM> for ProcessModBuf<E> {
             // Scan objects in the modbuf and forward pointers
             let modbuf = std::mem::take(&mut self.modbuf);
             GCWork::do_work(
-                &mut ScanObjects::<E>::new(modbuf, false, false),
+                &mut ScanObjects::<E>::new(modbuf, false, false, false),
                 worker,
                 mmtk,
             )
@@ -144,7 +150,7 @@ impl<E: ProcessEdgesWork> GCWork<E::VM> for ProcessRegionModBuf<E> {
                 }
             }
             // Forward entries
-            GCWork::do_work(&mut E::new(edges, false, mmtk), worker, mmtk)
+            GCWork::do_work(&mut E::new(edges, false, mmtk, false), worker, mmtk)
         }
     }
 }

src/plan/tracing.rs

@@ -75,23 +75,32 @@ impl ObjectQueue for VectorQueue<ObjectReference> {
 pub struct ObjectsClosure<'a, E: ProcessEdgesWork> {
     buffer: VectorQueue<EdgeOf<E>>,
     worker: &'a mut GCWorker<E::VM>,
+    is_immovable: bool,
 }
 
 impl<'a, E: ProcessEdgesWork> ObjectsClosure<'a, E> {
-    pub fn new(worker: &'a mut GCWorker<E::VM>) -> Self {
+    pub fn new(worker: &'a mut GCWorker<E::VM>, is_immovable: bool) -> Self {
         Self {
             buffer: VectorQueue::new(),
             worker,
+            is_immovable,
         }
     }
 
     fn flush(&mut self) {
         let buf = self.buffer.take();
         if !buf.is_empty() {
-            self.worker.add_work(
-                WorkBucketStage::Closure,
-                E::new(buf, false, self.worker.mmtk),
-            );
+            if self.is_immovable {
+                self.worker.add_work(
+                    WorkBucketStage::ClosureImmovable,
+                    E::new(buf, false, self.worker.mmtk, true),
+                );
+            } else {
+                self.worker.add_work(
+                    WorkBucketStage::Closure,
+                    E::new(buf, false, self.worker.mmtk, false),
+                );
+            }
         }
     }
 }

src/policy/immortalspace.rs

@@ -47,6 +47,18 @@ impl<VM: VMBinding> SFT for ImmortalSpace<VM> {
     fn is_object_pinned(&self, _object: ObjectReference) -> bool {
         true
     }
+    #[cfg(feature = "object_pinning")]
+    fn pin_object(&self, _object: ObjectReference) -> bool {
+        false
+    }
+    #[cfg(feature = "object_pinning")]
+    fn unpin_object(&self, _object: ObjectReference) -> bool {
+        false
+    }
+    #[cfg(feature = "object_pinning")]
+    fn is_object_pinned(&self, _object: ObjectReference) -> bool {
+        true
+    }
     fn is_movable(&self) -> bool {
         false
     }