hotspot/src/share/vm/runtime/mutexLocker.cpp
author david
Tue, 29 Sep 2015 11:02:08 +0200
changeset 33105 294e48b4f704
parent 33097 96e348cb0442
child 33451 0712796e4039
permissions -rw-r--r--
8080775: Better argument formatting for assert() and friends Reviewed-by: kbarrett, pliden
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
28831
454224c7e3ba 8069273: Decrease Hot Card Cache Lock contention
redestad
parents: 28163
diff changeset
     2
 * Copyright (c) 1997, 2015, 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/threadLocalStorage.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6058
diff changeset
    31
#include "runtime/vmThread.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// Mutexes used in the VM (see comment in mutexLocker.hpp):
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// Note that the following pointers are effectively final -- after having been
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// set at JVM startup-time, they should never be subsequently mutated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// Instead of using pointers to malloc()ed monitors and mutexes we should consider
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// eliminating the indirection and using instances instead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// Consider using GCC's __read_mostly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
Mutex*   Patching_lock                = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
Monitor* SystemDictionary_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
Mutex*   PackageTable_lock            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
Mutex*   CompiledIC_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
Mutex*   InlineCacheBuffer_lock       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
Mutex*   VMStatistic_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
Mutex*   JNIGlobalHandle_lock         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
Mutex*   JNIHandleBlockFreeList_lock  = NULL;
17029
9ff8d7c0ed79 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents: 14583
diff changeset
    49
Mutex*   MemberNameTable_lock         = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
Mutex*   JmethodIdCreation_lock       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
Mutex*   JfieldIdCreation_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
Monitor* JNICritical_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
Mutex*   JvmtiThreadState_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
Monitor* JvmtiPendingEvent_lock       = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    55
Monitor* Heap_lock                    = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
Mutex*   ExpandHeap_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
Mutex*   AdapterHandlerLibrary_lock   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
Mutex*   SignatureHandlerLibrary_lock = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
Mutex*   VtableStubs_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
Mutex*   SymbolTable_lock             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
Mutex*   StringTable_lock             = NULL;
23472
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
    62
Monitor* StringDedupQueue_lock        = NULL;
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
    63
Mutex*   StringDedupTable_lock        = NULL;
27420
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 25468
diff changeset
    64
Monitor* CodeCache_lock               = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
Mutex*   MethodData_lock              = NULL;
31790
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31608
diff changeset
    66
Mutex*   TouchedMethodLog_lock        = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
Mutex*   RetData_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
Monitor* VMOperationQueue_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
Monitor* VMOperationRequest_lock      = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
Monitor* Safepoint_lock               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
Monitor* SerializePage_lock           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
Monitor* Threads_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
Monitor* CGC_lock                     = NULL;
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 23472
diff changeset
    74
Monitor* STS_lock                     = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
Monitor* SLT_lock                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
Monitor* FullGCCount_lock             = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    77
Monitor* CMark_lock                   = NULL;
5242
85cf92183e39 6940310: G1: MT-unsafe calls to CM::region_stack_push() / CM::region_stack_pop()
tonyp
parents: 3261
diff changeset
    78
Mutex*   CMRegionStack_lock           = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    79
Mutex*   SATB_Q_FL_lock               = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    80
Monitor* SATB_Q_CBL_mon               = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    81
Mutex*   Shared_SATB_Q_lock           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    82
Mutex*   DirtyCardQ_FL_lock           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    83
Monitor* DirtyCardQ_CBL_mon           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    84
Mutex*   Shared_DirtyCardQ_lock       = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
Mutex*   ParGCRareEvent_lock          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
Mutex*   DerivedPointerTableGC_lock   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
Mutex*   Compile_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
Monitor* MethodCompileQueue_lock      = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
Monitor* CompileThread_lock           = NULL;
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
    90
Monitor* Compilation_lock             = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
Mutex*   CompileTaskAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
Mutex*   CompileStatistics_lock       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
Mutex*   MultiArray_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
Monitor* Terminator_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
Monitor* BeforeExit_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
Monitor* Notify_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
Monitor* Interrupt_lock               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
Monitor* ProfileVM_lock               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
Mutex*   ProfilePrint_lock            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
Mutex*   ExceptionCache_lock          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
Monitor* ObjAllocPost_lock            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
Mutex*   OsrList_lock                 = NULL;
31608
b5cb9a07591a 8080511: Refresh of jimage support
jfdenise
parents: 30108
diff changeset
   103
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
Mutex*   FullGCALot_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
Mutex*   Debug1_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
Mutex*   Debug2_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
Mutex*   Debug3_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
Mutex*   tty_lock                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
Mutex*   RawMonitor_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
Mutex*   PerfDataMemAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
Mutex*   PerfDataManager_lock         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
Mutex*   OopMapCacheAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   119
Mutex*   FreeList_lock                = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   120
Monitor* SecondaryFreeList_lock       = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   121
Mutex*   OldSets_lock                 = NULL;
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 10565
diff changeset
   122
Monitor* RootRegionScan_lock          = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   123
Mutex*   MMUTracker_lock              = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   124
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
Monitor* GCTaskManager_lock           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
Mutex*   Management_lock              = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   128
Monitor* Service_lock                 = NULL;
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   129
Monitor* PeriodicTask_lock            = NULL;
33097
96e348cb0442 8046148: JEP 158: Unified JVM Logging
mlarsson
parents: 32619
diff changeset
   130
Mutex*   LogConfiguration_lock        = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   131
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   132
#ifdef INCLUDE_TRACE
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   133
Mutex*   JfrStacktrace_lock           = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   134
Monitor* JfrMsg_lock                  = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   135
Mutex*   JfrBuffer_lock               = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   136
Mutex*   JfrStream_lock               = NULL;
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   137
Mutex*   JfrThreadGroups_lock         = NULL;
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   138
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
27874
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   140
#ifndef SUPPORTS_NATIVE_CX8
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   141
Mutex*   UnsafeJlong_lock             = NULL;
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   142
#endif
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   143
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
#define MAX_NUM_MUTEX 128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
static Monitor * _mutex_array[MAX_NUM_MUTEX];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
static int _num_mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
void assert_locked_or_safepoint(const Monitor * lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // check if this thread owns the lock (common case)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  if (lock->owned_by_self()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  if (SafepointSynchronize::is_at_safepoint()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  if (!Universe::is_fully_initialized()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // see if invoker of VM operation owns it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  VM_Operation* op = VMThread::vm_operation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  if (op != NULL && op->calling_thread() == lock->owner()) return;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 33097
diff changeset
   159
  fatal("must own lock %s", lock->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
// a stronger assertion than the above
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
void assert_lock_strong(const Monitor * lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  if (lock->owned_by_self()) return;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 33097
diff changeset
   167
  fatal("must own lock %s", lock->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   171
#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
   172
  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
   173
  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
   174
  _mutex_array[_num_mutex++] = var;                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
void mutex_init() {
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   178
  def(tty_lock                     , Mutex  , event,       true,  Monitor::_safepoint_check_never);      // allow to lock in VM
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   180
  def(CGC_lock                     , Monitor, special,     true,  Monitor::_safepoint_check_never);      // coordinate between fore- and background GC
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   181
  def(STS_lock                     , Monitor, leaf,        true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   182
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5707
diff changeset
   183
  if (UseConcMarkSweepGC || UseG1GC) {
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   184
    def(FullGCCount_lock           , Monitor, leaf,        true,  Monitor::_safepoint_check_never);      // in support of ExplicitGCInvokesConcurrent
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   186
  if (UseG1GC) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   187
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   188
    def(CMark_lock                 , Monitor, nonleaf,     true,  Monitor::_safepoint_check_never);      // coordinate concurrent mark thread
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   189
    def(CMRegionStack_lock         , Mutex,   leaf,        true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   190
    def(SATB_Q_FL_lock             , Mutex  , special,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   191
    def(SATB_Q_CBL_mon             , Monitor, nonleaf,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   192
    def(Shared_SATB_Q_lock         , Mutex,   nonleaf,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   193
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   194
    def(DirtyCardQ_FL_lock         , Mutex  , special,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   195
    def(DirtyCardQ_CBL_mon         , Monitor, nonleaf,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   196
    def(Shared_DirtyCardQ_lock     , Mutex,   nonleaf,     true,  Monitor::_safepoint_check_never);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   197
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   198
    def(FreeList_lock              , Mutex,   leaf     ,   true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   199
    def(SecondaryFreeList_lock     , Monitor, leaf     ,   true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   200
    def(OldSets_lock               , Mutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   201
    def(RootRegionScan_lock        , Monitor, leaf     ,   true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   202
    def(MMUTracker_lock            , Mutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
23472
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
   203
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   204
    def(StringDedupQueue_lock      , Monitor, leaf,        true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   205
    def(StringDedupTable_lock      , Mutex  , leaf,        true,  Monitor::_safepoint_check_never);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   206
  }
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   207
  def(ParGCRareEvent_lock          , Mutex  , leaf     ,   true,  Monitor::_safepoint_check_sometimes);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   208
  def(DerivedPointerTableGC_lock   , Mutex,   leaf,        true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   209
  def(CodeCache_lock               , Mutex  , special,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   210
  def(Interrupt_lock               , Monitor, special,     true,  Monitor::_safepoint_check_never);      // used for interrupt processing
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   211
  def(RawMonitor_lock              , Mutex,   special,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   212
  def(OopMapCacheAlloc_lock        , Mutex,   leaf,        true,  Monitor::_safepoint_check_always);     // used for oop_map_cache allocation.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   214
  def(Patching_lock                , Mutex  , special,     true,  Monitor::_safepoint_check_never);      // used for safepointing and code patching.
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   215
  def(ObjAllocPost_lock            , Monitor, special,     false, Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   216
  def(Service_lock                 , Monitor, special,     true,  Monitor::_safepoint_check_never);      // used for service thread operations
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   217
  def(JmethodIdCreation_lock       , Mutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for creating jmethodIDs.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   219
  def(SystemDictionary_lock        , Monitor, leaf,        true,  Monitor::_safepoint_check_always);     // lookups done by VM thread
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   220
  def(PackageTable_lock            , Mutex  , leaf,        false, Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   221
  def(InlineCacheBuffer_lock       , Mutex  , leaf,        true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   222
  def(VMStatistic_lock             , Mutex  , leaf,        false, Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   223
  def(ExpandHeap_lock              , Mutex  , leaf,        true,  Monitor::_safepoint_check_always);     // Used during compilation by VM thread
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   224
  def(JNIHandleBlockFreeList_lock  , Mutex  , leaf,        true,  Monitor::_safepoint_check_never);      // handles are used by VM thread
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   225
  def(SignatureHandlerLibrary_lock , Mutex  , leaf,        false, Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   226
  def(SymbolTable_lock             , Mutex  , leaf+2,      true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   227
  def(StringTable_lock             , Mutex  , leaf,        true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   228
  def(ProfilePrint_lock            , Mutex  , leaf,        false, Monitor::_safepoint_check_always);     // serial profile printing
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   229
  def(ExceptionCache_lock          , Mutex  , leaf,        false, Monitor::_safepoint_check_always);     // serial profile printing
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   230
  def(OsrList_lock                 , Mutex  , leaf,        true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   231
  def(Debug1_lock                  , Mutex  , leaf,        true,  Monitor::_safepoint_check_never);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
#ifndef PRODUCT
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   233
  def(FullGCALot_lock              , Mutex  , leaf,        false, Monitor::_safepoint_check_always);     // a lock to make FullGCALot MT safe
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
#endif
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   235
  def(BeforeExit_lock              , Monitor, leaf,        true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   236
  def(PerfDataMemAlloc_lock        , Mutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for allocating PerfData memory for performance data
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   237
  def(PerfDataManager_lock         , Mutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for synchronized access to PerfDataManager resources
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // 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
   240
  // 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
   241
  // CMS_freeList_lock                        leaf 2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   243
  def(Safepoint_lock               , Monitor, safepoint,   true,  Monitor::_safepoint_check_sometimes);  // locks SnippetCache_lock/Threads_lock
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   245
  def(Threads_lock                 , Monitor, barrier,     true,  Monitor::_safepoint_check_sometimes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   247
  def(VMOperationQueue_lock        , Monitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);  // VM_thread allowed to block on these
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   248
  def(VMOperationRequest_lock      , Monitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   249
  def(RetData_lock                 , Mutex  , nonleaf,     false, Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   250
  def(Terminator_lock              , Monitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   251
  def(VtableStubs_lock             , Mutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   252
  def(Notify_lock                  , Monitor, nonleaf,     true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   253
  def(JNIGlobalHandle_lock         , Mutex  , nonleaf,     true,  Monitor::_safepoint_check_always);     // locks JNIHandleBlockFreeList_lock
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   254
  def(JNICritical_lock             , Monitor, nonleaf,     true,  Monitor::_safepoint_check_always);     // used for JNI critical regions
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   255
  def(AdapterHandlerLibrary_lock   , Mutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  if (UseConcMarkSweepGC) {
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   257
    def(SLT_lock                   , Monitor, nonleaf,     false, Monitor::_safepoint_check_never);      // used in CMS GC for locking PLL lock
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  }
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   259
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   260
  def(Heap_lock                    , Monitor, nonleaf+1,   false, Monitor::_safepoint_check_sometimes);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   261
  def(JfieldIdCreation_lock        , Mutex  , nonleaf+1,   true,  Monitor::_safepoint_check_always);     // jfieldID, Used in VM_Operation
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   262
  def(MemberNameTable_lock         , Mutex  , nonleaf+1,   false, Monitor::_safepoint_check_always);     // Used to protect MemberNameTable
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   264
  def(CompiledIC_lock              , Mutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // locks VtableStubs_lock, InlineCacheBuffer_lock
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   265
  def(CompileTaskAlloc_lock        , Mutex  , nonleaf+2,   true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   266
  def(CompileStatistics_lock       , Mutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   267
  def(MultiArray_lock              , Mutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // locks SymbolTable_lock
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   269
  def(JvmtiThreadState_lock        , Mutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // Used by JvmtiThreadState/JvmtiEventController
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   270
  def(JvmtiPendingEvent_lock       , Monitor, nonleaf,     false, Monitor::_safepoint_check_never);      // Used by JvmtiCodeBlobEvents
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   271
  def(Management_lock              , Mutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // used for JVM management
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   273
  def(Compile_lock                 , Mutex  , nonleaf+3,   true,  Monitor::_safepoint_check_sometimes);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   274
  def(MethodData_lock              , Mutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
31790
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31608
diff changeset
   275
  def(TouchedMethodLog_lock        , Mutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   277
  def(MethodCompileQueue_lock      , Monitor, nonleaf+4,   true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   278
  def(Debug2_lock                  , Mutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   279
  def(Debug3_lock                  , Mutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   280
  def(ProfileVM_lock               , Monitor, special,     false, Monitor::_safepoint_check_never);      // used for profiling of the VMThread
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   281
  def(CompileThread_lock           , Monitor, nonleaf+5,   false, Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   282
  def(PeriodicTask_lock            , Monitor, nonleaf+5,   true,  Monitor::_safepoint_check_sometimes);
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   283
  if (WhiteBoxAPI) {
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   284
    def(Compilation_lock           , Monitor, leaf,        false, Monitor::_safepoint_check_never);
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   285
  }
33097
96e348cb0442 8046148: JEP 158: Unified JVM Logging
mlarsson
parents: 32619
diff changeset
   286
  def(LogConfiguration_lock        , Mutex,   nonleaf,     false, 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
   287
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   288
#ifdef INCLUDE_TRACE
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   289
  def(JfrMsg_lock                  , Monitor, leaf,        true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   290
  def(JfrBuffer_lock               , Mutex,   leaf,        true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   291
  def(JfrThreadGroups_lock         , Mutex,   leaf,        true,  Monitor::_safepoint_check_always);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   292
  def(JfrStream_lock               , Mutex,   nonleaf,     true,  Monitor::_safepoint_check_never);
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   293
  def(JfrStacktrace_lock           , Mutex,   special,     true,  Monitor::_safepoint_check_sometimes);
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   294
#endif
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   295
27874
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   296
#ifndef SUPPORTS_NATIVE_CX8
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27874
diff changeset
   297
  def(UnsafeJlong_lock             , Mutex,   special,     false, Monitor::_safepoint_check_never);
27874
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java
dholmes
parents: 27645
diff changeset
   298
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
GCMutexLocker::GCMutexLocker(Monitor * mutex) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  if (SafepointSynchronize::is_at_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    _locked = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    _mutex = mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    _locked = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    _mutex->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
// Print all mutexes/monitors that are currently owned by a thread; called
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
// by fatal error handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
void print_owned_locks_on_error(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  st->print("VM Mutex/Monitor currently owned by a thread: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  bool none = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  for (int i = 0; i < _num_mutex; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
     // see if it has an owner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
     if (_mutex_array[i]->owner() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
       if (none) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
          // print format used by Mutex::print_on_error()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
          st->print_cr(" ([mutex/lock_event])");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
          none = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
       _mutex_array[i]->print_on_error(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
       st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  if (none) st->print_cr("None");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
}