Implement JuliaMemorySlice, and expose mmtk_memory_region_copy (mmtk#53)

Merge with mmtk/julia#10.

Author: qinsoon

mmtk/Cargo.lock

@@ -10,7 +10,7 @@ edition = "2018"
 [package.metadata.julia]
 # Our CI matches the following line and extract mmtk/julia. If this line is updated, please check ci yaml files and make sure it works.
 julia_repo = "https://github.com/mmtk/julia.git"
-julia_version = "a760a7ee28150261669cb0b31a8284214b3635c7"
+julia_version = "95bc54ab673fcdf11604324638f597f32158a22f"
 
 [lib]
 crate-type = ["staticlib", "rlib", "dylib"]
@@ -29,7 +29,7 @@ lazy_static = "1.1"
 # - 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 = "2cc34abe2b3ce4ee213b9ac4b9295160dac754cc" }
+mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "ed347f19f230dfec8c05a24032f1529e9079478c" }
 # Uncomment the following to build locally
 # mmtk = { path = "../repos/mmtk-core" }
 log = {version = "0.4", features = ["max_level_trace", "release_max_level_off"] }

mmtk/Cargo.toml

@@ -57,6 +57,8 @@ extern void modify_check(void* ref);
 extern int object_is_managed_by_mmtk(void* addr);
 extern void runtime_panic(void);
 
+// Write barriers
+extern void mmtk_memory_region_copy(MMTk_Mutator mutator, void* src_obj, void* src_addr, void* dst_obj, void* dst_addr, size_t size);
 extern void mmtk_object_reference_write_post(MMTk_Mutator mutator, const void* src, const void* target);
 extern uint8_t mmtk_needs_write_barrier(void);
 

mmtk/api/mmtk.h

@@ -443,11 +443,34 @@ pub extern "C" fn mmtk_gc_poll(tls: VMMutatorThread) {
 }
 
 #[no_mangle]
-
 pub extern "C" fn runtime_panic() {
     panic!("Panicking at runtime!")
 }
 
+#[no_mangle]
+pub extern "C" fn mmtk_memory_region_copy(
+    mutator: *mut Mutator<JuliaVM>,
+    src_obj: ObjectReference,
+    src_addr: Address,
+    dst_obj: ObjectReference,
+    dst_addr: Address,
+    count: usize,
+) {
+    use crate::edges::JuliaMemorySlice;
+    let src = JuliaMemorySlice {
+        owner: src_obj,
+        start: src_addr,
+        count,
+    };
+    let dst = JuliaMemorySlice {
+        owner: dst_obj,
+        start: dst_addr,
+        count,
+    };
+    let mutator = unsafe { &mut *mutator };
+    memory_manager::memory_region_copy(mutator, src, dst);
+}
+
 #[no_mangle]
 pub extern "C" fn mmtk_object_reference_write_post(
     mutator: *mut Mutator<JuliaVM>,

mmtk/src/api.rs

@@ -74,3 +74,90 @@ impl Edge for OffsetEdge {
         unsafe { (*self.slot_addr).store(middle, atomic::Ordering::Relaxed) }
     }
 }
+
+#[derive(Hash, Clone, PartialEq, Eq, Debug)]
+pub struct JuliaMemorySlice {
+    pub owner: ObjectReference,
+    pub start: Address,
+    pub count: usize,
+}
+
+impl mmtk::vm::edge_shape::MemorySlice for JuliaMemorySlice {
+    type Edge = JuliaVMEdge;
+    type EdgeIterator = JuliaMemorySliceEdgeIterator;
+
+    fn iter_edges(&self) -> Self::EdgeIterator {
+        JuliaMemorySliceEdgeIterator {
+            cursor: self.start,
+            limit: self.start.shift::<Address>(self.count as isize),
+        }
+    }
+
+    fn object(&self) -> Option<ObjectReference> {
+        Some(self.owner)
+    }
+
+    fn start(&self) -> Address {
+        self.start
+    }
+
+    fn bytes(&self) -> usize {
+        self.count << mmtk::util::constants::LOG_BYTES_IN_ADDRESS
+    }
+
+    fn copy(src: &Self, tgt: &Self) {
+        use std::sync::atomic::*;
+        // Raw memory copy -- we should be consistent with jl_array_ptr_copy in array.c
+        unsafe {
+            let words = tgt.bytes() >> mmtk::util::constants::LOG_BYTES_IN_ADDRESS;
+            // let src = src.start().to_ptr::<usize>();
+            // let tgt = tgt.start().to_mut_ptr::<usize>();
+            // std::ptr::copy(src, tgt, words)
+
+            let src_addr = src.start();
+            let tgt_addr = tgt.start();
+
+            let n: isize = words as isize;
+
+            if tgt_addr < src_addr || tgt_addr > src_addr + tgt.bytes() {
+                // non overlaping
+                for i in 0..n {
+                    let val: usize = src_addr
+                        .shift::<usize>(i)
+                        .atomic_load::<AtomicUsize>(Ordering::Relaxed);
+                    tgt_addr
+                        .shift::<usize>(i)
+                        .atomic_store::<AtomicUsize>(val, Ordering::Release);
+                }
+            } else {
+                for i in 0..n {
+                    let val = src_addr
+                        .shift::<usize>(n - i - 1)
+                        .atomic_load::<AtomicUsize>(Ordering::Relaxed);
+                    tgt_addr
+                        .shift::<usize>(n - i - 1)
+                        .atomic_store::<AtomicUsize>(val, Ordering::Release);
+                }
+            }
+        }
+    }
+}
+
+pub struct JuliaMemorySliceEdgeIterator {
+    cursor: Address,
+    limit: Address,
+}
+
+impl Iterator for JuliaMemorySliceEdgeIterator {
+    type Item = JuliaVMEdge;
+
+    fn next(&mut self) -> Option<JuliaVMEdge> {
+        if self.cursor >= self.limit {
+            None
+        } else {
+            let edge = self.cursor;
+            self.cursor = self.cursor.shift::<ObjectReference>(1);
+            Some(JuliaVMEdge::Simple(SimpleEdge::from_address(edge)))
+        }
+    }
+}

mmtk/src/edges.rs

@@ -8,7 +8,6 @@ use mmtk::scheduler::*;
 use mmtk::util::opaque_pointer::*;
 use mmtk::util::Address;
 use mmtk::util::ObjectReference;
-use mmtk::vm::edge_shape;
 use mmtk::vm::EdgeVisitor;
 use mmtk::vm::VMBinding;
 use mmtk::MMTKBuilder;
@@ -50,7 +49,7 @@ impl VMBinding for JuliaVM {
     type VMCollection = collection::VMCollection;
     type VMActivePlan = active_plan::VMActivePlan;
     type VMReferenceGlue = reference_glue::VMReferenceGlue;
-    type VMMemorySlice = edge_shape::UnimplementedMemorySlice<JuliaVMEdge>;
+    type VMMemorySlice = edges::JuliaMemorySlice;
     type VMEdge = JuliaVMEdge;
 }