Fix compilation errors

Author: wks

openjdk/share/mmtk.h

@@ -103,7 +103,6 @@ extern bool process_bulk(char* options);
 extern void scan_region();
 extern void handle_user_collection_request(void *tls);
 
-extern void start_control_collector(void *tls, void *context);
 extern void start_worker(void *tls, void* worker);
 
 extern size_t mmtk_add_nmethod_oop(void* object);

openjdk/share/mmtkContextThread.cpp

@@ -49,6 +49,7 @@
 #include "prims/jvmtiExport.hpp"
 #include "runtime/jniHandles.hpp"
 #include "runtime/atomic.hpp"
+#include "runtime/globals_extension.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/java.hpp"
 #include "runtime/thread.hpp"
@@ -76,7 +77,7 @@ MMTkHeap* MMTkHeap::_heap = NULL;
 MMTkHeap::MMTkHeap() :
   CollectedHeap(),
   _n_workers(0),
-  _gc_lock(new Monitor(Mutex::safepoint, "MMTkHeap::_gc_lock", true, Monitor::_safepoint_check_never)),
+  _gc_lock(new Monitor(Mutex::safepoint, "MMTkHeap::_gc_lock", true)),
   _num_root_scan_tasks(0),
   _soft_ref_policy(),
   _last_gc_time(0)
@@ -144,8 +145,8 @@ jint MMTkHeap::initialize() {
   ReservedHeapSpace heap_rs = Universe::reserve_heap(MaxHeapSize, HeapAlignment);
   //  printf("start: %p, end: %p\n", _start, _end);
   if (UseCompressedOops) {
-    Universe::set_narrow_oop_base((address) mmtk_narrow_oop_base());
-    Universe::set_narrow_oop_shift(mmtk_narrow_oop_shift());
+    CompressedOops::set_base((address) mmtk_narrow_oop_base());
+    CompressedOops::set_shift(mmtk_narrow_oop_shift());
   }
 
   initialize_reserved_region(heap_rs);
@@ -202,7 +203,9 @@ void MMTkHeap::post_initialize() {
   ScavengableNMethods::initialize(&_is_scavengable);
 
   if (UseCompressedOops) {
-    mmtk_set_compressed_klass_base_and_shift((void*) Universe::narrow_klass_base(), (size_t) Universe::narrow_klass_shift());
+    mmtk_set_compressed_klass_base_and_shift(
+      (void*)CompressedKlassPointers::base(),
+      (size_t)CompressedKlassPointers::shift());
   }
 }
 

openjdk/share/mmtkContextThread.hpp

@@ -91,7 +91,7 @@ static void mmtk_resume_mutators(void *tls) {
 
   log_debug(gc)("Notifying mutators blocking on the start-the-world counter...");
   {
-    MutexLockerEx locker(MMTkHeap::heap()->gc_lock(), Mutex::_no_safepoint_check_flag);
+    MutexLocker locker(MMTkHeap::heap()->gc_lock(), Mutex::_no_safepoint_check_flag);
     MMTkHeap::heap()->gc_lock()->notify_all();
   }
 }
@@ -140,12 +140,12 @@ static void mmtk_block_for_gc() {
     ThreadBlockInVM tbivm(thread);
 
     // No safepoint check.  We are already in safepoint.
-    MutexLockerEx locker(MMTkHeap::heap()->gc_lock(), Mutex::_no_safepoint_check_flag);
+    MutexLocker locker(MMTkHeap::heap()->gc_lock(), Mutex::_no_safepoint_check_flag);
 
     while (Atomic::load(&mmtk_start_the_world_count) < next_count) {
       // wait() may wake up spuriously, but the authoritative condition for unblocking is
       // mmtk_start_the_world_count being incremented.
-      MMTkHeap::heap()->gc_lock()->wait(Mutex::_no_safepoint_check_flag);
+      MMTkHeap::heap()->gc_lock()->wait_without_safepoint_check();
     }
   }
   log_debug(gc)("Resumed after GC finished.");

openjdk/share/mmtkHeap.cpp

@@ -50,7 +50,7 @@ void MMTkVMCompanionThread::run() {
       MutexLocker locker(_lock, Mutex::_no_safepoint_check_flag);
       assert(_reached_state == _threads_resumed, "Threads should be running at this moment.");
       while (_desired_state != _threads_suspended) {
-        _lock->wait(Mutex::_no_safepoint_check_flag);
+        _lock->wait_without_safepoint_check();
       }
       assert(_reached_state == _threads_resumed, "Threads should still be running at this moment.");
     }
@@ -88,7 +88,7 @@ void MMTkVMCompanionThread::request(stw_state desired_state, bool wait_until_rea
 
   if (wait_until_reached) {
     while (_reached_state != desired_state) {
-      _lock->wait(Mutex::_no_safepoint_check_flag);
+      _lock->wait_without_safepoint_check();
     }
   }
 }
@@ -104,7 +104,7 @@ void MMTkVMCompanionThread::wait_for_reached(stw_state desired_state) {
   assert(_desired_state == desired_state, "State %d not requested.", desired_state);
 
   while (_reached_state != desired_state) {
-    _lock->wait(Mutex::_no_safepoint_check_flag);
+    _lock->wait_without_safepoint_check();
   }
 }
 
@@ -115,7 +115,7 @@ void MMTkVMCompanionThread::do_mmtk_stw_operation() {
   assert(Thread::current()->is_VM_thread(), "do_mmtk_stw_operation can only be executed by the VM thread");
 
   {
-    MutexLockerEx locker(_lock, Mutex::_no_safepoint_check_flag);
+    MutexLocker locker(_lock, Mutex::_no_safepoint_check_flag);
 
     // Tell the waiter thread that Java threads have stopped at yieldpoints.
     _reached_state = _threads_suspended;
@@ -124,7 +124,7 @@ void MMTkVMCompanionThread::do_mmtk_stw_operation() {
 
     // Wait until resume-the-world is requested
     while (_desired_state != _threads_resumed) {
-      _lock->wait(Mutex::_no_safepoint_check_flag);
+      _lock->wait_without_safepoint_check();
     }
 
     // Tell the waiter thread that Java threads will eventually resume from yieldpoints.  This
@@ -165,7 +165,7 @@ void MMTkVMCompanionThread::do_mmtk_stw_operation() {
   }
 
   {
-    MutexLockerEx x(Heap_lock, Mutex::_no_safepoint_check_flag);
+    MutexLocker x(Heap_lock, Mutex::_no_safepoint_check_flag);
     if (Universe::has_reference_pending_list()) {
       Heap_lock->notify_all();
     }

openjdk/share/mmtkUpcalls.cpp

@@ -43,7 +43,7 @@ void ThirdPartyHeapArguments::initialize() {
   assert(UseThirdPartyHeap , "Error, should UseThirdPartyHeap");
   FLAG_SET_DEFAULT(UseTLAB, false);
   FLAG_SET_DEFAULT(UseCompressedClassPointers, UseCompressedOops);
-  FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
+  FLAG_SET_DEFAULT(ParallelGCThreads, WorkerPolicy::parallel_worker_threads());
   if (ParallelGCThreads == 0) {
     assert(!FLAG_IS_DEFAULT(ParallelGCThreads), "ParallelGCThreads should not be 0.");
     vm_exit_during_initialization("The flag -XX:+UseUseThirdPartyHeap can not be combined with -XX:ParallelGCThreads=0", NULL);
@@ -52,6 +52,11 @@ void ThirdPartyHeapArguments::initialize() {
   // make sure to add appropriate code to MMTkHeap::set_mmtk_options.
 }
 
+void ThirdPartyHeapArguments::initialize_alignments() {
+  SpaceAlignment =  1 << 19;
+  HeapAlignment = SpaceAlignment;
+}
+
 CollectedHeap* ThirdPartyHeapArguments::create_heap() {
   return new MMTkHeap();
 }

openjdk/share/mmtkVMCompanionThread.cpp

@@ -32,7 +32,6 @@ class CollectedHeap;
 class ThirdPartyHeapArguments : public GCArguments {
 private:
   virtual void initialize_alignments();
-
   virtual void initialize();
   virtual size_t conservative_max_heap_alignment();
   virtual CollectedHeap* create_heap();