archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 14:54:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8231472: Clean up Monitor::_safepoint_check usage to Mutex::_safepoint_check

Browse source 
Change Monitor:: to Mutex:: when allocating a Mutex, and in mutexLocker.

Reviewed-by: rehn, dholmes
This commit is contained in:
Coleen Phillimore 2019-09-27 07:56:02 -04:00
parent 2f2ec624a2
commit 59dcb50e96
8 changed files with 105 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/hotspot/share/classfile/classLoaderData.cpp
View file

@ -129,8 +129,8 @@ void ClassLoaderData::initialize_name(Handle class_loader) {
ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_unsafe_anonymous) : ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_unsafe_anonymous) :
_metaspace(NULL), _metaspace(NULL),
_metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true, _metaspace_lock(new Mutex(Mutex::leaf+1, "Metaspace allocation lock", true,
Monitor::_safepoint_check_never)), Mutex::_safepoint_check_never)),
_unloading(false), _is_unsafe_anonymous(is_unsafe_anonymous), _unloading(false), _is_unsafe_anonymous(is_unsafe_anonymous),
_modified_oops(true), _accumulated_modified_oops(false), _modified_oops(true), _accumulated_modified_oops(false),
// An unsafe anonymous class loader data doesn't have anything to keep // An unsafe anonymous class loader data doesn't have anything to keep

2
src/hotspot/share/gc/g1/g1RootProcessor.cpp
View file

@ -71,7 +71,7 @@ G1RootProcessor::G1RootProcessor(G1CollectedHeap* g1h, uint n_workers) :
_g1h(g1h), _g1h(g1h),
_process_strong_tasks(G1RP_PS_NumElements), _process_strong_tasks(G1RP_PS_NumElements),
_srs(n_workers), _srs(n_workers),
_lock(Mutex::leaf, "G1 Root Scan barrier lock", false, Monitor::_safepoint_check_never), _lock(Mutex::leaf, "G1 Root Scan barrier lock", false, Mutex::_safepoint_check_never),
_n_workers_discovered_strong_classes(0) {} _n_workers_discovered_strong_classes(0) {}
void G1RootProcessor::evacuate_roots(G1ParScanThreadState* pss, uint worker_id) { void G1RootProcessor::evacuate_roots(G1ParScanThreadState* pss, uint worker_id) {

2
src/hotspot/share/gc/g1/heapRegionRemSet.cpp
View file

@ -428,7 +428,7 @@ HeapRegionRemSet::HeapRegionRemSet(G1BlockOffsetTable* bot,
HeapRegion* hr) HeapRegion* hr)
: _bot(bot), : _bot(bot),
_code_roots(), _code_roots(),
_m(Mutex::leaf, FormatBuffer<128>("HeapRegionRemSet lock #%u", hr->hrm_index()), true, Monitor::_safepoint_check_never), _m(Mutex::leaf, FormatBuffer<128>("HeapRegionRemSet lock #%u", hr->hrm_index()), true, Mutex::_safepoint_check_never),
_other_regions(&_m), _other_regions(&_m),
_hr(hr), _hr(hr),
_state(Untracked) _state(Untracked)

2
src/hotspot/share/oops/methodData.cpp
View file

@ -1212,7 +1212,7 @@ void MethodData::post_initialize(BytecodeStream* stream) {
// Initialize the MethodData* corresponding to a given method. // Initialize the MethodData* corresponding to a given method.
MethodData::MethodData(const methodHandle& method, int size, TRAPS) MethodData::MethodData(const methodHandle& method, int size, TRAPS)
: _extra_data_lock(Monitor::leaf, "MDO extra data lock"), : _extra_data_lock(Mutex::leaf, "MDO extra data lock"),
_parameters_type_data_di(parameters_uninitialized) { _parameters_type_data_di(parameters_uninitialized) {
// Set the method back-pointer. // Set the method back-pointer.
_method = method(); _method = method();

2
src/hotspot/share/oops/methodData.hpp
View file

@ -2011,7 +2011,7 @@ private:
MethodData(const methodHandle& method, int size, TRAPS); MethodData(const methodHandle& method, int size, TRAPS);
public: public:
static MethodData* allocate(ClassLoaderData* loader_data, const methodHandle& method, TRAPS); static MethodData* allocate(ClassLoaderData* loader_data, const methodHandle& method, TRAPS);
MethodData() : _extra_data_lock(Monitor::leaf, "MDO extra data lock") {}; // For ciMethodData MethodData() : _extra_data_lock(Mutex::leaf, "MDO extra data lock") {}; // For ciMethodData
bool is_methodData() const volatile { return true; } bool is_methodData() const volatile { return true; }
void initialize(); void initialize();

12
src/hotspot/share/prims/whitebox.cpp
View file

@ -1735,12 +1735,12 @@ WB_ENTRY(jlong, WB_MetaspaceReserveAlignment(JNIEnv* env, jobject wb))
WB_END WB_END
WB_ENTRY(void, WB_AssertMatchingSafepointCalls(JNIEnv* env, jobject o, jboolean mutexSafepointValue, jboolean attemptedNoSafepointValue)) WB_ENTRY(void, WB_AssertMatchingSafepointCalls(JNIEnv* env, jobject o, jboolean mutexSafepointValue, jboolean attemptedNoSafepointValue))
Monitor::SafepointCheckRequired sfpt_check_required = mutexSafepointValue ? Mutex::SafepointCheckRequired sfpt_check_required = mutexSafepointValue ?
Monitor::_safepoint_check_always : Mutex::_safepoint_check_always :
Monitor::_safepoint_check_never; Mutex::_safepoint_check_never;
Monitor::SafepointCheckFlag sfpt_check_attempted = attemptedNoSafepointValue ? Mutex::SafepointCheckFlag sfpt_check_attempted = attemptedNoSafepointValue ?
Monitor::_no_safepoint_check_flag : Mutex::_no_safepoint_check_flag :
Monitor::_safepoint_check_flag; Mutex::_safepoint_check_flag;
MutexLocker ml(new Mutex(Mutex::leaf, "SFPT_Test_lock", true, sfpt_check_required), MutexLocker ml(new Mutex(Mutex::leaf, "SFPT_Test_lock", true, sfpt_check_required),
sfpt_check_attempted); sfpt_check_attempted);
WB_END WB_END

184
src/hotspot/share/runtime/mutexLocker.cpp
View file

@ -191,148 +191,148 @@ void assert_lock_strong(const Mutex* lock) {
#endif #endif
#define def(var, type, pri, vm_block, safepoint_check_allowed ) { \ #define def(var, type, pri, vm_block, safepoint_check_allowed ) { \
var = new type(Mutex::pri, #var, vm_block, safepoint_check_allowed); \ var = new type(Mutex::pri, #var, vm_block, Mutex::safepoint_check_allowed); \
assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX"); \ assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX"); \
_mutex_array[_num_mutex++] = var; \ _mutex_array[_num_mutex++] = var; \
} }
// Using Padded subclasses to prevent false sharing of these global monitors and mutexes. // Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
void mutex_init() { void mutex_init() {
def(tty_lock , PaddedMutex , tty, true, Monitor::_safepoint_check_never); // allow to lock in VM def(tty_lock , PaddedMutex , tty, true, _safepoint_check_never); // allow to lock in VM
def(CGC_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); // coordinate between fore- and background GC def(CGC_lock , PaddedMonitor, special, true, _safepoint_check_never); // coordinate between fore- and background GC
def(STS_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); def(STS_lock , PaddedMonitor, leaf, true, _safepoint_check_never);
def(FullGCCount_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); // in support of ExplicitGCInvokesConcurrent def(FullGCCount_lock , PaddedMonitor, leaf, true, _safepoint_check_never); // in support of ExplicitGCInvokesConcurrent
if (UseG1GC) { if (UseG1GC) {
def(DirtyCardQ_CBL_mon , PaddedMonitor, access, true, Monitor::_safepoint_check_never); def(DirtyCardQ_CBL_mon , PaddedMonitor, access, true, _safepoint_check_never);
def(Shared_DirtyCardQ_lock , PaddedMutex , access + 1, true, Monitor::_safepoint_check_never); def(Shared_DirtyCardQ_lock , PaddedMutex , access + 1, true, _safepoint_check_never);
def(FreeList_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never); def(FreeList_lock , PaddedMutex , leaf , true, _safepoint_check_never);
def(OldSets_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never); def(OldSets_lock , PaddedMutex , leaf , true, _safepoint_check_never);
def(RootRegionScan_lock , PaddedMonitor, leaf , true, Monitor::_safepoint_check_never); def(RootRegionScan_lock , PaddedMonitor, leaf , true, _safepoint_check_never);
def(StringDedupQueue_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); def(StringDedupQueue_lock , PaddedMonitor, leaf, true, _safepoint_check_never);
def(StringDedupTable_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(StringDedupTable_lock , PaddedMutex , leaf, true, _safepoint_check_never);
def(MarkStackFreeList_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never); def(MarkStackFreeList_lock , PaddedMutex , leaf , true, _safepoint_check_never);
def(MarkStackChunkList_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_never); def(MarkStackChunkList_lock , PaddedMutex , leaf , true, _safepoint_check_never);
def(MonitoringSupport_lock , PaddedMutex , native , true, Monitor::_safepoint_check_never); // used for serviceability monitoring support def(MonitoringSupport_lock , PaddedMutex , native , true, _safepoint_check_never); // used for serviceability monitoring support
} }
if (UseShenandoahGC) { if (UseShenandoahGC) {
def(StringDedupQueue_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); def(StringDedupQueue_lock , PaddedMonitor, leaf, true, _safepoint_check_never);
def(StringDedupTable_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(StringDedupTable_lock , PaddedMutex , leaf, true, _safepoint_check_never);
} }
def(ParGCRareEvent_lock , PaddedMutex , leaf , true, Monitor::_safepoint_check_always); def(ParGCRareEvent_lock , PaddedMutex , leaf , true, _safepoint_check_always);
def(CGCPhaseManager_lock , PaddedMonitor, leaf, false, Monitor::_safepoint_check_always); def(CGCPhaseManager_lock , PaddedMonitor, leaf, false, _safepoint_check_always);
def(CodeCache_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); def(CodeCache_lock , PaddedMonitor, special, true, _safepoint_check_never);
def(RawMonitor_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); def(RawMonitor_lock , PaddedMutex , special, true, _safepoint_check_never);
def(OopMapCacheAlloc_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for oop_map_cache allocation. def(OopMapCacheAlloc_lock , PaddedMutex , leaf, true, _safepoint_check_always); // used for oop_map_cache allocation.
def(MetaspaceExpand_lock , PaddedMutex , leaf-1, true, Monitor::_safepoint_check_never); def(MetaspaceExpand_lock , PaddedMutex , leaf-1, true, _safepoint_check_never);
def(ClassLoaderDataGraph_lock , PaddedMutex , nonleaf, false, Monitor::_safepoint_check_always); def(ClassLoaderDataGraph_lock , PaddedMutex , nonleaf, false, _safepoint_check_always);
def(Patching_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); // used for safepointing and code patching. def(Patching_lock , PaddedMutex , special, true, _safepoint_check_never); // used for safepointing and code patching.
def(CompiledMethod_lock , PaddedMutex , special-1, true, Monitor::_safepoint_check_never); def(CompiledMethod_lock , PaddedMutex , special-1, true, _safepoint_check_never);
def(Service_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); // used for service thread operations def(Service_lock , PaddedMonitor, special, true, _safepoint_check_never); // used for service thread operations
def(JmethodIdCreation_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for creating jmethodIDs. def(JmethodIdCreation_lock , PaddedMutex , leaf, true, _safepoint_check_always); // used for creating jmethodIDs.
def(SystemDictionary_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_always); def(SystemDictionary_lock , PaddedMonitor, leaf, true, _safepoint_check_always);
def(ProtectionDomainSet_lock , PaddedMutex , leaf-1, true, Monitor::_safepoint_check_never); def(ProtectionDomainSet_lock , PaddedMutex , leaf-1, true, _safepoint_check_never);
def(SharedDictionary_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); def(SharedDictionary_lock , PaddedMutex , leaf, true, _safepoint_check_always);
def(Module_lock , PaddedMutex , leaf+2, false, Monitor::_safepoint_check_always); def(Module_lock , PaddedMutex , leaf+2, false, _safepoint_check_always);
def(InlineCacheBuffer_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(InlineCacheBuffer_lock , PaddedMutex , leaf, true, _safepoint_check_never);
def(VMStatistic_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); def(VMStatistic_lock , PaddedMutex , leaf, false, _safepoint_check_always);
def(ExpandHeap_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // Used during compilation by VM thread def(ExpandHeap_lock , PaddedMutex , leaf, true, _safepoint_check_always); // Used during compilation by VM thread
def(JNIHandleBlockFreeList_lock , PaddedMutex , leaf-1, true, Monitor::_safepoint_check_never); // handles are used by VM thread def(JNIHandleBlockFreeList_lock , PaddedMutex , leaf-1, true, _safepoint_check_never); // handles are used by VM thread
def(SignatureHandlerLibrary_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); def(SignatureHandlerLibrary_lock , PaddedMutex , leaf, false, _safepoint_check_always);
def(SymbolArena_lock , PaddedMutex , leaf+2, true, Monitor::_safepoint_check_never); def(SymbolArena_lock , PaddedMutex , leaf+2, true, _safepoint_check_never);
def(ProfilePrint_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); // serial profile printing def(ProfilePrint_lock , PaddedMutex , leaf, false, _safepoint_check_always); // serial profile printing
def(ExceptionCache_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); // serial profile printing def(ExceptionCache_lock , PaddedMutex , leaf, false, _safepoint_check_always); // serial profile printing
def(Debug1_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(Debug1_lock , PaddedMutex , leaf, true, _safepoint_check_never);
#ifndef PRODUCT #ifndef PRODUCT
def(FullGCALot_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); // a lock to make FullGCALot MT safe def(FullGCALot_lock , PaddedMutex , leaf, false, _safepoint_check_always); // a lock to make FullGCALot MT safe
#endif #endif
def(BeforeExit_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_always); def(BeforeExit_lock , PaddedMonitor, leaf, true, _safepoint_check_always);
def(PerfDataMemAlloc_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for allocating PerfData memory for performance data def(PerfDataMemAlloc_lock , PaddedMutex , leaf, true, _safepoint_check_always); // used for allocating PerfData memory for performance data
def(PerfDataManager_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for synchronized access to PerfDataManager resources def(PerfDataManager_lock , PaddedMutex , leaf, true, _safepoint_check_always); // used for synchronized access to PerfDataManager resources
// CMS_modUnionTable_lock leaf // CMS_modUnionTable_lock leaf
// CMS_bitMap_lock leaf 1 // CMS_bitMap_lock leaf 1
// CMS_freeList_lock leaf 2 // CMS_freeList_lock leaf 2
def(Threads_lock , PaddedMonitor, barrier, true, Monitor::_safepoint_check_always); // Used for safepoint protocol. def(Threads_lock , PaddedMonitor, barrier, true, _safepoint_check_always); // Used for safepoint protocol.
def(NonJavaThreadsList_lock , PaddedMutex, leaf, true, Monitor::_safepoint_check_never); def(NonJavaThreadsList_lock , PaddedMutex, leaf, true, _safepoint_check_never);
def(NonJavaThreadsListSync_lock , PaddedMutex, leaf, true, Monitor::_safepoint_check_never); def(NonJavaThreadsListSync_lock , PaddedMutex, leaf, true, _safepoint_check_never);
def(VMOperationQueue_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_never); // VM_thread allowed to block on these def(VMOperationQueue_lock , PaddedMonitor, nonleaf, true, _safepoint_check_never); // VM_thread allowed to block on these
def(VMOperationRequest_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always); def(VMOperationRequest_lock , PaddedMonitor, nonleaf, true, _safepoint_check_always);
def(RetData_lock , PaddedMutex , nonleaf, false, Monitor::_safepoint_check_always); def(RetData_lock , PaddedMutex , nonleaf, false, _safepoint_check_always);
def(Terminator_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always); def(Terminator_lock , PaddedMonitor, nonleaf, true, _safepoint_check_always);
def(InitCompleted_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); def(InitCompleted_lock , PaddedMonitor, leaf, true, _safepoint_check_never);
def(VtableStubs_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_never); def(VtableStubs_lock , PaddedMutex , nonleaf, true, _safepoint_check_never);
def(Notify_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always); def(Notify_lock , PaddedMonitor, nonleaf, true, _safepoint_check_always);
def(JNICritical_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always); // used for JNI critical regions def(JNICritical_lock , PaddedMonitor, nonleaf, true, _safepoint_check_always); // used for JNI critical regions
def(AdapterHandlerLibrary_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always); def(AdapterHandlerLibrary_lock , PaddedMutex , nonleaf, true, _safepoint_check_always);
def(Heap_lock , PaddedMonitor, nonleaf+1, false, Monitor::_safepoint_check_sometimes); // Doesn't safepoint check during termination. def(Heap_lock , PaddedMonitor, nonleaf+1, false, _safepoint_check_sometimes); // Doesn't safepoint check during termination.
def(JfieldIdCreation_lock , PaddedMutex , nonleaf+1, true, Monitor::_safepoint_check_always); // jfieldID, Used in VM_Operation def(JfieldIdCreation_lock , PaddedMutex , nonleaf+1, true, _safepoint_check_always); // jfieldID, Used in VM_Operation
def(CompiledIC_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_never); // locks VtableStubs_lock, InlineCacheBuffer_lock def(CompiledIC_lock , PaddedMutex , nonleaf+2, false, _safepoint_check_never); // locks VtableStubs_lock, InlineCacheBuffer_lock
def(CompileTaskAlloc_lock , PaddedMutex , nonleaf+2, true, Monitor::_safepoint_check_always); def(CompileTaskAlloc_lock , PaddedMutex , nonleaf+2, true, _safepoint_check_always);
def(CompileStatistics_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); def(CompileStatistics_lock , PaddedMutex , nonleaf+2, false, _safepoint_check_always);
def(DirectivesStack_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); def(DirectivesStack_lock , PaddedMutex , special, true, _safepoint_check_never);
def(MultiArray_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); def(MultiArray_lock , PaddedMutex , nonleaf+2, false, _safepoint_check_always);
def(JvmtiThreadState_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); // Used by JvmtiThreadState/JvmtiEventController def(JvmtiThreadState_lock , PaddedMutex , nonleaf+2, false, _safepoint_check_always); // Used by JvmtiThreadState/JvmtiEventController
def(Management_lock , PaddedMutex , nonleaf+2, false, Monitor::_safepoint_check_always); // used for JVM management def(Management_lock , PaddedMutex , nonleaf+2, false, _safepoint_check_always); // used for JVM management
def(Compile_lock , PaddedMutex , nonleaf+3, true, Monitor::_safepoint_check_always); def(Compile_lock , PaddedMutex , nonleaf+3, true, _safepoint_check_always);
def(MethodData_lock , PaddedMutex , nonleaf+3, false, Monitor::_safepoint_check_always); def(MethodData_lock , PaddedMutex , nonleaf+3, false, _safepoint_check_always);
def(TouchedMethodLog_lock , PaddedMutex , nonleaf+3, false, Monitor::_safepoint_check_always); def(TouchedMethodLog_lock , PaddedMutex , nonleaf+3, false, _safepoint_check_always);
def(MethodCompileQueue_lock , PaddedMonitor, nonleaf+4, false, Monitor::_safepoint_check_always); def(MethodCompileQueue_lock , PaddedMonitor, nonleaf+4, false, _safepoint_check_always);
def(Debug2_lock , PaddedMutex , nonleaf+4, true, Monitor::_safepoint_check_never); def(Debug2_lock , PaddedMutex , nonleaf+4, true, _safepoint_check_never);
def(Debug3_lock , PaddedMutex , nonleaf+4, true, Monitor::_safepoint_check_never); def(Debug3_lock , PaddedMutex , nonleaf+4, true, _safepoint_check_never);
def(CompileThread_lock , PaddedMonitor, nonleaf+5, false, Monitor::_safepoint_check_always); def(CompileThread_lock , PaddedMonitor, nonleaf+5, false, _safepoint_check_always);
def(PeriodicTask_lock , PaddedMonitor, nonleaf+5, true, Monitor::_safepoint_check_always); def(PeriodicTask_lock , PaddedMonitor, nonleaf+5, true, _safepoint_check_always);
def(RedefineClasses_lock , PaddedMonitor, nonleaf+5, true, Monitor::_safepoint_check_always); def(RedefineClasses_lock , PaddedMonitor, nonleaf+5, true, _safepoint_check_always);
if (WhiteBoxAPI) { if (WhiteBoxAPI) {
def(Compilation_lock , PaddedMonitor, leaf, false, Monitor::_safepoint_check_never); def(Compilation_lock , PaddedMonitor, leaf, false, _safepoint_check_never);
} }
#if INCLUDE_JFR #if INCLUDE_JFR
def(JfrMsg_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_always); def(JfrMsg_lock , PaddedMonitor, leaf, true, _safepoint_check_always);
def(JfrBuffer_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(JfrBuffer_lock , PaddedMutex , leaf, true, _safepoint_check_never);
def(JfrStream_lock , PaddedMutex , leaf+1, true, Monitor::_safepoint_check_never); // ensure to rank lower than 'safepoint' def(JfrStream_lock , PaddedMutex , leaf+1, true, _safepoint_check_never); // ensure to rank lower than 'safepoint'
def(JfrStacktrace_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); def(JfrStacktrace_lock , PaddedMutex , special, true, _safepoint_check_never);
def(JfrThreadSampler_lock , PaddedMonitor, leaf, true, Monitor::_safepoint_check_never); def(JfrThreadSampler_lock , PaddedMonitor, leaf, true, _safepoint_check_never);
#endif #endif
#ifndef SUPPORTS_NATIVE_CX8 #ifndef SUPPORTS_NATIVE_CX8
def(UnsafeJlong_lock , PaddedMutex , special, false, Monitor::_safepoint_check_never); def(UnsafeJlong_lock , PaddedMutex , special, false, _safepoint_check_never);
#endif #endif
def(CodeHeapStateAnalytics_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(CodeHeapStateAnalytics_lock , PaddedMutex , leaf, true, _safepoint_check_never);
def(NMethodSweeperStats_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); def(NMethodSweeperStats_lock , PaddedMutex , special, true, _safepoint_check_never);
def(ThreadsSMRDelete_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); def(ThreadsSMRDelete_lock , PaddedMonitor, special, true, _safepoint_check_never);
def(ThreadIdTableCreate_lock , PaddedMutex , leaf, false, Monitor::_safepoint_check_always); def(ThreadIdTableCreate_lock , PaddedMutex , leaf, false, _safepoint_check_always);
def(SharedDecoder_lock , PaddedMutex , native, false, Monitor::_safepoint_check_never); def(SharedDecoder_lock , PaddedMutex , native, false, _safepoint_check_never);
def(DCmdFactory_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(DCmdFactory_lock , PaddedMutex , leaf, true, _safepoint_check_never);
#if INCLUDE_NMT #if INCLUDE_NMT
def(NMTQuery_lock , PaddedMutex , max_nonleaf, false, Monitor::_safepoint_check_always); def(NMTQuery_lock , PaddedMutex , max_nonleaf, false, _safepoint_check_always);
#endif #endif
#if INCLUDE_CDS #if INCLUDE_CDS
#if INCLUDE_JVMTI #if INCLUDE_JVMTI
def(CDSClassFileStream_lock , PaddedMutex , max_nonleaf, false, Monitor::_safepoint_check_always); def(CDSClassFileStream_lock , PaddedMutex , max_nonleaf, false, _safepoint_check_always);
#endif #endif
#if INCLUDE_JVMCI #if INCLUDE_JVMCI
def(JVMCI_lock , PaddedMonitor, nonleaf+2, true, Monitor::_safepoint_check_always); def(JVMCI_lock , PaddedMonitor, nonleaf+2, true, _safepoint_check_always);
#endif #endif
def(DumpTimeTable_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_never); def(DumpTimeTable_lock , PaddedMutex , leaf, true, _safepoint_check_never);
#endif // INCLUDE_CDS #endif // INCLUDE_CDS
} }

2
src/hotspot/share/services/memoryManager.cpp
View file

@ -178,7 +178,7 @@ GCMemoryManager::GCMemoryManager(const char* name, const char* gc_end_message) :
_num_collections = 0; _num_collections = 0;
_last_gc_stat = NULL; _last_gc_stat = NULL;
_last_gc_lock = new Mutex(Mutex::leaf, "_last_gc_lock", true, _last_gc_lock = new Mutex(Mutex::leaf, "_last_gc_lock", true,
Monitor::_safepoint_check_never); Mutex::_safepoint_check_never);
_current_gc_stat = NULL; _current_gc_stat = NULL;
_num_gc_threads = 1; _num_gc_threads = 1;
_notification_enabled = false; _notification_enabled = false;