Edge trait

Note that this commit does not add support for compressed OOPs.

Author: wks

mmtk/src/abi.rs

@@ -3,10 +3,86 @@ use mmtk::util::constants::*;
 use mmtk::util::conversions;
 use mmtk::util::ObjectReference;
 use mmtk::util::{Address, OpaquePointer};
+use mmtk::vm::edge_shape::Edge;
+use mmtk::vm::edge_shape::SimpleEdge;
 use std::ffi::CStr;
 use std::fmt;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
 use std::{mem, slice};
 
+#[derive(Clone, Copy)]
+pub struct CompressedOopEdge {
+    slot_addr: *mut AtomicU32,
+}
+
+unsafe impl Send for CompressedOopEdge {}
+
+impl CompressedOopEdge {
+    pub fn from_address(address: Address) -> Self {
+        Self { slot_addr: address.to_mut_ptr() }
+    }
+
+    pub fn as_address(&self) -> Address {
+        Address::from_mut_ptr(self.slot_addr)
+    }
+}
+
+impl Edge for CompressedOopEdge {
+    fn load(&self) -> ObjectReference {
+        let compressed = unsafe { (*self.slot_addr).load(Ordering::Relaxed) };
+        let expanded = (compressed as usize) << 3;
+        unsafe { Address::from_usize(expanded).to_object_reference() }
+    }
+
+    fn store(&self, object: ObjectReference) {
+        let expanded = object.to_address().as_usize();
+        let compressed = (expanded >> 3) as u32;
+        unsafe { (*self.slot_addr).store(compressed, Ordering::Relaxed) }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum OpenJDKEdge {
+    Simple(SimpleEdge),
+    Compressed(CompressedOopEdge),
+}
+
+unsafe impl Send for OpenJDKEdge {}
+
+impl OpenJDKEdge {
+    #[inline(always)]
+    pub fn simple_from_addr(edge: Address) -> Self {
+        Self::Simple(SimpleEdge::from_address(edge))
+    }
+
+    #[inline(always)]
+    pub fn from_oop_ref(oop_ref: &Oop) -> Self {
+        Self::Simple(SimpleEdge::from_address(Address::from_ref(oop_ref)))
+    }
+
+    #[inline(always)]
+    pub fn compressed_from_addr(edge: Address) -> Self {
+        Self::Compressed(CompressedOopEdge::from_address(edge))
+    }
+}
+
+impl Edge for OpenJDKEdge {
+    fn load(&self) -> ObjectReference {
+        match self {
+            Self::Simple(s) => s.load(),
+            Self::Compressed(c) => c.load(),
+        }
+    }
+
+    fn store(&self, object: ObjectReference) {
+        match self {
+            Self::Simple(s) => s.store(object),
+            Self::Compressed(c) => c.store(object),
+        }
+    }
+}
+
 #[repr(i32)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 #[allow(dead_code)]

mmtk/src/lib.rs

@@ -6,6 +6,7 @@ extern crate once_cell;
 
 use std::ptr::null_mut;
 
+use abi::OpenJDKEdge;
 use libc::{c_char, c_void, uintptr_t};
 use mmtk::util::alloc::AllocationError;
 use mmtk::util::opaque_pointer::*;
@@ -103,6 +104,7 @@ impl VMBinding for OpenJDK {
     type VMCollection = collection::VMCollection;
     type VMActivePlan = active_plan::VMActivePlan;
     type VMReferenceGlue = reference_glue::VMReferenceGlue;
+    type VMEdge = OpenJDKEdge;
 }
 
 lazy_static! {

mmtk/src/object_scanning.rs

@@ -2,28 +2,28 @@ use super::abi::*;
 use super::UPCALLS;
 use mmtk::util::constants::*;
 use mmtk::util::opaque_pointer::*;
-use mmtk::util::{Address, ObjectReference};
+use mmtk::util::ObjectReference;
 use mmtk::vm::EdgeVisitor;
 use std::{mem, slice};
 
 trait OopIterate: Sized {
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor);
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>);
 }
 
 impl OopIterate for OopMapBlock {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         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.visit_edge(edge);
+            closure.visit_edge(OpenJDKEdge::simple_from_addr(edge));
         }
     }
 }
 
 impl OopIterate for InstanceKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         let oop_maps = self.nonstatic_oop_maps();
         for map in oop_maps {
             map.oop_iterate(oop, closure)
@@ -33,7 +33,7 @@ impl OopIterate for InstanceKlass {
 
 impl OopIterate for InstanceMirrorKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         self.instance_klass.oop_iterate(oop, closure);
         // if (Devirtualizer::do_metadata(closure)) {
         //     Klass* klass = java_lang_Class::as_Klass(obj);
@@ -67,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.visit_edge(Address::from_ref(oop as &Oop));
+            closure.visit_edge(OpenJDKEdge::from_oop_ref(oop));
         }
     }
 }
 
 impl OopIterate for InstanceClassLoaderKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         self.instance_klass.oop_iterate(oop, closure);
         // if (Devirtualizer::do_metadata(closure)) {
         //     ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj);
@@ -88,25 +88,25 @@ impl OopIterate for InstanceClassLoaderKlass {
 
 impl OopIterate for ObjArrayKlass {
     #[inline]
-    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         let array = unsafe { oop.as_array_oop() };
         for oop in unsafe { array.data::<Oop>(BasicType::T_OBJECT) } {
-            closure.visit_edge(Address::from_ref(oop as &Oop));
+            closure.visit_edge(OpenJDKEdge::from_oop_ref(oop));
         }
     }
 }
 
 impl OopIterate for TypeArrayKlass {
     #[inline]
-    fn oop_iterate(&self, _oop: Oop, _closure: &mut impl EdgeVisitor) {
+    fn oop_iterate(&self, _oop: Oop, _closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         // 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 EdgeVisitor) {
+    fn oop_iterate(&self, oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         use crate::abi::*;
         use crate::api::{add_phantom_candidate, add_soft_candidate, add_weak_candidate};
         self.instance_klass.oop_iterate(oop, closure);
@@ -139,23 +139,23 @@ impl InstanceRefKlass {
         !*SINGLETON.get_options().no_reference_types
     }
     #[inline]
-    fn process_ref_as_strong(oop: Oop, closure: &mut impl EdgeVisitor) {
+    fn process_ref_as_strong(oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
         let referent_addr = Self::referent_address(oop);
-        closure.visit_edge(referent_addr);
+        closure.visit_edge(OpenJDKEdge::simple_from_addr(referent_addr));
         let discovered_addr = Self::discovered_address(oop);
-        closure.visit_edge(discovered_addr);
+        closure.visit_edge(OpenJDKEdge::simple_from_addr(discovered_addr));
     }
 }
 
 #[allow(unused)]
-fn oop_iterate_slow(oop: Oop, closure: &mut impl EdgeVisitor, tls: OpaquePointer) {
+fn oop_iterate_slow(oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>, tls: OpaquePointer) {
     unsafe {
         ((*UPCALLS).scan_object)(closure as *mut _ as _, mem::transmute(oop), tls);
     }
 }
 
 #[inline]
-fn oop_iterate(oop: Oop, closure: &mut impl EdgeVisitor) {
+fn oop_iterate(oop: Oop, closure: &mut impl EdgeVisitor<OpenJDKEdge>) {
     let klass_id = oop.klass.id;
     debug_assert!(
         klass_id as i32 >= 0 && (klass_id as i32) < 6,
@@ -192,7 +192,7 @@ fn oop_iterate(oop: Oop, closure: &mut impl EdgeVisitor) {
 }
 
 #[inline]
-pub fn scan_object(object: ObjectReference, closure: &mut impl EdgeVisitor, _tls: VMWorkerThread) {
+pub fn scan_object(object: ObjectReference, closure: &mut impl EdgeVisitor<OpenJDKEdge>, _tls: VMWorkerThread) {
     // println!("*****scan_object(0x{:x}) -> \n 0x{:x}, 0x{:x} \n",
     //     object,
     //     unsafe { *(object.value() as *const usize) },

mmtk/src/scanning.rs

@@ -1,6 +1,7 @@
 use super::gc_work::*;
 use super::{NewBuffer, SINGLETON, UPCALLS};
 use crate::OpenJDK;
+use crate::abi::OpenJDKEdge;
 use mmtk::memory_manager;
 use mmtk::scheduler::ProcessEdgesWork;
 use mmtk::scheduler::WorkBucketStage;
@@ -19,10 +20,11 @@ pub(crate) extern "C" fn create_process_edges_work<W: ProcessEdgesWork<VM = Open
 ) -> NewBuffer {
     if !ptr.is_null() {
         let buf = unsafe { Vec::<Address>::from_raw_parts(ptr, length, capacity) };
+        let edges = buf.iter().copied().map(OpenJDKEdge::simple_from_addr).collect::<Vec<_>>();
         memory_manager::add_work_packet(
             &SINGLETON,
             WorkBucketStage::Closure,
-            W::new(buf, true, &SINGLETON),
+            W::new(edges, true, &SINGLETON),
         );
     }
     let (ptr, _, capacity) = {
@@ -39,7 +41,7 @@ impl Scanning<OpenJDK> for VMScanning {
     const SCAN_MUTATORS_IN_SAFEPOINT: bool = false;
     const SINGLE_THREAD_MUTATOR_SCANNING: bool = false;
 
-    fn scan_object<EV: EdgeVisitor>(
+    fn scan_object<EV: EdgeVisitor<OpenJDKEdge>>(
         tls: VMWorkerThread,
         object: ObjectReference,
         edge_visitor: &mut EV,
@@ -75,17 +77,17 @@ impl Scanning<OpenJDK> for VMScanning {
             &SINGLETON,
             WorkBucketStage::Prepare,
             vec![
-                Box::new(ScanUniverseRoots::<W>::new()),
-                Box::new(ScanJNIHandlesRoots::<W>::new()),
-                Box::new(ScanObjectSynchronizerRoots::<W>::new()),
-                Box::new(ScanManagementRoots::<W>::new()),
-                Box::new(ScanJvmtiExportRoots::<W>::new()),
-                Box::new(ScanAOTLoaderRoots::<W>::new()),
-                Box::new(ScanSystemDictionaryRoots::<W>::new()),
-                Box::new(ScanCodeCacheRoots::<W>::new()),
-                Box::new(ScanStringTableRoots::<W>::new()),
-                Box::new(ScanClassLoaderDataGraphRoots::<W>::new()),
-                Box::new(ScanWeakProcessorRoots::<W>::new()),
+                Box::new(ScanUniverseRoots::<W>::new()) as _,
+                Box::new(ScanJNIHandlesRoots::<W>::new()) as _,
+                Box::new(ScanObjectSynchronizerRoots::<W>::new()) as _,
+                Box::new(ScanManagementRoots::<W>::new()) as _,
+                Box::new(ScanJvmtiExportRoots::<W>::new()) as _,
+                Box::new(ScanAOTLoaderRoots::<W>::new()) as _,
+                Box::new(ScanSystemDictionaryRoots::<W>::new()) as _,
+                Box::new(ScanCodeCacheRoots::<W>::new()) as _,
+                Box::new(ScanStringTableRoots::<W>::new()) as _,
+                Box::new(ScanClassLoaderDataGraphRoots::<W>::new()) as _,
+                Box::new(ScanWeakProcessorRoots::<W>::new()) as _,
             ],
         );
         if !(Self::SCAN_MUTATORS_IN_SAFEPOINT && Self::SINGLE_THREAD_MUTATOR_SCANNING) {