Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/hotspot/share/runtime/mutexLocker.cpp
branchdatagramsocketimpl-branch
changeset 58678 9cf78a70fa4f
parent 55005 9b70ebd131b4
child 58679 9c3209ff7550
equal deleted inserted replaced
58677:13588c901957 58678:9cf78a70fa4f 
    45 Mutex*   SharedDictionary_lock        = NULL;
 
    45 Mutex*   SharedDictionary_lock        = NULL;
 
    46 Mutex*   Module_lock                  = NULL;
 
    46 Mutex*   Module_lock                  = NULL;
 
    47 Mutex*   CompiledIC_lock              = NULL;
 
    47 Mutex*   CompiledIC_lock              = NULL;
 
    48 Mutex*   InlineCacheBuffer_lock       = NULL;
 
    48 Mutex*   InlineCacheBuffer_lock       = NULL;
 
    49 Mutex*   VMStatistic_lock             = NULL;
 
    49 Mutex*   VMStatistic_lock             = NULL;
 
    50 Mutex*   JNIGlobalAlloc_lock          = NULL;
 
       
    51 Mutex*   JNIGlobalActive_lock         = NULL;
 
       
    52 Mutex*   JNIWeakAlloc_lock            = NULL;
 
       
    53 Mutex*   JNIWeakActive_lock           = NULL;
 
       
    54 Mutex*   StringTableWeakAlloc_lock    = NULL;
 
       
    55 Mutex*   StringTableWeakActive_lock   = NULL;
 
       
    56 Mutex*   JNIHandleBlockFreeList_lock  = NULL;
 
    50 Mutex*   JNIHandleBlockFreeList_lock  = NULL;
 
    57 Mutex*   VMWeakAlloc_lock             = NULL;
 
       
    58 Mutex*   VMWeakActive_lock            = NULL;
 
       
    59 Mutex*   ResolvedMethodTableWeakAlloc_lock  = NULL;
 
       
    60 Mutex*   ResolvedMethodTableWeakActive_lock = NULL;
 
       
    61 Mutex*   JmethodIdCreation_lock       = NULL;
 
    51 Mutex*   JmethodIdCreation_lock       = NULL;
 
    62 Mutex*   JfieldIdCreation_lock        = NULL;
 
    52 Mutex*   JfieldIdCreation_lock        = NULL;
 
    63 Monitor* JNICritical_lock             = NULL;
 
    53 Monitor* JNICritical_lock             = NULL;
 
    64 Mutex*   JvmtiThreadState_lock        = NULL;
 
    54 Mutex*   JvmtiThreadState_lock        = NULL;
 
    65 Monitor* Heap_lock                    = NULL;
 
    55 Monitor* Heap_lock                    = NULL;
 
    74 Mutex*   MethodData_lock              = NULL;
 
    64 Mutex*   MethodData_lock              = NULL;
 
    75 Mutex*   TouchedMethodLog_lock        = NULL;
 
    65 Mutex*   TouchedMethodLog_lock        = NULL;
 
    76 Mutex*   RetData_lock                 = NULL;
 
    66 Mutex*   RetData_lock                 = NULL;
 
    77 Monitor* VMOperationQueue_lock        = NULL;
 
    67 Monitor* VMOperationQueue_lock        = NULL;
 
    78 Monitor* VMOperationRequest_lock      = NULL;
 
    68 Monitor* VMOperationRequest_lock      = NULL;
 
    79 Monitor* SerializePage_lock           = NULL;
 
       
    80 Monitor* Threads_lock                 = NULL;
 
    69 Monitor* Threads_lock                 = NULL;
 
    81 Mutex*   NonJavaThreadsList_lock      = NULL;
 
    70 Mutex*   NonJavaThreadsList_lock      = NULL;
 
    82 Mutex*   NonJavaThreadsListSync_lock  = NULL;
 
    71 Mutex*   NonJavaThreadsListSync_lock  = NULL;
 
    83 Monitor* CGC_lock                     = NULL;
 
    72 Monitor* CGC_lock                     = NULL;
 
    84 Monitor* STS_lock                     = NULL;
 
    73 Monitor* STS_lock                     = NULL;
 
    85 Monitor* FullGCCount_lock             = NULL;
 
    74 Monitor* FullGCCount_lock             = NULL;
 
    86 Monitor* SATB_Q_CBL_mon               = NULL;
 
       
    87 Monitor* DirtyCardQ_CBL_mon           = NULL;
 
    75 Monitor* DirtyCardQ_CBL_mon           = NULL;
 
    88 Mutex*   Shared_DirtyCardQ_lock       = NULL;
 
    76 Mutex*   Shared_DirtyCardQ_lock       = NULL;
 
    89 Mutex*   MarkStackFreeList_lock       = NULL;
 
    77 Mutex*   MarkStackFreeList_lock       = NULL;
 
    90 Mutex*   MarkStackChunkList_lock      = NULL;
 
    78 Mutex*   MarkStackChunkList_lock      = NULL;
 
    91 Mutex*   MonitoringSupport_lock       = NULL;
 
    79 Mutex*   MonitoringSupport_lock       = NULL;
 
   103 Monitor* InitCompleted_lock           = NULL;
 
    91 Monitor* InitCompleted_lock           = NULL;
 
   104 Monitor* BeforeExit_lock              = NULL;
 
    92 Monitor* BeforeExit_lock              = NULL;
 
   105 Monitor* Notify_lock                  = NULL;
 
    93 Monitor* Notify_lock                  = NULL;
 
   106 Mutex*   ProfilePrint_lock            = NULL;
 
    94 Mutex*   ProfilePrint_lock            = NULL;
 
   107 Mutex*   ExceptionCache_lock          = NULL;
 
    95 Mutex*   ExceptionCache_lock          = NULL;
 
   108 Mutex*   OsrList_lock                 = NULL;
 
       
   109 Mutex*   NMethodSweeperStats_lock     = NULL;
 
    96 Mutex*   NMethodSweeperStats_lock     = NULL;
 
   110 #ifndef PRODUCT
 
    97 #ifndef PRODUCT
 
   111 Mutex*   FullGCALot_lock              = NULL;
 
    98 Mutex*   FullGCALot_lock              = NULL;
 
   112 #endif
 
    99 #endif
 
   113 
   100 
   124 
   111 
   125 Mutex*   FreeList_lock                = NULL;
 
   112 Mutex*   FreeList_lock                = NULL;
 
   126 Mutex*   OldSets_lock                 = NULL;
 
   113 Mutex*   OldSets_lock                 = NULL;
 
   127 Monitor* RootRegionScan_lock          = NULL;
 
   114 Monitor* RootRegionScan_lock          = NULL;
 
   128 
   115 
   129 Monitor* GCTaskManager_lock           = NULL;
 
       
   130 
       
   131 Mutex*   Management_lock              = NULL;
 
   116 Mutex*   Management_lock              = NULL;
 
   132 Monitor* Service_lock                 = NULL;
 
   117 Monitor* Service_lock                 = NULL;
 
       
   118 Monitor* Notification_lock            = NULL;
 
   133 Monitor* PeriodicTask_lock            = NULL;
 
   119 Monitor* PeriodicTask_lock            = NULL;
 
   134 Monitor* RedefineClasses_lock         = NULL;
 
   120 Monitor* RedefineClasses_lock         = NULL;
 
       
   121 Mutex*   Verify_lock                  = NULL;
 
   135 
   122 
   136 #if INCLUDE_JFR
 
   123 #if INCLUDE_JFR
 
   137 Mutex*   JfrStacktrace_lock           = NULL;
 
   124 Mutex*   JfrStacktrace_lock           = NULL;
 
   138 Monitor* JfrMsg_lock                  = NULL;
 
   125 Monitor* JfrMsg_lock                  = NULL;
 
   139 Mutex*   JfrBuffer_lock               = NULL;
 
   126 Mutex*   JfrBuffer_lock               = NULL;
 
   142 #endif
 
   129 #endif
 
   143 
   130 
   144 #ifndef SUPPORTS_NATIVE_CX8
 
   131 #ifndef SUPPORTS_NATIVE_CX8
 
   145 Mutex*   UnsafeJlong_lock             = NULL;
 
   132 Mutex*   UnsafeJlong_lock             = NULL;
 
   146 #endif
 
   133 #endif
 
   147 Monitor* CodeHeapStateAnalytics_lock  = NULL;
 
   134 Mutex*   CodeHeapStateAnalytics_lock  = NULL;
 
   148 
   135 
   149 Mutex*   MetaspaceExpand_lock         = NULL;
 
   136 Mutex*   MetaspaceExpand_lock         = NULL;
 
   150 Mutex*   ClassLoaderDataGraph_lock    = NULL;
 
   137 Mutex*   ClassLoaderDataGraph_lock    = NULL;
 
   151 Monitor* ThreadsSMRDelete_lock        = NULL;
 
   138 Monitor* ThreadsSMRDelete_lock        = NULL;
 
       
   139 Mutex*   ThreadIdTableCreate_lock     = NULL;
 
   152 Mutex*   SharedDecoder_lock           = NULL;
 
   140 Mutex*   SharedDecoder_lock           = NULL;
 
   153 Mutex*   DCmdFactory_lock             = NULL;
 
   141 Mutex*   DCmdFactory_lock             = NULL;
 
   154 #if INCLUDE_NMT
 
   142 #if INCLUDE_NMT
 
   155 Mutex*   NMTQuery_lock                = NULL;
 
   143 Mutex*   NMTQuery_lock                = NULL;
 
   156 #endif
 
   144 #endif
 
   161 Mutex*   DumpTimeTable_lock           = NULL;
 
   149 Mutex*   DumpTimeTable_lock           = NULL;
 
   162 #endif // INCLUDE_CDS
 
   150 #endif // INCLUDE_CDS
 
   163 
   151 
   164 #if INCLUDE_JVMCI
 
   152 #if INCLUDE_JVMCI
 
   165 Monitor* JVMCI_lock                   = NULL;
 
   153 Monitor* JVMCI_lock                   = NULL;
 
   166 Mutex*   JVMCIGlobalAlloc_lock        = NULL;
 
       
   167 Mutex*   JVMCIGlobalActive_lock       = NULL;
 
       
   168 #endif
 
   154 #endif
 
   169 
   155 
   170 
   156 
   171 #define MAX_NUM_MUTEX 128
 
   157 #define MAX_NUM_MUTEX 128
 
   172 static Monitor * _mutex_array[MAX_NUM_MUTEX];
 
   158 static Mutex* _mutex_array[MAX_NUM_MUTEX];
 
   173 static int _num_mutex;
 
   159 static int _num_mutex;
 
   174 
   160 
   175 #ifdef ASSERT
 
   161 #ifdef ASSERT
 
   176 void assert_locked_or_safepoint(const Monitor * lock) {
 
   162 void assert_locked_or_safepoint(const Mutex* lock) {
 
   177   // check if this thread owns the lock (common case)
 
   163   // check if this thread owns the lock (common case)
 
   178   if (IgnoreLockingAssertions) return;
 
       
   179   assert(lock != NULL, "Need non-NULL lock");
 
   164   assert(lock != NULL, "Need non-NULL lock");
 
   180   if (lock->owned_by_self()) return;
 
   165   if (lock->owned_by_self()) return;
 
   181   if (SafepointSynchronize::is_at_safepoint()) return;
 
   166   if (SafepointSynchronize::is_at_safepoint()) return;
 
   182   if (!Universe::is_fully_initialized()) return;
 
   167   if (!Universe::is_fully_initialized()) return;
 
   183   // see if invoker of VM operation owns it
 
   168   // see if invoker of VM operation owns it
 
   185   if (op != NULL && op->calling_thread() == lock->owner()) return;
 
   170   if (op != NULL && op->calling_thread() == lock->owner()) return;
 
   186   fatal("must own lock %s", lock->name());
 
   171   fatal("must own lock %s", lock->name());
 
   187 }
 
   172 }
 
   188 
   173 
   189 // a weaker assertion than the above
 
   174 // a weaker assertion than the above
 
   190 void assert_locked_or_safepoint_weak(const Monitor * lock) {
 
   175 void assert_locked_or_safepoint_weak(const Mutex* lock) {
 
   191   if (IgnoreLockingAssertions) return;
 
       
   192   assert(lock != NULL, "Need non-NULL lock");
 
   176   assert(lock != NULL, "Need non-NULL lock");
 
   193   if (lock->is_locked()) return;
 
   177   if (lock->is_locked()) return;
 
   194   if (SafepointSynchronize::is_at_safepoint()) return;
 
   178   if (SafepointSynchronize::is_at_safepoint()) return;
 
   195   if (!Universe::is_fully_initialized()) return;
 
   179   if (!Universe::is_fully_initialized()) return;
 
   196   fatal("must own lock %s", lock->name());
 
   180   fatal("must own lock %s", lock->name());
 
   197 }
 
   181 }
 
   198 
   182 
   199 // a stronger assertion than the above
 
   183 // a stronger assertion than the above
 
   200 void assert_lock_strong(const Monitor * lock) {
 
   184 void assert_lock_strong(const Mutex* lock) {
 
   201   if (IgnoreLockingAssertions) return;
 
       
   202   assert(lock != NULL, "Need non-NULL lock");
 
   185   assert(lock != NULL, "Need non-NULL lock");
 
   203   if (lock->owned_by_self()) return;
 
   186   if (lock->owned_by_self()) return;
 
   204   fatal("must own lock %s", lock->name());
 
   187   fatal("must own lock %s", lock->name());
 
   205 }
 
   188 }
 
   206 #endif
 
   189 #endif
 
   207 
   190 
   208 #define def(var, type, pri, vm_block, safepoint_check_allowed ) {      \
 
   191 #define def(var, type, pri, vm_block, safepoint_check_allowed ) {      \
 
   209   var = new type(Mutex::pri, #var, vm_block, safepoint_check_allowed); \
 
   192   var = new type(Mutex::pri, #var, vm_block, Mutex::safepoint_check_allowed); \
 
   210   assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX");        \
 
   193   assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX");        \
 
   211   _mutex_array[_num_mutex++] = var;                                      \
 
   194   _mutex_array[_num_mutex++] = var;                                      \
 
   212 }
 
   195 }
 
   213 
   196 
   214 // Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
 
   197 // Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
 
   215 void mutex_init() {
 
   198 void mutex_init() {
 
   216   def(tty_lock                     , PaddedMutex  , tty,         true,  Monitor::_safepoint_check_never);      // allow to lock in VM
 
   199   def(tty_lock                     , PaddedMutex  , tty,         true,  _safepoint_check_never);      // allow to lock in VM
 
   217 
   200 
   218   def(CGC_lock                     , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // coordinate between fore- and background GC
 
   201   def(CGC_lock                     , PaddedMonitor, special,     true,  _safepoint_check_never);      // coordinate between fore- and background GC
 
   219   def(STS_lock                     , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 
   202   def(STS_lock                     , PaddedMonitor, leaf,        true,  _safepoint_check_never);
 
   220 
   203 
   221   def(VMWeakAlloc_lock             , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 
   204   def(FullGCCount_lock             , PaddedMonitor, leaf,        true,  _safepoint_check_never);      // in support of ExplicitGCInvokesConcurrent
 
   222   def(VMWeakActive_lock            , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 
       
   223 
       
   224   def(StringTableWeakAlloc_lock    , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 
       
   225   def(StringTableWeakActive_lock   , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 
       
   226 
       
   227   def(ResolvedMethodTableWeakAlloc_lock    , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 
       
   228   def(ResolvedMethodTableWeakActive_lock   , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 
       
   229 
       
   230   def(FullGCCount_lock             , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);      // in support of ExplicitGCInvokesConcurrent
 
       
   231   if (UseG1GC) {
 
   205   if (UseG1GC) {
 
   232     def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 
   206     def(DirtyCardQ_CBL_mon         , PaddedMonitor, access,      true,  _safepoint_check_never);
 
   233 
   207     def(Shared_DirtyCardQ_lock     , PaddedMutex  , access + 1,  true,  _safepoint_check_never);
 
   234     def(DirtyCardQ_CBL_mon         , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 
   208 
   235     def(Shared_DirtyCardQ_lock     , PaddedMutex  , access + 1,  true,  Monitor::_safepoint_check_never);
 
   209     def(FreeList_lock              , PaddedMutex  , leaf     ,   true,  _safepoint_check_never);
 
   236 
   210     def(OldSets_lock               , PaddedMutex  , leaf     ,   true,  _safepoint_check_never);
 
   237     def(FreeList_lock              , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 
   211     def(RootRegionScan_lock        , PaddedMonitor, leaf     ,   true,  _safepoint_check_never);
 
   238     def(OldSets_lock               , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 
   212 
   239     def(RootRegionScan_lock        , PaddedMonitor, leaf     ,   true,  Monitor::_safepoint_check_never);
 
   213     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  _safepoint_check_never);
 
   240 
   214     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   241     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 
   215 
   242     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   216     def(MarkStackFreeList_lock     , PaddedMutex  , leaf     ,   true,  _safepoint_check_never);
 
   243 
   217     def(MarkStackChunkList_lock    , PaddedMutex  , leaf     ,   true,  _safepoint_check_never);
 
   244     def(MarkStackFreeList_lock     , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 
   218 
   245     def(MarkStackChunkList_lock    , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 
   219     def(MonitoringSupport_lock     , PaddedMutex  , native   ,   true,  _safepoint_check_never);      // used for serviceability monitoring support
 
   246 
       
   247     def(MonitoringSupport_lock     , PaddedMutex  , native   ,   true,  Monitor::_safepoint_check_never);      // used for serviceability monitoring support
 
       
   248   }
 
   220   }
 
   249   if (UseShenandoahGC) {
 
   221   if (UseShenandoahGC) {
 
   250     def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 
   222     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  _safepoint_check_never);
 
   251 
   223     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   252     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 
   224   }
 
   253     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   225   def(ParGCRareEvent_lock          , PaddedMutex  , leaf     ,   true,  _safepoint_check_always);
 
   254   }
 
   226   def(CGCPhaseManager_lock         , PaddedMonitor, leaf,        false, _safepoint_check_always);
 
   255   def(ParGCRareEvent_lock          , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_always);
 
   227   def(CodeCache_lock               , PaddedMonitor, special,     true,  _safepoint_check_never);
 
   256   def(CGCPhaseManager_lock         , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_always);
 
   228   def(RawMonitor_lock              , PaddedMutex  , special,     true,  _safepoint_check_never);
 
   257   def(CodeCache_lock               , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 
   229   def(OopMapCacheAlloc_lock        , PaddedMutex  , leaf,        true,  _safepoint_check_always); // used for oop_map_cache allocation.
 
   258   def(RawMonitor_lock              , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 
   230 
   259   def(OopMapCacheAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for oop_map_cache allocation.
 
   231   def(MetaspaceExpand_lock         , PaddedMutex  , leaf-1,      true,  _safepoint_check_never);
 
   260 
   232   def(ClassLoaderDataGraph_lock    , PaddedMutex  , nonleaf,     false, _safepoint_check_always);
 
   261   def(MetaspaceExpand_lock         , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);
 
   233 
   262   def(ClassLoaderDataGraph_lock    , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
 
   234   def(Patching_lock                , PaddedMutex  , special,     true,  _safepoint_check_never);      // used for safepointing and code patching.
 
   263 
   235   def(CompiledMethod_lock          , PaddedMutex  , special-1,   true,  _safepoint_check_never);
 
   264   def(Patching_lock                , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);      // used for safepointing and code patching.
 
   236   def(Service_lock                 , PaddedMonitor, special,     true,  _safepoint_check_never);      // used for service thread operations
 
   265   def(OsrList_lock                 , PaddedMutex  , special-1,   true,  Monitor::_safepoint_check_never);
 
   237 
   266   def(CompiledMethod_lock          , PaddedMutex  , special-1,   true,  Monitor::_safepoint_check_never);
 
   238   if (UseNotificationThread) {
 
   267   def(Service_lock                 , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // used for service thread operations
 
   239     def(Notification_lock            , PaddedMonitor, special,     true,  _safepoint_check_never);  // used for notification thread operations
 
   268   def(JmethodIdCreation_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for creating jmethodIDs.
 
   240   } else {
 
   269 
   241     Notification_lock = Service_lock;
 
   270   def(SystemDictionary_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 
   242   }
 
   271   def(ProtectionDomainSet_lock     , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);
 
   243 
   272   def(SharedDictionary_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);
 
   244   def(JmethodIdCreation_lock       , PaddedMutex  , leaf,        true,  _safepoint_check_always); // used for creating jmethodIDs.
 
   273   def(Module_lock                  , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_always);
 
   245 
   274   def(InlineCacheBuffer_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   246   def(SystemDictionary_lock        , PaddedMonitor, leaf,        true,  _safepoint_check_always);
 
   275   def(VMStatistic_lock             , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
 
   247   def(ProtectionDomainSet_lock     , PaddedMutex  , leaf-1,      true,  _safepoint_check_never);
 
   276   def(ExpandHeap_lock              , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // Used during compilation by VM thread
 
   248   def(SharedDictionary_lock        , PaddedMutex  , leaf,        true,  _safepoint_check_always);
 
   277   def(JNIHandleBlockFreeList_lock  , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);      // handles are used by VM thread
 
   249   def(Module_lock                  , PaddedMutex  , leaf+2,      false, _safepoint_check_always);
 
   278   def(SignatureHandlerLibrary_lock , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
 
   250   def(InlineCacheBuffer_lock       , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   279   def(SymbolArena_lock             , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_never);
 
   251   def(VMStatistic_lock             , PaddedMutex  , leaf,        false, _safepoint_check_always);
 
   280   def(ProfilePrint_lock            , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always); // serial profile printing
 
   252   def(ExpandHeap_lock              , PaddedMutex  , leaf,        true,  _safepoint_check_always); // Used during compilation by VM thread
 
   281   def(ExceptionCache_lock          , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always); // serial profile printing
 
   253   def(JNIHandleBlockFreeList_lock  , PaddedMutex  , leaf-1,      true,  _safepoint_check_never);      // handles are used by VM thread
 
   282   def(Debug1_lock                  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   254   def(SignatureHandlerLibrary_lock , PaddedMutex  , leaf,        false, _safepoint_check_always);
 
       
   255   def(SymbolArena_lock             , PaddedMutex  , leaf+2,      true,  _safepoint_check_never);
 
       
   256   def(ProfilePrint_lock            , PaddedMutex  , leaf,        false, _safepoint_check_always); // serial profile printing
 
       
   257   def(ExceptionCache_lock          , PaddedMutex  , leaf,        false, _safepoint_check_always); // serial profile printing
 
       
   258   def(Debug1_lock                  , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   283 #ifndef PRODUCT
 
   259 #ifndef PRODUCT
 
   284   def(FullGCALot_lock              , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always); // a lock to make FullGCALot MT safe
 
   260   def(FullGCALot_lock              , PaddedMutex  , leaf,        false, _safepoint_check_always); // a lock to make FullGCALot MT safe
 
   285 #endif
 
   261 #endif
 
   286   def(BeforeExit_lock              , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 
   262   def(BeforeExit_lock              , PaddedMonitor, leaf,        true,  _safepoint_check_always);
 
   287   def(PerfDataMemAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for allocating PerfData memory for performance data
 
   263   def(PerfDataMemAlloc_lock        , PaddedMutex  , leaf,        true,  _safepoint_check_always); // used for allocating PerfData memory for performance data
 
   288   def(PerfDataManager_lock         , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for synchronized access to PerfDataManager resources
 
   264   def(PerfDataManager_lock         , PaddedMutex  , leaf,        true,  _safepoint_check_always); // used for synchronized access to PerfDataManager resources
 
   289 
   265 
   290   // CMS_modUnionTable_lock                   leaf
 
   266   // CMS_modUnionTable_lock                   leaf
 
   291   // CMS_bitMap_lock                          leaf 1
 
   267   // CMS_bitMap_lock                          leaf 1
 
   292   // CMS_freeList_lock                        leaf 2
 
   268   // CMS_freeList_lock                        leaf 2
 
   293 
   269 
   294   def(Threads_lock                 , PaddedMonitor, barrier,     true,  Monitor::_safepoint_check_sometimes);  // Used for safepoint protocol.
 
   270   def(Threads_lock                 , PaddedMonitor, barrier,     true,  _safepoint_check_always);  // Used for safepoint protocol.
 
   295   def(NonJavaThreadsList_lock      , PaddedMutex,   leaf,        true,  Monitor::_safepoint_check_never);
 
   271   def(NonJavaThreadsList_lock      , PaddedMutex,   leaf,        true,  _safepoint_check_never);
 
   296   def(NonJavaThreadsListSync_lock  , PaddedMutex,   leaf,        true,  Monitor::_safepoint_check_never);
 
   272   def(NonJavaThreadsListSync_lock  , PaddedMutex,   leaf,        true,  _safepoint_check_never);
 
   297 
   273 
   298   def(VMOperationQueue_lock        , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_never);  // VM_thread allowed to block on these
 
   274   def(VMOperationQueue_lock        , PaddedMonitor, nonleaf,     true,  _safepoint_check_never);  // VM_thread allowed to block on these
 
   299   def(VMOperationRequest_lock      , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 
   275   def(VMOperationRequest_lock      , PaddedMonitor, nonleaf,     true,  _safepoint_check_always);
 
   300   def(RetData_lock                 , PaddedMutex  , nonleaf,     false, Monitor::_safepoint_check_always);
 
   276   def(RetData_lock                 , PaddedMutex  , nonleaf,     false, _safepoint_check_always);
 
   301   def(Terminator_lock              , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 
   277   def(Terminator_lock              , PaddedMonitor, nonleaf,     true,  _safepoint_check_always);
 
   302   def(InitCompleted_lock           , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 
   278   def(InitCompleted_lock           , PaddedMonitor, leaf,        true,  _safepoint_check_never);
 
   303   def(VtableStubs_lock             , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 
   279   def(VtableStubs_lock             , PaddedMutex  , nonleaf,     true,  _safepoint_check_never);
 
   304   def(Notify_lock                  , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 
   280   def(Notify_lock                  , PaddedMonitor, nonleaf,     true,  _safepoint_check_always);
 
   305   def(JNIGlobalAlloc_lock          , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 
   281   def(JNICritical_lock             , PaddedMonitor, nonleaf,     true,  _safepoint_check_always); // used for JNI critical regions
 
   306   def(JNIGlobalActive_lock         , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 
   282   def(AdapterHandlerLibrary_lock   , PaddedMutex  , nonleaf,     true,  _safepoint_check_always);
 
   307   def(JNIWeakAlloc_lock            , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 
   283 
   308   def(JNIWeakActive_lock           , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 
   284   def(Heap_lock                    , PaddedMonitor, nonleaf+1,   false, _safepoint_check_sometimes);  // Doesn't safepoint check during termination.
 
   309   def(JNICritical_lock             , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always); // used for JNI critical regions
 
   285   def(JfieldIdCreation_lock        , PaddedMutex  , nonleaf+1,   true,  _safepoint_check_always); // jfieldID, Used in VM_Operation
 
   310   def(AdapterHandlerLibrary_lock   , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
 
   286 
   311 
   287   def(CompiledIC_lock              , PaddedMutex  , nonleaf+2,   false, _safepoint_check_never);      // locks VtableStubs_lock, InlineCacheBuffer_lock
 
   312   def(Heap_lock                    , PaddedMonitor, nonleaf+1,   false, Monitor::_safepoint_check_sometimes);  // Doesn't safepoint check during termination.
 
   288   def(CompileTaskAlloc_lock        , PaddedMutex  , nonleaf+2,   true,  _safepoint_check_always);
 
   313   def(JfieldIdCreation_lock        , PaddedMutex  , nonleaf+1,   true,  Monitor::_safepoint_check_always); // jfieldID, Used in VM_Operation
 
   289   def(CompileStatistics_lock       , PaddedMutex  , nonleaf+2,   false, _safepoint_check_always);
 
   314 
   290   def(DirectivesStack_lock         , PaddedMutex  , special,     true,  _safepoint_check_never);
 
   315   def(CompiledIC_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_never);      // locks VtableStubs_lock, InlineCacheBuffer_lock
 
   291   def(MultiArray_lock              , PaddedMutex  , nonleaf+2,   false, _safepoint_check_always);
 
   316   def(CompileTaskAlloc_lock        , PaddedMutex  , nonleaf+2,   true,  Monitor::_safepoint_check_always);
 
   292 
   317   def(CompileStatistics_lock       , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
 
   293   def(JvmtiThreadState_lock        , PaddedMutex  , nonleaf+2,   false, _safepoint_check_always); // Used by JvmtiThreadState/JvmtiEventController
 
   318   def(DirectivesStack_lock         , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 
   294   def(Management_lock              , PaddedMutex  , nonleaf+2,   false, _safepoint_check_always); // used for JVM management
 
   319   def(MultiArray_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
 
   295 
   320 
   296   def(Compile_lock                 , PaddedMutex  , nonleaf+3,   false, _safepoint_check_always);
 
   321   def(JvmtiThreadState_lock        , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always); // Used by JvmtiThreadState/JvmtiEventController
 
   297   def(MethodData_lock              , PaddedMutex  , nonleaf+3,   false, _safepoint_check_always);
 
   322   def(Management_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always); // used for JVM management
 
   298   def(TouchedMethodLog_lock        , PaddedMutex  , nonleaf+3,   false, _safepoint_check_always);
 
   323 
   299 
   324   def(Compile_lock                 , PaddedMutex  , nonleaf+3,   true,  Monitor::_safepoint_check_always);
 
   300   def(MethodCompileQueue_lock      , PaddedMonitor, nonleaf+4,   false, _safepoint_check_always);
 
   325   def(MethodData_lock              , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
 
   301   def(Debug2_lock                  , PaddedMutex  , nonleaf+4,   true,  _safepoint_check_never);
 
   326   def(TouchedMethodLog_lock        , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
 
   302   def(Debug3_lock                  , PaddedMutex  , nonleaf+4,   true,  _safepoint_check_never);
 
   327 
   303   def(CompileThread_lock           , PaddedMonitor, nonleaf+5,   false, _safepoint_check_always);
 
   328   def(MethodCompileQueue_lock      , PaddedMonitor, nonleaf+4,   true,  Monitor::_safepoint_check_always);
 
   304   def(PeriodicTask_lock            , PaddedMonitor, nonleaf+5,   true,  _safepoint_check_always);
 
   329   def(Debug2_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
 
   305   def(RedefineClasses_lock         , PaddedMonitor, nonleaf+5,   true,  _safepoint_check_always);
 
   330   def(Debug3_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
 
   306   def(Verify_lock                  , PaddedMutex,   nonleaf+5,   true,  _safepoint_check_always);
 
   331   def(CompileThread_lock           , PaddedMonitor, nonleaf+5,   false, Monitor::_safepoint_check_always);
 
       
   332   def(PeriodicTask_lock            , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_always);
 
       
   333   def(RedefineClasses_lock         , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_always);
 
       
   334 
   307 
   335   if (WhiteBoxAPI) {
 
   308   if (WhiteBoxAPI) {
 
   336     def(Compilation_lock           , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_never);
 
   309     def(Compilation_lock           , PaddedMonitor, leaf,        false, _safepoint_check_never);
 
   337   }
 
   310   }
 
   338 
   311 
   339 #if INCLUDE_JFR
 
   312 #if INCLUDE_JFR
 
   340   def(JfrMsg_lock                  , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 
   313   def(JfrMsg_lock                  , PaddedMonitor, leaf,        true,  _safepoint_check_always);
 
   341   def(JfrBuffer_lock               , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   314   def(JfrBuffer_lock               , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   342   def(JfrStream_lock               , PaddedMutex  , leaf+1,      true,  Monitor::_safepoint_check_never);      // ensure to rank lower than 'safepoint'
 
   315   def(JfrStream_lock               , PaddedMutex  , leaf+1,      true,  _safepoint_check_never);      // ensure to rank lower than 'safepoint'
 
   343   def(JfrStacktrace_lock           , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 
   316   def(JfrStacktrace_lock           , PaddedMutex  , special,     true,  _safepoint_check_never);
 
   344   def(JfrThreadSampler_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 
   317   def(JfrThreadSampler_lock        , PaddedMonitor, leaf,        true,  _safepoint_check_never);
 
   345 #endif
 
   318 #endif
 
   346 
   319 
   347 #ifndef SUPPORTS_NATIVE_CX8
 
   320 #ifndef SUPPORTS_NATIVE_CX8
 
   348   def(UnsafeJlong_lock             , PaddedMutex  , special,     false, Monitor::_safepoint_check_never);
 
   321   def(UnsafeJlong_lock             , PaddedMutex  , special,     false, _safepoint_check_never);
 
   349 #endif
 
   322 #endif
 
   350 
   323 
   351   def(CodeHeapStateAnalytics_lock  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   324   def(CodeHeapStateAnalytics_lock  , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   352   def(NMethodSweeperStats_lock     , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 
   325   def(NMethodSweeperStats_lock     , PaddedMutex  , special,     true,  _safepoint_check_never);
 
   353   def(ThreadsSMRDelete_lock        , PaddedMonitor, special,     false, Monitor::_safepoint_check_never);
 
   326   def(ThreadsSMRDelete_lock        , PaddedMonitor, special,     true,  _safepoint_check_never);
 
   354   def(SharedDecoder_lock           , PaddedMutex  , native,      false, Monitor::_safepoint_check_never);
 
   327   def(ThreadIdTableCreate_lock     , PaddedMutex  , leaf,        false, _safepoint_check_always);
 
   355   def(DCmdFactory_lock             , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
   328   def(SharedDecoder_lock           , PaddedMutex  , native,      false, _safepoint_check_never);
 
       
   329   def(DCmdFactory_lock             , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   356 #if INCLUDE_NMT
 
   330 #if INCLUDE_NMT
 
   357   def(NMTQuery_lock                , PaddedMutex  , max_nonleaf, false, Monitor::_safepoint_check_always);
 
   331   def(NMTQuery_lock                , PaddedMutex  , max_nonleaf, false, _safepoint_check_always);
 
   358 #endif
 
   332 #endif
 
   359 #if INCLUDE_CDS
 
   333 #if INCLUDE_CDS
 
   360 #if INCLUDE_JVMTI
 
   334 #if INCLUDE_JVMTI
 
   361   def(CDSClassFileStream_lock      , PaddedMutex  , max_nonleaf, false, Monitor::_safepoint_check_always);
 
   335   def(CDSClassFileStream_lock      , PaddedMutex  , max_nonleaf, false, _safepoint_check_always);
 
   362 #endif
 
   336 #endif
 
   363 
   337 
   364 #if INCLUDE_JVMCI
 
   338 #if INCLUDE_JVMCI
 
   365   def(JVMCI_lock                   , PaddedMonitor, nonleaf+2,   true,  Monitor::_safepoint_check_always);
 
   339   def(JVMCI_lock                   , PaddedMonitor, nonleaf+2,   true,  _safepoint_check_always);
 
   366   def(JVMCIGlobalAlloc_lock        , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 
   340 #endif
 
   367   def(JVMCIGlobalActive_lock       , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 
   341   def(DumpTimeTable_lock           , PaddedMutex  , leaf,        true,  _safepoint_check_never);
 
   368 #endif
 
       
   369   def(DumpTimeTable_lock           , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 
       
   370 #endif // INCLUDE_CDS
 
   342 #endif // INCLUDE_CDS
 
   371 }
 
   343 }
 
   372 
   344 
   373 GCMutexLocker::GCMutexLocker(Monitor * mutex) {
 
   345 GCMutexLocker::GCMutexLocker(Mutex* mutex) {
 
   374   if (SafepointSynchronize::is_at_safepoint()) {
 
   346   if (SafepointSynchronize::is_at_safepoint()) {
 
   375     _locked = false;
 
   347     _locked = false;
 
   376   } else {
 
   348   } else {
 
   377     _mutex = mutex;
 
   349     _mutex = mutex;
 
   378     _locked = true;
 
   350     _locked = true;
jdk-sandbox