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