8272480: Remove Mutex::access rank

Reviewed-by: dholmes, eosterlund

Author: coleenp

src/hotspot/share/runtime/mutex.cpp

@@ -287,6 +287,8 @@ Mutex::Mutex(int Rank, const char * name, bool allow_vm_block,
 
   assert(_rank > special || _safepoint_check_required == _safepoint_check_never,
          "Special locks or below should never safepoint");
+
+  assert(_rank >= 0, "Bad lock rank");
 #endif
 }
 
@@ -364,7 +366,6 @@ Mutex* Mutex::get_least_ranked_lock_besides_this(Mutex* locks) {
 
 // Tests for rank violations that might indicate exposure to deadlock.
 void Mutex::check_rank(Thread* thread) {
-  assert(this->rank() >= 0, "bad lock rank");
   Mutex* locks_owned = thread->owned_locks();
 
   if (!SafepointSynchronize::is_at_safepoint()) {

src/hotspot/share/runtime/mutex.hpp

@@ -42,27 +42,12 @@
 class Mutex : public CHeapObj<mtSynchronizer> {
 
  public:
-  // A special lock: Is a lock where you are guaranteed not to block while you are
-  // holding it, i.e., no vm operation can happen, taking other (blocking) locks, etc.
-  // The rank 'access' is similar to 'special' and has the same restrictions on usage.
-  // It is reserved for locks that may be required in order to perform memory accesses
-  // that require special barriers, e.g. SATB GC barriers, that in turn uses locks.
-  // The rank 'tty' is also similar to 'special' and has the same restrictions.
-  // It is reserved for the tty_lock.
-  // Since memory accesses should be able to be performed pretty much anywhere
-  // in the code, that requires locks required for performing accesses being
-  // inherently a bit more special than even locks of the 'special' rank.
-  // NOTE: It is critical that the rank 'special' be the lowest (earliest)
-  // (except for "event" and "access") for the deadlock detection to work correctly.
-  // While at a safepoint no mutexes of rank safepoint are held by any thread.
-  // The rank named "leaf" is probably historical (and should
-  // be changed) -- mutexes of this rank aren't really leaf mutexes
-  // at all.
+  // Special low level locks are given names and ranges avoid overlap.
   enum lock_types {
        event,
-       access         = event          +   1,
-       service        = access         +   3,
-       tty            = service        +   3,
+       service        = event          +   3,
+       stackwatermark = service        +   3,
+       tty            = stackwatermark +   3,
        special        = tty            +   3,
        oopstorage     = special        +   3,
        leaf           = oopstorage     +   2,

src/hotspot/share/runtime/mutexLocker.cpp

@@ -241,7 +241,7 @@ void mutex_init() {
 
   def(Patching_lock                , PaddedMutex  , special,     true,  _safepoint_check_never);      // used for safepointing and code patching.
   def(CompiledMethod_lock          , PaddedMutex  , special-1,   true,  _safepoint_check_never);
-  def(MonitorDeflation_lock        , PaddedMonitor, tty-2,       true,  _safepoint_check_never);      // used for monitor deflation thread operations
+  def(MonitorDeflation_lock        , PaddedMonitor, special,     true,  _safepoint_check_never);      // used for monitor deflation thread operations
   def(Service_lock                 , PaddedMonitor, service,     true,  _safepoint_check_never);      // used for service thread operations
 
   if (UseNotificationThread) {
@@ -320,7 +320,7 @@ void mutex_init() {
   def(JfrMsg_lock                  , PaddedMonitor, leaf,        true,  _safepoint_check_always);
   def(JfrBuffer_lock               , PaddedMutex  , leaf,        true,  _safepoint_check_never);
   def(JfrStream_lock               , PaddedMutex  , nonleaf + 1, false, _safepoint_check_never);
-  def(JfrStacktrace_lock           , PaddedMutex  , tty-2,       true,  _safepoint_check_never);
+  def(JfrStacktrace_lock           , PaddedMutex  , stackwatermark-1,  true,  _safepoint_check_never);
   def(JfrThreadSampler_lock        , PaddedMonitor, leaf,        true,  _safepoint_check_never);
 #endif
 

src/hotspot/share/runtime/stackWatermark.cpp

@@ -164,7 +164,7 @@ StackWatermark::StackWatermark(JavaThread* jt, StackWatermarkKind kind, uint32_t
     _next(NULL),
     _jt(jt),
     _iterator(NULL),
-    _lock(Mutex::tty - 1, "stack_watermark_lock", true, Mutex::_safepoint_check_never),
+    _lock(Mutex::stackwatermark, "StackWatermark_lock", true, Mutex::_safepoint_check_never),
     _kind(kind),
     _linked_watermark(NULL) {
 }

test/hotspot/gtest/runtime/test_mutex.cpp

@@ -128,19 +128,19 @@ TEST_VM_ASSERT_MSG(MutexRank, mutex_trylock_rank_out_of_orderB,
   mutex_rankA->unlock();
 }
 
-TEST_VM_ASSERT_MSG(MutexRank, mutex_lock_access_leaf,
-                   ".* Attempting to acquire lock mutex_rank_leaf/.* out of order with lock mutex_rank_access/1 "
+TEST_VM_ASSERT_MSG(MutexRank, mutex_lock_event_leaf,
+                   ".* Attempting to acquire lock mutex_rank_leaf/.* out of order with lock mutex_rank_event/0 "
                    "-- possible deadlock") {
   JavaThread* THREAD = JavaThread::current();
   ThreadInVMfromNative invm(THREAD);
 
-  Mutex* mutex_rank_access = new Mutex(Mutex::access, "mutex_rank_access", false, Mutex::_safepoint_check_never);
+  Mutex* mutex_rank_event = new Mutex(Mutex::event, "mutex_rank_event", false, Mutex::_safepoint_check_never);
   Mutex* mutex_rank_leaf = new Mutex(Mutex::leaf, "mutex_rank_leaf", false, Mutex::_safepoint_check_never);
 
-  mutex_rank_access->lock_without_safepoint_check();
+  mutex_rank_event->lock_without_safepoint_check();
   mutex_rank_leaf->lock_without_safepoint_check();
   mutex_rank_leaf->unlock();
-  mutex_rank_access->unlock();
+  mutex_rank_event->unlock();
 }
 
 TEST_VM_ASSERT_MSG(MutexRank, mutex_lock_tty_special,
@@ -220,19 +220,19 @@ TEST_VM_ASSERT_MSG(MutexRank, monitor_wait_rank_special,
   monitor_rank_special->unlock();
 }
 
-TEST_VM_ASSERT_MSG(MutexRank, monitor_wait_access_leaf,
-                   ".* Attempting to wait on monitor monitor_rank_access/1 while holding lock monitor_rank_tty/.*"
+TEST_VM_ASSERT_MSG(MutexRank, monitor_wait_event_tty,
+                   ".* Attempting to wait on monitor monitor_rank_event/0 while holding lock monitor_rank_tty/.*"
                    "-- possible deadlock. Should not block\\(wait\\) while holding a lock of rank special.") {
   JavaThread* THREAD = JavaThread::current();
   ThreadInVMfromNative invm(THREAD);
 
   Monitor* monitor_rank_tty = new Monitor(Mutex::tty, "monitor_rank_tty", false, Mutex::_safepoint_check_never);
-  Monitor* monitor_rank_access = new Monitor(Mutex::access, "monitor_rank_access", false, Mutex::_safepoint_check_never);
+  Monitor* monitor_rank_event = new Monitor(Mutex::event, "monitor_rank_event", false, Mutex::_safepoint_check_never);
 
   monitor_rank_tty->lock_without_safepoint_check();
-  monitor_rank_access->lock_without_safepoint_check();
-  monitor_rank_access->wait_without_safepoint_check(1);
-  monitor_rank_access->unlock();
+  monitor_rank_event->lock_without_safepoint_check();
+  monitor_rank_event->wait_without_safepoint_check(1);
+  monitor_rank_event->unlock();
   monitor_rank_tty->unlock();
 }
 
@@ -251,4 +251,14 @@ TEST_VM_ASSERT_MSG(MutexRank, monitor_wait_tty_special,
   monitor_rank_tty->unlock();
   monitor_rank_special->unlock();
 }
+
+TEST_VM_ASSERT_MSG(MutexRank, monitor_negative_rank,
+                   ".*Bad lock rank") {
+  JavaThread* THREAD = JavaThread::current();
+  ThreadInVMfromNative invm(THREAD);
+
+  Monitor* monitor_rank_broken = new Monitor(Mutex::event-1, "monitor_rank_broken", false, Mutex::_safepoint_check_never);
+  monitor_rank_broken->lock_without_safepoint_check();
+  monitor_rank_broken->unlock();
+}
 #endif // ASSERT