Implement eden_allocate

Author: caizixian

mmtk/Cargo.toml

@@ -17,7 +17,7 @@ lto = true
 [package.metadata.openjdk]
 # Our CI matches the following line and extract mmtk/openjdk. If this line is updated, please check ci yaml files and make sure it works.
 openjdk_repo = "https://github.com/caizixian/jdk-mmtk.git"
-openjdk_version = "0c5806b797026a902718eb83588b6adf181e3d80"
+openjdk_version = "b369f54e36e79d5cc3e67424209be3bbae60d644"
 
 [dependencies]
 libc = "0.2"

openjdk/cpu/riscv/mmtkBarrierSetAssembler_riscv.cpp

@@ -35,9 +35,102 @@
 
 #define __ masm->
 
-void MMTkBarrierSetAssembler::eden_allocate(MacroAssembler* masm, Register thread, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register t1, Label& slow_case) {
-  // assert(false, "Not implemented");
-  __ j(slow_case); // just jal with x0/zr
+void MMTkBarrierSetAssembler::eden_allocate(MacroAssembler* masm, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register tmp1, Register tmp2, Label& slow_case, bool is_far) {
+  // XXX tmp1 seems to be -1
+  assert_different_registers(obj, tmp2);
+  assert_different_registers(obj, var_size_in_bytes);
+  assert(tmp2->is_valid(), "need temp reg");
+
+  if (!MMTK_ENABLE_ALLOCATION_FASTPATH) {
+    __ j(slow_case);
+  } else {
+    //  printf("generating mmtk allocation fast path\n");
+    // MMTk size check. If the alloc size is larger than the allowed max size for non los,
+    // we jump to slow path and allodate with LOS in slowpath.
+    // Note that OpenJDK has a slow path check. Search for layout_helper_needs_slow_path and FastAllocateSizeLimit.
+    // I tried to set FastAllocateSizeLimit in MMTkHeap::initialize(). But there are still large objects allocated into the
+    // default space.
+    assert(MMTkMutatorContext::max_non_los_default_alloc_bytes != 0, "max_non_los_default_alloc_bytes hasn't been initialized");
+    size_t max_non_los_bytes = MMTkMutatorContext::max_non_los_default_alloc_bytes;
+    size_t extra_header = 0;
+    // fastpath, we only use default allocator
+    Allocator allocator = AllocatorDefault;
+    // We need to figure out which allocator we are using by querying MMTk.
+    AllocatorSelector selector = get_allocator_mapping(allocator);
+
+    // XXX riscv: disallow markcompact and global alloc bit for now
+    assert(selector.tag != TAG_MARK_COMPACT, "mark compact not supported for now");
+
+    if (var_size_in_bytes == noreg) {
+      // constant alloc size. If it is larger than max_non_los_bytes, we directly go to slowpath.
+      if ((size_t)con_size_in_bytes > max_non_los_bytes - extra_header) {
+        __ j(slow_case);
+        return;
+      }
+    } else {
+      // var alloc size. We compare with max_non_los_bytes and conditionally jump to slowpath.
+      //  printf("max_non_los_bytes %lu\n",max_non_los_bytes);
+      __ li(t0, max_non_los_bytes - extra_header);
+      __ bgeu(var_size_in_bytes, t0, slow_case, is_far);
+    }
+
+    if (selector.tag == TAG_MALLOC || selector.tag == TAG_LARGE_OBJECT) {
+      __ j(slow_case);
+      return;
+    }
+
+    // Calculate offsets of TLAB top and end
+    Address cursor, limit;
+    MMTkAllocatorOffsets alloc_offsets = get_tlab_top_and_end_offsets(selector);
+
+    cursor = Address(xthread, alloc_offsets.tlab_top_offset);
+    limit = Address(xthread, alloc_offsets.tlab_end_offset);
+
+    // XXX disassembly
+    // 0x7fffe85597e0:      ld      a0,688(s7)
+    // 0x7fffe85597e4:      add     a1,a0,a3
+    // 0x7fffe85597e8:      bltu    a1,a0,0x7fffe8559878
+    // 0x7fffe85597ec:      ld      t0,696(s7)
+    // 0x7fffe85597f0:      bltu    t0,a1,0x7fffe8559878
+    // 0x7fffe85597f4:      sd      a1,688(s7)
+
+    // obj = load lab.cursor
+    __ ld(obj, cursor);
+    // end = obj + size
+    Register end = tmp2;
+    if (var_size_in_bytes == noreg) {
+      __ la(end, Address(obj, con_size_in_bytes));
+    } else {
+      __ add(end, obj, var_size_in_bytes);
+    }
+    // slowpath if end < obj
+    __ bltu(end, obj, slow_case, is_far);
+    // slowpath if end > lab.limit
+    __ ld(t0, limit);
+    // XXX debug use, force slow path
+    // __ bgtu(end, zr, slow_case, is_far);
+    __ bgtu(end, t0, slow_case, is_far);
+    // lab.cursor = end
+    __ sd(end, cursor);
+
+    // recover var_size_in_bytes if necessary
+    if (var_size_in_bytes == end) {
+      __ sub(var_size_in_bytes, var_size_in_bytes, obj);
+    }
+    // if the above is removed, and the register holding the object size is
+    // clobbered, operations that rely on the size, such as array copy will
+    // crash
+
+    // XXX debug use, force segfault to disassemble in gdb
+    // __ ld(t0, zr);
+
+    // XXX debug use, force double allocation
+    // __ j(slow_case);
+
+  #ifdef MMTK_ENABLE_GLOBAL_ALLOC_BIT
+    assert(false, "global alloc bit not supported");
+  #endif
+  }
 }
 
 #undef __

openjdk/cpu/riscv/mmtkBarrierSetAssembler_riscv.hpp

@@ -30,7 +30,15 @@ class MMTkBarrierSetAssembler: public BarrierSetAssembler {
   virtual void generate_c1_write_barrier_runtime_stub(StubAssembler* sasm) const;
 
 public:
-  virtual void eden_allocate(MacroAssembler* masm, Register thread, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register t1, Label& slow_case);
+  virtual void eden_allocate(MacroAssembler* masm,
+    Register obj,                      // result: pointer to object after successful allocation
+    Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
+    int      con_size_in_bytes,        // object size in bytes if   known at compile time
+    Register tmp1,                     // temp register
+    Register tmp2,                     // temp register
+    Label&   slow_case,                // continuation point if fast allocation fails
+    bool is_far = false
+  ) override;
   virtual void store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
     if (type == T_OBJECT || type == T_ARRAY) object_reference_write_pre(masm, decorators, dst, val, tmp1, tmp2);
     BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);