jdk-sandbox: hotspot/src/share/vm/runtime/mutexLocker.cpp@b830f5141dbb (annotated)

1 489c9b5090e2 Initial load duke parents: diff changeset	1	/*
36357 953ab5f53cff 8150506: Remove unused locks dholmes parents: 35228 diff changeset	2	* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
1 489c9b5090e2 Initial load duke parents: diff changeset	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load duke parents: diff changeset	4	*
489c9b5090e2 Initial load duke parents: diff changeset	5	* This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load duke parents: diff changeset	6	* under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load duke parents: diff changeset	7	* published by the Free Software Foundation.
489c9b5090e2 Initial load duke parents: diff changeset	8	*
489c9b5090e2 Initial load duke parents: diff changeset	9	* This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load duke parents: diff changeset	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load duke parents: diff changeset	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
489c9b5090e2 Initial load duke parents: diff changeset	12	* version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load duke parents: diff changeset	13	* accompanied this code).
489c9b5090e2 Initial load duke parents: diff changeset	14	*
489c9b5090e2 Initial load duke parents: diff changeset	15	* You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load duke parents: diff changeset	16	* 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load duke parents: diff changeset	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load duke parents: diff changeset	18	*
5547 f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 5403 diff changeset	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 5403 diff changeset	20	* or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 5403 diff changeset	21	* questions.
1 489c9b5090e2 Initial load duke parents: diff changeset	22	*
489c9b5090e2 Initial load duke parents: diff changeset	23	*/
489c9b5090e2 Initial load duke parents: diff changeset	24
7397 5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 6058 diff changeset	25	#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 6058 diff changeset	26	#include "runtime/mutexLocker.hpp"
25468 5331df506290 8048241: Introduce umbrella header os.inline.hpp and clean up includes goetz parents: 24839 diff changeset	27	#include "runtime/os.inline.hpp"
7397 5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 6058 diff changeset	28	#include "runtime/safepoint.hpp"
14583 d70ee55535f4 8003935: Simplify the needed includes for using Thread::current() stefank parents: 14390 diff changeset	29	#include "runtime/thread.inline.hpp"
7397 5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 6058 diff changeset	30	#include "runtime/vmThread.hpp"
1 489c9b5090e2 Initial load duke parents: diff changeset	31
489c9b5090e2 Initial load duke parents: diff changeset	32	// Mutexes used in the VM (see comment in mutexLocker.hpp):
489c9b5090e2 Initial load duke parents: diff changeset	33	//
489c9b5090e2 Initial load duke parents: diff changeset	34	// Note that the following pointers are effectively final -- after having been
489c9b5090e2 Initial load duke parents: diff changeset	35	// set at JVM startup-time, they should never be subsequently mutated.
489c9b5090e2 Initial load duke parents: diff changeset	36	// Instead of using pointers to malloc()ed monitors and mutexes we should consider
489c9b5090e2 Initial load duke parents: diff changeset	37	// eliminating the indirection and using instances instead.
489c9b5090e2 Initial load duke parents: diff changeset	38	// Consider using GCC's __read_mostly.
489c9b5090e2 Initial load duke parents: diff changeset	39
489c9b5090e2 Initial load duke parents: diff changeset	40	Mutex* Patching_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	41	Monitor* SystemDictionary_lock = NULL;
36508 5f9eee6b383b 8142968: Module System implementation alanb parents: 36357 diff changeset	42	Mutex* Module_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	43	Mutex* CompiledIC_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	44	Mutex* InlineCacheBuffer_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	45	Mutex* VMStatistic_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	46	Mutex* JNIGlobalHandle_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	47	Mutex* JNIHandleBlockFreeList_lock = NULL;
17029 9ff8d7c0ed79 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 14583 diff changeset	48	Mutex* MemberNameTable_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	49	Mutex* JmethodIdCreation_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	50	Mutex* JfieldIdCreation_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	51	Monitor* JNICritical_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	52	Mutex* JvmtiThreadState_lock = NULL;
1374 4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	53	Monitor* Heap_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	54	Mutex* ExpandHeap_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	55	Mutex* AdapterHandlerLibrary_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	56	Mutex* SignatureHandlerLibrary_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	57	Mutex* VtableStubs_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	58	Mutex* SymbolTable_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	59	Mutex* StringTable_lock = NULL;
23472 35e93890ed88 8029075: String deduplication in G1 pliden parents: 20017 diff changeset	60	Monitor* StringDedupQueue_lock = NULL;
35e93890ed88 8029075: String deduplication in G1 pliden parents: 20017 diff changeset	61	Mutex* StringDedupTable_lock = NULL;
27420 04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full. anoll parents: 25468 diff changeset	62	Monitor* CodeCache_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	63	Mutex* MethodData_lock = NULL;
31790 4a08476437e8 8025692: Log what methods are touched at run-time minqi parents: 31608 diff changeset	64	Mutex* TouchedMethodLog_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	65	Mutex* RetData_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	66	Monitor* VMOperationQueue_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	67	Monitor* VMOperationRequest_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	68	Monitor* Safepoint_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	69	Monitor* SerializePage_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	70	Monitor* Threads_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	71	Monitor* CGC_lock = NULL;
24094 5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet pliden parents: 23472 diff changeset	72	Monitor* STS_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	73	Monitor* FullGCCount_lock = NULL;
1374 4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	74	Mutex* SATB_Q_FL_lock = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	75	Monitor* SATB_Q_CBL_mon = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	76	Mutex* Shared_SATB_Q_lock = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	77	Mutex* DirtyCardQ_FL_lock = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	78	Monitor* DirtyCardQ_CBL_mon = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	79	Mutex* Shared_DirtyCardQ_lock = NULL;
41176 ff9f64534cff 8159422: Very high Concurrent Mark mark stack contention tschatzl parents: 39208 diff changeset	80	Mutex* MarkStackFreeList_lock = NULL;
ff9f64534cff 8159422: Very high Concurrent Mark mark stack contention tschatzl parents: 39208 diff changeset	81	Mutex* MarkStackChunkList_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	82	Mutex* ParGCRareEvent_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	83	Mutex* DerivedPointerTableGC_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	84	Mutex* Compile_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	85	Monitor* MethodCompileQueue_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	86	Monitor* CompileThread_lock = NULL;
27642 8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature iignatyev parents: 27420 diff changeset	87	Monitor* Compilation_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	88	Mutex* CompileTaskAlloc_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	89	Mutex* CompileStatistics_lock = NULL;
33451 0712796e4039 8137167: JEP165: Compiler Control: Implementation task neliasso parents: 33105 diff changeset	90	Mutex* DirectivesStack_lock = NULL;
1 489c9b5090e2 Initial load duke parents: diff changeset	91	Mutex* MultiArray_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	92	Monitor* Terminator_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	93	Monitor* BeforeExit_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	94	Monitor* Notify_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	95	Mutex* ProfilePrint_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	96	Mutex* ExceptionCache_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	97	Mutex* OsrList_lock = NULL;
31608 b5cb9a07591a 8080511: Refresh of jimage support jfdenise parents: 30108 diff changeset	98
1 489c9b5090e2 Initial load duke parents: diff changeset	99	#ifndef PRODUCT
489c9b5090e2 Initial load duke parents: diff changeset	100	Mutex* FullGCALot_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	101	#endif
489c9b5090e2 Initial load duke parents: diff changeset	102
489c9b5090e2 Initial load duke parents: diff changeset	103	Mutex* Debug1_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	104	Mutex* Debug2_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	105	Mutex* Debug3_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	106
489c9b5090e2 Initial load duke parents: diff changeset	107	Mutex* tty_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	108
489c9b5090e2 Initial load duke parents: diff changeset	109	Mutex* RawMonitor_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	110	Mutex* PerfDataMemAlloc_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	111	Mutex* PerfDataManager_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	112	Mutex* OopMapCacheAlloc_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	113
7923 fc200fcd4e05 6977804: G1: remove the zero-filling thread tonyp parents: 7397 diff changeset	114	Mutex* FreeList_lock = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread tonyp parents: 7397 diff changeset	115	Monitor* SecondaryFreeList_lock = NULL;
fc200fcd4e05 6977804: G1: remove the zero-filling thread tonyp parents: 7397 diff changeset	116	Mutex* OldSets_lock = NULL;
11584 e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause tonyp parents: 10565 diff changeset	117	Monitor* RootRegionScan_lock = NULL;
1374 4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	118	Mutex* MMUTracker_lock = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	119
1 489c9b5090e2 Initial load duke parents: diff changeset	120	Monitor* GCTaskManager_lock = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	121
489c9b5090e2 Initial load duke parents: diff changeset	122	Mutex* Management_lock = NULL;
11480 1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 10565 diff changeset	123	Monitor* Service_lock = NULL;
19542 e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	124	Monitor* PeriodicTask_lock = NULL;
38309 9b8e9c373740 8155951: VM crash in nsk/jvmti/RedefineClasses/StressRedefine: assert failed: Corrupted constant pool coleenp parents: 37179 diff changeset	125	Monitor* RedefineClasses_lock = NULL;
11480 1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 10565 diff changeset	126
19542 e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	127	#ifdef INCLUDE_TRACE
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	128	Mutex* JfrStacktrace_lock = NULL;
11480 1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 10565 diff changeset	129	Monitor* JfrMsg_lock = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 10565 diff changeset	130	Mutex* JfrBuffer_lock = NULL;
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 10565 diff changeset	131	Mutex* JfrStream_lock = NULL;
19542 e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	132	Mutex* JfrThreadGroups_lock = NULL;
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	133	#endif
1 489c9b5090e2 Initial load duke parents: diff changeset	134
27874 e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java dholmes parents: 27645 diff changeset	135	#ifndef SUPPORTS_NATIVE_CX8
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java dholmes parents: 27645 diff changeset	136	Mutex* UnsafeJlong_lock = NULL;
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java dholmes parents: 27645 diff changeset	137	#endif
e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java dholmes parents: 27645 diff changeset	138
1 489c9b5090e2 Initial load duke parents: diff changeset	139	#define MAX_NUM_MUTEX 128
489c9b5090e2 Initial load duke parents: diff changeset	140	static Monitor * _mutex_array[MAX_NUM_MUTEX];
489c9b5090e2 Initial load duke parents: diff changeset	141	static int _num_mutex;
489c9b5090e2 Initial load duke parents: diff changeset	142
489c9b5090e2 Initial load duke parents: diff changeset	143	#ifdef ASSERT
489c9b5090e2 Initial load duke parents: diff changeset	144	void assert_locked_or_safepoint(const Monitor * lock) {
489c9b5090e2 Initial load duke parents: diff changeset	145	// check if this thread owns the lock (common case)
489c9b5090e2 Initial load duke parents: diff changeset	146	if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load duke parents: diff changeset	147	assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load duke parents: diff changeset	148	if (lock->owned_by_self()) return;
489c9b5090e2 Initial load duke parents: diff changeset	149	if (SafepointSynchronize::is_at_safepoint()) return;
489c9b5090e2 Initial load duke parents: diff changeset	150	if (!Universe::is_fully_initialized()) return;
489c9b5090e2 Initial load duke parents: diff changeset	151	// see if invoker of VM operation owns it
489c9b5090e2 Initial load duke parents: diff changeset	152	VM_Operation* op = VMThread::vm_operation();
489c9b5090e2 Initial load duke parents: diff changeset	153	if (op != NULL && op->calling_thread() == lock->owner()) return;
33105 294e48b4f704 8080775: Better argument formatting for assert() and friends david parents: 33097 diff changeset	154	fatal("must own lock %s", lock->name());
1 489c9b5090e2 Initial load duke parents: diff changeset	155	}
489c9b5090e2 Initial load duke parents: diff changeset	156
489c9b5090e2 Initial load duke parents: diff changeset	157	// a stronger assertion than the above
489c9b5090e2 Initial load duke parents: diff changeset	158	void assert_lock_strong(const Monitor * lock) {
489c9b5090e2 Initial load duke parents: diff changeset	159	if (IgnoreLockingAssertions) return;
489c9b5090e2 Initial load duke parents: diff changeset	160	assert(lock != NULL, "Need non-NULL lock");
489c9b5090e2 Initial load duke parents: diff changeset	161	if (lock->owned_by_self()) return;
33105 294e48b4f704 8080775: Better argument formatting for assert() and friends david parents: 33097 diff changeset	162	fatal("must own lock %s", lock->name());
1 489c9b5090e2 Initial load duke parents: diff changeset	163	}
489c9b5090e2 Initial load duke parents: diff changeset	164	#endif
489c9b5090e2 Initial load duke parents: diff changeset	165
28163 322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	166	#define def(var, type, pri, vm_block, safepoint_check_allowed ) { \
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	167	var = new type(Mutex::pri, #var, vm_block, safepoint_check_allowed); \
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	168	assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX"); \
30108 fbe647bcbc25 8072128: mutexLocker.cpp _mutex_array[] initialization broken with safepoint check change mockner parents: 28831 diff changeset	169	_mutex_array[_num_mutex++] = var; \
1 489c9b5090e2 Initial load duke parents: diff changeset	170	}
489c9b5090e2 Initial load duke parents: diff changeset	171
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	172	// Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
1 489c9b5090e2 Initial load duke parents: diff changeset	173	void mutex_init() {
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	174	def(tty_lock , PaddedMutex , event, true, Monitor::_safepoint_check_never); // allow to lock in VM
1 489c9b5090e2 Initial load duke parents: diff changeset	175
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	176	def(CGC_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); // coordinate between fore- and background GC
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	177	def(STS_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never);
28163 322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	178
6058 9c9aec6ab47d 6944166: G1: explicit GCs are not always handled correctly tonyp parents: 5707 diff changeset	179	if (UseConcMarkSweepGC \|\| UseG1GC) {
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	180	def(FullGCCount_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); // in support of ExplicitGCInvokesConcurrent
1 489c9b5090e2 Initial load duke parents: diff changeset	181	}
1374 4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	182	if (UseG1GC) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	183
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	184	def(SATB_Q_FL_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	185	def(SATB_Q_CBL_mon , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	186	def(Shared_SATB_Q_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_never);
28163 322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	187
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	188	def(DirtyCardQ_FL_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	189	def(DirtyCardQ_CBL_mon , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	190	def(Shared_DirtyCardQ_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_never);
1374 4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	191
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	192	def(FreeList_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	193	def(SecondaryFreeList_lock , PaddedMonitor, leaf , true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	194	def(OldSets_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	195	def(RootRegionScan_lock , PaddedMonitor, leaf , true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	196	def(MMUTracker_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never);
23472 35e93890ed88 8029075: String deduplication in G1 pliden parents: 20017 diff changeset	197
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	198	def(StringDedupQueue_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	199	def(StringDedupTable_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never);
41176 ff9f64534cff 8159422: Very high Concurrent Mark mark stack contention tschatzl parents: 39208 diff changeset	200
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	201	def(MarkStackFreeList_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	202	def(MarkStackChunkList_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never);
1374 4c24294029a9 6711316: Open source the Garbage-First garbage collector ysr parents: 228 diff changeset	203	}
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	204	def(ParGCRareEvent_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	205	def(DerivedPointerTableGC_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	206	def(CodeCache_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	207	def(RawMonitor_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	208	def(OopMapCacheAlloc_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for oop_map_cache allocation.
1 489c9b5090e2 Initial load duke parents: diff changeset	209
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	210	def(Patching_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); // used for safepointing and code patching.
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	211	def(Service_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); // used for service thread operations
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	212	def(JmethodIdCreation_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for creating jmethodIDs.
1 489c9b5090e2 Initial load duke parents: diff changeset	213
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	214	def(SystemDictionary_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_always); // lookups done by VM thread
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	215	def(Module_lock , PaddedMutex , leaf+2, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	216	def(InlineCacheBuffer_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	217	def(VMStatistic_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	218	def(ExpandHeap_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // Used during compilation by VM thread
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	219	def(JNIHandleBlockFreeList_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); // handles are used by VM thread
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	220	def(SignatureHandlerLibrary_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	221	def(SymbolTable_lock , PaddedMutex , leaf+2, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	222	def(StringTable_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	223	def(ProfilePrint_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); // serial profile printing
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	224	def(ExceptionCache_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); // serial profile printing
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	225	def(OsrList_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	226	def(Debug1_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never);
1 489c9b5090e2 Initial load duke parents: diff changeset	227	#ifndef PRODUCT
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	228	def(FullGCALot_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); // a lock to make FullGCALot MT safe
1 489c9b5090e2 Initial load duke parents: diff changeset	229	#endif
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	230	def(BeforeExit_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	231	def(PerfDataMemAlloc_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for allocating PerfData memory for performance data
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	232	def(PerfDataManager_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for synchronized access to PerfDataManager resources
1 489c9b5090e2 Initial load duke parents: diff changeset	233
489c9b5090e2 Initial load duke parents: diff changeset	234	// CMS_modUnionTable_lock leaf
28163 322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	235	// CMS_bitMap_lock leaf 1
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	236	// CMS_freeList_lock leaf 2
1 489c9b5090e2 Initial load duke parents: diff changeset	237
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	238	def(Safepoint_lock , PaddedMonitor, safepoint, true, Monitor::_safepoint_check_sometimes); // locks SnippetCache_lock/Threads_lock
1 489c9b5090e2 Initial load duke parents: diff changeset	239
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	240	def(Threads_lock , PaddedMonitor, barrier, true, Monitor::_safepoint_check_sometimes);
1 489c9b5090e2 Initial load duke parents: diff changeset	241
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	242	def(VMOperationQueue_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_sometimes); // VM_thread allowed to block on these
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	243	def(VMOperationRequest_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	244	def(RetData_lock , PaddedMutex , nonleaf, false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	245	def(Terminator_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	246	def(VtableStubs_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	247	def(Notify_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	248	def(JNIGlobalHandle_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always); // locks JNIHandleBlockFreeList_lock
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	249	def(JNICritical_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always); // used for JNI critical regions
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	250	def(AdapterHandlerLibrary_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always);
28163 322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	251
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	252	def(Heap_lock , PaddedMonitor, nonleaf+1, false, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	253	def(JfieldIdCreation_lock , PaddedMutex , nonleaf+1, true, Monitor::_safepoint_check_always); // jfieldID, Used in VM_Operation
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	254	def(MemberNameTable_lock , PaddedMutex , nonleaf+1, false, Monitor::_safepoint_check_always); // Used to protect MemberNameTable
1 489c9b5090e2 Initial load duke parents: diff changeset	255
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	256	def(CompiledIC_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); // locks VtableStubs_lock, InlineCacheBuffer_lock
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	257	def(CompileTaskAlloc_lock , PaddedMutex , nonleaf+2, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	258	def(CompileStatistics_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	259	def(DirectivesStack_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	260	def(MultiArray_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); // locks SymbolTable_lock
1 489c9b5090e2 Initial load duke parents: diff changeset	261
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	262	def(JvmtiThreadState_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); // Used by JvmtiThreadState/JvmtiEventController
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	263	def(Management_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); // used for JVM management
1 489c9b5090e2 Initial load duke parents: diff changeset	264
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	265	def(Compile_lock , PaddedMutex , nonleaf+3, true, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	266	def(MethodData_lock , PaddedMutex , nonleaf+3, false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	267	def(TouchedMethodLog_lock , PaddedMutex , nonleaf+3, false, Monitor::_safepoint_check_always);
1 489c9b5090e2 Initial load duke parents: diff changeset	268
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	269	def(MethodCompileQueue_lock , PaddedMonitor, nonleaf+4, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	270	def(Debug2_lock , PaddedMutex , nonleaf+4, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	271	def(Debug3_lock , PaddedMutex , nonleaf+4, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	272	def(CompileThread_lock , PaddedMonitor, nonleaf+5, false, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	273	def(PeriodicTask_lock , PaddedMonitor, nonleaf+5, true, Monitor::_safepoint_check_sometimes);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	274	def(RedefineClasses_lock , PaddedMonitor, nonleaf+5, true, Monitor::_safepoint_check_always);
27642 8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature iignatyev parents: 27420 diff changeset	275	if (WhiteBoxAPI) {
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	276	def(Compilation_lock , PaddedMonitor, leaf, false, Monitor::_safepoint_check_never);
27642 8c9eff693145 8059624: Test task: WhiteBox API for testing segmented codecache feature iignatyev parents: 27420 diff changeset	277	}
28163 322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint coleenp parents: 27874 diff changeset	278
19542 e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	279	#ifdef INCLUDE_TRACE
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	280	def(JfrMsg_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	281	def(JfrBuffer_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	282	def(JfrThreadGroups_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always);
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	283	def(JfrStream_lock , PaddedMutex , leaf+1, true, Monitor::_safepoint_check_never); // ensure to rank lower than 'safepoint'
b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	284	def(JfrStacktrace_lock , PaddedMutex , special, true, Monitor::_safepoint_check_sometimes);
19542 e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	285	#endif
e55d447cc2a1 8023457: Event based tracing framework needs a mutex for thread groups mgronlun parents: 18025 diff changeset	286
27874 e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java dholmes parents: 27645 diff changeset	287	#ifndef SUPPORTS_NATIVE_CX8
41710 b830f5141dbb 8166970: Adapt mutex padding according to DEFAULT_CACHE_LINE_SIZE mdoerr parents: 41176 diff changeset	288	def(UnsafeJlong_lock , PaddedMutex , special, false, Monitor::_safepoint_check_never);
27874 e9b44eb1613f 8035663: Suspicious failure of test java/util/concurrent/Phaser/FickleRegister.java dholmes parents: 27645 diff changeset	289	#endif
1 489c9b5090e2 Initial load duke parents: diff changeset	290	}
489c9b5090e2 Initial load duke parents: diff changeset	291
489c9b5090e2 Initial load duke parents: diff changeset	292	GCMutexLocker::GCMutexLocker(Monitor * mutex) {
489c9b5090e2 Initial load duke parents: diff changeset	293	if (SafepointSynchronize::is_at_safepoint()) {
489c9b5090e2 Initial load duke parents: diff changeset	294	_locked = false;
489c9b5090e2 Initial load duke parents: diff changeset	295	} else {
489c9b5090e2 Initial load duke parents: diff changeset	296	_mutex = mutex;
489c9b5090e2 Initial load duke parents: diff changeset	297	_locked = true;
489c9b5090e2 Initial load duke parents: diff changeset	298	_mutex->lock();
489c9b5090e2 Initial load duke parents: diff changeset	299	}
489c9b5090e2 Initial load duke parents: diff changeset	300	}
489c9b5090e2 Initial load duke parents: diff changeset	301
489c9b5090e2 Initial load duke parents: diff changeset	302	// Print all mutexes/monitors that are currently owned by a thread; called
489c9b5090e2 Initial load duke parents: diff changeset	303	// by fatal error handler.
489c9b5090e2 Initial load duke parents: diff changeset	304	void print_owned_locks_on_error(outputStream* st) {
489c9b5090e2 Initial load duke parents: diff changeset	305	st->print("VM Mutex/Monitor currently owned by a thread: ");
489c9b5090e2 Initial load duke parents: diff changeset	306	bool none = true;
489c9b5090e2 Initial load duke parents: diff changeset	307	for (int i = 0; i < _num_mutex; i++) {
489c9b5090e2 Initial load duke parents: diff changeset	308	// see if it has an owner
489c9b5090e2 Initial load duke parents: diff changeset	309	if (_mutex_array[i]->owner() != NULL) {
489c9b5090e2 Initial load duke parents: diff changeset	310	if (none) {
489c9b5090e2 Initial load duke parents: diff changeset	311	// print format used by Mutex::print_on_error()
489c9b5090e2 Initial load duke parents: diff changeset	312	st->print_cr(" ([mutex/lock_event])");
489c9b5090e2 Initial load duke parents: diff changeset	313	none = false;
489c9b5090e2 Initial load duke parents: diff changeset	314	}
489c9b5090e2 Initial load duke parents: diff changeset	315	_mutex_array[i]->print_on_error(st);
489c9b5090e2 Initial load duke parents: diff changeset	316	st->cr();
489c9b5090e2 Initial load duke parents: diff changeset	317	}
489c9b5090e2 Initial load duke parents: diff changeset	318	}
489c9b5090e2 Initial load duke parents: diff changeset	319	if (none) st->print_cr("None");
489c9b5090e2 Initial load duke parents: diff changeset	320	}

author	mdoerr
	Wed, 12 Oct 2016 10:41:00 +0200
changeset 41710	b830f5141dbb
parent 41176	ff9f64534cff
child 46304	8d4d88f90669
child 44316	a0f13c798ee1
permissions	-rw-r--r--