mutexLocker.hpp revision 356:1ee8caae33af
1/* 2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. 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// Mutexes used in the VM. 26 27extern Mutex* Patching_lock; // a lock used to guard code patching of compiled code 28extern Monitor* SystemDictionary_lock; // a lock on the system dictonary 29extern Mutex* PackageTable_lock; // a lock on the class loader package table 30extern Mutex* CompiledIC_lock; // a lock used to guard compiled IC patching and access 31extern Mutex* InlineCacheBuffer_lock; // a lock used to guard the InlineCacheBuffer 32extern Mutex* VMStatistic_lock; // a lock used to guard statistics count increment 33extern Mutex* JNIGlobalHandle_lock; // a lock on creating JNI global handles 34extern Mutex* JNIHandleBlockFreeList_lock; // a lock on the JNI handle block free list 35extern Mutex* JNICachedItableIndex_lock; // a lock on caching an itable index during JNI invoke 36extern Mutex* JmethodIdCreation_lock; // a lock on creating JNI method identifiers 37extern Mutex* JfieldIdCreation_lock; // a lock on creating JNI static field identifiers 38extern Monitor* JNICritical_lock; // a lock used while entering and exiting JNI critical regions, allows GC to sometimes get in 39extern Mutex* JvmtiThreadState_lock; // a lock on modification of JVMTI thread data 40extern Monitor* JvmtiPendingEvent_lock; // a lock on the JVMTI pending events list 41extern Monitor* Heap_lock; // a lock on the heap 42extern Mutex* ExpandHeap_lock; // a lock on expanding the heap 43extern Mutex* AdapterHandlerLibrary_lock; // a lock on the AdapterHandlerLibrary 44extern Mutex* SignatureHandlerLibrary_lock; // a lock on the SignatureHandlerLibrary 45extern Mutex* VtableStubs_lock; // a lock on the VtableStubs 46extern Mutex* SymbolTable_lock; // a lock on the symbol table 47extern Mutex* StringTable_lock; // a lock on the interned string table 48extern Mutex* CodeCache_lock; // a lock on the CodeCache, rank is special, use MutexLockerEx 49extern Mutex* MethodData_lock; // a lock on installation of method data 50extern Mutex* RetData_lock; // a lock on installation of RetData inside method data 51extern Mutex* DerivedPointerTableGC_lock; // a lock to protect the derived pointer table 52extern Monitor* VMOperationQueue_lock; // a lock on queue of vm_operations waiting to execute 53extern Monitor* VMOperationRequest_lock; // a lock on Threads waiting for a vm_operation to terminate 54extern Monitor* Safepoint_lock; // a lock used by the safepoint abstraction 55extern Monitor* Threads_lock; // a lock on the Threads table of active Java threads 56 // (also used by Safepoints too to block threads creation/destruction) 57extern Monitor* CGC_lock; // used for coordination between 58 // fore- & background GC threads. 59extern Mutex* STS_init_lock; // coordinate initialization of SuspendibleThreadSets. 60extern Monitor* SLT_lock; // used in CMS GC for acquiring PLL 61extern Monitor* iCMS_lock; // CMS incremental mode start/stop notification 62extern Monitor* FullGCCount_lock; // in support of "concurrent" full gc 63extern Monitor* CMark_lock; // used for concurrent mark thread coordination 64extern Monitor* ZF_mon; // used for G1 conc zero-fill. 65extern Monitor* Cleanup_mon; // used for G1 conc cleanup. 66extern Monitor* G1ConcRefine_mon; // used for G1 conc-refine 67 // coordination. 68 69extern Mutex* SATB_Q_FL_lock; // Protects SATB Q 70 // buffer free list. 71extern Monitor* SATB_Q_CBL_mon; // Protects SATB Q 72 // completed buffer queue. 73extern Mutex* Shared_SATB_Q_lock; // Lock protecting SATB 74 // queue shared by 75 // non-Java threads. 76 77extern Mutex* DirtyCardQ_FL_lock; // Protects dirty card Q 78 // buffer free list. 79extern Monitor* DirtyCardQ_CBL_mon; // Protects dirty card Q 80 // completed buffer queue. 81extern Mutex* Shared_DirtyCardQ_lock; // Lock protecting dirty card 82 // queue shared by 83 // non-Java threads. 84 // (see option ExplicitGCInvokesConcurrent) 85extern Mutex* ParGCRareEvent_lock; // Synchronizes various (rare) parallel GC ops. 86extern Mutex* EvacFailureStack_lock; // guards the evac failure scan stack 87extern Mutex* Compile_lock; // a lock held when Compilation is updating code (used to block CodeCache traversal, CHA updates, etc) 88extern Monitor* MethodCompileQueue_lock; // a lock held when method compilations are enqueued, dequeued 89#ifdef TIERED 90extern Monitor* C1_lock; // a lock to ensure on single c1 compile is ever active 91#endif // TIERED 92extern Monitor* CompileThread_lock; // a lock held by compile threads during compilation system initialization 93extern Mutex* CompileTaskAlloc_lock; // a lock held when CompileTasks are allocated 94extern Mutex* CompileStatistics_lock; // a lock held when updating compilation statistics 95extern Mutex* MultiArray_lock; // a lock used to guard allocation of multi-dim arrays 96extern Monitor* Terminator_lock; // a lock used to guard termination of the vm 97extern Monitor* BeforeExit_lock; // a lock used to guard cleanups and shutdown hooks 98extern Monitor* Notify_lock; // a lock used to synchronize the start-up of the vm 99extern Monitor* Interrupt_lock; // a lock used for condition variable mediated interrupt processing 100extern Monitor* ProfileVM_lock; // a lock used for profiling the VMThread 101extern Mutex* ProfilePrint_lock; // a lock used to serialize the printing of profiles 102extern Mutex* ExceptionCache_lock; // a lock used to synchronize exception cache updates 103extern Mutex* OsrList_lock; // a lock used to serialize access to OSR queues 104 105#ifndef PRODUCT 106extern Mutex* FullGCALot_lock; // a lock to make FullGCALot MT safe 107#endif 108extern Mutex* Debug1_lock; // A bunch of pre-allocated locks that can be used for tracing 109extern Mutex* Debug2_lock; // down synchronization related bugs! 110extern Mutex* Debug3_lock; 111 112extern Mutex* RawMonitor_lock; 113extern Mutex* PerfDataMemAlloc_lock; // a lock on the allocator for PerfData memory for performance data 114extern Mutex* PerfDataManager_lock; // a long on access to PerfDataManager resources 115extern Mutex* ParkerFreeList_lock; 116extern Mutex* OopMapCacheAlloc_lock; // protects allocation of oop_map caches 117 118extern Mutex* MMUTracker_lock; // protects the MMU 119 // tracker data structures 120extern Mutex* HotCardCache_lock; // protects the hot card cache 121 122extern Mutex* Management_lock; // a lock used to serialize JVM management 123extern Monitor* LowMemory_lock; // a lock used for low memory detection 124 125// A MutexLocker provides mutual exclusion with respect to a given mutex 126// for the scope which contains the locker. The lock is an OS lock, not 127// an object lock, and the two do not interoperate. Do not use Mutex-based 128// locks to lock on Java objects, because they will not be respected if a 129// that object is locked using the Java locking mechanism. 130// 131// NOTE WELL!! 132// 133// See orderAccess.hpp. We assume throughout the VM that MutexLocker's 134// and friends constructors do a fence, a lock and an acquire *in that 135// order*. And that their destructors do a release and unlock, in *that* 136// order. If their implementations change such that these assumptions 137// are violated, a whole lot of code will break. 138 139// Print all mutexes/monitors that are currently owned by a thread; called 140// by fatal error handler. 141void print_owned_locks_on_error(outputStream* st); 142 143char *lock_name(Mutex *mutex); 144 145class MutexLocker: StackObj { 146 private: 147 Monitor * _mutex; 148 public: 149 MutexLocker(Monitor * mutex) { 150 assert(mutex->rank() != Mutex::special, 151 "Special ranked mutex should only use MutexLockerEx"); 152 _mutex = mutex; 153 _mutex->lock(); 154 } 155 156 // Overloaded constructor passing current thread 157 MutexLocker(Monitor * mutex, Thread *thread) { 158 assert(mutex->rank() != Mutex::special, 159 "Special ranked mutex should only use MutexLockerEx"); 160 _mutex = mutex; 161 _mutex->lock(thread); 162 } 163 164 ~MutexLocker() { 165 _mutex->unlock(); 166 } 167 168}; 169 170// for debugging: check that we're already owning this lock (or are at a safepoint) 171#ifdef ASSERT 172void assert_locked_or_safepoint(const Monitor * lock); 173void assert_lock_strong(const Monitor * lock); 174#else 175#define assert_locked_or_safepoint(lock) 176#define assert_lock_strong(lock) 177#endif 178 179// A MutexLockerEx behaves like a MutexLocker when its constructor is 180// called with a Mutex. Unlike a MutexLocker, its constructor can also be 181// called with NULL, in which case the MutexLockerEx is a no-op. There 182// is also a corresponding MutexUnlockerEx. We want to keep the 183// basic MutexLocker as fast as possible. MutexLockerEx can also lock 184// without safepoint check. 185 186class MutexLockerEx: public StackObj { 187 private: 188 Monitor * _mutex; 189 public: 190 MutexLockerEx(Monitor * mutex, bool no_safepoint_check = !Mutex::_no_safepoint_check_flag) { 191 _mutex = mutex; 192 if (_mutex != NULL) { 193 assert(mutex->rank() > Mutex::special || no_safepoint_check, 194 "Mutexes with rank special or lower should not do safepoint checks"); 195 if (no_safepoint_check) 196 _mutex->lock_without_safepoint_check(); 197 else 198 _mutex->lock(); 199 } 200 } 201 202 ~MutexLockerEx() { 203 if (_mutex != NULL) { 204 _mutex->unlock(); 205 } 206 } 207}; 208 209// A MonitorLockerEx is like a MutexLockerEx above, except it takes 210// a possibly null Monitor, and allows wait/notify as well which are 211// delegated to the underlying Monitor. 212 213class MonitorLockerEx: public MutexLockerEx { 214 private: 215 Monitor * _monitor; 216 public: 217 MonitorLockerEx(Monitor* monitor, 218 bool no_safepoint_check = !Mutex::_no_safepoint_check_flag): 219 MutexLockerEx(monitor, no_safepoint_check), 220 _monitor(monitor) { 221 // Superclass constructor did locking 222 } 223 224 ~MonitorLockerEx() { 225 #ifdef ASSERT 226 if (_monitor != NULL) { 227 assert_lock_strong(_monitor); 228 } 229 #endif // ASSERT 230 // Superclass destructor will do unlocking 231 } 232 233 bool wait(bool no_safepoint_check = !Mutex::_no_safepoint_check_flag, 234 long timeout = 0, 235 bool as_suspend_equivalent = !Mutex::_as_suspend_equivalent_flag) { 236 if (_monitor != NULL) { 237 return _monitor->wait(no_safepoint_check, timeout, as_suspend_equivalent); 238 } 239 return false; 240 } 241 242 bool notify_all() { 243 if (_monitor != NULL) { 244 return _monitor->notify_all(); 245 } 246 return true; 247 } 248 249 bool notify() { 250 if (_monitor != NULL) { 251 return _monitor->notify(); 252 } 253 return true; 254 } 255}; 256 257 258 259// A GCMutexLocker is usually initialized with a mutex that is 260// automatically acquired in order to do GC. The function that 261// synchronizes using a GCMutexLocker may be called both during and between 262// GC's. Thus, it must acquire the mutex if GC is not in progress, but not 263// if GC is in progress (since the mutex is already held on its behalf.) 264 265class GCMutexLocker: public StackObj { 266private: 267 Monitor * _mutex; 268 bool _locked; 269public: 270 GCMutexLocker(Monitor * mutex); 271 ~GCMutexLocker() { if (_locked) _mutex->unlock(); } 272}; 273 274 275 276// A MutexUnlocker temporarily exits a previously 277// entered mutex for the scope which contains the unlocker. 278 279class MutexUnlocker: StackObj { 280 private: 281 Monitor * _mutex; 282 283 public: 284 MutexUnlocker(Monitor * mutex) { 285 _mutex = mutex; 286 _mutex->unlock(); 287 } 288 289 ~MutexUnlocker() { 290 _mutex->lock(); 291 } 292}; 293 294// A MutexUnlockerEx temporarily exits a previously 295// entered mutex for the scope which contains the unlocker. 296 297class MutexUnlockerEx: StackObj { 298 private: 299 Monitor * _mutex; 300 bool _no_safepoint_check; 301 302 public: 303 MutexUnlockerEx(Monitor * mutex, bool no_safepoint_check = !Mutex::_no_safepoint_check_flag) { 304 _mutex = mutex; 305 _no_safepoint_check = no_safepoint_check; 306 _mutex->unlock(); 307 } 308 309 ~MutexUnlockerEx() { 310 if (_no_safepoint_check == Mutex::_no_safepoint_check_flag) { 311 _mutex->lock_without_safepoint_check(); 312 } else { 313 _mutex->lock(); 314 } 315 } 316}; 317 318#ifndef PRODUCT 319// 320// A special MutexLocker that allows: 321// - reentrant locking 322// - locking out of order 323// 324// Only too be used for verify code, where we can relaxe out dead-lock 325// dection code a bit (unsafe, but probably ok). This code is NEVER to 326// be included in a product version. 327// 328class VerifyMutexLocker: StackObj { 329 private: 330 Monitor * _mutex; 331 bool _reentrant; 332 public: 333 VerifyMutexLocker(Monitor * mutex) { 334 _mutex = mutex; 335 _reentrant = mutex->owned_by_self(); 336 if (!_reentrant) { 337 // We temp. diable strict safepoint checking, while we require the lock 338 FlagSetting fs(StrictSafepointChecks, false); 339 _mutex->lock(); 340 } 341 } 342 343 ~VerifyMutexLocker() { 344 if (!_reentrant) { 345 _mutex->unlock(); 346 } 347 } 348}; 349 350#endif 351