Update openjdk to tag: jdk-11+28-mmtk (for future mmtk-barrier support)

Author: Wenyu Zhao

.gitmodules

@@ -1,7 +1,7 @@
 [submodule "repos/openjdk"]
 	path = repos/openjdk
 	url = ../openjdk.git
-	branch = mmtk
+	branch = jdk-11+28-mmtk
 [submodule "repos/mmtk-core"]
 	path = repos/mmtk-core
 	url = ../mmtk-core.git

ThirdPartyHeap.md

@@ -16,7 +16,7 @@
 ```makefile
 # TOPDIR points to openjdk root directory
 JVM_SRC_DIRS += $(TOPDIR)/my_third_party_heap
-JVM_CFLAGS += -DTHIRD_PARTY_HEAP -DTHIRD_PARTY_HEAP_SRC=$(TOPDIR)/my_third_party_heap
+JVM_CFLAGS += -DINCLUDE_THIRD_PARTY_HEAP -DTHIRD_PARTY_HEAP_SRC=$(TOPDIR)/my_third_party_heap
 ```
 This will compile every `.cpp` files under `$PWD/my_third_party_heap` and link to _libjava.so_.
 

openjdk/CompileThirdPartyHeap.gmk

@@ -22,6 +22,6 @@ FORCE:
 
 TARGETS += $(LIB_MMTK)
 JVM_SRC_DIRS += $(MMTK_CPP_ROOT)
-JVM_CFLAGS += -DTHIRD_PARTY_HEAP -DTHIRD_PARTY_HEAP_SRC=$(MMTK_CPP_ROOT)
+JVM_CFLAGS += -DINCLUDE_THIRD_PARTY_HEAP -DTHIRD_PARTY_HEAP_SRC=$(MMTK_CPP_ROOT)
 
 $(BUILD_LIBJVM): $(LIB_MMTK)

openjdk/barrier.cpp

@@ -24,15 +24,26 @@
 
 #include "barrier.hpp"
 
+#ifdef COMPILER1
+#include "gc/shared/c1/barrierSetC1.hpp"
+#endif
+#ifdef COMPILER2
+#include "gc/shared/c2/barrierSetC2.hpp"
+#endif
+
+
+NoBarrier::NoBarrier(MemRegion whole_heap): BarrierSet(
+      make_barrier_set_assembler<BarrierSetAssembler>(),
+      make_barrier_set_c1<BarrierSetC1>(),
+      make_barrier_set_c2<BarrierSetC2>(),
+      BarrierSet::FakeRtti(BarrierSet::NoBarrier)
+    )
+    , _whole_heap(whole_heap) {}
+
 void NoBarrier::write_ref_array_work(MemRegion mr) {
     guarantee(false, "NoBarrier::write_ref_arrey_work not supported");
 }
 
-void NoBarrier::write_region_work(MemRegion mr) {
-    //guarantee(false, "NoBarrier::write_region_work not supported");
-}
-
-
 // Inform the BarrierSet that the the covered heap region that starts
 // with "base" has been changed to have the given size (possibly from 0,
 // for initialization.)

openjdk/barrier.hpp

@@ -38,34 +38,26 @@
 
 class NoBarrier : public BarrierSet {
   friend class VMStructs;
-  private:
-      MemRegion _whole_heap;
+private:
+  MemRegion _whole_heap;
 
 protected:
   virtual void write_ref_array_work(MemRegion mr) ;
 
-protected:
-  virtual void write_region_work(MemRegion mr) ;
-
 public:
-
-    NoBarrier(MemRegion whole_heap): BarrierSet((BarrierSet::FakeRtti(BarrierSet::NoBarrier))
-        .add_tag(BarrierSet::NoBarrier)),
-            _whole_heap(whole_heap){
-        
-    }
+  NoBarrier(MemRegion whole_heap);
 
   // Inform the BarrierSet that the the covered heap region that starts
   // with "base" has been changed to have the given size (possibly from 0,
   // for initialization.)
-  virtual void resize_covered_region(MemRegion new_region) ;
+  virtual void resize_covered_region(MemRegion new_region);
 
   // If the barrier set imposes any alignment restrictions on boundaries
   // within the heap, this function tells whether they are met.
-  virtual bool is_aligned(HeapWord* addr) ;
+  virtual bool is_aligned(HeapWord* addr);
 
   // Print a description of the memory for the barrier set
-  virtual void print_on(outputStream* st) const ;
+  virtual void print_on(outputStream* st) const;
 
 
   // The AccessBarrier of a BarrierSet subclass is called by the Access API
@@ -79,10 +71,26 @@ class NoBarrier : public BarrierSet {
   // 1) Provide an enum "name" for the BarrierSet in barrierSetConfig.hpp
   // 2) Make sure the barrier set headers are included from barrierSetConfig.inline.hpp
   // 3) Provide specializations for BarrierSet::GetName and BarrierSet::GetType.
- template <DecoratorSet decorators, typename BarrierSetT = NoBarrier>
+  template <DecoratorSet decorators, typename BarrierSetT = NoBarrier>
   class AccessBarrier: public BarrierSet::AccessBarrier<decorators, BarrierSetT> {
- 
- };
+  private:
+    typedef RawAccessBarrier<decorators> Raw;
+  public:
+    template <typename T>
+    static void oop_store_in_heap(T* addr, oop value) {
+      // printf("oop_store_in_heap(addr=%p, value=%p)\n", addr, value);
+      Raw::oop_store(addr, value);
+    }
+
+    static void oop_store_in_heap_at(oop base, ptrdiff_t offset, oop value) {
+      // printf("oop_store_in_heap_at(base=%p, offset=%ld, value=%p)\n", base, offset, value);
+      Raw::oop_store_at(base, offset, value);
+    }
+  };
+
+  // void post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val) {
+
+  // }
 };
 
 

openjdk/mmtkArguments.cpp

@@ -39,8 +39,8 @@ size_t MMTkArguments::conservative_max_heap_alignment() {
   return CollectorPolicy::compute_heap_alignment();
 }
 
-void MMTkArguments::initialize_flags() {
-  GCArguments::initialize_flags();
+void MMTkArguments::initialize() {
+  GCArguments::initialize();
   assert(UseThirdPartyHeap , "Error, should UseThirdPartyHeap");
   FLAG_SET_DEFAULT(UseTLAB, false);
 

openjdk/mmtkArguments.hpp

@@ -31,7 +31,7 @@ class CollectedHeap;
 
 class MMTkArguments : public GCArguments {
 public:
-  virtual void initialize_flags();
+  virtual void initialize();
   virtual size_t conservative_max_heap_alignment();
   virtual CollectedHeap* create_heap();
 };

openjdk/mmtkHeap.cpp

@@ -60,6 +60,12 @@ object iterator??!!
 
 MMTkHeap* MMTkHeap::_heap = NULL;
 
+MMTkHeap::MMTkHeap(MMTkCollectorPolicy* policy) : CollectedHeap(), _collector_policy(policy), _root_tasks(new SubTasksDone(MMTk_NumElements)), _n_workers(0), _gc_lock(new Monitor(Mutex::safepoint, "MMTkHeap::_gc_lock", true, Monitor::_safepoint_check_sometimes))
+// , _par_state_string(StringTable::weak_storage()) 
+{
+   _heap = this;
+}
+
 jint MMTkHeap::initialize() {
 
     const size_t heap_size = collector_policy()->max_heap_byte_size();
@@ -92,7 +98,7 @@ jint MMTkHeap::initialize() {
 
     NoBarrier* const barrier_set = new NoBarrier(reserved_region());
     //barrier_set->initialize();
-    set_barrier_set(barrier_set);
+    BarrierSet::set_barrier_set(barrier_set);
 
     // Set up the GCTaskManager
     //  _mmtk_gc_task_manager = mmtkGCTaskManager::create(ParallelGCThreads);
@@ -325,10 +331,11 @@ void MMTkHeap::scan_global_roots(OopClosure& cl) {
    if (!_root_tasks->is_task_claimed(MMTk_Management_oops_do)) Management::oops_do(&cl);
    if (!_root_tasks->is_task_claimed(MMTk_jvmti_oops_do)) JvmtiExport::oops_do(&cl);
    if (UseAOT && !_root_tasks->is_task_claimed(MMTk_aot_oops_do)) AOTLoader::oops_do(&cl);
-   if (!_root_tasks->is_task_claimed(MMTk_SystemDictionary_oops_do)) SystemDictionary::roots_oops_do(&cl, &cl);
+   if (!_root_tasks->is_task_claimed(MMTk_SystemDictionary_oops_do)) SystemDictionary::oops_do(&cl);
    if (!_root_tasks->is_task_claimed(MMTk_CodeCache_oops_do)) CodeCache::blobs_do(&cb_cl);
 
-   StringTable::possibly_parallel_oops_do(&cl);
+   OopStorage::ParState<false, false> _par_state_string(StringTable::weak_storage());   
+   StringTable::possibly_parallel_oops_do(&_par_state_string, &cl);
 
    // if (!_root_tasks->is_task_claimed(MMTk_ClassLoaderDataGraph_oops_do)) ClassLoaderDataGraph::roots_cld_do(&cld_cl, &cld_cl);
    if (!_root_tasks->is_task_claimed(MMTk_ClassLoaderDataGraph_oops_do)) ClassLoaderDataGraph::cld_do(&cld_cl);
@@ -348,7 +355,7 @@ void MMTkHeap::scan_thread_roots(OopClosure& cl) {
       if (_root_tasks->all_tasks_completed(_n_workers) == 0) {
          nmethod::oops_do_marking_prologue();
          Threads::change_thread_claim_parity();
-         StringTable::clear_parallel_claimed_index();
+         // StringTable::clear_parallel_claimed_index();
       }
    }
    CodeBlobToOopClosure cb_cl(&cl, false);
@@ -375,13 +382,13 @@ void MMTkHeap::scan_roots(OopClosure& cl) {
    Management::oops_do(&cl);
    JvmtiExport::oops_do(&cl);
    if (UseAOT) AOTLoader::oops_do(&cl);
-   SystemDictionary::roots_oops_do(&cl, &cl);
+   SystemDictionary::oops_do(&cl);
    {
       MutexLockerEx lock(CodeCache_lock, Mutex::_no_safepoint_check_flag);
       CodeCache::blobs_do(&cb_cl);
    }
    if (is_parallel) {
-      StringTable::possibly_parallel_oops_do(&cl);
+      StringTable::possibly_parallel_oops_do(NULL, &cl);
    } else {
       StringTable::oops_do(&cl);
    }

openjdk/mmtkHeap.hpp

@@ -27,6 +27,7 @@
 
 #include "gc/shared/collectedHeap.hpp"
 #include "gc/shared/collectorPolicy.hpp"
+#include "gc/shared/oopStorage.hpp"
 #include "gc/shared/gcPolicyCounters.hpp"
 #include "gc/shared/gcWhen.hpp"
 #include "gc/shared/strongRootsScope.hpp"
@@ -37,7 +38,7 @@
 #include "memory/iterator.hpp"
 #include "gc/shared/workgroup.hpp"
 #include "mmtkCollectorPolicy.hpp"
-
+#include "gc/shared/oopStorageParState.hpp"
 
 class GCMemoryManager;
 class MemoryPool;
@@ -54,6 +55,7 @@ class MMTkHeap : public CollectedHeap {
     SubTasksDone* _root_tasks;
     size_t _n_workers;
     Monitor* _gc_lock;
+    ContiguousSpace* _space;
 
   enum mmtk_strong_roots_tasks {
     MMTk_Universe_oops_do,
@@ -72,13 +74,12 @@ class MMTkHeap : public CollectedHeap {
 
 private:
    // static mmtkGCTaskManager* _mmtk_gc_task_manager;
+  //  OopStorage::ParState<false, false> _par_state_string;
 
 
 public:
 
-  MMTkHeap(MMTkCollectorPolicy* policy) : CollectedHeap(), _collector_policy(policy), _root_tasks(new SubTasksDone(MMTk_NumElements)), _n_workers(0), _gc_lock(new Monitor(Mutex::safepoint, "MMTkHeap::_gc_lock", true, Monitor::_safepoint_check_sometimes)) {
-    _heap = this;
-  }
+  MMTkHeap(MMTkCollectorPolicy* policy);
 
   inline static MMTkHeap* heap() {
     return _heap;

openjdk/mmtkRootsClosure.hpp

@@ -21,12 +21,12 @@ class MMTkRootsClosure : public OopClosure {
 
   virtual void do_oop(oop* p)       { do_oop_work(p); }
   virtual void do_oop(narrowOop* p) {
-    printf("narrowoop root %p -> %d %p %p\n", (void*) p, *p, *((void**) p), (void*) oopDesc::load_decode_heap_oop(p));
+    // printf("narrowoop root %p -> %d %p %p\n", (void*) p, *p, *((void**) p), (void*) oopDesc::load_decode_heap_oop(p));
     do_oop_work(p);
   }
 };
 
-class MMTkScanObjectClosure : public ExtendedOopClosure {
+class MMTkScanObjectClosure : public BasicOopIterateClosure {
   void* _trace;
   CLDToOopClosure follow_cld_closure;
 
@@ -41,7 +41,7 @@ class MMTkScanObjectClosure : public ExtendedOopClosure {
 
   virtual void do_oop(oop* p)       { do_oop_work(p); }
   virtual void do_oop(narrowOop* p) {
-    printf("narrowoop edge %p -> %d %p %p\n", (void*) p, *p, *((void**) p), (void*) oopDesc::load_decode_heap_oop(p));
+    // printf("narrowoop edge %p -> %d %p %p\n", (void*) p, *p, *((void**) p), (void*) oopDesc::load_decode_heap_oop(p));
     do_oop_work(p);
   }
 

openjdk/mmtkUpcalls.cpp

@@ -42,6 +42,7 @@
 #include "runtime/threadSMR.hpp"
 #include "classfile/stringTable.hpp"
 #include "code/nmethod.hpp"
+#include "memory/iterator.inline.hpp"
 
 static bool gcInProgress = false;
 

openjdk/thirdPartyHeap.cpp

@@ -3,6 +3,10 @@
 #include "mmtk.h"
 #include "mmtkArguments.hpp"
 
+// GCArguments* mmtk_new_gc_arguments() {
+//     return new MMTkArguments();
+// }
+
 namespace third_party_heap {
 
 class MutatorContext;
@@ -12,7 +16,7 @@ MutatorContext* bind_mutator(::Thread* current) {
 }
 
 GCArguments* new_gc_arguments() {
-    return new MMTkArguments();
+    return NULL;
 }
 
 };