Mercurial > hg > truffle
annotate src/share/vm/runtime/mutexLocker.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 291ffc492eb6 |
| children | 836a62f43af9 |
| 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" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6939
diff
changeset
|
28 #include "runtime/thread.inline.hpp" |
| 1972 | 29 #include "runtime/threadLocalStorage.hpp" |
| 30 #include "runtime/vmThread.hpp" | |
| 0 | 31 |
| 32 // Mutexes used in the VM (see comment in mutexLocker.hpp): | |
| 33 // | |
| 34 // Note that the following pointers are effectively final -- after having been | |
| 35 // set at JVM startup-time, they should never be subsequently mutated. | |
| 36 // Instead of using pointers to malloc()ed monitors and mutexes we should consider | |
| 37 // eliminating the indirection and using instances instead. | |
| 38 // Consider using GCC's __read_mostly. | |
| 39 | |
| 40 Mutex* Patching_lock = NULL; | |
| 41 Monitor* SystemDictionary_lock = NULL; | |
| 42 Mutex* PackageTable_lock = NULL; | |
| 43 Mutex* CompiledIC_lock = NULL; | |
| 44 Mutex* InlineCacheBuffer_lock = NULL; | |
| 45 Mutex* VMStatistic_lock = NULL; | |
| 46 Mutex* JNIGlobalHandle_lock = NULL; | |
| 47 Mutex* JNIHandleBlockFreeList_lock = NULL; | |
| 48 Mutex* JNICachedItableIndex_lock = NULL; | |
| 49 Mutex* JmethodIdCreation_lock = NULL; | |
| 50 Mutex* JfieldIdCreation_lock = NULL; | |
| 51 Monitor* JNICritical_lock = NULL; | |
| 52 Mutex* JvmtiThreadState_lock = NULL; | |
| 53 Monitor* JvmtiPendingEvent_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
54 Monitor* Heap_lock = NULL; |
| 0 | 55 Mutex* ExpandHeap_lock = NULL; |
| 56 Mutex* AdapterHandlerLibrary_lock = NULL; | |
| 57 Mutex* SignatureHandlerLibrary_lock = NULL; | |
| 58 Mutex* VtableStubs_lock = NULL; | |
| 59 Mutex* SymbolTable_lock = NULL; | |
| 60 Mutex* StringTable_lock = NULL; | |
| 61 Mutex* CodeCache_lock = NULL; | |
| 62 Mutex* MethodData_lock = NULL; | |
| 63 Mutex* RetData_lock = NULL; | |
| 64 Monitor* VMOperationQueue_lock = NULL; | |
| 65 Monitor* VMOperationRequest_lock = NULL; | |
| 66 Monitor* Safepoint_lock = NULL; | |
| 67 Monitor* SerializePage_lock = NULL; | |
| 68 Monitor* Threads_lock = NULL; | |
| 69 Monitor* CGC_lock = NULL; | |
| 70 Mutex* STS_init_lock = NULL; | |
| 71 Monitor* SLT_lock = NULL; | |
| 72 Monitor* iCMS_lock = NULL; | |
| 73 Monitor* FullGCCount_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
74 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
|
75 Mutex* CMRegionStack_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
76 Mutex* SATB_Q_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
77 Monitor* SATB_Q_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
78 Mutex* Shared_SATB_Q_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
79 Mutex* DirtyCardQ_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
80 Monitor* DirtyCardQ_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
81 Mutex* Shared_DirtyCardQ_lock = NULL; |
| 0 | 82 Mutex* ParGCRareEvent_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
83 Mutex* EvacFailureStack_lock = NULL; |
| 0 | 84 Mutex* DerivedPointerTableGC_lock = NULL; |
| 85 Mutex* Compile_lock = NULL; | |
| 86 Monitor* MethodCompileQueue_lock = NULL; | |
| 87 Monitor* CompileThread_lock = NULL; | |
| 88 Mutex* CompileTaskAlloc_lock = NULL; | |
| 89 Mutex* CompileStatistics_lock = NULL; | |
| 90 Mutex* MultiArray_lock = NULL; | |
| 91 Monitor* Terminator_lock = NULL; | |
| 92 Monitor* BeforeExit_lock = NULL; | |
| 93 Monitor* Notify_lock = NULL; | |
| 94 Monitor* Interrupt_lock = NULL; | |
| 95 Monitor* ProfileVM_lock = NULL; | |
| 96 Mutex* ProfilePrint_lock = NULL; | |
| 97 Mutex* ExceptionCache_lock = NULL; | |
| 98 Monitor* ObjAllocPost_lock = NULL; | |
| 99 Mutex* OsrList_lock = NULL; | |
| 100 #ifndef PRODUCT | |
| 101 Mutex* FullGCALot_lock = NULL; | |
| 102 #endif | |
| 103 | |
| 104 Mutex* Debug1_lock = NULL; | |
| 105 Mutex* Debug2_lock = NULL; | |
| 106 Mutex* Debug3_lock = NULL; | |
| 107 | |
| 108 Mutex* tty_lock = NULL; | |
| 109 | |
| 110 Mutex* RawMonitor_lock = NULL; | |
| 111 Mutex* PerfDataMemAlloc_lock = NULL; | |
| 112 Mutex* PerfDataManager_lock = NULL; | |
| 113 Mutex* OopMapCacheAlloc_lock = NULL; | |
| 114 | |
| 2152 | 115 Mutex* FreeList_lock = NULL; |
| 116 Monitor* SecondaryFreeList_lock = NULL; | |
| 117 Mutex* OldSets_lock = NULL; | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
118 Monitor* RootRegionScan_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
119 Mutex* MMUTracker_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
120 Mutex* HotCardCache_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
121 |
| 0 | 122 Monitor* GCTaskManager_lock = NULL; |
| 123 | |
| 124 Mutex* Management_lock = NULL; | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
125 Monitor* Service_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
126 Mutex* Stacktrace_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
127 |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
128 Monitor* JfrQuery_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
129 Monitor* JfrMsg_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
130 Mutex* JfrBuffer_lock = NULL; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
131 Mutex* JfrStream_lock = NULL; |
|
6939
c284cf4781f0
7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents:
6725
diff
changeset
|
132 Monitor* PeriodicTask_lock = NULL; |
| 0 | 133 |
|
5129
51111665eda6
Support for recording a leaf graph id for each deoptimization point in the debug info.
Lukas Stadler <lukas.stadler@jku.at>
parents:
4840
diff
changeset
|
134 #ifdef GRAAL |
|
51111665eda6
Support for recording a leaf graph id for each deoptimization point in the debug info.
Lukas Stadler <lukas.stadler@jku.at>
parents:
4840
diff
changeset
|
135 Mutex* GraalDeoptLeafGraphIds_lock = NULL; |
|
51111665eda6
Support for recording a leaf graph id for each deoptimization point in the debug info.
Lukas Stadler <lukas.stadler@jku.at>
parents:
4840
diff
changeset
|
136 #endif // GRAAL |
|
51111665eda6
Support for recording a leaf graph id for each deoptimization point in the debug info.
Lukas Stadler <lukas.stadler@jku.at>
parents:
4840
diff
changeset
|
137 |
| 0 | 138 #define MAX_NUM_MUTEX 128 |
| 139 static Monitor * _mutex_array[MAX_NUM_MUTEX]; | |
| 140 static int _num_mutex; | |
| 141 | |
| 142 #ifdef ASSERT | |
| 143 void assert_locked_or_safepoint(const Monitor * lock) { | |
| 144 // check if this thread owns the lock (common case) | |
| 145 if (IgnoreLockingAssertions) return; | |
| 146 assert(lock != NULL, "Need non-NULL lock"); | |
| 147 if (lock->owned_by_self()) return; | |
| 148 if (SafepointSynchronize::is_at_safepoint()) return; | |
| 149 if (!Universe::is_fully_initialized()) return; | |
| 150 // see if invoker of VM operation owns it | |
| 151 VM_Operation* op = VMThread::vm_operation(); | |
| 152 if (op != NULL && op->calling_thread() == lock->owner()) return; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1358
diff
changeset
|
153 fatal(err_msg("must own lock %s", lock->name())); |
| 0 | 154 } |
| 155 | |
| 156 // a stronger assertion than the above | |
| 157 void assert_lock_strong(const Monitor * lock) { | |
| 158 if (IgnoreLockingAssertions) return; | |
| 159 assert(lock != NULL, "Need non-NULL lock"); | |
| 160 if (lock->owned_by_self()) return; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1358
diff
changeset
|
161 fatal(err_msg("must own lock %s", lock->name())); |
| 0 | 162 } |
| 163 #endif | |
| 164 | |
| 165 #define def(var, type, pri, vm_block) { \ | |
| 166 var = new type(Mutex::pri, #var, vm_block); \ | |
| 167 assert(_num_mutex < MAX_NUM_MUTEX, \ | |
| 168 "increase MAX_NUM_MUTEX"); \ | |
| 169 _mutex_array[_num_mutex++] = var; \ | |
| 170 } | |
| 171 | |
| 172 void mutex_init() { | |
| 173 def(tty_lock , Mutex , event, true ); // allow to lock in VM | |
| 174 | |
| 175 def(CGC_lock , Monitor, special, true ); // coordinate between fore- and background GC | |
| 176 def(STS_init_lock , Mutex, leaf, true ); | |
| 177 if (UseConcMarkSweepGC) { | |
| 178 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
|
179 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1584
diff
changeset
|
180 if (UseConcMarkSweepGC || UseG1GC) { |
| 0 | 181 def(FullGCCount_lock , Monitor, leaf, true ); // in support of ExplicitGCInvokesConcurrent |
| 182 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
183 if (UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
184 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
|
185 def(CMRegionStack_lock , Mutex, leaf, true ); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
186 def(SATB_Q_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
187 def(SATB_Q_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
188 def(Shared_SATB_Q_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
189 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
190 def(DirtyCardQ_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
191 def(DirtyCardQ_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
192 def(Shared_DirtyCardQ_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
193 |
| 2152 | 194 def(FreeList_lock , Mutex, leaf , true ); |
| 195 def(SecondaryFreeList_lock , Monitor, leaf , true ); | |
| 196 def(OldSets_lock , Mutex , leaf , true ); | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
197 def(RootRegionScan_lock , Monitor, leaf , true ); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
198 def(MMUTracker_lock , Mutex , leaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
199 def(HotCardCache_lock , Mutex , special , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
200 def(EvacFailureStack_lock , Mutex , nonleaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
201 } |
| 0 | 202 def(ParGCRareEvent_lock , Mutex , leaf , true ); |
| 203 def(DerivedPointerTableGC_lock , Mutex, leaf, true ); | |
| 204 def(CodeCache_lock , Mutex , special, true ); | |
| 205 def(Interrupt_lock , Monitor, special, true ); // used for interrupt processing | |
| 206 def(RawMonitor_lock , Mutex, special, true ); | |
| 207 def(OopMapCacheAlloc_lock , Mutex, leaf, true ); // used for oop_map_cache allocation. | |
| 208 | |
| 209 def(Patching_lock , Mutex , special, true ); // used for safepointing and code patching. | |
| 210 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
|
211 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
|
212 def(Stacktrace_lock , Mutex, special, true ); // used for JFR stacktrace database |
| 0 | 213 def(JmethodIdCreation_lock , Mutex , leaf, true ); // used for creating jmethodIDs. |
| 214 | |
| 215 def(SystemDictionary_lock , Monitor, leaf, true ); // lookups done by VM thread | |
| 216 def(PackageTable_lock , Mutex , leaf, false); | |
| 217 def(InlineCacheBuffer_lock , Mutex , leaf, true ); | |
| 218 def(VMStatistic_lock , Mutex , leaf, false); | |
| 219 def(ExpandHeap_lock , Mutex , leaf, true ); // Used during compilation by VM thread | |
| 220 def(JNIHandleBlockFreeList_lock , Mutex , leaf, true ); // handles are used by VM thread | |
| 221 def(SignatureHandlerLibrary_lock , Mutex , leaf, false); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4840
diff
changeset
|
222 def(SymbolTable_lock , Mutex , leaf+2, true ); |
| 0 | 223 def(StringTable_lock , Mutex , leaf, true ); |
| 224 def(ProfilePrint_lock , Mutex , leaf, false); // serial profile printing | |
| 225 def(ExceptionCache_lock , Mutex , leaf, false); // serial profile printing | |
| 226 def(OsrList_lock , Mutex , leaf, true ); | |
| 227 def(Debug1_lock , Mutex , leaf, true ); | |
| 228 #ifndef PRODUCT | |
| 229 def(FullGCALot_lock , Mutex , leaf, false); // a lock to make FullGCALot MT safe | |
| 230 #endif | |
| 231 def(BeforeExit_lock , Monitor, leaf, true ); | |
| 232 def(PerfDataMemAlloc_lock , Mutex , leaf, true ); // used for allocating PerfData memory for performance data | |
| 233 def(PerfDataManager_lock , Mutex , leaf, true ); // used for synchronized access to PerfDataManager resources | |
| 234 | |
| 235 // CMS_modUnionTable_lock leaf | |
| 236 // CMS_bitMap_lock leaf + 1 | |
| 237 // CMS_freeList_lock leaf + 2 | |
| 238 | |
| 239 def(Safepoint_lock , Monitor, safepoint, true ); // locks SnippetCache_lock/Threads_lock | |
| 240 | |
| 241 def(Threads_lock , Monitor, barrier, true ); | |
| 242 | |
| 243 def(VMOperationQueue_lock , Monitor, nonleaf, true ); // VM_thread allowed to block on these | |
| 244 def(VMOperationRequest_lock , Monitor, nonleaf, true ); | |
| 245 def(RetData_lock , Mutex , nonleaf, false); | |
| 246 def(Terminator_lock , Monitor, nonleaf, true ); | |
| 247 def(VtableStubs_lock , Mutex , nonleaf, true ); | |
| 248 def(Notify_lock , Monitor, nonleaf, true ); | |
| 249 def(JNIGlobalHandle_lock , Mutex , nonleaf, true ); // locks JNIHandleBlockFreeList_lock | |
| 250 def(JNICritical_lock , Monitor, nonleaf, true ); // used for JNI critical regions | |
| 251 def(AdapterHandlerLibrary_lock , Mutex , nonleaf, true); | |
| 252 if (UseConcMarkSweepGC) { | |
| 253 def(SLT_lock , Monitor, nonleaf, false ); | |
| 254 // used in CMS GC for locking PLL lock | |
| 255 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
256 def(Heap_lock , Monitor, nonleaf+1, false); |
| 0 | 257 def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation |
| 258 def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke | |
| 259 | |
| 260 def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock | |
| 261 def(CompileTaskAlloc_lock , Mutex , nonleaf+2, true ); | |
| 262 def(CompileStatistics_lock , Mutex , nonleaf+2, false); | |
| 263 def(MultiArray_lock , Mutex , nonleaf+2, false); // locks SymbolTable_lock | |
| 264 | |
| 265 def(JvmtiThreadState_lock , Mutex , nonleaf+2, false); // Used by JvmtiThreadState/JvmtiEventController | |
| 266 def(JvmtiPendingEvent_lock , Monitor, nonleaf, false); // Used by JvmtiCodeBlobEvents | |
| 267 def(Management_lock , Mutex , nonleaf+2, false); // used for JVM management | |
| 268 | |
| 269 def(Compile_lock , Mutex , nonleaf+3, true ); | |
| 270 def(MethodData_lock , Mutex , nonleaf+3, false); | |
| 271 | |
| 272 def(MethodCompileQueue_lock , Monitor, nonleaf+4, true ); | |
| 273 def(Debug2_lock , Mutex , nonleaf+4, true ); | |
| 274 def(Debug3_lock , Mutex , nonleaf+4, true ); | |
| 275 def(ProfileVM_lock , Monitor, nonleaf+4, false); // used for profiling of the VMThread | |
| 276 def(CompileThread_lock , Monitor, nonleaf+5, false ); | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
277 |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
278 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
|
279 def(JfrMsg_lock , Monitor, nonleaf+2, true); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
280 def(JfrBuffer_lock , Mutex, nonleaf+3, true); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
281 def(JfrStream_lock , Mutex, nonleaf+4, true); |
|
6939
c284cf4781f0
7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents:
6725
diff
changeset
|
282 def(PeriodicTask_lock , Monitor, nonleaf+5, true); |
|
5129
51111665eda6
Support for recording a leaf graph id for each deoptimization point in the debug info.
Lukas Stadler <lukas.stadler@jku.at>
parents:
4840
diff
changeset
|
283 #ifdef GRAAL |
|
7154
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6948
diff
changeset
|
284 def(GraalDeoptLeafGraphIds_lock , Mutex, special, true); |
|
5129
51111665eda6
Support for recording a leaf graph id for each deoptimization point in the debug info.
Lukas Stadler <lukas.stadler@jku.at>
parents:
4840
diff
changeset
|
285 #endif // GRAAL |
| 0 | 286 } |
| 287 | |
| 288 GCMutexLocker::GCMutexLocker(Monitor * mutex) { | |
| 289 if (SafepointSynchronize::is_at_safepoint()) { | |
| 290 _locked = false; | |
| 291 } else { | |
| 292 _mutex = mutex; | |
| 293 _locked = true; | |
| 294 _mutex->lock(); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 // Print all mutexes/monitors that are currently owned by a thread; called | |
| 299 // by fatal error handler. | |
| 300 void print_owned_locks_on_error(outputStream* st) { | |
| 301 st->print("VM Mutex/Monitor currently owned by a thread: "); | |
| 302 bool none = true; | |
| 303 for (int i = 0; i < _num_mutex; i++) { | |
| 304 // see if it has an owner | |
| 305 if (_mutex_array[i]->owner() != NULL) { | |
| 306 if (none) { | |
| 307 // print format used by Mutex::print_on_error() | |
| 308 st->print_cr(" ([mutex/lock_event])"); | |
| 309 none = false; | |
| 310 } | |
| 311 _mutex_array[i]->print_on_error(st); | |
| 312 st->cr(); | |
| 313 } | |
| 314 } | |
| 315 if (none) st->print_cr("None"); | |
| 316 } |