Concurrent Immix

mmtk/Cargo.toml

@@ -35,9 +35,9 @@ probe = "0.5"
 # - 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 = "c5ead72a87bcc8cc49b5e7a62cf71d848b4b4c9b" }
+# mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "c5ead72a87bcc8cc49b5e7a62cf71d848b4b4c9b" }
 # Uncomment the following to build locally
-# mmtk = { path = "../repos/mmtk-core" }
+mmtk = { path = "../../mmtk-core" }
 
 [build-dependencies]
 built = { version = "0.7.7", features = ["git2"] }

mmtk/src/api.rs

@@ -47,6 +47,7 @@ macro_rules! with_mutator {
 static NO_BARRIER: sync::Lazy<CString> = sync::Lazy::new(|| CString::new("NoBarrier").unwrap());
 static OBJECT_BARRIER: sync::Lazy<CString> =
     sync::Lazy::new(|| CString::new("ObjectBarrier").unwrap());
+static SATB_BARRIER: sync::Lazy<CString> = sync::Lazy::new(|| CString::new("SATBBarrier").unwrap());
 
 #[no_mangle]
 pub extern "C" fn get_mmtk_version() -> *const c_char {
@@ -59,6 +60,7 @@ pub extern "C" fn mmtk_active_barrier() -> *const c_char {
         match singleton.get_plan().constraints().barrier {
             BarrierSelector::NoBarrier => NO_BARRIER.as_ptr(),
             BarrierSelector::ObjectBarrier => OBJECT_BARRIER.as_ptr(),
+             BarrierSelector::SATBBarrier => SATB_BARRIER.as_ptr(),
             // In case we have more barriers in mmtk-core.
             #[allow(unreachable_patterns)]
             _ => unimplemented!(),
@@ -381,6 +383,19 @@ pub extern "C" fn executable() -> bool {
     true
 }
 
+#[no_mangle]
+pub extern "C" fn mmtk_load_reference(mutator: *mut libc::c_void, o: ObjectReference) {
+    with_mutator!(|mutator| mutator.barrier().load_reference(o))
+}
+
+#[no_mangle]
+pub extern "C" fn mmtk_object_reference_clone_pre(
+    mutator: *mut libc::c_void,
+    obj: ObjectReference,
+) {
+    with_mutator!(|mutator| mutator.barrier().object_reference_clone_pre(obj))
+}
+
 /// Full pre barrier
 #[no_mangle]
 pub extern "C" fn mmtk_object_reference_write_pre(

mmtk/src/collection.rs

@@ -57,4 +57,8 @@ impl<const COMPRESSED: bool> Collection<OpenJDK<COMPRESSED>> for VMCollection {
             ((*UPCALLS).schedule_finalizer)();
         }
     }
+
+    fn set_concurrent_marking_state(active: bool) {
+        unsafe { crate::CONCURRENT_MARKING_ACTIVE = if active { 1 } else { 0 } }
+    }
 }

mmtk/src/lib.rs

@@ -139,6 +139,9 @@ pub static VO_BIT_ADDRESS: uintptr_t =
 pub static FREE_LIST_ALLOCATOR_SIZE: uintptr_t =
     std::mem::size_of::<mmtk::util::alloc::FreeListAllocator<OpenJDK<false>>>();
 
+#[no_mangle]
+pub static mut CONCURRENT_MARKING_ACTIVE: u8 = 0;
+
 #[derive(Default)]
 pub struct OpenJDK<const COMPRESSED: bool>;
 

openjdk/barriers/mmtkObjectBarrier.cpp

@@ -136,6 +136,57 @@ void MMTkObjectBarrierSetAssembler::arraycopy_epilogue(MacroAssembler* masm, Dec
 
 #undef __
 
+#define __ sasm->
+
+void MMTkObjectBarrierSetAssembler::generate_c1_post_write_barrier_runtime_stub(StubAssembler* sasm) const {
+  __ prologue("mmtk_object_barrier", false);
+
+  Label done, runtime;
+
+  __ push(c_rarg0);
+  __ push(c_rarg1);
+  __ push(c_rarg2);
+  __ push(rax);
+
+  __ load_parameter(0, c_rarg0);
+  __ load_parameter(1, c_rarg1);
+  __ load_parameter(2, c_rarg2);
+
+  __ bind(runtime);
+
+  __ save_live_registers_no_oop_map(true);
+
+#if MMTK_ENABLE_BARRIER_FASTPATH
+  __ call_VM_leaf_base(FN_ADDR(MMTkBarrierSetRuntime::object_reference_write_slow_call), 3);
+#else
+  __ call_VM_leaf_base(FN_ADDR(MMTkBarrierSetRuntime::object_reference_write_post_call), 3);
+#endif
+
+  __ restore_live_registers(true);
+
+  __ bind(done);
+  __ pop(rax);
+  __ pop(c_rarg2);
+  __ pop(c_rarg1);
+  __ pop(c_rarg0);
+
+  __ epilogue();
+}
+
+#undef __
+#define __ ce->masm()->
+
+void MMTkObjectBarrierSetAssembler::generate_c1_post_write_barrier_stub(LIR_Assembler* ce, MMTkC1PostBarrierStub* stub) const {
+  MMTkBarrierSetC1* bs = (MMTkBarrierSetC1*) BarrierSet::barrier_set()->barrier_set_c1();
+  __ bind(*stub->entry());
+  ce->store_parameter(stub->src->as_pointer_register(), 0);
+  ce->store_parameter(stub->slot->as_pointer_register(), 1);
+  ce->store_parameter(stub->new_val->as_pointer_register(), 2);
+  __ call(RuntimeAddress(bs->post_barrier_c1_runtime_code_blob()->code_begin()));
+  __ jmp(*stub->continuation());
+}
+#undef __
+
 #ifdef ASSERT
 #define __ gen->lir(__FILE__, __LINE__)->
 #else
@@ -176,7 +227,7 @@ void MMTkObjectBarrierSetC1::object_reference_write_post(LIRAccess& access, LIR_
     new_val = new_val_reg;
   }
   assert(new_val->is_register(), "must be a register at this point");
-  CodeStub* slow = new MMTkC1BarrierStub(src, slot, new_val);
+  CodeStub* slow = new MMTkC1PostBarrierStub(src, slot, new_val);
 
 #if MMTK_ENABLE_BARRIER_FASTPATH
   LIR_Opr addr = src;

openjdk/barriers/mmtkObjectBarrier.hpp

@@ -31,7 +31,10 @@ class MMTkObjectBarrierSetRuntime: public MMTkBarrierSetRuntime {
 class MMTkObjectBarrierSetAssembler: public MMTkBarrierSetAssembler {
 protected:
   virtual void object_reference_write_post(MacroAssembler* masm, DecoratorSet decorators, Address dst, Register val, Register tmp1, Register tmp2, bool compensate_val_reg) const override;
+  /// Generate C1 write barrier slow-call assembly code
+  virtual void generate_c1_post_write_barrier_runtime_stub(StubAssembler* sasm) const;
 public:
+  virtual void generate_c1_post_write_barrier_stub(LIR_Assembler* ce, MMTkC1PostBarrierStub* stub) const;
   virtual void arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Register src, Register dst, Register count) override;
   virtual void arraycopy_epilogue(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Register src, Register dst, Register count) override;
 };