Select barrier based on active plan (#44)

Author: wenyuzhao

mmtk/Cargo.toml

@@ -21,7 +21,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 = "ssh://[email protected]/mmtk/mmtk-core.git", rev = "4bc6d859fb6828d876aa7d1b0973fc2dda297850" }
+mmtk = { git = "ssh://[email protected]/mmtk/mmtk-core.git", rev = "1c7d7abb8e2adc5a9f64326af2f5af6a5d335497" }
 # Uncomment the following to build locally
 # mmtk = { path = "../repos/mmtk-core" }
 
@@ -31,7 +31,7 @@ nogc_lock_free = ["mmtk/nogc_lock_free"]
 nogc_no_zeroing = ["mmtk/nogc_no_zeroing"]
 
 # We can select plan at runtime. So no need to use any of these features.
-# However, if any of these is provided during build-time, we will ignore any runtime flag and 
+# However, if any of these is provided during build-time, we will ignore any runtime flag and
 # always run this plan. Performance-wise there is no difference. The main reason for these features
 # is to temporarily allow running performance tests without changing performance scripts.
 nogc = []

mmtk/src/api.rs

@@ -1,6 +1,6 @@
 use libc::{c_char, c_void};
-use std::ffi::CStr;
-
+use std::ffi::{CStr, CString};
+use std::lazy::SyncLazy;
 use mmtk::memory_manager;
 use mmtk::scheduler::GCWorker;
 use mmtk::util::alloc::allocators::AllocatorSelector;
@@ -10,12 +10,26 @@ use mmtk::AllocationSemantics;
 use mmtk::MutatorContext;
 use mmtk::Mutator;
 use mmtk::{Plan, MMTK};
-
+use mmtk::util::options::PlanSelector;
+use mmtk::plan::barriers::BarrierSelector;
 use crate::OpenJDK;
 use crate::OpenJDK_Upcalls;
 use crate::SINGLETON;
 use crate::UPCALLS;
 
+// Supported barriers:
+static NO_BARRIER: SyncLazy<CString> = SyncLazy::new(|| CString::new("NoBarrier").unwrap());
+static OBJECT_BARRIER: SyncLazy<CString> = SyncLazy::new(|| CString::new("ObjectBarrier").unwrap());
+
+#[no_mangle]
+pub extern "C" fn mmtk_active_barrier() -> *const c_char {
+    match SINGLETON.plan.constraints().barrier {
+        BarrierSelector::NoBarrier => NO_BARRIER.as_ptr(),
+        BarrierSelector::ObjectBarrier => OBJECT_BARRIER.as_ptr(),
+        _ => unimplemented!()
+    }
+}
+
 #[no_mangle]
 pub extern "C" fn release_buffer(ptr: *mut Address, length: usize, capacity: usize) {
     let _vec = unsafe { Vec::<Address>::from_raw_parts(ptr, length, capacity) };
@@ -30,11 +44,6 @@ pub extern "C" fn openjdk_gc_init(calls: *const OpenJDK_Upcalls, heap_size: usiz
     memory_manager::gc_init(singleton_mut, heap_size);
 }
 
-#[no_mangle]
-pub extern "C" fn openjdk_needs_write_barrier() -> bool {
-    SINGLETON.plan.constraints().needs_write_barrier
-}
-
 #[no_mangle]
 pub extern "C" fn start_control_collector(tls: OpaquePointer) {
     memory_manager::start_control_collector(&SINGLETON, tls);

mmtk/src/lib.rs

@@ -2,6 +2,7 @@
 #![feature(const_fn)]
 #![feature(box_syntax)]
 #![feature(vec_into_raw_parts)]
+#![feature(once_cell)]
 
 extern crate libc;
 extern crate mmtk;

openjdk/CompileThirdPartyHeap.gmk

@@ -31,7 +31,7 @@ JVM_LDFLAGS += '-Wl,-rpath,$$ORIGIN'
 FORCE:
 
 TARGETS += $(LIB_MMTK)
-JVM_SRC_DIRS += $(MMTK_CPP_ROOT)
+JVM_SRC_DIRS += $(MMTK_CPP_ROOT) $(MMTK_CPP_ROOT)/barriers
 JVM_CFLAGS += -DINCLUDE_THIRD_PARTY_HEAP -DTHIRD_PARTY_HEAP_SRC=$(MMTK_CPP_ROOT)
 
 $(BUILD_LIBJVM): $(LIB_MMTK)

openjdk/barriers/mmtkNoBarrier.hpp

@@ -0,0 +1,24 @@
+#ifndef MMTK_BARRIERS_NO_BARRIER
+#define MMTK_BARRIERS_NO_BARRIER
+
+#include "../mmtkBarrierSet.hpp"
+#include "../mmtkBarrierSetAssembler_x86.hpp"
+#include "../mmtkBarrierSetC1.hpp"
+#include "../mmtkBarrierSetC2.hpp"
+
+class MMTkNoBarrierSetRuntime: public MMTkBarrierSetRuntime {};
+
+class MMTkNoBarrierSetAssembler: public MMTkBarrierSetAssembler {};
+
+class MMTkNoBarrierSetC1: public MMTkBarrierSetC1 {};
+
+class MMTkNoBarrierSetC2: public MMTkBarrierSetC2 {};
+
+struct MMTkNoBarrier: MMTkBarrierImpl<
+  MMTkNoBarrierSetRuntime,
+  MMTkNoBarrierSetAssembler,
+  MMTkNoBarrierSetC1,
+  MMTkNoBarrierSetC2
+> {};
+
+#endif

openjdk/barriers/mmtkObjectBarrier.cpp

@@ -0,0 +1,119 @@
+#include "mmtkObjectBarrier.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+
+void MMTkObjectBarrierSetRuntime::record_modified_node_slow(void* obj) {
+  ::record_modified_node((MMTk_Mutator) &Thread::current()->third_party_heap_mutator, (void*) obj);
+}
+
+void MMTkObjectBarrierSetRuntime::record_modified_node(oop src) {
+  record_modified_node_slow((void*) src);
+}
+
+#define __ masm->
+
+void MMTkObjectBarrierSetAssembler::oop_store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Address dst, Register val, Register tmp1, Register tmp2) {
+  bool in_heap = (decorators & IN_HEAP) != 0;
+  bool as_normal = (decorators & AS_NORMAL) != 0;
+  assert((decorators & IS_DEST_UNINITIALIZED) == 0, "unsupported");
+
+  if (!in_heap || val == noreg) {
+    BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2);
+    return;
+  }
+
+  assert_different_registers(tmp1, noreg);
+  assert_different_registers(tmp2, noreg);
+  assert_different_registers(tmp1, tmp2);
+
+  __ push(dst.base());
+
+  if (dst.index() == noreg && dst.disp() == 0) {
+    if (dst.base() != tmp1) {
+      __ movptr(tmp1, dst.base());
+    }
+  } else {
+    __ lea(tmp1, dst);
+  }
+
+  BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp1, 0), val, noreg, noreg);
+
+  __ pop(tmp2);
+
+  record_modified_node(masm, tmp2);
+}
+
+void MMTkObjectBarrierSetAssembler::record_modified_node(MacroAssembler* masm, Register obj) {
+  __ pusha();
+  __ movptr(c_rarg0, obj);
+  __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, MMTkObjectBarrierSetRuntime::record_modified_node_slow), 1);
+  __ popa();
+}
+
+#undef __
+
+#ifdef ASSERT
+#define __ gen->lir(__FILE__, __LINE__)->
+#else
+#define __ gen->lir()->
+#endif
+
+void MMTkObjectBarrierSetC1::record_modified_node(LIRAccess& access, LIR_Opr src, LIR_Opr slot, LIR_Opr new_val) {
+  LIRGenerator* gen = access.gen();
+  DecoratorSet decorators = access.decorators();
+  if ((decorators & IN_HEAP) == 0) return;
+  if (!src->is_register()) {
+    LIR_Opr reg = gen->new_pointer_register();
+    if (src->is_constant()) {
+      __ move(src, reg);
+    } else {
+      __ leal(src, reg);
+    }
+    src = reg;
+  }
+  assert(src->is_register(), "must be a register at this point");
+  if (!slot->is_register()) {
+    LIR_Opr reg = gen->new_pointer_register();
+    if (slot->is_constant()) {
+      __ move(slot, reg);
+    } else {
+      __ leal(slot, reg);
+    }
+    slot = reg;
+  }
+  assert(slot->is_register(), "must be a register at this point");
+  if (!new_val->is_register()) {
+    LIR_Opr new_val_reg = gen->new_register(T_OBJECT);
+    if (new_val->is_constant()) {
+      __ move(new_val, new_val_reg);
+    } else {
+      __ leal(new_val, new_val_reg);
+    }
+    new_val = new_val_reg;
+  }
+  assert(new_val->is_register(), "must be a register at this point");
+  CodeStub* slow = new MMTkObjectBarrierStub(src, slot, new_val);
+  __ jump(slow);
+  __ branch_destination(slow->continuation());
+}
+
+#undef __
+
+#define __ ideal.
+
+const TypeFunc* record_modified_node_entry_Type() {
+  const Type **fields = TypeTuple::fields(1);
+  fields[TypeFunc::Parms+0] = TypeOopPtr::BOTTOM; // oop src
+  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
+  fields = TypeTuple::fields(0);
+  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
+  return TypeFunc::make(domain, range);
+}
+
+void MMTkObjectBarrierSetC2::record_modified_node(GraphKit* kit, Node* node) const {
+  IdealKit ideal(kit, true);
+  const TypeFunc *tf = record_modified_node_entry_Type();
+  Node* x = __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, MMTkObjectBarrierSetRuntime::record_modified_node_slow), "record_modified_node", node);
+  kit->final_sync(ideal); // Final sync IdealKit and GraphKit.
+}
+
+#undef __