Mercurial > hg > truffle
annotate src/share/vm/runtime/mutexLocker.cpp @ 1145:e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
Summary: Autonomic per-worker free block cache sizing, tunable coalition policies, fixes to per-size block statistics, retuned gain and bandwidth of some feedback loop filters to allow quicker reactivity to abrupt changes in ambient demand, and other heuristics to reduce fragmentation of the CMS old gen. Also tightened some assertions, including those related to locking.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Wed, 23 Dec 2009 09:23:54 -0800 |
| parents | bd02caa94611 |
| children | 72f725c5a7be |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 844 | 2 * Copyright 1997-2009 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 #include "incls/_precompiled.incl" | |
| 26 #include "incls/_mutexLocker.cpp.incl" | |
| 27 | |
| 28 // Mutexes used in the VM (see comment in mutexLocker.hpp): | |
| 29 // | |
| 30 // Note that the following pointers are effectively final -- after having been | |
| 31 // set at JVM startup-time, they should never be subsequently mutated. | |
| 32 // Instead of using pointers to malloc()ed monitors and mutexes we should consider | |
| 33 // eliminating the indirection and using instances instead. | |
| 34 // Consider using GCC's __read_mostly. | |
| 35 | |
| 36 Mutex* Patching_lock = NULL; | |
| 37 Monitor* SystemDictionary_lock = NULL; | |
| 38 Mutex* PackageTable_lock = NULL; | |
| 39 Mutex* CompiledIC_lock = NULL; | |
| 40 Mutex* InlineCacheBuffer_lock = NULL; | |
| 41 Mutex* VMStatistic_lock = NULL; | |
| 42 Mutex* JNIGlobalHandle_lock = NULL; | |
| 43 Mutex* JNIHandleBlockFreeList_lock = NULL; | |
| 44 Mutex* JNICachedItableIndex_lock = NULL; | |
| 45 Mutex* JmethodIdCreation_lock = NULL; | |
| 46 Mutex* JfieldIdCreation_lock = NULL; | |
| 47 Monitor* JNICritical_lock = NULL; | |
| 48 Mutex* JvmtiThreadState_lock = NULL; | |
| 49 Monitor* JvmtiPendingEvent_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
50 Monitor* Heap_lock = NULL; |
| 0 | 51 Mutex* ExpandHeap_lock = NULL; |
| 52 Mutex* AdapterHandlerLibrary_lock = NULL; | |
| 53 Mutex* SignatureHandlerLibrary_lock = NULL; | |
| 54 Mutex* VtableStubs_lock = NULL; | |
| 55 Mutex* SymbolTable_lock = NULL; | |
| 56 Mutex* StringTable_lock = NULL; | |
| 57 Mutex* CodeCache_lock = NULL; | |
| 58 Mutex* MethodData_lock = NULL; | |
| 59 Mutex* RetData_lock = NULL; | |
| 60 Monitor* VMOperationQueue_lock = NULL; | |
| 61 Monitor* VMOperationRequest_lock = NULL; | |
| 62 Monitor* Safepoint_lock = NULL; | |
| 63 Monitor* SerializePage_lock = NULL; | |
| 64 Monitor* Threads_lock = NULL; | |
| 65 Monitor* CGC_lock = NULL; | |
| 66 Mutex* STS_init_lock = NULL; | |
| 67 Monitor* SLT_lock = NULL; | |
| 68 Monitor* iCMS_lock = NULL; | |
| 69 Monitor* FullGCCount_lock = NULL; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
70 Monitor* CMark_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
71 Monitor* ZF_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
72 Monitor* Cleanup_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
73 Mutex* SATB_Q_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
74 Monitor* SATB_Q_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
75 Mutex* Shared_SATB_Q_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
76 Mutex* DirtyCardQ_FL_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
77 Monitor* DirtyCardQ_CBL_mon = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
78 Mutex* Shared_DirtyCardQ_lock = NULL; |
| 0 | 79 Mutex* ParGCRareEvent_lock = NULL; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
80 Mutex* EvacFailureStack_lock = NULL; |
| 0 | 81 Mutex* DerivedPointerTableGC_lock = NULL; |
| 82 Mutex* Compile_lock = NULL; | |
| 83 Monitor* MethodCompileQueue_lock = NULL; | |
| 84 #ifdef TIERED | |
| 85 Monitor* C1_lock = NULL; | |
| 86 #endif // TIERED | |
| 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 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
115 Mutex* MMUTracker_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
116 Mutex* HotCardCache_lock = NULL; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
117 |
| 0 | 118 Monitor* GCTaskManager_lock = NULL; |
| 119 | |
| 120 Mutex* Management_lock = NULL; | |
| 121 Monitor* LowMemory_lock = NULL; | |
| 122 | |
| 123 #define MAX_NUM_MUTEX 128 | |
| 124 static Monitor * _mutex_array[MAX_NUM_MUTEX]; | |
| 125 static int _num_mutex; | |
| 126 | |
| 127 #ifdef ASSERT | |
| 128 void assert_locked_or_safepoint(const Monitor * lock) { | |
| 129 // check if this thread owns the lock (common case) | |
| 130 if (IgnoreLockingAssertions) return; | |
| 131 assert(lock != NULL, "Need non-NULL lock"); | |
| 132 if (lock->owned_by_self()) return; | |
| 133 if (SafepointSynchronize::is_at_safepoint()) return; | |
| 134 if (!Universe::is_fully_initialized()) return; | |
| 135 // see if invoker of VM operation owns it | |
| 136 VM_Operation* op = VMThread::vm_operation(); | |
| 137 if (op != NULL && op->calling_thread() == lock->owner()) return; | |
| 138 fatal1("must own lock %s", lock->name()); | |
| 139 } | |
| 140 | |
| 141 // a stronger assertion than the above | |
| 142 void assert_lock_strong(const Monitor * lock) { | |
| 143 if (IgnoreLockingAssertions) return; | |
| 144 assert(lock != NULL, "Need non-NULL lock"); | |
| 145 if (lock->owned_by_self()) return; | |
| 146 fatal1("must own lock %s", lock->name()); | |
| 147 } | |
| 148 #endif | |
| 149 | |
| 150 #define def(var, type, pri, vm_block) { \ | |
| 151 var = new type(Mutex::pri, #var, vm_block); \ | |
| 152 assert(_num_mutex < MAX_NUM_MUTEX, \ | |
| 153 "increase MAX_NUM_MUTEX"); \ | |
| 154 _mutex_array[_num_mutex++] = var; \ | |
| 155 } | |
| 156 | |
| 157 void mutex_init() { | |
| 158 def(tty_lock , Mutex , event, true ); // allow to lock in VM | |
| 159 | |
| 160 def(CGC_lock , Monitor, special, true ); // coordinate between fore- and background GC | |
| 161 def(STS_init_lock , Mutex, leaf, true ); | |
| 162 if (UseConcMarkSweepGC) { | |
| 163 def(iCMS_lock , Monitor, special, true ); // CMS incremental mode start/stop notification | |
| 164 def(FullGCCount_lock , Monitor, leaf, true ); // in support of ExplicitGCInvokesConcurrent | |
| 165 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
166 if (UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
167 def(CMark_lock , Monitor, nonleaf, true ); // coordinate concurrent mark thread |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
168 def(ZF_mon , Monitor, leaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
169 def(Cleanup_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
170 def(SATB_Q_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
171 def(SATB_Q_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
172 def(Shared_SATB_Q_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
173 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
174 def(DirtyCardQ_FL_lock , Mutex , special, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
175 def(DirtyCardQ_CBL_mon , Monitor, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
176 def(Shared_DirtyCardQ_lock , Mutex, nonleaf, true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
177 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
178 def(MMUTracker_lock , Mutex , leaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
179 def(HotCardCache_lock , Mutex , special , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
180 def(EvacFailureStack_lock , Mutex , nonleaf , true ); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
181 } |
| 0 | 182 def(ParGCRareEvent_lock , Mutex , leaf , true ); |
| 183 def(DerivedPointerTableGC_lock , Mutex, leaf, true ); | |
| 184 def(CodeCache_lock , Mutex , special, true ); | |
| 185 def(Interrupt_lock , Monitor, special, true ); // used for interrupt processing | |
| 186 def(RawMonitor_lock , Mutex, special, true ); | |
| 187 def(OopMapCacheAlloc_lock , Mutex, leaf, true ); // used for oop_map_cache allocation. | |
| 188 | |
| 189 def(Patching_lock , Mutex , special, true ); // used for safepointing and code patching. | |
| 190 def(ObjAllocPost_lock , Monitor, special, false); | |
| 191 def(LowMemory_lock , Monitor, special, true ); // used for low memory detection | |
| 192 def(JmethodIdCreation_lock , Mutex , leaf, true ); // used for creating jmethodIDs. | |
| 193 | |
| 194 def(SystemDictionary_lock , Monitor, leaf, true ); // lookups done by VM thread | |
| 195 def(PackageTable_lock , Mutex , leaf, false); | |
| 196 def(InlineCacheBuffer_lock , Mutex , leaf, true ); | |
| 197 def(VMStatistic_lock , Mutex , leaf, false); | |
| 198 def(ExpandHeap_lock , Mutex , leaf, true ); // Used during compilation by VM thread | |
| 199 def(JNIHandleBlockFreeList_lock , Mutex , leaf, true ); // handles are used by VM thread | |
| 200 def(SignatureHandlerLibrary_lock , Mutex , leaf, false); | |
| 201 def(SymbolTable_lock , Mutex , leaf, true ); | |
| 202 def(StringTable_lock , Mutex , leaf, true ); | |
| 203 def(ProfilePrint_lock , Mutex , leaf, false); // serial profile printing | |
| 204 def(ExceptionCache_lock , Mutex , leaf, false); // serial profile printing | |
| 205 def(OsrList_lock , Mutex , leaf, true ); | |
| 206 def(Debug1_lock , Mutex , leaf, true ); | |
| 207 #ifndef PRODUCT | |
| 208 def(FullGCALot_lock , Mutex , leaf, false); // a lock to make FullGCALot MT safe | |
| 209 #endif | |
| 210 def(BeforeExit_lock , Monitor, leaf, true ); | |
| 211 def(PerfDataMemAlloc_lock , Mutex , leaf, true ); // used for allocating PerfData memory for performance data | |
| 212 def(PerfDataManager_lock , Mutex , leaf, true ); // used for synchronized access to PerfDataManager resources | |
| 213 | |
| 214 // CMS_modUnionTable_lock leaf | |
| 215 // CMS_bitMap_lock leaf + 1 | |
| 216 // CMS_freeList_lock leaf + 2 | |
| 217 | |
| 218 def(Safepoint_lock , Monitor, safepoint, true ); // locks SnippetCache_lock/Threads_lock | |
| 219 | |
| 220 def(Threads_lock , Monitor, barrier, true ); | |
| 221 | |
| 222 def(VMOperationQueue_lock , Monitor, nonleaf, true ); // VM_thread allowed to block on these | |
| 223 def(VMOperationRequest_lock , Monitor, nonleaf, true ); | |
| 224 def(RetData_lock , Mutex , nonleaf, false); | |
| 225 def(Terminator_lock , Monitor, nonleaf, true ); | |
| 226 def(VtableStubs_lock , Mutex , nonleaf, true ); | |
| 227 def(Notify_lock , Monitor, nonleaf, true ); | |
| 228 def(JNIGlobalHandle_lock , Mutex , nonleaf, true ); // locks JNIHandleBlockFreeList_lock | |
| 229 def(JNICritical_lock , Monitor, nonleaf, true ); // used for JNI critical regions | |
| 230 def(AdapterHandlerLibrary_lock , Mutex , nonleaf, true); | |
| 231 if (UseConcMarkSweepGC) { | |
| 232 def(SLT_lock , Monitor, nonleaf, false ); | |
| 233 // used in CMS GC for locking PLL lock | |
| 234 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
55
diff
changeset
|
235 def(Heap_lock , Monitor, nonleaf+1, false); |
| 0 | 236 def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation |
| 237 def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke | |
| 238 | |
| 239 def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock | |
| 240 def(CompileTaskAlloc_lock , Mutex , nonleaf+2, true ); | |
| 241 def(CompileStatistics_lock , Mutex , nonleaf+2, false); | |
| 242 def(MultiArray_lock , Mutex , nonleaf+2, false); // locks SymbolTable_lock | |
| 243 | |
| 244 def(JvmtiThreadState_lock , Mutex , nonleaf+2, false); // Used by JvmtiThreadState/JvmtiEventController | |
| 245 def(JvmtiPendingEvent_lock , Monitor, nonleaf, false); // Used by JvmtiCodeBlobEvents | |
| 246 def(Management_lock , Mutex , nonleaf+2, false); // used for JVM management | |
| 247 | |
| 248 def(Compile_lock , Mutex , nonleaf+3, true ); | |
| 249 def(MethodData_lock , Mutex , nonleaf+3, false); | |
| 250 | |
| 251 def(MethodCompileQueue_lock , Monitor, nonleaf+4, true ); | |
| 252 def(Debug2_lock , Mutex , nonleaf+4, true ); | |
| 253 def(Debug3_lock , Mutex , nonleaf+4, true ); | |
| 254 def(ProfileVM_lock , Monitor, nonleaf+4, false); // used for profiling of the VMThread | |
| 255 def(CompileThread_lock , Monitor, nonleaf+5, false ); | |
| 256 #ifdef TIERED | |
| 257 def(C1_lock , Monitor, nonleaf+5, false ); | |
| 258 #endif // TIERED | |
| 259 | |
| 260 | |
| 261 } | |
| 262 | |
| 263 GCMutexLocker::GCMutexLocker(Monitor * mutex) { | |
| 264 if (SafepointSynchronize::is_at_safepoint()) { | |
| 265 _locked = false; | |
| 266 } else { | |
| 267 _mutex = mutex; | |
| 268 _locked = true; | |
| 269 _mutex->lock(); | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 // Print all mutexes/monitors that are currently owned by a thread; called | |
| 274 // by fatal error handler. | |
| 275 void print_owned_locks_on_error(outputStream* st) { | |
| 276 st->print("VM Mutex/Monitor currently owned by a thread: "); | |
| 277 bool none = true; | |
| 278 for (int i = 0; i < _num_mutex; i++) { | |
| 279 // see if it has an owner | |
| 280 if (_mutex_array[i]->owner() != NULL) { | |
| 281 if (none) { | |
| 282 // print format used by Mutex::print_on_error() | |
| 283 st->print_cr(" ([mutex/lock_event])"); | |
| 284 none = false; | |
| 285 } | |
| 286 _mutex_array[i]->print_on_error(st); | |
| 287 st->cr(); | |
| 288 } | |
| 289 } | |
| 290 if (none) st->print_cr("None"); | |
| 291 } |