Replace TransitiveClosure with EdgeVisitor (#148)

* Replace TransitiveClosure with EdgeVisitor

In respond to an upstream API change, we now use EdgeVisitor for object
scanning.  This also removes `unreachable!()` implementations for
`process_node()`.

* Remove ObjectsClosure

ObjectsClosure was moved to mmtk-core.  Now `scan_objects` is
implemented in mmtk-core.

Author: wks

mmtk/Cargo.toml

@@ -28,7 +28,7 @@ once_cell = "1.10.0"
 # - change branch
 # - change repo name
 # But other changes including adding/removing whitespaces in commented lines may break the CI.
-mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "be96a270815c0f20a169a7214eebccfe50484be4" }
+mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "0babba20290d3c4e4cdb2a83284aa7204c9a23cc" }
 # Uncomment the following to build locally
 # mmtk = { path = "../repos/mmtk-core" }
 

mmtk/src/object_scanning.rs

@@ -1,33 +1,29 @@
 use super::abi::*;
 use super::UPCALLS;
-use crate::{OpenJDK, SINGLETON};
-use mmtk::scheduler::ProcessEdgesWork;
-use mmtk::scheduler::{GCWorker, WorkBucketStage};
 use mmtk::util::constants::*;
 use mmtk::util::opaque_pointer::*;
 use mmtk::util::{Address, ObjectReference};
-use mmtk::TransitiveClosure;
-use std::marker::PhantomData;
+use mmtk::vm::EdgeVisitor;
 use std::{mem, slice};
 
 trait OopIterate: Sized {
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure);
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor);
 }
 
 impl OopIterate for OopMapBlock {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
         let start = oop.get_field_address(self.offset);
         for i in 0..self.count as usize {
             let edge = start + (i << LOG_BYTES_IN_ADDRESS);
-            closure.process_edge(edge);
+            closure.visit_edge(edge);
         }
     }
 }
 
 impl OopIterate for InstanceKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
         let oop_maps = self.nonstatic_oop_maps();
         for map in oop_maps {
             map.oop_iterate(oop, closure)
@@ -37,7 +33,7 @@ impl OopIterate for InstanceKlass {
 
 impl OopIterate for InstanceMirrorKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
         self.instance_klass.oop_iterate(oop, closure);
         // if (Devirtualizer::do_metadata(closure)) {
         //     Klass* klass = java_lang_Class::as_Klass(obj);
@@ -71,14 +67,14 @@ impl OopIterate for InstanceMirrorKlass {
         let len = Self::static_oop_field_count(oop);
         let slice = unsafe { slice::from_raw_parts(start, len as _) };
         for oop in slice {
-            closure.process_edge(Address::from_ref(oop as &Oop));
+            closure.visit_edge(Address::from_ref(oop as &Oop));
         }
     }
 }
 
 impl OopIterate for InstanceClassLoaderKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
         self.instance_klass.oop_iterate(oop, closure);
         // if (Devirtualizer::do_metadata(closure)) {
         //     ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj);
@@ -92,42 +88,42 @@ impl OopIterate for InstanceClassLoaderKlass {
 
 impl OopIterate for ObjArrayKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
         let array = unsafe { oop.as_array_oop() };
         for oop in unsafe { array.data::<Oop>(BasicType::T_OBJECT) } {
-            closure.process_edge(Address::from_ref(oop as &Oop));
+            closure.visit_edge(Address::from_ref(oop as &Oop));
         }
     }
 }
 
 impl OopIterate for TypeArrayKlass {
     #[inline]
-    fn oop_iterate(&self, _oop: Oop, _closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, _oop: Oop, _closure: &mut impl EdgeVisitor) {
         // Performance tweak: We skip processing the klass pointer since all
         // TypeArrayKlasses are guaranteed processed via the null class loader.
     }
 }
 
 impl OopIterate for InstanceRefKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl TransitiveClosure) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
         self.instance_klass.oop_iterate(oop, closure);
         let referent_addr = Self::referent_address(oop);
-        closure.process_edge(referent_addr);
+        closure.visit_edge(referent_addr);
         let discovered_addr = Self::discovered_address(oop);
-        closure.process_edge(discovered_addr);
+        closure.visit_edge(discovered_addr);
     }
 }
 
 #[allow(unused)]
-fn oop_iterate_slow(oop: Oop, closure: &mut impl TransitiveClosure, tls: OpaquePointer) {
+fn oop_iterate_slow(oop: Oop, closure: &mut impl EdgeVisitor, tls: OpaquePointer) {
     unsafe {
         ((*UPCALLS).scan_object)(closure as *mut _ as _, mem::transmute(oop), tls);
     }
 }
 
 #[inline]
-fn oop_iterate(oop: Oop, closure: &mut impl TransitiveClosure) {
+fn oop_iterate(oop: Oop, closure: &mut impl EdgeVisitor) {
     let klass_id = oop.klass.id;
     debug_assert!(
         klass_id as i32 >= 0 && (klass_id as i32) < 6,
@@ -164,68 +160,11 @@ fn oop_iterate(oop: Oop, closure: &mut impl TransitiveClosure) {
 }
 
 #[inline]
-pub fn scan_object(
-    object: ObjectReference,
-    closure: &mut impl TransitiveClosure,
-    _tls: VMWorkerThread,
-) {
+pub fn scan_object(object: ObjectReference, closure: &mut impl EdgeVisitor, _tls: VMWorkerThread) {
     // println!("*****scan_object(0x{:x}) -> \n 0x{:x}, 0x{:x} \n",
     //     object,
     //     unsafe { *(object.value() as *const usize) },
     //     unsafe { *((object.value() + 8) as *const usize) }
     // );
     unsafe { oop_iterate(mem::transmute(object), closure) }
 }
-
-pub struct ObjectsClosure<'a, E: ProcessEdgesWork<VM = OpenJDK>>(
-    Vec<Address>,
-    &'a mut GCWorker<OpenJDK>,
-    PhantomData<E>,
-);
-
-impl<'a, E: ProcessEdgesWork<VM = OpenJDK>> TransitiveClosure for ObjectsClosure<'a, E> {
-    #[inline]
-    fn process_edge(&mut self, slot: Address) {
-        if self.0.is_empty() {
-            self.0.reserve(E::CAPACITY);
-        }
-        self.0.push(slot);
-        if self.0.len() >= E::CAPACITY {
-            let mut new_edges = Vec::new();
-            mem::swap(&mut new_edges, &mut self.0);
-            self.1.add_work(
-                WorkBucketStage::Closure,
-                E::new(new_edges, false, &SINGLETON),
-            );
-        }
-    }
-    fn process_node(&mut self, _object: ObjectReference) {
-        unreachable!()
-    }
-}
-
-impl<'a, E: ProcessEdgesWork<VM = OpenJDK>> Drop for ObjectsClosure<'a, E> {
-    #[inline]
-    fn drop(&mut self) {
-        let mut new_edges = Vec::new();
-        mem::swap(&mut new_edges, &mut self.0);
-        self.1.add_work(
-            WorkBucketStage::Closure,
-            E::new(new_edges, false, &SINGLETON),
-        );
-    }
-}
-
-pub fn scan_objects_and_create_edges_work<E: ProcessEdgesWork<VM = OpenJDK>>(
-    objects: &[ObjectReference],
-    worker: &mut GCWorker<OpenJDK>,
-) {
-    let mut closure = ObjectsClosure::<E>(Vec::new(), worker, PhantomData);
-    for object in objects {
-        scan_object(
-            *object,
-            &mut closure,
-            VMWorkerThread(VMThread::UNINITIALIZED),
-        );
-    }
-}

mmtk/src/scanning.rs

@@ -3,12 +3,12 @@ use super::{NewBuffer, SINGLETON, UPCALLS};
 use crate::OpenJDK;
 use mmtk::memory_manager;
 use mmtk::scheduler::ProcessEdgesWork;
-use mmtk::scheduler::{GCWorker, WorkBucketStage};
+use mmtk::scheduler::WorkBucketStage;
 use mmtk::util::opaque_pointer::*;
 use mmtk::util::{Address, ObjectReference};
-use mmtk::vm::Scanning;
+use mmtk::vm::{EdgeVisitor, Scanning};
+use mmtk::Mutator;
 use mmtk::MutatorContext;
-use mmtk::{Mutator, TransitiveClosure};
 
 pub struct VMScanning {}
 
@@ -39,26 +39,19 @@ impl Scanning<OpenJDK> for VMScanning {
     const SCAN_MUTATORS_IN_SAFEPOINT: bool = false;
     const SINGLE_THREAD_MUTATOR_SCANNING: bool = false;
 
-    fn scan_object<T: TransitiveClosure>(
-        trace: &mut T,
-        object: ObjectReference,
+    fn scan_object<EV: EdgeVisitor>(
         tls: VMWorkerThread,
+        object: ObjectReference,
+        edge_visitor: &mut EV,
     ) {
-        crate::object_scanning::scan_object(object, trace, tls)
+        crate::object_scanning::scan_object(object, edge_visitor, tls)
     }
 
     fn notify_initial_thread_scan_complete(_partial_scan: bool, _tls: VMWorkerThread) {
         // unimplemented!()
         // TODO
     }
 
-    fn scan_objects<W: ProcessEdgesWork<VM = OpenJDK>>(
-        objects: &[ObjectReference],
-        worker: &mut GCWorker<OpenJDK>,
-    ) {
-        crate::object_scanning::scan_objects_and_create_edges_work::<W>(objects, worker);
-    }
-
     fn scan_thread_roots<W: ProcessEdgesWork<VM = OpenJDK>>() {
         let process_edges = create_process_edges_work::<W>;
         unsafe {