Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/mutexLocker.cpp @ 2152:0fa27f37d4d4
6977804: G1: remove the zero-filling thread
Summary: This changeset removes the zero-filling thread from G1 and collapses the two free region lists we had before (the "free" and "unclean" lists) into one. The new free list uses the new heap region sets / lists abstractions that we'll ultimately use it to keep track of all regions in the heap. A heap region set was also introduced for the humongous regions. Finally, this change increases the concurrency between the thread that completes freeing regions (after a cleanup pause) and the rest of the system (before we'd have to wait for said thread to complete before allocating a new region). The changest also includes a lot of refactoring and code simplification.
Reviewed-by: jcoomes, johnc
| author | tonyp |
|---|---|
| date | Wed, 19 Jan 2011 19:30:42 -0500 |
| parents | f95d63e2154a |
| children | bf8517f4e4d0 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2152 | 2 * Copyright (c) 1997, 2011, 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 | |
| 0 | 39 |
| 40 // Mutexes used in the VM (see comment in mutexLocker.hpp): | |
| 41 // | |
| 42 // Note that the following pointers are effectively final -- after having been | |
| 43 // set at JVM startup-time, they should never be subsequently mutated. | |
| 44 // Instead of using pointers to malloc()ed monitors and mutexes we should consider | |
| 45 // eliminating the indirection and using instances instead. | |
| 46 // Consider using GCC's __read_mostly. | |
| 47 | |
| 48 Mutex* Patching_lock = NULL; | |
| 49 Monitor* SystemDictionary_lock = NULL; | |
| 50 Mutex* PackageTable_lock = NULL; | |
| 51 Mutex* CompiledIC_lock = NULL; | |
| 52 Mutex* InlineCacheBuffer_lock = NULL; | |
| 53 Mutex* VMStatistic_lock = NULL; | |
| 54 Mutex* JNIGlobalHandle_lock = NULL; | |
| 55 Mutex* JNIHandleBlockFreeList_lock = NULL; | |
| 56 Mutex* JNICachedItableIndex_lock = NULL; | |
| 57 Mutex* JmethodIdCreation_lock = NULL; | |
| 58 Mutex* JfieldIdCreation_lock = NULL; | |
| 59 Monitor* JNICritical_lock = NULL; | |
| 60 Mutex* JvmtiThreadState_lock = NULL; | |
| 61 Monitor* JvmtiPendingEvent_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
62 Monitor* Heap_lock = NULL; |
| 0 | 63 Mutex* ExpandHeap_lock = NULL; |
| 64 Mutex* AdapterHandlerLibrary_lock = NULL; | |
| 65 Mutex* SignatureHandlerLibrary_lock = NULL; | |
| 66 Mutex* VtableStubs_lock = NULL; | |
| 67 Mutex* SymbolTable_lock = NULL; | |
| 68 Mutex* StringTable_lock = NULL; | |
| 69 Mutex* CodeCache_lock = NULL; | |
| 70 Mutex* MethodData_lock = NULL; | |
| 71 Mutex* RetData_lock = NULL; | |
| 72 Monitor* VMOperationQueue_lock = NULL; | |
| 73 Monitor* VMOperationRequest_lock = NULL; | |
| 74 Monitor* Safepoint_lock = NULL; | |
| 75 Monitor* SerializePage_lock = NULL; | |
| 76 Monitor* Threads_lock = NULL; | |
| 77 Monitor* CGC_lock = NULL; | |
| 78 Mutex* STS_init_lock = NULL; | |
| 79 Monitor* SLT_lock = NULL; | |
| 80 Monitor* iCMS_lock = NULL; | |
| 81 Monitor* FullGCCount_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
82 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
|
83 Mutex* CMRegionStack_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
84 Mutex* SATB_Q_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
85 Monitor* SATB_Q_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
86 Mutex* Shared_SATB_Q_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
87 Mutex* DirtyCardQ_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
88 Monitor* DirtyCardQ_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
89 Mutex* Shared_DirtyCardQ_lock = NULL; |
| 0 | 90 Mutex* ParGCRareEvent_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
91 Mutex* EvacFailureStack_lock = NULL; |
| 0 | 92 Mutex* DerivedPointerTableGC_lock = NULL; |
| 93 Mutex* Compile_lock = NULL; | |
| 94 Monitor* MethodCompileQueue_lock = NULL; | |
| 95 Monitor* CompileThread_lock = NULL; | |
| 96 Mutex* CompileTaskAlloc_lock = NULL; | |
| 97 Mutex* CompileStatistics_lock = NULL; | |
| 98 Mutex* MultiArray_lock = NULL; | |
| 99 Monitor* Terminator_lock = NULL; | |
| 100 Monitor* BeforeExit_lock = NULL; | |
| 101 Monitor* Notify_lock = NULL; | |
| 102 Monitor* Interrupt_lock = NULL; | |
| 103 Monitor* ProfileVM_lock = NULL; | |
| 104 Mutex* ProfilePrint_lock = NULL; | |
| 105 Mutex* ExceptionCache_lock = NULL; | |
| 106 Monitor* ObjAllocPost_lock = NULL; | |
| 107 Mutex* OsrList_lock = NULL; | |
| 108 #ifndef PRODUCT | |
| 109 Mutex* FullGCALot_lock = NULL; | |
| 110 #endif | |
| 111 | |
| 112 Mutex* Debug1_lock = NULL; | |
| 113 Mutex* Debug2_lock = NULL; | |
| 114 Mutex* Debug3_lock = NULL; | |
| 115 | |
| 116 Mutex* tty_lock = NULL; | |
| 117 | |
| 118 Mutex* RawMonitor_lock = NULL; | |
| 119 Mutex* PerfDataMemAlloc_lock = NULL; | |
| 120 Mutex* PerfDataManager_lock = NULL; | |
| 121 Mutex* OopMapCacheAlloc_lock = NULL; | |
| 122 | |
| 2152 | 123 Mutex* FreeList_lock = NULL; |
| 124 Monitor* SecondaryFreeList_lock = NULL; | |
| 125 Mutex* OldSets_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
126 Mutex* MMUTracker_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
127 Mutex* HotCardCache_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
128 |
| 0 | 129 Monitor* GCTaskManager_lock = NULL; |
| 130 | |
| 131 Mutex* Management_lock = NULL; | |
| 132 Monitor* LowMemory_lock = NULL; | |
| 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 ); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
193 def(MMUTracker_lock , Mutex , leaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
194 def(HotCardCache_lock , Mutex , special , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
195 def(EvacFailureStack_lock , Mutex , nonleaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
196 } |
| 0 | 197 def(ParGCRareEvent_lock , Mutex , leaf , true ); |
| 198 def(DerivedPointerTableGC_lock , Mutex, leaf, true ); | |
| 199 def(CodeCache_lock , Mutex , special, true ); | |
| 200 def(Interrupt_lock , Monitor, special, true ); // used for interrupt processing | |
| 201 def(RawMonitor_lock , Mutex, special, true ); | |
| 202 def(OopMapCacheAlloc_lock , Mutex, leaf, true ); // used for oop_map_cache allocation. | |
| 203 | |
| 204 def(Patching_lock , Mutex , special, true ); // used for safepointing and code patching. | |
| 205 def(ObjAllocPost_lock , Monitor, special, false); | |
| 206 def(LowMemory_lock , Monitor, special, true ); // used for low memory detection | |
| 207 def(JmethodIdCreation_lock , Mutex , leaf, true ); // used for creating jmethodIDs. | |
| 208 | |
| 209 def(SystemDictionary_lock , Monitor, leaf, true ); // lookups done by VM thread | |
| 210 def(PackageTable_lock , Mutex , leaf, false); | |
| 211 def(InlineCacheBuffer_lock , Mutex , leaf, true ); | |
| 212 def(VMStatistic_lock , Mutex , leaf, false); | |
| 213 def(ExpandHeap_lock , Mutex , leaf, true ); // Used during compilation by VM thread | |
| 214 def(JNIHandleBlockFreeList_lock , Mutex , leaf, true ); // handles are used by VM thread | |
| 215 def(SignatureHandlerLibrary_lock , Mutex , leaf, false); | |
| 216 def(SymbolTable_lock , Mutex , leaf, true ); | |
| 217 def(StringTable_lock , Mutex , leaf, true ); | |
| 218 def(ProfilePrint_lock , Mutex , leaf, false); // serial profile printing | |
| 219 def(ExceptionCache_lock , Mutex , leaf, false); // serial profile printing | |
| 220 def(OsrList_lock , Mutex , leaf, true ); | |
| 221 def(Debug1_lock , Mutex , leaf, true ); | |
| 222 #ifndef PRODUCT | |
| 223 def(FullGCALot_lock , Mutex , leaf, false); // a lock to make FullGCALot MT safe | |
| 224 #endif | |
| 225 def(BeforeExit_lock , Monitor, leaf, true ); | |
| 226 def(PerfDataMemAlloc_lock , Mutex , leaf, true ); // used for allocating PerfData memory for performance data | |
| 227 def(PerfDataManager_lock , Mutex , leaf, true ); // used for synchronized access to PerfDataManager resources | |
| 228 | |
| 229 // CMS_modUnionTable_lock leaf | |
| 230 // CMS_bitMap_lock leaf + 1 | |
| 231 // CMS_freeList_lock leaf + 2 | |
| 232 | |
| 233 def(Safepoint_lock , Monitor, safepoint, true ); // locks SnippetCache_lock/Threads_lock | |
| 234 | |
| 235 def(Threads_lock , Monitor, barrier, true ); | |
| 236 | |
| 237 def(VMOperationQueue_lock , Monitor, nonleaf, true ); // VM_thread allowed to block on these | |
| 238 def(VMOperationRequest_lock , Monitor, nonleaf, true ); | |
| 239 def(RetData_lock , Mutex , nonleaf, false); | |
| 240 def(Terminator_lock , Monitor, nonleaf, true ); | |
| 241 def(VtableStubs_lock , Mutex , nonleaf, true ); | |
| 242 def(Notify_lock , Monitor, nonleaf, true ); | |
| 243 def(JNIGlobalHandle_lock , Mutex , nonleaf, true ); // locks JNIHandleBlockFreeList_lock | |
| 244 def(JNICritical_lock , Monitor, nonleaf, true ); // used for JNI critical regions | |
| 245 def(AdapterHandlerLibrary_lock , Mutex , nonleaf, true); | |
| 246 if (UseConcMarkSweepGC) { | |
| 247 def(SLT_lock , Monitor, nonleaf, false ); | |
| 248 // used in CMS GC for locking PLL lock | |
| 249 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
250 def(Heap_lock , Monitor, nonleaf+1, false); |
| 0 | 251 def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation |
| 252 def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke | |
| 253 | |
| 254 def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock | |
| 255 def(CompileTaskAlloc_lock , Mutex , nonleaf+2, true ); | |
| 256 def(CompileStatistics_lock , Mutex , nonleaf+2, false); | |
| 257 def(MultiArray_lock , Mutex , nonleaf+2, false); // locks SymbolTable_lock | |
| 258 | |
| 259 def(JvmtiThreadState_lock , Mutex , nonleaf+2, false); // Used by JvmtiThreadState/JvmtiEventController | |
| 260 def(JvmtiPendingEvent_lock , Monitor, nonleaf, false); // Used by JvmtiCodeBlobEvents | |
| 261 def(Management_lock , Mutex , nonleaf+2, false); // used for JVM management | |
| 262 | |
| 263 def(Compile_lock , Mutex , nonleaf+3, true ); | |
| 264 def(MethodData_lock , Mutex , nonleaf+3, false); | |
| 265 | |
| 266 def(MethodCompileQueue_lock , Monitor, nonleaf+4, true ); | |
| 267 def(Debug2_lock , Mutex , nonleaf+4, true ); | |
| 268 def(Debug3_lock , Mutex , nonleaf+4, true ); | |
| 269 def(ProfileVM_lock , Monitor, nonleaf+4, false); // used for profiling of the VMThread | |
| 270 def(CompileThread_lock , Monitor, nonleaf+5, false ); | |
| 271 } | |
| 272 | |
| 273 GCMutexLocker::GCMutexLocker(Monitor * mutex) { | |
| 274 if (SafepointSynchronize::is_at_safepoint()) { | |
| 275 _locked = false; | |
| 276 } else { | |
| 277 _mutex = mutex; | |
| 278 _locked = true; | |
| 279 _mutex->lock(); | |
| 280 } | |
| 281 } | |
| 282 | |
| 283 // Print all mutexes/monitors that are currently owned by a thread; called | |
| 284 // by fatal error handler. | |
| 285 void print_owned_locks_on_error(outputStream* st) { | |
| 286 st->print("VM Mutex/Monitor currently owned by a thread: "); | |
| 287 bool none = true; | |
| 288 for (int i = 0; i < _num_mutex; i++) { | |
| 289 // see if it has an owner | |
| 290 if (_mutex_array[i]->owner() != NULL) { | |
| 291 if (none) { | |
| 292 // print format used by Mutex::print_on_error() | |
| 293 st->print_cr(" ([mutex/lock_event])"); | |
| 294 none = false; | |
| 295 } | |
| 296 _mutex_array[i]->print_on_error(st); | |
| 297 st->cr(); | |
| 298 } | |
| 299 } | |
| 300 if (none) st->print_cr("None"); | |
| 301 } |