Mercurial > hg > truffle
annotate src/share/vm/runtime/mutexLocker.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | da91efe96a93 |
| children | c284cf4781f0 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "runtime/mutexLocker.hpp" | |
| 27 #include "runtime/safepoint.hpp" | |
| 28 #include "runtime/threadLocalStorage.hpp" | |
| 29 #include "runtime/vmThread.hpp" | |
| 30 #ifdef TARGET_OS_FAMILY_linux | |
| 31 # include "thread_linux.inline.hpp" | |
| 32 #endif | |
| 33 #ifdef TARGET_OS_FAMILY_solaris | |
| 34 # include "thread_solaris.inline.hpp" | |
| 35 #endif | |
| 36 #ifdef TARGET_OS_FAMILY_windows | |
| 37 # include "thread_windows.inline.hpp" | |
| 38 #endif | |
| 3960 | 39 #ifdef TARGET_OS_FAMILY_bsd |
| 40 # include "thread_bsd.inline.hpp" | |
| 41 #endif | |
| 0 | 42 |
| 43 // Mutexes used in the VM (see comment in mutexLocker.hpp): | |
| 44 // | |
| 45 // Note that the following pointers are effectively final -- after having been | |
| 46 // set at JVM startup-time, they should never be subsequently mutated. | |
| 47 // Instead of using pointers to malloc()ed monitors and mutexes we should consider | |
| 48 // eliminating the indirection and using instances instead. | |
| 49 // Consider using GCC's __read_mostly. | |
| 50 | |
| 51 Mutex* Patching_lock = NULL; | |
| 52 Monitor* SystemDictionary_lock = NULL; | |
| 53 Mutex* PackageTable_lock = NULL; | |
| 54 Mutex* CompiledIC_lock = NULL; | |
| 55 Mutex* InlineCacheBuffer_lock = NULL; | |
| 56 Mutex* VMStatistic_lock = NULL; | |
| 57 Mutex* JNIGlobalHandle_lock = NULL; | |
| 58 Mutex* JNIHandleBlockFreeList_lock = NULL; | |
| 59 Mutex* JNICachedItableIndex_lock = NULL; | |
| 60 Mutex* JmethodIdCreation_lock = NULL; | |
| 61 Mutex* JfieldIdCreation_lock = NULL; | |
| 62 Monitor* JNICritical_lock = NULL; | |
| 63 Mutex* JvmtiThreadState_lock = NULL; | |
| 64 Monitor* JvmtiPendingEvent_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
65 Monitor* Heap_lock = NULL; |
| 0 | 66 Mutex* ExpandHeap_lock = NULL; |
| 67 Mutex* AdapterHandlerLibrary_lock = NULL; | |
| 68 Mutex* SignatureHandlerLibrary_lock = NULL; | |
| 69 Mutex* VtableStubs_lock = NULL; | |
| 70 Mutex* SymbolTable_lock = NULL; | |
| 71 Mutex* StringTable_lock = NULL; | |
| 72 Mutex* CodeCache_lock = NULL; | |
| 73 Mutex* MethodData_lock = NULL; | |
| 74 Mutex* RetData_lock = NULL; | |
| 75 Monitor* VMOperationQueue_lock = NULL; | |
| 76 Monitor* VMOperationRequest_lock = NULL; | |
| 77 Monitor* Safepoint_lock = NULL; | |
| 78 Monitor* SerializePage_lock = NULL; | |
| 79 Monitor* Threads_lock = NULL; | |
| 80 Monitor* CGC_lock = NULL; | |
| 81 Mutex* STS_init_lock = NULL; | |
| 82 Monitor* SLT_lock = NULL; | |
| 83 Monitor* iCMS_lock = NULL; | |
| 84 Monitor* FullGCCount_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
85 Monitor* CMark_lock = NULL; |
|
1358
72f725c5a7be
6940310: G1: MT-unsafe calls to CM::region_stack_push() / CM::region_stack_pop()
tonyp
parents:
844
diff
changeset
|
86 Mutex* CMRegionStack_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
87 Mutex* SATB_Q_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
88 Monitor* SATB_Q_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
89 Mutex* Shared_SATB_Q_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
90 Mutex* DirtyCardQ_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
91 Monitor* DirtyCardQ_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
92 Mutex* Shared_DirtyCardQ_lock = NULL; |
| 0 | 93 Mutex* ParGCRareEvent_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
94 Mutex* EvacFailureStack_lock = NULL; |
| 0 | 95 Mutex* DerivedPointerTableGC_lock = NULL; |
| 96 Mutex* Compile_lock = NULL; | |
| 97 Monitor* MethodCompileQueue_lock = NULL; | |
| 98 Monitor* CompileThread_lock = NULL; | |
| 99 Mutex* CompileTaskAlloc_lock = NULL; | |
| 100 Mutex* CompileStatistics_lock = NULL; | |
| 101 Mutex* MultiArray_lock = NULL; | |
| 102 Monitor* Terminator_lock = NULL; | |
| 103 Monitor* BeforeExit_lock = NULL; | |
| 104 Monitor* Notify_lock = NULL; | |
| 105 Monitor* Interrupt_lock = NULL; | |
| 106 Monitor* ProfileVM_lock = NULL; | |
| 107 Mutex* ProfilePrint_lock = NULL; | |
| 108 Mutex* ExceptionCache_lock = NULL; | |
| 109 Monitor* ObjAllocPost_lock = NULL; | |
| 110 Mutex* OsrList_lock = NULL; | |
| 111 #ifndef PRODUCT | |
| 112 Mutex* FullGCALot_lock = NULL; | |
| 113 #endif | |
| 114 | |
| 115 Mutex* Debug1_lock = NULL; | |
| 116 Mutex* Debug2_lock = NULL; | |
| 117 Mutex* Debug3_lock = NULL; | |
| 118 | |
| 119 Mutex* tty_lock = NULL; | |
| 120 | |
| 121 Mutex* RawMonitor_lock = NULL; | |
| 122 Mutex* PerfDataMemAlloc_lock = NULL; | |
| 123 Mutex* PerfDataManager_lock = NULL; | |
| 124 Mutex* OopMapCacheAlloc_lock = NULL; | |
| 125 | |
| 2152 | 126 Mutex* FreeList_lock = NULL; |
| 127 Monitor* SecondaryFreeList_lock = NULL; | |
| 128 Mutex* OldSets_lock = NULL; | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
129 Monitor* RootRegionScan_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
130 Mutex* MMUTracker_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
131 Mutex* HotCardCache_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
132 |
| 0 | 133 Monitor* GCTaskManager_lock = NULL; |
| 134 | |
| 135 Mutex* Management_lock = NULL; | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
136 Monitor* Service_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
137 Mutex* Stacktrace_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
138 |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
139 Monitor* JfrQuery_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
140 Monitor* JfrMsg_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
141 Mutex* JfrBuffer_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
142 Mutex* JfrStream_lock = NULL; |
| 0 | 143 |
| 144 #define MAX_NUM_MUTEX 128 | |
| 145 static Monitor * _mutex_array[MAX_NUM_MUTEX]; | |
| 146 static int _num_mutex; | |
| 147 | |
| 148 #ifdef ASSERT | |
| 149 void assert_locked_or_safepoint(const Monitor * lock) { | |
| 150 // check if this thread owns the lock (common case) | |
| 151 if (IgnoreLockingAssertions) return; | |
| 152 assert(lock != NULL, "Need non-NULL lock"); | |
| 153 if (lock->owned_by_self()) return; | |
| 154 if (SafepointSynchronize::is_at_safepoint()) return; | |
| 155 if (!Universe::is_fully_initialized()) return; | |
| 156 // see if invoker of VM operation owns it | |
| 157 VM_Operation* op = VMThread::vm_operation(); | |
| 158 if (op != NULL && op->calling_thread() == lock->owner()) return; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1358
diff
changeset
|
159 fatal(err_msg("must own lock %s", lock->name())); |
| 0 | 160 } |
| 161 | |
| 162 // a stronger assertion than the above | |
| 163 void assert_lock_strong(const Monitor * lock) { | |
| 164 if (IgnoreLockingAssertions) return; | |
| 165 assert(lock != NULL, "Need non-NULL lock"); | |
| 166 if (lock->owned_by_self()) return; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1358
diff
changeset
|
167 fatal(err_msg("must own lock %s", lock->name())); |
| 0 | 168 } |
| 169 #endif | |
| 170 | |
| 171 #define def(var, type, pri, vm_block) { \ | |
| 172 var = new type(Mutex::pri, #var, vm_block); \ | |
| 173 assert(_num_mutex < MAX_NUM_MUTEX, \ | |
| 174 "increase MAX_NUM_MUTEX"); \ | |
| 175 _mutex_array[_num_mutex++] = var; \ | |
| 176 } | |
| 177 | |
| 178 void mutex_init() { | |
| 179 def(tty_lock , Mutex , event, true ); // allow to lock in VM | |
| 180 | |
| 181 def(CGC_lock , Monitor, special, true ); // coordinate between fore- and background GC | |
| 182 def(STS_init_lock , Mutex, leaf, true ); | |
| 183 if (UseConcMarkSweepGC) { | |
| 184 def(iCMS_lock , Monitor, special, true ); // CMS incremental mode start/stop notification | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1584
diff
changeset
|
185 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1584
diff
changeset
|
186 if (UseConcMarkSweepGC || UseG1GC) { |
| 0 | 187 def(FullGCCount_lock , Monitor, leaf, true ); // in support of ExplicitGCInvokesConcurrent |
| 188 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
189 if (UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
190 def(CMark_lock , Monitor, nonleaf, true ); // coordinate concurrent mark thread |
|
1358
72f725c5a7be
6940310: G1: MT-unsafe calls to CM::region_stack_push() / CM::region_stack_pop()
tonyp
parents:
844
diff
changeset
|
191 def(CMRegionStack_lock , Mutex, leaf, true ); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
192 def(SATB_Q_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
193 def(SATB_Q_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
194 def(Shared_SATB_Q_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
195 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
196 def(DirtyCardQ_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
197 def(DirtyCardQ_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
198 def(Shared_DirtyCardQ_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
199 |
| 2152 | 200 def(FreeList_lock , Mutex, leaf , true ); |
| 201 def(SecondaryFreeList_lock , Monitor, leaf , true ); | |
| 202 def(OldSets_lock , Mutex , leaf , true ); | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
203 def(RootRegionScan_lock , Monitor, leaf , true ); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
204 def(MMUTracker_lock , Mutex , leaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
205 def(HotCardCache_lock , Mutex , special , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
206 def(EvacFailureStack_lock , Mutex , nonleaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
207 } |
| 0 | 208 def(ParGCRareEvent_lock , Mutex , leaf , true ); |
| 209 def(DerivedPointerTableGC_lock , Mutex, leaf, true ); | |
| 210 def(CodeCache_lock , Mutex , special, true ); | |
| 211 def(Interrupt_lock , Monitor, special, true ); // used for interrupt processing | |
| 212 def(RawMonitor_lock , Mutex, special, true ); | |
| 213 def(OopMapCacheAlloc_lock , Mutex, leaf, true ); // used for oop_map_cache allocation. | |
| 214 | |
| 215 def(Patching_lock , Mutex , special, true ); // used for safepointing and code patching. | |
| 216 def(ObjAllocPost_lock , Monitor, special, false); | |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2152
diff
changeset
|
217 def(Service_lock , Monitor, special, true ); // used for service thread operations |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
218 def(Stacktrace_lock , Mutex, special, true ); // used for JFR stacktrace database |
| 0 | 219 def(JmethodIdCreation_lock , Mutex , leaf, true ); // used for creating jmethodIDs. |
| 220 | |
| 221 def(SystemDictionary_lock , Monitor, leaf, true ); // lookups done by VM thread | |
| 222 def(PackageTable_lock , Mutex , leaf, false); | |
| 223 def(InlineCacheBuffer_lock , Mutex , leaf, true ); | |
| 224 def(VMStatistic_lock , Mutex , leaf, false); | |
| 225 def(ExpandHeap_lock , Mutex , leaf, true ); // Used during compilation by VM thread | |
| 226 def(JNIHandleBlockFreeList_lock , Mutex , leaf, true ); // handles are used by VM thread | |
| 227 def(SignatureHandlerLibrary_lock , Mutex , leaf, false); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4840
diff
changeset
|
228 def(SymbolTable_lock , Mutex , leaf+2, true ); |
| 0 | 229 def(StringTable_lock , Mutex , leaf, true ); |
| 230 def(ProfilePrint_lock , Mutex , leaf, false); // serial profile printing | |
| 231 def(ExceptionCache_lock , Mutex , leaf, false); // serial profile printing | |
| 232 def(OsrList_lock , Mutex , leaf, true ); | |
| 233 def(Debug1_lock , Mutex , leaf, true ); | |
| 234 #ifndef PRODUCT | |
| 235 def(FullGCALot_lock , Mutex , leaf, false); // a lock to make FullGCALot MT safe | |
| 236 #endif | |
| 237 def(BeforeExit_lock , Monitor, leaf, true ); | |
| 238 def(PerfDataMemAlloc_lock , Mutex , leaf, true ); // used for allocating PerfData memory for performance data | |
| 239 def(PerfDataManager_lock , Mutex , leaf, true ); // used for synchronized access to PerfDataManager resources | |
| 240 | |
| 241 // CMS_modUnionTable_lock leaf | |
| 242 // CMS_bitMap_lock leaf + 1 | |
| 243 // CMS_freeList_lock leaf + 2 | |
| 244 | |
| 245 def(Safepoint_lock , Monitor, safepoint, true ); // locks SnippetCache_lock/Threads_lock | |
| 246 | |
| 247 def(Threads_lock , Monitor, barrier, true ); | |
| 248 | |
| 249 def(VMOperationQueue_lock , Monitor, nonleaf, true ); // VM_thread allowed to block on these | |
| 250 def(VMOperationRequest_lock , Monitor, nonleaf, true ); | |
| 251 def(RetData_lock , Mutex , nonleaf, false); | |
| 252 def(Terminator_lock , Monitor, nonleaf, true ); | |
| 253 def(VtableStubs_lock , Mutex , nonleaf, true ); | |
| 254 def(Notify_lock , Monitor, nonleaf, true ); | |
| 255 def(JNIGlobalHandle_lock , Mutex , nonleaf, true ); // locks JNIHandleBlockFreeList_lock | |
| 256 def(JNICritical_lock , Monitor, nonleaf, true ); // used for JNI critical regions | |
| 257 def(AdapterHandlerLibrary_lock , Mutex , nonleaf, true); | |
| 258 if (UseConcMarkSweepGC) { | |
| 259 def(SLT_lock , Monitor, nonleaf, false ); | |
| 260 // used in CMS GC for locking PLL lock | |
| 261 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
262 def(Heap_lock , Monitor, nonleaf+1, false); |
| 0 | 263 def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation |
| 264 def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke | |
| 265 | |
| 266 def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock | |
| 267 def(CompileTaskAlloc_lock , Mutex , nonleaf+2, true ); | |
| 268 def(CompileStatistics_lock , Mutex , nonleaf+2, false); | |
| 269 def(MultiArray_lock , Mutex , nonleaf+2, false); // locks SymbolTable_lock | |
| 270 | |
| 271 def(JvmtiThreadState_lock , Mutex , nonleaf+2, false); // Used by JvmtiThreadState/JvmtiEventController | |
| 272 def(JvmtiPendingEvent_lock , Monitor, nonleaf, false); // Used by JvmtiCodeBlobEvents | |
| 273 def(Management_lock , Mutex , nonleaf+2, false); // used for JVM management | |
| 274 | |
| 275 def(Compile_lock , Mutex , nonleaf+3, true ); | |
| 276 def(MethodData_lock , Mutex , nonleaf+3, false); | |
| 277 | |
| 278 def(MethodCompileQueue_lock , Monitor, nonleaf+4, true ); | |
| 279 def(Debug2_lock , Mutex , nonleaf+4, true ); | |
| 280 def(Debug3_lock , Mutex , nonleaf+4, true ); | |
| 281 def(ProfileVM_lock , Monitor, nonleaf+4, false); // used for profiling of the VMThread | |
| 282 def(CompileThread_lock , Monitor, nonleaf+5, false ); | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
283 |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
284 def(JfrQuery_lock , Monitor, nonleaf, true); // JFR locks, keep these in consecutive order |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
285 def(JfrMsg_lock , Monitor, nonleaf+2, true); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
286 def(JfrBuffer_lock , Mutex, nonleaf+3, true); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
287 def(JfrStream_lock , Mutex, nonleaf+4, true); |
| 0 | 288 } |
| 289 | |
| 290 GCMutexLocker::GCMutexLocker(Monitor * mutex) { | |
| 291 if (SafepointSynchronize::is_at_safepoint()) { | |
| 292 _locked = false; | |
| 293 } else { | |
| 294 _mutex = mutex; | |
| 295 _locked = true; | |
| 296 _mutex->lock(); | |
| 297 } | |
| 298 } | |
| 299 | |
| 300 // Print all mutexes/monitors that are currently owned by a thread; called | |
| 301 // by fatal error handler. | |
| 302 void print_owned_locks_on_error(outputStream* st) { | |
| 303 st->print("VM Mutex/Monitor currently owned by a thread: "); | |
| 304 bool none = true; | |
| 305 for (int i = 0; i < _num_mutex; i++) { | |
| 306 // see if it has an owner | |
| 307 if (_mutex_array[i]->owner() != NULL) { | |
| 308 if (none) { | |
| 309 // print format used by Mutex::print_on_error() | |
| 310 st->print_cr(" ([mutex/lock_event])"); | |
| 311 none = false; | |
| 312 } | |
| 313 _mutex_array[i]->print_on_error(st); | |
| 314 st->cr(); | |
| 315 } | |
| 316 } | |
| 317 if (none) st->print_cr("None"); | |
| 318 } |