src/hotspot/share/runtime/mutexLocker.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 46685 hotspot/src/share/vm/runtime/mutexLocker.cpp@b218dfc2853a
child 47756 55714c3d544c
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46384
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46369
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6058
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6058
diff changeset
    26
#include "runtime/mutexLocker.hpp"
25468
5331df506290 8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents: 24839
diff changeset
    27
#include "runtime/os.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6058
diff changeset
    28
#include "runtime/safepoint.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14390
diff changeset
    29
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6058
diff changeset
    30
#include "runtime/vmThread.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// Mutexes used in the VM (see comment in mutexLocker.hpp):
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// Note that the following pointers are effectively final -- after having been
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// set at JVM startup-time, they should never be subsequently mutated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// Instead of using pointers to malloc()ed monitors and mutexes we should consider
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// eliminating the indirection and using instances instead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// Consider using GCC's __read_mostly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
Mutex*   Patching_lock                = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
Monitor* SystemDictionary_lock        = NULL;
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36357
diff changeset
    42
Mutex*   Module_lock                  = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
Mutex*   CompiledIC_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
Mutex*   InlineCacheBuffer_lock       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
Mutex*   VMStatistic_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
Mutex*   JNIGlobalHandle_lock         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
Mutex*   JNIHandleBlockFreeList_lock  = NULL;
46505
fd4bc78630b1 8174749: Use hash table/oops for MemberName table
coleenp
parents: 46384
diff changeset
    48
Mutex*   ResolvedMethodTable_lock     = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
Mutex*   JmethodIdCreation_lock       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
Mutex*   JfieldIdCreation_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
Monitor* JNICritical_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
Mutex*   JvmtiThreadState_lock        = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    53
Monitor* Heap_lock                    = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
Mutex*   ExpandHeap_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
Mutex*   AdapterHandlerLibrary_lock   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
Mutex*   SignatureHandlerLibrary_lock = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
Mutex*   VtableStubs_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
Mutex*   SymbolTable_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
Mutex*   StringTable_lock             = NULL;
23472
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
    60
Monitor* StringDedupQueue_lock        = NULL;
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
    61
Mutex*   StringDedupTable_lock        = NULL;
27420
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 25468
diff changeset
    62
Monitor* CodeCache_lock               = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
Mutex*   MethodData_lock              = NULL;
31790
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31608
diff changeset
    64
Mutex*   TouchedMethodLog_lock        = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
Mutex*   RetData_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
Monitor* VMOperationQueue_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
Monitor* VMOperationRequest_lock      = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
Monitor* Safepoint_lock               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
Monitor* SerializePage_lock           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
Monitor* Threads_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
Monitor* CGC_lock                     = NULL;
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 23472
diff changeset
    72
Monitor* STS_lock                     = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
Monitor* FullGCCount_lock             = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    74
Mutex*   SATB_Q_FL_lock               = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    75
Monitor* SATB_Q_CBL_mon               = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    76
Mutex*   Shared_SATB_Q_lock           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    77
Mutex*   DirtyCardQ_FL_lock           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    78
Monitor* DirtyCardQ_CBL_mon           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    79
Mutex*   Shared_DirtyCardQ_lock       = NULL;
41176
ff9f64534cff 8159422: Very high Concurrent Mark mark stack contention
tschatzl
parents: 39208
diff changeset
    80
Mutex*   MarkStackFreeList_lock       = NULL;
ff9f64534cff 8159422: Very high Concurrent Mark mark stack contention
tschatzl
parents: 39208
diff changeset
    81
Mutex*   MarkStackChunkList_lock      = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
Mutex*   ParGCRareEvent_lock          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
Mutex*   DerivedPointerTableGC_lock   = NULL;
46384
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46369
diff changeset
    84
Monitor* CGCPhaseManager_lock         = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
Mutex*   Compile_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
Monitor* MethodCompileQueue_lock      = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
Monitor* CompileThread_lock           = NULL;
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
    88
Monitor* Compilation_lock             = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
Mutex*   CompileTaskAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
Mutex*   CompileStatistics_lock       = NULL;
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33105
diff changeset
    91
Mutex*   DirectivesStack_lock         = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
Mutex*   MultiArray_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
Monitor* Terminator_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
Monitor* BeforeExit_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
Monitor* Notify_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
Mutex*   ProfilePrint_lock            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
Mutex*   ExceptionCache_lock          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
Mutex*   OsrList_lock                 = NULL;
31608
b5cb9a07591a 8080511: Refresh of jimage support
jfdenise
parents: 30108
diff changeset
    99
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
Mutex*   FullGCALot_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
Mutex*   Debug1_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
Mutex*   Debug2_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
Mutex*   Debug3_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
Mutex*   tty_lock                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
Mutex*   RawMonitor_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
Mutex*   PerfDataMemAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
Mutex*   PerfDataManager_lock         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
Mutex*   OopMapCacheAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   115
Mutex*   FreeList_lock                = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   116
Monitor* SecondaryFreeList_lock       = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   117
Mutex*   OldSets_lock                 = NULL;
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 10565
diff changeset
   118
Monitor* RootRegionScan_lock          = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   119
Mutex*   MMUTracker_lock              = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   120
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
Monitor* GCTaskManager_lock           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
Mutex*   Management_lock              = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   124
Monitor* Service_lock                 = NULL;
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   125
Monitor* PeriodicTask_lock            = NULL;
38309
9b8e9c373740 8155951: VM crash in nsk/jvmti/RedefineClasses/StressRedefine: assert failed: Corrupted constant pool
coleenp
parents: 37179
diff changeset
   126
Monitor* RedefineClasses_lock         = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   127
46304
8d4d88f90669 8176096: Wrong macro checks for INCLUDE_TRACE
rehn
parents: 41710
diff changeset
   128
#if INCLUDE_TRACE
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   129
Mutex*   JfrStacktrace_lock           = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   130
Monitor* JfrMsg_lock                  = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   131
Mutex*   JfrBuffer_lock               = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   132
Mutex*   JfrStream_lock               = NULL;
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   133
Mutex*   JfrThreadGroups_lock         = NULL;
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   134
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
27874
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   136
#ifndef SUPPORTS_NATIVE_CX8
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   137
Mutex*   UnsafeJlong_lock             = NULL;
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   138
#endif
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   139
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
#define MAX_NUM_MUTEX 128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
static Monitor * _mutex_array[MAX_NUM_MUTEX];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
static int _num_mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
void assert_locked_or_safepoint(const Monitor * lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // check if this thread owns the lock (common case)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  if (lock->owned_by_self()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  if (SafepointSynchronize::is_at_safepoint()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  if (!Universe::is_fully_initialized()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // see if invoker of VM operation owns it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  VM_Operation* op = VMThread::vm_operation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  if (op != NULL && op->calling_thread() == lock->owner()) return;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 33097
diff changeset
   155
  fatal("must own lock %s", lock->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
// a stronger assertion than the above
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
void assert_lock_strong(const Monitor * lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  if (lock->owned_by_self()) return;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 33097
diff changeset
   163
  fatal("must own lock %s", lock->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   167
#define def(var, type, pri, vm_block, safepoint_check_allowed ) {      \
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   168
  var = new type(Mutex::pri, #var, vm_block, safepoint_check_allowed); \
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   169
  assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX");        \
30108
fbe647bcbc25 8072128: mutexLocker.cpp _mutex_array[] initialization broken with safepoint check change
mockner
parents: 28831
diff changeset
   170
  _mutex_array[_num_mutex++] = var;                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   173
// Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
void mutex_init() {
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   175
  def(tty_lock                     , PaddedMutex  , event,       true,  Monitor::_safepoint_check_never);      // allow to lock in VM
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   177
  def(CGC_lock                     , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // coordinate between fore- and background GC
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   178
  def(STS_lock                     , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   179
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5707
diff changeset
   180
  if (UseConcMarkSweepGC || UseG1GC) {
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   181
    def(FullGCCount_lock           , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);      // in support of ExplicitGCInvokesConcurrent
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   183
  if (UseG1GC) {
46685
b218dfc2853a 8182703: Correct G1 barrier queue lock orderings
eosterlund
parents: 46505
diff changeset
   184
    def(SATB_Q_FL_lock             , PaddedMutex  , access,      true,  Monitor::_safepoint_check_never);
b218dfc2853a 8182703: Correct G1 barrier queue lock orderings
eosterlund
parents: 46505
diff changeset
   185
    def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
b218dfc2853a 8182703: Correct G1 barrier queue lock orderings
eosterlund
parents: 46505
diff changeset
   186
    def(Shared_SATB_Q_lock         , PaddedMutex  , access + 1,  true,  Monitor::_safepoint_check_never);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   187
46685
b218dfc2853a 8182703: Correct G1 barrier queue lock orderings
eosterlund
parents: 46505
diff changeset
   188
    def(DirtyCardQ_FL_lock         , PaddedMutex  , access,      true,  Monitor::_safepoint_check_never);
b218dfc2853a 8182703: Correct G1 barrier queue lock orderings
eosterlund
parents: 46505
diff changeset
   189
    def(DirtyCardQ_CBL_mon         , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
b218dfc2853a 8182703: Correct G1 barrier queue lock orderings
eosterlund
parents: 46505
diff changeset
   190
    def(Shared_DirtyCardQ_lock     , PaddedMutex  , access + 1,  true,  Monitor::_safepoint_check_never);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   191
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   192
    def(FreeList_lock              , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   193
    def(SecondaryFreeList_lock     , PaddedMonitor, leaf     ,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   194
    def(OldSets_lock               , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   195
    def(RootRegionScan_lock        , PaddedMonitor, leaf     ,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   196
    def(MMUTracker_lock            , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
23472
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
   197
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   198
    def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   199
    def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
41176
ff9f64534cff 8159422: Very high Concurrent Mark mark stack contention
tschatzl
parents: 39208
diff changeset
   200
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   201
    def(MarkStackFreeList_lock     , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   202
    def(MarkStackChunkList_lock    , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   203
  }
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   204
  def(ParGCRareEvent_lock          , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   205
  def(DerivedPointerTableGC_lock   , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
46384
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46369
diff changeset
   206
#ifdef INCLUDE_ALL_GCS
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46369
diff changeset
   207
  def(CGCPhaseManager_lock         , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_sometimes);
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46369
diff changeset
   208
#endif
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   209
  def(CodeCache_lock               , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   210
  def(RawMonitor_lock              , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   211
  def(OopMapCacheAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for oop_map_cache allocation.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   213
  def(Patching_lock                , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);      // used for safepointing and code patching.
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   214
  def(Service_lock                 , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // used for service thread operations
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   215
  def(JmethodIdCreation_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for creating jmethodIDs.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   217
  def(SystemDictionary_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);     // lookups done by VM thread
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   218
  def(Module_lock                  , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   219
  def(InlineCacheBuffer_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   220
  def(VMStatistic_lock             , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   221
  def(ExpandHeap_lock              , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // Used during compilation by VM thread
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   222
  def(JNIHandleBlockFreeList_lock  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);      // handles are used by VM thread
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   223
  def(SignatureHandlerLibrary_lock , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   224
  def(SymbolTable_lock             , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   225
  def(StringTable_lock             , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   226
  def(ProfilePrint_lock            , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);     // serial profile printing
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   227
  def(ExceptionCache_lock          , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);     // serial profile printing
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   228
  def(OsrList_lock                 , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   229
  def(Debug1_lock                  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
#ifndef PRODUCT
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   231
  def(FullGCALot_lock              , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);     // a lock to make FullGCALot MT safe
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
#endif
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   233
  def(BeforeExit_lock              , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   234
  def(PerfDataMemAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for allocating PerfData memory for performance data
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   235
  def(PerfDataManager_lock         , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for synchronized access to PerfDataManager resources
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // CMS_modUnionTable_lock                   leaf
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   238
  // CMS_bitMap_lock                          leaf 1
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   239
  // CMS_freeList_lock                        leaf 2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   241
  def(Safepoint_lock               , PaddedMonitor, safepoint,   true,  Monitor::_safepoint_check_sometimes);  // locks SnippetCache_lock/Threads_lock
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   243
  def(Threads_lock                 , PaddedMonitor, barrier,     true,  Monitor::_safepoint_check_sometimes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   245
  def(VMOperationQueue_lock        , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);  // VM_thread allowed to block on these
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   246
  def(VMOperationRequest_lock      , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   247
  def(RetData_lock                 , PaddedMutex  , nonleaf,     false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   248
  def(Terminator_lock              , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   249
  def(VtableStubs_lock             , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   250
  def(Notify_lock                  , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   251
  def(JNIGlobalHandle_lock         , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);     // locks JNIHandleBlockFreeList_lock
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   252
  def(JNICritical_lock             , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);     // used for JNI critical regions
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   253
  def(AdapterHandlerLibrary_lock   , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   254
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   255
  def(Heap_lock                    , PaddedMonitor, nonleaf+1,   false, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   256
  def(JfieldIdCreation_lock        , PaddedMutex  , nonleaf+1,   true,  Monitor::_safepoint_check_always);     // jfieldID, Used in VM_Operation
46505
fd4bc78630b1 8174749: Use hash table/oops for MemberName table
coleenp
parents: 46384
diff changeset
   257
  def(ResolvedMethodTable_lock     , PaddedMutex  , nonleaf+1,   false, Monitor::_safepoint_check_always);     // Used to protect ResolvedMethodTable
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   259
  def(CompiledIC_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // locks VtableStubs_lock, InlineCacheBuffer_lock
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   260
  def(CompileTaskAlloc_lock        , PaddedMutex  , nonleaf+2,   true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   261
  def(CompileStatistics_lock       , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   262
  def(DirectivesStack_lock         , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   263
  def(MultiArray_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // locks SymbolTable_lock
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   265
  def(JvmtiThreadState_lock        , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // Used by JvmtiThreadState/JvmtiEventController
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   266
  def(Management_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // used for JVM management
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   268
  def(Compile_lock                 , PaddedMutex  , nonleaf+3,   true,  Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   269
  def(MethodData_lock              , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   270
  def(TouchedMethodLog_lock        , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   272
  def(MethodCompileQueue_lock      , PaddedMonitor, nonleaf+4,   true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   273
  def(Debug2_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   274
  def(Debug3_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   275
  def(CompileThread_lock           , PaddedMonitor, nonleaf+5,   false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   276
  def(PeriodicTask_lock            , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   277
  def(RedefineClasses_lock         , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_always);
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   278
  if (WhiteBoxAPI) {
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   279
    def(Compilation_lock           , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_never);
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   280
  }
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   281
46304
8d4d88f90669 8176096: Wrong macro checks for INCLUDE_TRACE
rehn
parents: 41710
diff changeset
   282
#if INCLUDE_TRACE
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   283
  def(JfrMsg_lock                  , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   284
  def(JfrBuffer_lock               , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   285
  def(JfrThreadGroups_lock         , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   286
  def(JfrStream_lock               , PaddedMutex  , leaf+1,      true,  Monitor::_safepoint_check_never);      // ensure to rank lower than 'safepoint'
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   287
  def(JfrStacktrace_lock           , PaddedMutex  , special,     true,  Monitor::_safepoint_check_sometimes);
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   288
#endif
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   289
27874
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   290
#ifndef SUPPORTS_NATIVE_CX8
41710
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE
mdoerr
parents: 41176
diff changeset
   291
  def(UnsafeJlong_lock             , PaddedMutex  , special,     false, Monitor::_safepoint_check_never);
27874
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   292
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
GCMutexLocker::GCMutexLocker(Monitor * mutex) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  if (SafepointSynchronize::is_at_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
    _locked = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    _mutex = mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    _locked = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    _mutex->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
// Print all mutexes/monitors that are currently owned by a thread; called
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
// by fatal error handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
void print_owned_locks_on_error(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  st->print("VM Mutex/Monitor currently owned by a thread: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  bool none = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  for (int i = 0; i < _num_mutex; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
     // see if it has an owner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
     if (_mutex_array[i]->owner() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
       if (none) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
          // print format used by Mutex::print_on_error()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
          st->print_cr(" ([mutex/lock_event])");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
          none = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
       _mutex_array[i]->print_on_error(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
       st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  if (none) st->print_cr("None");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
}