Mercurial > hg > truffle
annotate src/share/vm/runtime/mutexLocker.cpp @ 4837:eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
Summary: Re-enable survivors during the initial-mark pause. Afterwards, the concurrent marking threads have to scan them and mark everything reachable from them. The next GC will have to wait for the survivors to be scanned.
Reviewed-by: brutisso, johnc
| author | tonyp |
|---|---|
| date | Wed, 25 Jan 2012 12:58:23 -0500 |
| parents | f08d439fab8c |
| children | 0a10d80352d5 |
| 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; | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
3960
diff
changeset
|
136 Monitor* Service_lock = NULL; |
| 0 | 137 |
| 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 |
| 0 | 212 def(JmethodIdCreation_lock , Mutex , leaf, true ); // used for creating jmethodIDs. |
| 213 | |
| 214 def(SystemDictionary_lock , Monitor, leaf, true ); // lookups done by VM thread | |
| 215 def(PackageTable_lock , Mutex , leaf, false); | |
| 216 def(InlineCacheBuffer_lock , Mutex , leaf, true ); | |
| 217 def(VMStatistic_lock , Mutex , leaf, false); | |
| 218 def(ExpandHeap_lock , Mutex , leaf, true ); // Used during compilation by VM thread | |
| 219 def(JNIHandleBlockFreeList_lock , Mutex , leaf, true ); // handles are used by VM thread | |
| 220 def(SignatureHandlerLibrary_lock , Mutex , leaf, false); | |
| 221 def(SymbolTable_lock , Mutex , leaf, true ); | |
| 222 def(StringTable_lock , Mutex , leaf, true ); | |
| 223 def(ProfilePrint_lock , Mutex , leaf, false); // serial profile printing | |
| 224 def(ExceptionCache_lock , Mutex , leaf, false); // serial profile printing | |
| 225 def(OsrList_lock , Mutex , leaf, true ); | |
| 226 def(Debug1_lock , Mutex , leaf, true ); | |
| 227 #ifndef PRODUCT | |
| 228 def(FullGCALot_lock , Mutex , leaf, false); // a lock to make FullGCALot MT safe | |
| 229 #endif | |
| 230 def(BeforeExit_lock , Monitor, leaf, true ); | |
| 231 def(PerfDataMemAlloc_lock , Mutex , leaf, true ); // used for allocating PerfData memory for performance data | |
| 232 def(PerfDataManager_lock , Mutex , leaf, true ); // used for synchronized access to PerfDataManager resources | |
| 233 | |
| 234 // CMS_modUnionTable_lock leaf | |
| 235 // CMS_bitMap_lock leaf + 1 | |
| 236 // CMS_freeList_lock leaf + 2 | |
| 237 | |
| 238 def(Safepoint_lock , Monitor, safepoint, true ); // locks SnippetCache_lock/Threads_lock | |
| 239 | |
| 240 def(Threads_lock , Monitor, barrier, true ); | |
| 241 | |
| 242 def(VMOperationQueue_lock , Monitor, nonleaf, true ); // VM_thread allowed to block on these | |
| 243 def(VMOperationRequest_lock , Monitor, nonleaf, true ); | |
| 244 def(RetData_lock , Mutex , nonleaf, false); | |
| 245 def(Terminator_lock , Monitor, nonleaf, true ); | |
| 246 def(VtableStubs_lock , Mutex , nonleaf, true ); | |
| 247 def(Notify_lock , Monitor, nonleaf, true ); | |
| 248 def(JNIGlobalHandle_lock , Mutex , nonleaf, true ); // locks JNIHandleBlockFreeList_lock | |
| 249 def(JNICritical_lock , Monitor, nonleaf, true ); // used for JNI critical regions | |
| 250 def(AdapterHandlerLibrary_lock , Mutex , nonleaf, true); | |
| 251 if (UseConcMarkSweepGC) { | |
| 252 def(SLT_lock , Monitor, nonleaf, false ); | |
| 253 // used in CMS GC for locking PLL lock | |
| 254 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
255 def(Heap_lock , Monitor, nonleaf+1, false); |
| 0 | 256 def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation |
| 257 def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke | |
| 258 | |
| 259 def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock | |
| 260 def(CompileTaskAlloc_lock , Mutex , nonleaf+2, true ); | |
| 261 def(CompileStatistics_lock , Mutex , nonleaf+2, false); | |
| 262 def(MultiArray_lock , Mutex , nonleaf+2, false); // locks SymbolTable_lock | |
| 263 | |
| 264 def(JvmtiThreadState_lock , Mutex , nonleaf+2, false); // Used by JvmtiThreadState/JvmtiEventController | |
| 265 def(JvmtiPendingEvent_lock , Monitor, nonleaf, false); // Used by JvmtiCodeBlobEvents | |
| 266 def(Management_lock , Mutex , nonleaf+2, false); // used for JVM management | |
| 267 | |
| 268 def(Compile_lock , Mutex , nonleaf+3, true ); | |
| 269 def(MethodData_lock , Mutex , nonleaf+3, false); | |
| 270 | |
| 271 def(MethodCompileQueue_lock , Monitor, nonleaf+4, true ); | |
| 272 def(Debug2_lock , Mutex , nonleaf+4, true ); | |
| 273 def(Debug3_lock , Mutex , nonleaf+4, true ); | |
| 274 def(ProfileVM_lock , Monitor, nonleaf+4, false); // used for profiling of the VMThread | |
| 275 def(CompileThread_lock , Monitor, nonleaf+5, false ); | |
| 276 } | |
| 277 | |
| 278 GCMutexLocker::GCMutexLocker(Monitor * mutex) { | |
| 279 if (SafepointSynchronize::is_at_safepoint()) { | |
| 280 _locked = false; | |
| 281 } else { | |
| 282 _mutex = mutex; | |
| 283 _locked = true; | |
| 284 _mutex->lock(); | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 // Print all mutexes/monitors that are currently owned by a thread; called | |
| 289 // by fatal error handler. | |
| 290 void print_owned_locks_on_error(outputStream* st) { | |
| 291 st->print("VM Mutex/Monitor currently owned by a thread: "); | |
| 292 bool none = true; | |
| 293 for (int i = 0; i < _num_mutex; i++) { | |
| 294 // see if it has an owner | |
| 295 if (_mutex_array[i]->owner() != NULL) { | |
| 296 if (none) { | |
| 297 // print format used by Mutex::print_on_error() | |
| 298 st->print_cr(" ([mutex/lock_event])"); | |
| 299 none = false; | |
| 300 } | |
| 301 _mutex_array[i]->print_on_error(st); | |
| 302 st->cr(); | |
| 303 } | |
| 304 } | |
| 305 if (none) st->print_cr("None"); | |
| 306 } |