Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/mutexLocker.cpp @ 8854:754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
Summary: Ergonomics now also takes available virtual memory into account when deciding for a heap size. The helper method to determine the maximum allocatable memory block now uses the appropriate OS specific calls to retrieve available virtual memory for the java process. In 32 bit environments this method now also searches for the maximum actually reservable amount of memory. Merge previously separate implementations for Linux/BSD/Solaris into a single method.
Reviewed-by: jmasa, tamao
| author | tschatzl |
|---|---|
| date | Wed, 27 Mar 2013 19:21:18 +0100 |
| parents | f34d701e952e |
| children | 291ffc492eb6 6337ca4dcad8 |
| 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 |
| 134 #define MAX_NUM_MUTEX 128 | |
| 135 static Monitor * _mutex_array[MAX_NUM_MUTEX]; | |
| 136 static int _num_mutex; | |
| 137 | |
| 138 #ifdef ASSERT | |
| 139 void assert_locked_or_safepoint(const Monitor * lock) { | |
| 140 // check if this thread owns the lock (common case) | |
| 141 if (IgnoreLockingAssertions) return; | |
| 142 assert(lock != NULL, "Need non-NULL lock"); | |
| 143 if (lock->owned_by_self()) return; | |
| 144 if (SafepointSynchronize::is_at_safepoint()) return; | |
| 145 if (!Universe::is_fully_initialized()) return; | |
| 146 // see if invoker of VM operation owns it | |
| 147 VM_Operation* op = VMThread::vm_operation(); | |
| 148 if (op != NULL && op->calling_thread() == lock->owner()) return; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1358
diff
changeset
|
149 fatal(err_msg("must own lock %s", lock->name())); |
| 0 | 150 } |
| 151 | |
| 152 // a stronger assertion than the above | |
| 153 void assert_lock_strong(const Monitor * lock) { | |
| 154 if (IgnoreLockingAssertions) return; | |
| 155 assert(lock != NULL, "Need non-NULL lock"); | |
| 156 if (lock->owned_by_self()) return; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1358
diff
changeset
|
157 fatal(err_msg("must own lock %s", lock->name())); |
| 0 | 158 } |
| 159 #endif | |
| 160 | |
| 161 #define def(var, type, pri, vm_block) { \ | |
| 162 var = new type(Mutex::pri, #var, vm_block); \ | |
| 163 assert(_num_mutex < MAX_NUM_MUTEX, \ | |
| 164 "increase MAX_NUM_MUTEX"); \ | |
| 165 _mutex_array[_num_mutex++] = var; \ | |
| 166 } | |
| 167 | |
| 168 void mutex_init() { | |
| 169 def(tty_lock , Mutex , event, true ); // allow to lock in VM | |
| 170 | |
| 171 def(CGC_lock , Monitor, special, true ); // coordinate between fore- and background GC | |
| 172 def(STS_init_lock , Mutex, leaf, true ); | |
| 173 if (UseConcMarkSweepGC) { | |
| 174 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
|
175 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1584
diff
changeset
|
176 if (UseConcMarkSweepGC || UseG1GC) { |
| 0 | 177 def(FullGCCount_lock , Monitor, leaf, true ); // in support of ExplicitGCInvokesConcurrent |
| 178 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
179 if (UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
180 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
|
181 def(CMRegionStack_lock , Mutex, leaf, true ); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
182 def(SATB_Q_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
183 def(SATB_Q_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
184 def(Shared_SATB_Q_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
185 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
186 def(DirtyCardQ_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
187 def(DirtyCardQ_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
188 def(Shared_DirtyCardQ_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
189 |
| 2152 | 190 def(FreeList_lock , Mutex, leaf , true ); |
| 191 def(SecondaryFreeList_lock , Monitor, leaf , true ); | |
| 192 def(OldSets_lock , Mutex , leaf , true ); | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
193 def(RootRegionScan_lock , Monitor, leaf , true ); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
194 def(MMUTracker_lock , Mutex , leaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
195 def(HotCardCache_lock , Mutex , special , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
196 def(EvacFailureStack_lock , Mutex , nonleaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
197 } |
| 0 | 198 def(ParGCRareEvent_lock , Mutex , leaf , true ); |
| 199 def(DerivedPointerTableGC_lock , Mutex, leaf, true ); | |
| 200 def(CodeCache_lock , Mutex , special, true ); | |
| 201 def(Interrupt_lock , Monitor, special, true ); // used for interrupt processing | |
| 202 def(RawMonitor_lock , Mutex, special, true ); | |
| 203 def(OopMapCacheAlloc_lock , Mutex, leaf, true ); // used for oop_map_cache allocation. | |
| 204 | |
| 205 def(Patching_lock , Mutex , special, true ); // used for safepointing and code patching. | |
| 206 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
|
207 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
|
208 def(Stacktrace_lock , Mutex, special, true ); // used for JFR stacktrace database |
| 0 | 209 def(JmethodIdCreation_lock , Mutex , leaf, true ); // used for creating jmethodIDs. |
| 210 | |
| 211 def(SystemDictionary_lock , Monitor, leaf, true ); // lookups done by VM thread | |
| 212 def(PackageTable_lock , Mutex , leaf, false); | |
| 213 def(InlineCacheBuffer_lock , Mutex , leaf, true ); | |
| 214 def(VMStatistic_lock , Mutex , leaf, false); | |
| 215 def(ExpandHeap_lock , Mutex , leaf, true ); // Used during compilation by VM thread | |
| 216 def(JNIHandleBlockFreeList_lock , Mutex , leaf, true ); // handles are used by VM thread | |
| 217 def(SignatureHandlerLibrary_lock , Mutex , leaf, false); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4840
diff
changeset
|
218 def(SymbolTable_lock , Mutex , leaf+2, true ); |
| 0 | 219 def(StringTable_lock , Mutex , leaf, true ); |
| 220 def(ProfilePrint_lock , Mutex , leaf, false); // serial profile printing | |
| 221 def(ExceptionCache_lock , Mutex , leaf, false); // serial profile printing | |
| 222 def(OsrList_lock , Mutex , leaf, true ); | |
| 223 def(Debug1_lock , Mutex , leaf, true ); | |
| 224 #ifndef PRODUCT | |
| 225 def(FullGCALot_lock , Mutex , leaf, false); // a lock to make FullGCALot MT safe | |
| 226 #endif | |
| 227 def(BeforeExit_lock , Monitor, leaf, true ); | |
| 228 def(PerfDataMemAlloc_lock , Mutex , leaf, true ); // used for allocating PerfData memory for performance data | |
| 229 def(PerfDataManager_lock , Mutex , leaf, true ); // used for synchronized access to PerfDataManager resources | |
| 230 | |
| 231 // CMS_modUnionTable_lock leaf | |
| 232 // CMS_bitMap_lock leaf + 1 | |
| 233 // CMS_freeList_lock leaf + 2 | |
| 234 | |
| 235 def(Safepoint_lock , Monitor, safepoint, true ); // locks SnippetCache_lock/Threads_lock | |
| 236 | |
| 237 def(Threads_lock , Monitor, barrier, true ); | |
| 238 | |
| 239 def(VMOperationQueue_lock , Monitor, nonleaf, true ); // VM_thread allowed to block on these | |
| 240 def(VMOperationRequest_lock , Monitor, nonleaf, true ); | |
| 241 def(RetData_lock , Mutex , nonleaf, false); | |
| 242 def(Terminator_lock , Monitor, nonleaf, true ); | |
| 243 def(VtableStubs_lock , Mutex , nonleaf, true ); | |
| 244 def(Notify_lock , Monitor, nonleaf, true ); | |
| 245 def(JNIGlobalHandle_lock , Mutex , nonleaf, true ); // locks JNIHandleBlockFreeList_lock | |
| 246 def(JNICritical_lock , Monitor, nonleaf, true ); // used for JNI critical regions | |
| 247 def(AdapterHandlerLibrary_lock , Mutex , nonleaf, true); | |
| 248 if (UseConcMarkSweepGC) { | |
| 249 def(SLT_lock , Monitor, nonleaf, false ); | |
| 250 // used in CMS GC for locking PLL lock | |
| 251 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
252 def(Heap_lock , Monitor, nonleaf+1, false); |
| 0 | 253 def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation |
| 254 def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke | |
| 255 | |
| 256 def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock | |
| 257 def(CompileTaskAlloc_lock , Mutex , nonleaf+2, true ); | |
| 258 def(CompileStatistics_lock , Mutex , nonleaf+2, false); | |
| 259 def(MultiArray_lock , Mutex , nonleaf+2, false); // locks SymbolTable_lock | |
| 260 | |
| 261 def(JvmtiThreadState_lock , Mutex , nonleaf+2, false); // Used by JvmtiThreadState/JvmtiEventController | |
| 262 def(JvmtiPendingEvent_lock , Monitor, nonleaf, false); // Used by JvmtiCodeBlobEvents | |
| 263 def(Management_lock , Mutex , nonleaf+2, false); // used for JVM management | |
| 264 | |
| 265 def(Compile_lock , Mutex , nonleaf+3, true ); | |
| 266 def(MethodData_lock , Mutex , nonleaf+3, false); | |
| 267 | |
| 268 def(MethodCompileQueue_lock , Monitor, nonleaf+4, true ); | |
| 269 def(Debug2_lock , Mutex , nonleaf+4, true ); | |
| 270 def(Debug3_lock , Mutex , nonleaf+4, true ); | |
| 271 def(ProfileVM_lock , Monitor, nonleaf+4, false); // used for profiling of the VMThread | |
| 272 def(CompileThread_lock , Monitor, nonleaf+5, false ); | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
273 |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
274 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
|
275 def(JfrMsg_lock , Monitor, nonleaf+2, true); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
276 def(JfrBuffer_lock , Mutex, nonleaf+3, true); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3960
diff
changeset
|
277 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
|
278 def(PeriodicTask_lock , Monitor, nonleaf+5, true); |
| 0 | 279 } |
| 280 | |
| 281 GCMutexLocker::GCMutexLocker(Monitor * mutex) { | |
| 282 if (SafepointSynchronize::is_at_safepoint()) { | |
| 283 _locked = false; | |
| 284 } else { | |
| 285 _mutex = mutex; | |
| 286 _locked = true; | |
| 287 _mutex->lock(); | |
| 288 } | |
| 289 } | |
| 290 | |
| 291 // Print all mutexes/monitors that are currently owned by a thread; called | |
| 292 // by fatal error handler. | |
| 293 void print_owned_locks_on_error(outputStream* st) { | |
| 294 st->print("VM Mutex/Monitor currently owned by a thread: "); | |
| 295 bool none = true; | |
| 296 for (int i = 0; i < _num_mutex; i++) { | |
| 297 // see if it has an owner | |
| 298 if (_mutex_array[i]->owner() != NULL) { | |
| 299 if (none) { | |
| 300 // print format used by Mutex::print_on_error() | |
| 301 st->print_cr(" ([mutex/lock_event])"); | |
| 302 none = false; | |
| 303 } | |
| 304 _mutex_array[i]->print_on_error(st); | |
| 305 st->cr(); | |
| 306 } | |
| 307 } | |
| 308 if (none) st->print_cr("None"); | |
| 309 } |