archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 15:24:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8261280: Remove THREAD argument from compute_loader_lock_object

Browse source 
Reviewed-by: dcubed
This commit is contained in:
Coleen Phillimore 2021-02-06 16:35:30 +00:00
parent 74d40ab72f
commit 2c3a86f96e
3 changed files with 9 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/hotspot/share/classfile/systemDictionary.cpp
View file

@ -151,14 +151,14 @@ ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, bool cre
// ----------------------------------------------------------------------------
// Parallel class loading check
bool SystemDictionary::is_parallelCapable(Handle class_loader) {
bool is_parallelCapable(Handle class_loader) {
if (class_loader.is_null()) return true;
if (AlwaysLockClassLoader) return false;
return java_lang_ClassLoader::parallelCapable(class_loader());
}
// ----------------------------------------------------------------------------
// ParallelDefineClass flag does not apply to bootclass loader
bool SystemDictionary::is_parallelDefine(Handle class_loader) {
bool is_parallelDefine(Handle class_loader) {
if (class_loader.is_null()) return false;
if (AllowParallelDefineClass && java_lang_ClassLoader::parallelCapable(class_loader())) {
return true;
@ -185,7 +185,7 @@ bool SystemDictionary::is_platform_class_loader(oop class_loader) {
return (class_loader->klass() == vmClasses::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass());
}
Handle SystemDictionary::compute_loader_lock_object(Thread* thread, Handle class_loader) {
Handle SystemDictionary::compute_loader_lock_object(Handle class_loader) {
// If class_loader is NULL or parallelCapable, the JVM doesn't acquire a lock while loading.
if (is_parallelCapable(class_loader)) {
return Handle();
@ -703,7 +703,7 @@ InstanceKlass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
// the define.
// ParallelCapable Classloaders and the bootstrap classloader
// do not acquire lock here.
Handle lockObject = compute_loader_lock_object(THREAD, class_loader);
Handle lockObject = compute_loader_lock_object(class_loader);
ObjectLocker ol(lockObject, THREAD);
// Check again (after locking) if the class already exists in SystemDictionary
@ -1068,7 +1068,7 @@ InstanceKlass* SystemDictionary::resolve_from_stream(Symbol* class_name,
// Classloaders that support parallelism, e.g. bootstrap classloader,
// do not acquire lock here
Handle lockObject = compute_loader_lock_object(THREAD, class_loader);
Handle lockObject = compute_loader_lock_object(class_loader);
ObjectLocker ol(lockObject, THREAD);
// Parse the stream and create a klass.
@ -1359,7 +1359,7 @@ InstanceKlass* SystemDictionary::load_shared_class(InstanceKlass* ik,
ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
{
HandleMark hm(THREAD);
Handle lockObject = compute_loader_lock_object(THREAD, class_loader);
Handle lockObject = compute_loader_lock_object(class_loader);
ObjectLocker ol(lockObject, THREAD);
// prohibited package check assumes all classes loaded from archive call
// restore_unshareable_info which calls ik->set_package()
@ -1561,7 +1561,7 @@ void SystemDictionary::define_instance_class(InstanceKlass* k, Handle class_load
// hole with systemDictionary updates and check_constraints
if (!is_parallelCapable(class_loader)) {
assert(ObjectSynchronizer::current_thread_holds_lock(THREAD->as_Java_thread(),
compute_loader_lock_object(THREAD, class_loader)),
compute_loader_lock_object(class_loader)),
"define called without lock");
}

5
src/hotspot/share/classfile/systemDictionary.hpp
View file

@ -352,9 +352,6 @@ private:
Handle class_loader,
InstanceKlass* k, TRAPS);
static InstanceKlass* load_instance_class(Symbol* class_name, Handle class_loader, TRAPS);
static bool is_parallelDefine(Handle class_loader);
static Handle compute_loader_lock_object(Thread* thread, Handle class_loader);
static void check_loader_lock_contention(Thread* thread, Handle loader_lock);
static bool is_shared_class_visible(Symbol* class_name, InstanceKlass* ik,
PackageEntry* pkg_entry,
@ -390,7 +387,7 @@ protected:
static InstanceKlass* load_shared_boot_class(Symbol* class_name,
PackageEntry* pkg_entry,
TRAPS);
static bool is_parallelCapable(Handle class_loader);
static Handle compute_loader_lock_object(Handle class_loader);
static InstanceKlass* find_or_define_instance_class(Symbol* class_name,
Handle class_loader,
InstanceKlass* k, TRAPS);

2
src/hotspot/share/classfile/systemDictionaryShared.cpp
View file

@ -1036,7 +1036,7 @@ InstanceKlass* SystemDictionaryShared::find_or_load_shared_class(
// Note: currently, find_or_load_shared_class is called only from
// JVM_FindLoadedClass and used for PlatformClassLoader and AppClassLoader,
// which are parallel-capable loaders, so a lock here is NOT taken.
assert(is_parallelCapable(class_loader), "ObjectLocker not required");
assert(compute_loader_lock_object(class_loader) == NULL, "ObjectLocker not required");
{
MutexLocker mu(THREAD, SystemDictionary_lock);
InstanceKlass* check = dictionary->find_class(d_hash, name);