hotspot/src/share/vm/runtime/mutexLocker.cpp
author drchase
Thu, 13 Nov 2014 11:35:15 -0500
changeset 27645 8fe155d119af
parent 27628 b655b90d98f4
parent 27642 8c9eff693145
child 27874 e9b44eb1613f
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
23472
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
     2
 * Copyright (c) 1997, 2014, 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;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
Mutex*   RetData_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
Monitor* VMOperationQueue_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
Monitor* VMOperationRequest_lock      = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
Monitor* Safepoint_lock               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
Monitor* SerializePage_lock           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
Monitor* Threads_lock                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
Monitor* CGC_lock                     = NULL;
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 23472
diff changeset
    73
Monitor* STS_lock                     = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
Monitor* SLT_lock                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
Monitor* FullGCCount_lock             = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    76
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
    77
Mutex*   CMRegionStack_lock           = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    78
Mutex*   SATB_Q_FL_lock               = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    79
Monitor* SATB_Q_CBL_mon               = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    80
Mutex*   Shared_SATB_Q_lock           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    81
Mutex*   DirtyCardQ_FL_lock           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    82
Monitor* DirtyCardQ_CBL_mon           = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    83
Mutex*   Shared_DirtyCardQ_lock       = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
Mutex*   ParGCRareEvent_lock          = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
    85
Mutex*   EvacFailureStack_lock        = NULL;
1
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;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
Mutex*   FullGCALot_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
Mutex*   Debug1_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
Mutex*   Debug2_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
Mutex*   Debug3_lock                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
Mutex*   tty_lock                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
Mutex*   RawMonitor_lock              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
Mutex*   PerfDataMemAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
Mutex*   PerfDataManager_lock         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
Mutex*   OopMapCacheAlloc_lock        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   118
Mutex*   FreeList_lock                = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   119
Monitor* SecondaryFreeList_lock       = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   120
Mutex*   OldSets_lock                 = NULL;
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 10565
diff changeset
   121
Monitor* RootRegionScan_lock          = NULL;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   122
Mutex*   MMUTracker_lock              = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   123
Mutex*   HotCardCache_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;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   130
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   131
#ifdef INCLUDE_TRACE
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   132
Mutex*   JfrStacktrace_lock           = NULL;
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   133
Monitor* JfrMsg_lock                  = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   134
Mutex*   JfrBuffer_lock               = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10565
diff changeset
   135
Mutex*   JfrStream_lock               = NULL;
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   136
Mutex*   JfrThreadGroups_lock         = NULL;
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   137
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
#define MAX_NUM_MUTEX 128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
static Monitor * _mutex_array[MAX_NUM_MUTEX];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
static int _num_mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
void assert_locked_or_safepoint(const Monitor * lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // check if this thread owns the lock (common case)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  if (lock->owned_by_self()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  if (SafepointSynchronize::is_at_safepoint()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  if (!Universe::is_fully_initialized()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // see if invoker of VM operation owns it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  VM_Operation* op = VMThread::vm_operation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  if (op != NULL && op->calling_thread() == lock->owner()) return;
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 5242
diff changeset
   154
  fatal(err_msg("must own lock %s", lock->name()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
// a stronger assertion than the above
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
void assert_lock_strong(const Monitor * lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  if (lock->owned_by_self()) return;
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 5242
diff changeset
   162
  fatal(err_msg("must own lock %s", lock->name()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
#define def(var, type, pri, vm_block) {                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  var = new type(Mutex::pri, #var, vm_block);                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  assert(_num_mutex < MAX_NUM_MUTEX,                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
                    "increase MAX_NUM_MUTEX");                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  _mutex_array[_num_mutex++] = var;                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
void mutex_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  def(tty_lock                     , Mutex  , event,       true ); // allow to lock in VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  def(CGC_lock                   , Monitor, special,     true ); // coordinate between fore- and background GC
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 23472
diff changeset
   177
  def(STS_lock                   , Monitor, leaf,        true );
6058
9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 5707
diff changeset
   178
  if (UseConcMarkSweepGC || UseG1GC) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    def(FullGCCount_lock           , Monitor, leaf,        true ); // in support of ExplicitGCInvokesConcurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   181
  if (UseG1GC) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   182
    def(CMark_lock                 , Monitor, nonleaf,     true ); // coordinate concurrent mark thread
5242
85cf92183e39 6940310: G1: MT-unsafe calls to CM::region_stack_push() / CM::region_stack_pop()
tonyp
parents: 3261
diff changeset
   183
    def(CMRegionStack_lock         , Mutex,   leaf,        true );
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   184
    def(SATB_Q_FL_lock             , Mutex  , special,     true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   185
    def(SATB_Q_CBL_mon             , Monitor, nonleaf,     true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   186
    def(Shared_SATB_Q_lock         , Mutex,   nonleaf,     true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   187
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   188
    def(DirtyCardQ_FL_lock         , Mutex  , special,     true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   189
    def(DirtyCardQ_CBL_mon         , Monitor, nonleaf,     true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   190
    def(Shared_DirtyCardQ_lock     , Mutex,   nonleaf,     true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   191
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   192
    def(FreeList_lock              , Mutex,   leaf     ,   true );
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   193
    def(SecondaryFreeList_lock     , Monitor, leaf     ,   true );
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7397
diff changeset
   194
    def(OldSets_lock               , Mutex  , leaf     ,   true );
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 10565
diff changeset
   195
    def(RootRegionScan_lock        , Monitor, leaf     ,   true );
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   196
    def(MMUTracker_lock            , Mutex  , leaf     ,   true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   197
    def(HotCardCache_lock          , Mutex  , special  ,   true );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   198
    def(EvacFailureStack_lock      , Mutex  , nonleaf  ,   true );
23472
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
   199
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
   200
    def(StringDedupQueue_lock      , Monitor, leaf,        true );
35e93890ed88 8029075: String deduplication in G1
pliden
parents: 20017
diff changeset
   201
    def(StringDedupTable_lock      , Mutex  , leaf,        true );
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   202
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  def(ParGCRareEvent_lock          , Mutex  , leaf     ,   true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  def(DerivedPointerTableGC_lock   , Mutex,   leaf,        true );
27420
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 25468
diff changeset
   205
  def(CodeCache_lock               , Monitor, special,     true );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  def(Interrupt_lock               , Monitor, special,     true ); // used for interrupt processing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  def(RawMonitor_lock              , Mutex,   special,     true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  def(OopMapCacheAlloc_lock        , Mutex,   leaf,        true ); // used for oop_map_cache allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  def(Patching_lock                , Mutex  , special,     true ); // used for safepointing and code patching.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  def(ObjAllocPost_lock            , Monitor, special,     false);
8110
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7923
diff changeset
   212
  def(Service_lock                 , Monitor, special,     true ); // used for service thread operations
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  def(JmethodIdCreation_lock       , Mutex  , leaf,        true ); // used for creating jmethodIDs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  def(SystemDictionary_lock        , Monitor, leaf,        true ); // lookups done by VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  def(PackageTable_lock            , Mutex  , leaf,        false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  def(InlineCacheBuffer_lock       , Mutex  , leaf,        true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  def(VMStatistic_lock             , Mutex  , leaf,        false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  def(ExpandHeap_lock              , Mutex  , leaf,        true ); // Used during compilation by VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  def(JNIHandleBlockFreeList_lock  , Mutex  , leaf,        true ); // handles are used by VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  def(SignatureHandlerLibrary_lock , Mutex  , leaf,        false);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 11587
diff changeset
   222
  def(SymbolTable_lock             , Mutex  , leaf+2,      true );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  def(StringTable_lock             , Mutex  , leaf,        true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  def(ProfilePrint_lock            , Mutex  , leaf,        false); // serial profile printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  def(ExceptionCache_lock          , Mutex  , leaf,        false); // serial profile printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  def(OsrList_lock                 , Mutex  , leaf,        true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  def(Debug1_lock                  , Mutex  , leaf,        true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  def(FullGCALot_lock              , Mutex  , leaf,        false); // a lock to make FullGCALot MT safe
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  def(BeforeExit_lock              , Monitor, leaf,        true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  def(PerfDataMemAlloc_lock        , Mutex  , leaf,        true ); // used for allocating PerfData memory for performance data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  def(PerfDataManager_lock         , Mutex  , leaf,        true ); // used for synchronized access to PerfDataManager resources
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  // CMS_modUnionTable_lock                   leaf
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // CMS_bitMap_lock                          leaf + 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // CMS_freeList_lock                        leaf + 2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  def(Safepoint_lock               , Monitor, safepoint,   true ); // locks SnippetCache_lock/Threads_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  def(Threads_lock                 , Monitor, barrier,     true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  def(VMOperationQueue_lock        , Monitor, nonleaf,     true ); // VM_thread allowed to block on these
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  def(VMOperationRequest_lock      , Monitor, nonleaf,     true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  def(RetData_lock                 , Mutex  , nonleaf,     false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  def(Terminator_lock              , Monitor, nonleaf,     true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  def(VtableStubs_lock             , Mutex  , nonleaf,     true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  def(Notify_lock                  , Monitor, nonleaf,     true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  def(JNIGlobalHandle_lock         , Mutex  , nonleaf,     true ); // locks JNIHandleBlockFreeList_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  def(JNICritical_lock             , Monitor, nonleaf,     true ); // used for JNI critical regions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  def(AdapterHandlerLibrary_lock   , Mutex  , nonleaf,     true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  if (UseConcMarkSweepGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
    def(SLT_lock                   , Monitor, nonleaf,     false );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
                    // used in CMS GC for locking PLL lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 228
diff changeset
   256
  def(Heap_lock                    , Monitor, nonleaf+1,   false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  def(JfieldIdCreation_lock        , Mutex  , nonleaf+1,   true ); // jfieldID, Used in VM_Operation
17029
9ff8d7c0ed79 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents: 14583
diff changeset
   258
  def(MemberNameTable_lock         , Mutex  , nonleaf+1,   false); // Used to protect MemberNameTable
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  def(CompiledIC_lock              , Mutex  , nonleaf+2,   false); // locks VtableStubs_lock, InlineCacheBuffer_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  def(CompileTaskAlloc_lock        , Mutex  , nonleaf+2,   true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  def(CompileStatistics_lock       , Mutex  , nonleaf+2,   false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  def(MultiArray_lock              , Mutex  , nonleaf+2,   false); // locks SymbolTable_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  def(JvmtiThreadState_lock        , Mutex  , nonleaf+2,   false); // Used by JvmtiThreadState/JvmtiEventController
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  def(JvmtiPendingEvent_lock       , Monitor, nonleaf,     false); // Used by JvmtiCodeBlobEvents
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  def(Management_lock              , Mutex  , nonleaf+2,   false); // used for JVM management
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  def(Compile_lock                 , Mutex  , nonleaf+3,   true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  def(MethodData_lock              , Mutex  , nonleaf+3,   false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  def(MethodCompileQueue_lock      , Monitor, nonleaf+4,   true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  def(Debug2_lock                  , Mutex  , nonleaf+4,   true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  def(Debug3_lock                  , Mutex  , nonleaf+4,   true );
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17029
diff changeset
   275
  def(ProfileVM_lock               , Monitor, special,   false); // used for profiling of the VMThread
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  def(CompileThread_lock           , Monitor, nonleaf+5,   false );
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   277
  def(PeriodicTask_lock            , Monitor, nonleaf+5,   true);
27642
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   278
  if (WhiteBoxAPI) {
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   279
    def(Compilation_lock           , Monitor, leaf,        false );
8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents: 27420
diff changeset
   280
  }
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   281
#ifdef INCLUDE_TRACE
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17029
diff changeset
   282
  def(JfrMsg_lock                  , Monitor, leaf,        true);
24839
109aa8e66829 8044531: Event based tracing locks to rank as leafs where possible
mgronlun
parents: 24094
diff changeset
   283
  def(JfrBuffer_lock               , Mutex,   leaf,        true);
109aa8e66829 8044531: Event based tracing locks to rank as leafs where possible
mgronlun
parents: 24094
diff changeset
   284
  def(JfrThreadGroups_lock         , Mutex,   leaf,        true);
109aa8e66829 8044531: Event based tracing locks to rank as leafs where possible
mgronlun
parents: 24094
diff changeset
   285
  def(JfrStream_lock               , Mutex,   nonleaf,     true);
109aa8e66829 8044531: Event based tracing locks to rank as leafs where possible
mgronlun
parents: 24094
diff changeset
   286
  def(JfrStacktrace_lock           , Mutex,   special,     true);
19542
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   287
#endif
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups
mgronlun
parents: 18025
diff changeset
   288
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
GCMutexLocker::GCMutexLocker(Monitor * mutex) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  if (SafepointSynchronize::is_at_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    _locked = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    _mutex = mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    _locked = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
    _mutex->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
// Print all mutexes/monitors that are currently owned by a thread; called
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
// by fatal error handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
void print_owned_locks_on_error(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  st->print("VM Mutex/Monitor currently owned by a thread: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  bool none = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  for (int i = 0; i < _num_mutex; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
     // see if it has an owner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
     if (_mutex_array[i]->owner() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
       if (none) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
          // print format used by Mutex::print_on_error()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
          st->print_cr(" ([mutex/lock_event])");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
          none = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
       _mutex_array[i]->print_on_error(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
       st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  if (none) st->print_cr("None");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
}