Move edge types into a dedicated mod

Author: wks

mmtk/src/edges.rs

@@ -0,0 +1,103 @@
+use std::ops::Range;
+
+use mmtk::{
+    util::{Address, ObjectReference},
+    vm::edge_shape::{AddressRangeIterator, Edge, MemorySlice},
+};
+
+/// The type of edges in OpenJDK.
+/// Currently it has the same layout as `Address`, but we override its load and store methods.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+#[repr(transparent)]
+pub struct OpenJDKEdge {
+    pub addr: Address,
+}
+
+impl From<Address> for OpenJDKEdge {
+    fn from(value: Address) -> Self {
+        Self { addr: value }
+    }
+}
+
+impl Edge for OpenJDKEdge {
+    fn load(&self) -> ObjectReference {
+        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
+            // Workaround: On x86 (including x86_64), machine instructions may contain pointers as
+            // immediates, and they may be unaligned.  It is an undefined behavior in Rust to
+            // dereference unaligned pointers.  We have to explicitly use unaligned memory access
+            // methods.  On x86, ordinary MOV instructions can load and store memory at unaligned
+            // addresses, so we expect `ptr.read_unaligned()` to have no performance penalty over
+            // `ptr.read()` if `ptr` is actually aligned.
+            unsafe {
+                let ptr = self.addr.to_ptr::<ObjectReference>();
+                ptr.read_unaligned()
+            }
+        } else {
+            unsafe { self.addr.load() }
+        }
+    }
+
+    fn store(&self, object: ObjectReference) {
+        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
+            unsafe {
+                let ptr = self.addr.to_mut_ptr::<ObjectReference>();
+                ptr.write_unaligned(object)
+            }
+        } else {
+            unsafe { self.addr.store(object) }
+        }
+    }
+}
+
+/// A range of OpenJDKEdge, usually used for arrays.
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct OpenJDKEdgeRange {
+    range: Range<Address>,
+}
+
+impl From<Range<Address>> for OpenJDKEdgeRange {
+    fn from(value: Range<Address>) -> Self {
+        Self { range: value }
+    }
+}
+
+pub struct OpenJDKEdgeRangeIterator {
+    inner: AddressRangeIterator,
+}
+
+impl Iterator for OpenJDKEdgeRangeIterator {
+    type Item = OpenJDKEdge;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|a| a.into())
+    }
+}
+
+// Note that we cannot implement MemorySlice for `Range<OpenJDKEdgeRange>` because neither
+// `MemorySlice` nor `Range<T>` are defined in the `mmtk-openjdk` crate. ("orphan rule")
+impl MemorySlice for OpenJDKEdgeRange {
+    type Edge = OpenJDKEdge;
+    type EdgeIterator = OpenJDKEdgeRangeIterator;
+
+    fn iter_edges(&self) -> Self::EdgeIterator {
+        OpenJDKEdgeRangeIterator {
+            inner: self.range.iter_edges(),
+        }
+    }
+
+    fn object(&self) -> Option<ObjectReference> {
+        self.range.object()
+    }
+
+    fn start(&self) -> Address {
+        self.range.start()
+    }
+
+    fn bytes(&self) -> usize {
+        self.range.bytes()
+    }
+
+    fn copy(src: &Self, tgt: &Self) {
+        MemorySlice::copy(&src.range, &tgt.range)
+    }
+}

mmtk/src/lib.rs

@@ -2,16 +2,15 @@
 extern crate lazy_static;
 
 use std::collections::HashMap;
-use std::ops::Range;
 use std::ptr::null_mut;
 use std::sync::atomic::AtomicUsize;
 use std::sync::Mutex;
 
+use edges::{OpenJDKEdge, OpenJDKEdgeRange};
 use libc::{c_char, c_void, uintptr_t};
 use mmtk::util::alloc::AllocationError;
 use mmtk::util::opaque_pointer::*;
 use mmtk::util::{Address, ObjectReference};
-use mmtk::vm::edge_shape::{AddressRangeIterator, Edge, MemorySlice};
 use mmtk::vm::VMBinding;
 use mmtk::{MMTKBuilder, Mutator, MMTK};
 
@@ -20,6 +19,7 @@ pub mod active_plan;
 pub mod api;
 mod build_info;
 pub mod collection;
+mod edges;
 mod gc_work;
 pub mod object_model;
 mod object_scanning;
@@ -136,103 +136,6 @@ pub static FREE_LIST_ALLOCATOR_SIZE: uintptr_t =
 #[derive(Default)]
 pub struct OpenJDK;
 
-/// The type of edges in OpenJDK.
-/// Currently it has the same layout as `Address`, but we override its load and store methods.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-#[repr(transparent)]
-pub struct OpenJDKEdge {
-    pub addr: Address,
-}
-
-impl From<Address> for OpenJDKEdge {
-    fn from(value: Address) -> Self {
-        Self { addr: value }
-    }
-}
-
-impl Edge for OpenJDKEdge {
-    fn load(&self) -> ObjectReference {
-        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
-            // Workaround: On x86 (including x86_64), machine instructions may contain pointers as
-            // immediates, and they may be unaligned.  It is an undefined behavior in Rust to
-            // dereference unaligned pointers.  We have to explicitly use unaligned memory access
-            // methods.  On x86, ordinary MOV instructions can load and store memory at unaligned
-            // addresses, so we expect `ptr.read_unaligned()` to have no performance penalty over
-            // `ptr.read()` if `ptr` is actually aligned.
-            unsafe {
-                let ptr = self.addr.to_ptr::<ObjectReference>();
-                ptr.read_unaligned()
-            }
-        } else {
-            unsafe { self.addr.load() }
-        }
-    }
-
-    fn store(&self, object: ObjectReference) {
-        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
-            unsafe {
-                let ptr = self.addr.to_mut_ptr::<ObjectReference>();
-                ptr.write_unaligned(object)
-            }
-        } else {
-            unsafe { self.addr.store(object) }
-        }
-    }
-}
-
-/// A range of OpenJDKEdge, usually used for arrays.
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub struct OpenJDKEdgeRange {
-    range: Range<Address>,
-}
-
-impl From<Range<Address>> for OpenJDKEdgeRange {
-    fn from(value: Range<Address>) -> Self {
-        Self { range: value }
-    }
-}
-
-pub struct OpenJDKEdgeRangeIterator {
-    inner: AddressRangeIterator,
-}
-
-impl Iterator for OpenJDKEdgeRangeIterator {
-    type Item = OpenJDKEdge;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next().map(|a| a.into())
-    }
-}
-
-// Note that we cannot implement MemorySlice for `Range<OpenJDKEdgeRange>` because neither
-// `MemorySlice` nor `Range<T>` are defined in the `mmtk-openjdk` crate. ("orphan rule")
-impl MemorySlice for OpenJDKEdgeRange {
-    type Edge = OpenJDKEdge;
-    type EdgeIterator = OpenJDKEdgeRangeIterator;
-
-    fn iter_edges(&self) -> Self::EdgeIterator {
-        OpenJDKEdgeRangeIterator {
-            inner: self.range.iter_edges(),
-        }
-    }
-
-    fn object(&self) -> Option<ObjectReference> {
-        self.range.object()
-    }
-
-    fn start(&self) -> Address {
-        self.range.start()
-    }
-
-    fn bytes(&self) -> usize {
-        self.range.bytes()
-    }
-
-    fn copy(src: &Self, tgt: &Self) {
-        MemorySlice::copy(&src.range, &tgt.range)
-    }
-}
-
 impl VMBinding for OpenJDK {
     type VMObjectModel = object_model::VMObjectModel;
     type VMScanning = scanning::VMScanning;