packages/openjdk-17
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openjdk-17/Add-Class-Loader-Resource-Cache-module.patch

1220 lines
46 KiB
Diff
Raw Normal View History

sync master to openEuler-24.03-LTS
2024-11-18 16:55:21 +08:00
---
.../jbooster/client/clientDataManager.cpp | 15 +
src/hotspot/share/runtime/arguments.cpp | 52 ++
src/hotspot/share/runtime/arguments.hpp | 1 +
.../java/net/ClassLoaderResourceCache.java | 542 ++++++++++++++++++
.../classes/java/net/URLClassLoader.java | 58 ++
.../jdk/internal/loader/URLClassPath.java | 58 ++
.../ClassLoaderResourceCacheTest.java | 344 +++++++++++
7 files changed, 1070 insertions(+)
create mode 100644 src/java.base/share/classes/java/net/ClassLoaderResourceCache.java
create mode 100644 test/jdk/java/net/URLClassLoader/ClassLoaderResourceCacheTest.java
diff --git a/src/hotspot/share/jbooster/client/clientDataManager.cpp b/src/hotspot/share/jbooster/client/clientDataManager.cpp
index 55b7d2a82..93fa45d7c 100644
--- a/src/hotspot/share/jbooster/client/clientDataManager.cpp
+++ b/src/hotspot/share/jbooster/client/clientDataManager.cpp
@@ -135,6 +135,21 @@ void ClientDataManager::init_client_duty_under_local_mode() {
jint ClientDataManager::init_clr_options() {
if (!is_clr_allowed()) return JNI_OK;
+
+ if (FLAG_SET_CMDLINE(UseClassLoaderResourceCache, true) != JVMFlag::SUCCESS) {
+ return JNI_EINVAL;
+ }
+
+ if (is_clr_being_used()) {
+ if (FLAG_SET_CMDLINE(LoadClassLoaderResourceCacheFile, cache_clr_path()) != JVMFlag::SUCCESS) {
+ return JNI_EINVAL;
+ }
+ } else if (is_server_available()) {
+ if (FLAG_SET_CMDLINE(DumpClassLoaderResourceCacheFile, cache_clr_path()) != JVMFlag::SUCCESS) {
+ return JNI_EINVAL;
+ }
+ }
+
return JNI_OK;
}
diff --git a/src/hotspot/share/runtime/arguments.cpp b/src/hotspot/share/runtime/arguments.cpp
index 6a432ed6b..2921f3f38 100644
--- a/src/hotspot/share/runtime/arguments.cpp
+++ b/src/hotspot/share/runtime/arguments.cpp
@@ -4029,6 +4029,8 @@ jint Arguments::apply_ergo() {
result = JBoosterManager::init_phase1();
if (result != JNI_OK) return result;
}
+
+ init_class_loader_resource_cache_properties();
#endif // INCLUDE_JBOOSTER
result = set_shared_spaces_flags_and_archive_paths();
@@ -4358,6 +4360,56 @@ bool Arguments::copy_expand_pid(const char* src, size_t srclen,
}
#if INCLUDE_JBOOSTER
+
+jint Arguments::init_class_loader_resource_cache_properties() {
+ if (UseClassLoaderResourceCache == false) {
+ if (LoadClassLoaderResourceCacheFile != NULL || DumpClassLoaderResourceCacheFile != NULL) {
+ vm_exit_during_initialization("Set -XX:+UseClassLoaderResourceCache first");
+ }
+ return JNI_OK;
+ }
+
+ if (!add_property("jdk.jbooster.clrcache.enable=true", UnwriteableProperty, InternalProperty)) {
+ return JNI_ENOMEM;
+ }
+
+ const int buf_len = 4096;
+ char buffer[buf_len];
+
+ if (LoadClassLoaderResourceCacheFile != NULL) {
+ if (jio_snprintf(buffer, buf_len, "jdk.jbooster.clrcache.load=%s", LoadClassLoaderResourceCacheFile) < 0) {
+ return JNI_ENOMEM;
+ }
+ if (!add_property(buffer, UnwriteableProperty, InternalProperty)) {
+ return JNI_ENOMEM;
+ }
+ }
+
+ if (DumpClassLoaderResourceCacheFile != NULL) {
+ if (jio_snprintf(buffer, buf_len, "jdk.jbooster.clrcache.dump=%s", DumpClassLoaderResourceCacheFile) < 0) {
+ return JNI_ENOMEM;
+ }
+ if (!add_property(buffer, UnwriteableProperty, InternalProperty)) {
+ return JNI_ENOMEM;
+ }
+ }
+
+ if (jio_snprintf(buffer, buf_len, "jdk.jbooster.clrcache.size=%u", ClassLoaderResourceCacheSizeEachLoader) < 0) {
+ return JNI_ENOMEM;
+ }
+ if (!add_property(buffer, UnwriteableProperty, InternalProperty)) {
+ return JNI_ENOMEM;
+ }
+
+ if (ClassLoaderResourceCacheVerboseMode) {
+ if (!add_property("jdk.jbooster.clrcache.verbose=true", UnwriteableProperty, InternalProperty)) {
+ return JNI_ENOMEM;
+ }
+ }
+
+ return JNI_OK;
+}
+
jint Arguments::init_jbooster_startup_signal_properties(const char* klass_name,
const char* method_name,
const char* method_signature) {
diff --git a/src/hotspot/share/runtime/arguments.hpp b/src/hotspot/share/runtime/arguments.hpp
index a66cc0f4d..cb2a04a2d 100644
--- a/src/hotspot/share/runtime/arguments.hpp
+++ b/src/hotspot/share/runtime/arguments.hpp
@@ -642,6 +642,7 @@ class Arguments : AllStatic {
}
#if INCLUDE_JBOOSTER
+ static jint init_class_loader_resource_cache_properties();
static jint init_jbooster_startup_signal_properties(const char* klass_name,
const char* method_name,
const char* method_signature);
diff --git a/src/java.base/share/classes/java/net/ClassLoaderResourceCache.java b/src/java.base/share/classes/java/net/ClassLoaderResourceCache.java
new file mode 100644
index 000000000..77ee4000e
--- /dev/null
+++ b/src/java.base/share/classes/java/net/ClassLoaderResourceCache.java
@@ -0,0 +1,542 @@
+/*
+ * Copyright (c) 2020, 2023, Huawei Technologies Co., Ltd. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import jdk.internal.loader.URLClassPath;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.attribute.PosixFilePermission;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import sun.security.action.GetBooleanAction;
+import sun.security.action.GetIntegerAction;
+import sun.security.action.GetPropertyAction;
+
+/**
+ * We cache the mapping of "resource name -> resource url" to
+ * accelerate resource finding.
+ * Used only by {@link java.net.URLClassLoader}
+ */
+final class ClassLoaderResourceCache {
+ public static final int NO_IDX = -1;
+ public static final String NULL_OBJ = "<null>";
+
+ private static final boolean ENABLE_CACHE = GetBooleanAction.privilegedGetProperty("jdk.jbooster.clrcache.enable");
+ private static final String DUMP_CACHE_FILE = GetPropertyAction.privilegedGetProperty("jdk.jbooster.clrcache.dump");
+ private static final String LOAD_CACHE_FILE = GetPropertyAction.privilegedGetProperty("jdk.jbooster.clrcache.load");
+ private static final int MAX_CACHE_SIZE = GetIntegerAction.privilegedGetProperty("jdk.jbooster.clrcache.size", 2000);
+ private static final boolean VERBOSE_CACHE_FILE = GetBooleanAction.privilegedGetProperty("jdk.jbooster.clrcache.verbose");
+
+ private static final List<ClassLoaderResourceCache> cachesToDump;
+ private static final Map<ClassLoaderKey, LoadedCacheData> cachesToLoad;
+
+ static {
+ if ((DUMP_CACHE_FILE != null || LOAD_CACHE_FILE != null) && !ENABLE_CACHE) {
+ System.err.println("Please set loader.cache.enable to true!");
+ System.exit(1);
+ }
+
+ if (DUMP_CACHE_FILE != null) {
+ cachesToDump = Collections.synchronizedList(new ArrayList<>());
+ registerDumpShutdownHookPrivileged();
+ } else {
+ cachesToDump = null;
+ }
+
+ if (LOAD_CACHE_FILE != null) {
+ // This map will never be modified after its initialization.
+ // So it doesn't have to be thread-safe.
+ cachesToLoad = new HashMap<>();
+ loadPrivileged(LOAD_CACHE_FILE);
+ } else {
+ cachesToLoad = null;
+ }
+ }
+
+ public static boolean isEnabled() {
+ return ENABLE_CACHE;
+ }
+
+ public static ClassLoaderResourceCache createIfEnabled(URLClassLoader holder, URL[] urls) {
+ return isEnabled() ? new ClassLoaderResourceCache(holder, urls) : null;
+ }
+
+ public static URL findResource(URLClassPath ucp, String name, boolean check,
+ String cachedURLString, int cachedIndex,
+ int[] resIndex) {
+ return URLClassPathUtil.findResource(ucp, name, check, cachedURLString, cachedIndex, resIndex);
+ }
+
+ public static URL findResource(URLClassPath ucp, String name, boolean check, int[] resIndex) {
+ return URLClassPathUtil.findResource(ucp, name, check, resIndex);
+ }
+
+ @SuppressWarnings("removal")
+ private static void registerDumpShutdownHookPrivileged() {
+ AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+ Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+ AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+ dump(DUMP_CACHE_FILE);
+ return null;
+ });
+ }));
+ return null;
+ });
+ }
+
+ @SuppressWarnings("removal")
+ private static void loadPrivileged(String filePath) {
+ AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+ load(filePath);
+ return null;
+ });
+ }
+
+ /**
+ * Dump all class loader resource caches to a file.
+ *
+ * @param filePath The file to store the cache
+ */
+ private static void dump(String filePath) {
+ File file = new File(filePath);
+ // Do not re-dump if the cache file already exists.
+ if (file.isFile()) {
+ return;
+ }
+
+ // Treat the tmp file as a file lock (see JBoosterManager::calc_tmp_cache_path()).
+ String tmpFilePath = filePath.concat(".tmp");
+ File tmpFile = new File(tmpFilePath);
+ try {
+ // Create the tmp file. Skip dump if the tmp file already exists
+ // (meaning someone else is dumping) or fails to be created.
+ if (!tmpFile.createNewFile()) {
+ return;
+ }
+
+ // Double check if the cache file already exists.
+ if (file.isFile()) {
+ // Release the tmp file lock.
+ tmpFile.delete();
+ return;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ return;
+ }
+
+ try (PrintWriter writer = new PrintWriter(tmpFile)) {
+ // synchronized to avoid ConcurrentModificationException
+ synchronized (cachesToDump) {
+ for (ClassLoaderResourceCache cache : cachesToDump) {
+ writeCache(writer, cache);
+ }
+ }
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ return;
+ }
+
+ boolean renameSuccessful = false;
+ try {
+ // Do not rename if the target file already exists.
+ // Theoretically, the target file cannot exist.
+ if (!file.isFile()) {
+ Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
+ perms.add(PosixFilePermission.OWNER_READ);
+ Files.setPosixFilePermissions(tmpFile.toPath(), perms);
+ Files.move(tmpFile.toPath(), file.toPath(), StandardCopyOption.ATOMIC_MOVE);
+ renameSuccessful = true;
+ }
+ } catch (AtomicMoveNotSupportedException e) {
+ System.err.println("The file system does not support atomic move in the same dir?");
+ e.printStackTrace();
+ } catch (FileAlreadyExistsException e) {
+ System.err.println("The file already exists? Should be a bug.");
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } finally {
+ if (!renameSuccessful) {
+ // Release the tmp file lock if the renaming fails.
+ tmpFile.delete();
+ }
+ }
+ }
+
+ private static void writeCache(PrintWriter writer, ClassLoaderResourceCache cache) {
+ String holderClassName = cache.holderClassName;
+ String holderName = cache.holderName;
+ writer.println("L|" + holderClassName
+ + "|" + (holderName == null ? NULL_OBJ : holderName)
+ + "|" + cache.originalURLsHash);
+ synchronized (cache.resourceUrlCache) {
+ for (Map.Entry<String, ResourceCacheEntry> e : cache.resourceUrlCache.entrySet()) {
+ String resourceName = e.getKey();
+ ResourceCacheEntry entry = e.getValue();
+ if (entry.isFound()) {
+ writer.println("E|" + resourceName + "|" + entry.getIndex()
+ + (VERBOSE_CACHE_FILE ? ("|" + entry.getURL().toExternalForm()) : ""));
+ } else {
+ writer.println("E|" + resourceName + "|" + NO_IDX + (VERBOSE_CACHE_FILE ? ("|" + NULL_OBJ) : ""));
+ }
+ }
+ }
+ }
+
+ /**
+ * Load all class loader resource caches from a file.
+ *
+ * @param filePath The file that stores the cache
+ */
+ private static void load(String filePath) {
+ try (FileReader fr = new FileReader(filePath);
+ BufferedReader br = new BufferedReader(fr)) {
+ String line;
+ LoadedCacheData cacheData = null;
+ while ((line = br.readLine()) != null) {
+ if (line.startsWith("L|")) {
+ ClassLoaderKey key = readCacheLoader(line);
+ cacheData = new LoadedCacheData();
+ cachesToLoad.put(key, cacheData);
+ } else if (line.startsWith("E|")) {
+ readCacheEntry(line, cacheData);
+ } else {
+ System.err.println("Unknown line: " + line);
+ System.exit(1);
+ }
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ System.exit(1);
+ }
+ }
+
+ private static ClassLoaderKey readCacheLoader(String line) {
+ String[] sp = line.split("\\|");
+ if (sp.length != 4) {
+ System.err.println("Unknown line: " + line);
+ System.exit(1);
+ }
+ return new ClassLoaderKey(sp[1], NULL_OBJ.equals(sp[2]) ? null : sp[2], Integer.parseInt(sp[3]));
+ }
+
+ private static void readCacheEntry(String line, LoadedCacheData cacheData) {
+ String[] sp = line.split("\\|", VERBOSE_CACHE_FILE ? 4 : 3);
+ if (sp.length != (VERBOSE_CACHE_FILE ? 4 : 3)) {
+ System.err.println("Unknown line: " + line);
+ System.exit(1);
+ }
+ int idx = Integer.parseInt(sp[2]);
+ if (idx == NO_IDX && (VERBOSE_CACHE_FILE ? NULL_OBJ.equals(sp[3]) : true)) {
+ cacheData.addLoadedResourceCacheEntry(sp[1], null, NO_IDX);
+ } else {
+ cacheData.addLoadedResourceCacheEntry(sp[1], (VERBOSE_CACHE_FILE ? sp[3] : null), idx);
+ }
+ }
+
+ private static <K, V> Map<K, V> createCacheMap() {
+ return Collections.synchronizedMap(new LinkedHashMap<>(MAX_CACHE_SIZE, 0.75f, true) {
+ @Override
+ protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
+ return size() >= MAX_CACHE_SIZE;
+ }
+ });
+ }
+
+ private static int fastHashOfURLs(URL[] urls) {
+ if (urls.length == 0) return 0;
+ return urls.length ^ urls[0].hashCode();
+ }
+
+ private final String holderClassName;
+ private final String holderName;
+
+ private final int originalURLsHash;
+
+ private final Map<String, ResourceCacheEntry> resourceUrlCache;
+
+ // Stores the cached data loaded form the cache file. We use the
+ // index to find the url of the resource quickly. We didn't choose
+ // to generate the url from the url string and just put it into
+ // the resourceUrlCache because (1) creating a url costs much time;
+ // (2) we'd better check that our cache entry is correct.
+ private final Map<String, LoadedResourceCacheEntry> loadedResourceUrlCache;
+
+ private final Map<String, ClassNotFoundException> classNotFoundExceptionCache;
+
+ private ClassLoaderResourceCache(URLClassLoader holder, URL[] urls) {
+ this.holderClassName = holder.getClass().getName();
+ this.holderName = holder.getName();
+ this.originalURLsHash = fastHashOfURLs(urls);
+ this.resourceUrlCache = createCacheMap();
+ this.classNotFoundExceptionCache = createCacheMap();
+
+ Map<String, LoadedResourceCacheEntry> loadedMap = Collections.emptyMap();
+ if (cachesToLoad != null) {
+ ClassLoaderKey key = new ClassLoaderKey(holderClassName, holderName, originalURLsHash);
+ LoadedCacheData loadedCacheData = cachesToLoad.get(key);
+ if (loadedCacheData != null) {
+ loadedMap = loadedCacheData.getLoadedResourceUrlCache();
+ }
+ }
+ this.loadedResourceUrlCache = loadedMap;
+
+ if (cachesToDump != null) {
+ cachesToDump.add(this);
+ }
+ }
+
+ /**
+ * Throws the exception if cached.
+ *
+ * @param name the resource name
+ * @throws ClassNotFoundException if the exception is cached
+ */
+ public void fastClassNotFoundException(String name) throws ClassNotFoundException {
+ ClassNotFoundException classNotFoundException = classNotFoundExceptionCache.get(name);
+ if (classNotFoundException != null) {
+ throw classNotFoundException;
+ }
+ }
+
+ /**
+ * Puts the cache.
+ *
+ * @param name the resource name
+ * @param exception the value to cache
+ */
+ public void cacheClassNotFoundException(String name, ClassNotFoundException exception) {
+ classNotFoundExceptionCache.put(name, exception);
+ }
+
+ /**
+ * Gets the cache loaded from a file.
+ *
+ * @param name the resource name
+ * @return the cached value
+ */
+ public LoadedResourceCacheEntry getLoadedResourceCache(String name) {
+ return loadedResourceUrlCache.get(name);
+ }
+
+ /**
+ * Gets the cache.
+ *
+ * @param name the resource name
+ * @return the cached value
+ */
+ public ResourceCacheEntry getResourceCache(String name) {
+ return resourceUrlCache.get(name);
+ }
+
+ /**
+ * Puts the cache.
+ *
+ * @param name the resource name
+ * @param url the url to cache
+ * @param idx the index of url to cache
+ */
+ public void cacheResourceUrl(String name, URL url, int idx) {
+ resourceUrlCache.put(name, new ResourceCacheEntry(url, url == null ? NO_IDX : idx));
+ }
+
+ /**
+ * Clears the caches. No call site yet.
+ */
+ public void clearCache() {
+ classNotFoundExceptionCache.clear();
+ resourceUrlCache.clear();
+ }
+
+ /**
+ * The key to identify a class loader.
+ */
+ private static class ClassLoaderKey {
+ private final String className;
+ private final String name;
+ private final int urlsHash;
+
+ public ClassLoaderKey(String className, String name, int urlsHash) {
+ this.className = className;
+ this.name = name;
+ this.urlsHash = urlsHash;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o instanceof ClassLoaderKey that) {
+ return Objects.equals(className, that.className)
+ && Objects.equals(name, that.name)
+ && Objects.equals(urlsHash, that.urlsHash);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(className, name, urlsHash);
+ }
+ }
+
+ /**
+ * The cached resource info.
+ */
+ public static class ResourceCacheEntry {
+ private final URL url;
+ private final int index;
+
+ public ResourceCacheEntry(URL url, int index) {
+ this.url = url;
+ this.index = index;
+ }
+
+ public boolean isFound() {
+ return url != null;
+ }
+
+ public URL getURL() {
+ return url;
+ }
+
+ public int getIndex() {
+ return index;
+ }
+ }
+
+ public static class LoadedResourceCacheEntry {
+ private final String urlString;
+ private final int index;
+
+ public LoadedResourceCacheEntry(String urlString, int index) {
+ this.urlString = urlString;
+ this.index = index;
+ }
+
+ public String getURLString() {
+ return urlString;
+ }
+
+ public int getIndex() {
+ return index;
+ }
+ }
+
+ private static class LoadedCacheData {
+ private final Map<String, LoadedResourceCacheEntry> loadedResourceUrlCache;
+
+ public LoadedCacheData() {
+ this.loadedResourceUrlCache = new HashMap<>();
+ }
+
+ public Map<String, LoadedResourceCacheEntry> getLoadedResourceUrlCache() {
+ return loadedResourceUrlCache;
+ }
+
+ public void addLoadedResourceCacheEntry(String name, String urlString, int index) {
+ loadedResourceUrlCache.put(name, new LoadedResourceCacheEntry(urlString, index));
+ }
+ }
+}
+
+/**
+ * We don't want to add new public methods in URLClassPath. So we add two
+ * private method (findResourceWithIndex) and use method handle to invoke
+ * them.
+ */
+@SuppressWarnings("removal")
+class URLClassPathUtil {
+ private static final MethodHandle resourceFinder1;
+ private static final MethodHandle resourceFinder2;
+
+ static {
+ MethodHandle mh1 = null;
+ MethodHandle mh2 = null;
+ try {
+ MethodHandles.Lookup lookup = MethodHandles.lookup();
+ Method m1 = URLClassPath.class.getDeclaredMethod("findResourceWithIndex", String.class, boolean.class, String.class, int.class, int[].class);
+ Method m2 = URLClassPath.class.getDeclaredMethod("findResourceWithIndex", String.class, boolean.class, int[].class);
+ AccessController.doPrivileged(
+ (PrivilegedAction<Void>) () -> {
+ m1.setAccessible(true);
+ m2.setAccessible(true);
+ return null;
+ });
+ mh1 = lookup.unreflect(m1);
+ mh2 = lookup.unreflect(m2);
+ } catch (NoSuchMethodException | IllegalAccessException e) {
+ e.printStackTrace();
+ System.exit(1);
+ }
+ resourceFinder1 = mh1;
+ resourceFinder2 = mh2;
+ }
+
+ public static URL findResource(URLClassPath ucp, String name, boolean check,
+ String cachedURLString, int cachedIndex,
+ int[] resIndex) {
+ try {
+ return (URL) resourceFinder1.invoke(ucp, name, check, cachedURLString, cachedIndex, resIndex);
+ } catch (Throwable throwable) {
+ throwable.printStackTrace();
+ System.exit(1);
+ }
+ return null;
+ }
+
+ public static URL findResource(URLClassPath ucp, String name, boolean check, int[] resIndex) {
+ try {
+ return (URL) resourceFinder2.invoke(ucp, name, check, resIndex);
+ } catch (Throwable throwable) {
+ throwable.printStackTrace();
+ System.exit(1);
+ }
+ return null;
+ }
+}
diff --git a/src/java.base/share/classes/java/net/URLClassLoader.java b/src/java.base/share/classes/java/net/URLClassLoader.java
index 8314d5bb3..b3362d9f6 100644
--- a/src/java.base/share/classes/java/net/URLClassLoader.java
+++ b/src/java.base/share/classes/java/net/URLClassLoader.java
@@ -88,6 +88,8 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
@SuppressWarnings("removal")
private final AccessControlContext acc;
+ private final ClassLoaderResourceCache loaderCache;
+
/**
* Constructs a new URLClassLoader for the given URLs. The URLs will be
* searched in the order specified for classes and resources after first
@@ -115,6 +117,7 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
super(parent);
this.acc = AccessController.getContext();
this.ucp = new URLClassPath(urls, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
URLClassLoader(String name, URL[] urls, ClassLoader parent,
@@ -122,6 +125,7 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
super(name, parent);
this.acc = acc;
this.ucp = new URLClassPath(urls, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
/**
@@ -151,12 +155,14 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
super();
this.acc = AccessController.getContext();
this.ucp = new URLClassPath(urls, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
URLClassLoader(URL[] urls, @SuppressWarnings("removal") AccessControlContext acc) {
super();
this.acc = acc;
this.ucp = new URLClassPath(urls, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
/**
@@ -187,6 +193,7 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
super(parent);
this.acc = AccessController.getContext();
this.ucp = new URLClassPath(urls, factory, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
@@ -219,6 +226,7 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
super(name, parent);
this.acc = AccessController.getContext();
this.ucp = new URLClassPath(urls, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
/**
@@ -249,6 +257,7 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
super(name, parent);
this.acc = AccessController.getContext();
this.ucp = new URLClassPath(urls, factory, acc);
+ this.loaderCache = ClassLoaderResourceCache.createIfEnabled(this, urls);
}
/* A map (used as a set) to keep track of closeable local resources
@@ -401,6 +410,25 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
return ucp.getURLs();
}
+ /**
+ * This method is overrided by ClassLoaderResourceCache to quickly throw
+ * the ClassNotFoundException if it is cached.
+ */
+ protected Class<?> loadClass(String name, boolean resolve)
+ throws ClassNotFoundException
+ {
+ if (ClassLoaderResourceCache.isEnabled()) {
+ loaderCache.fastClassNotFoundException(name);
+ try {
+ return super.loadClass(name, resolve);
+ } catch (ClassNotFoundException ex) {
+ loaderCache.cacheClassNotFoundException(name, ex);
+ throw ex;
+ }
+ }
+ return super.loadClass(name, resolve);
+ }
+
/**
* Finds and loads the class with the specified name from the URL search
* path. Any URLs referring to JAR files are loaded and opened as needed
@@ -649,6 +677,36 @@ public class URLClassLoader extends SecureClassLoader implements Closeable {
* if the resource could not be found, or if the loader is closed.
*/
public URL findResource(final String name) {
+ if (ClassLoaderResourceCache.isEnabled()) {
+ ClassLoaderResourceCache.ResourceCacheEntry entry = loaderCache.getResourceCache(name);
+ if (entry != null) {
+ return entry.getURL();
+ }
+ ClassLoaderResourceCache.LoadedResourceCacheEntry loadedEntry
+ = loaderCache.getLoadedResourceCache(name);
+ int[] urlIndex = {-1};
+ @SuppressWarnings("removal")
+ URL url = AccessController.doPrivileged(
+ new PrivilegedAction<>() {
+ public URL run() {
+ if (loadedEntry == null) {
+ return ClassLoaderResourceCache.findResource(ucp, name, true, urlIndex);
+ } else if (loadedEntry.getIndex() == ClassLoaderResourceCache.NO_IDX) {
+ return null;
+ } else {
+ return ClassLoaderResourceCache.findResource(ucp, name, true,
+ loadedEntry.getURLString(), loadedEntry.getIndex(), urlIndex);
+ }
+ }
+ }, acc);
+
+ if (url != null) {
+ url = URLClassPath.checkURL(url);
+ }
+ loaderCache.cacheResourceUrl(name, url, urlIndex[0]);
+ return url;
+ }
+
/*
* The same restriction to finding classes applies to resources
*/
diff --git a/src/java.base/share/classes/jdk/internal/loader/URLClassPath.java b/src/java.base/share/classes/jdk/internal/loader/URLClassPath.java
index 0cc500127..61864b5f1 100644
--- a/src/java.base/share/classes/jdk/internal/loader/URLClassPath.java
+++ b/src/java.base/share/classes/jdk/internal/loader/URLClassPath.java
@@ -1294,4 +1294,62 @@ public class URLClassPath {
return null;
}
}
+
+ /**
+ * This method is only for java.net.ClassLoaderResourceCache!
+ *
+ * Finds the resource (and its index in url array) with the
+ * specified name on the URL search path or null if not found
+ * or security check fails.
+ * Search the specific index first.
+ *
+ * @param name the name of the resource
+ * @param check whether to perform a security check
+ * @param cachedURLString the url of cachedIndex
+ * @param cachedIndex the index of cachedURLString
+ * @param resIndex the index of URL in loaders
+ * @return a {@code URL} for the resource, or {@code null}
+ * if the resource could not be found.
+ * @see java.net.URLClassPathUtil
+ */
+ private URL findResourceWithIndex(String name, boolean check,
+ String cachedURLString, int cachedIndex,
+ int[] resIndex) {
+ Loader loader = getLoader(cachedIndex);
+ if (loader != null) {
+ URL url = loader.findResource(name, check);
+ if (url != null && (cachedURLString == null || cachedURLString.equals(url.toExternalForm()))) {
+ resIndex[0] = cachedIndex;
+ return url;
+ }
+ }
+ return findResourceWithIndex(name, check, resIndex);
+ }
+
+ /**
+ * This method is only for java.net.ClassLoaderResourceCache!
+ *
+ * Finds the resource (and its index in url array) with the
+ * specified name on the URL search path or null if not found
+ * or security check fails.
+ *
+ * @param name the name of the resource
+ * @param check whether to perform a security check
+ * @param resIndex the index of URL in loaders
+ * @return a {@code URL} for the resource, or {@code null}
+ * if the resource could not be found.
+ * @see java.net.URLClassPathUtil
+ */
+ private URL findResourceWithIndex(String name, boolean check, int[] resIndex) {
+ Loader loader;
+ for (int i = 0; (loader = getLoader(i)) != null; i++) {
+ URL url = loader.findResource(name, check);
+ if (url != null) {
+ resIndex[0] = i;
+ return url;
+ }
+ }
+ resIndex[0] = -1;
+ return null;
+ }
}
diff --git a/test/jdk/java/net/URLClassLoader/ClassLoaderResourceCacheTest.java b/test/jdk/java/net/URLClassLoader/ClassLoaderResourceCacheTest.java
new file mode 100644
index 000000000..550dc04be
--- /dev/null
+++ b/test/jdk/java/net/URLClassLoader/ClassLoaderResourceCacheTest.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2020, 2023, Huawei Technologies Co., Ltd. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.io.File;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Objects;
+
+/*
+ * @test
+ * @run testng/othervm
+ * --add-opens=java.base/java.net=ALL-UNNAMED
+ * --add-opens=java.base/jdk.internal.loader=ALL-UNNAMED
+ * -XX:+UnlockExperimentalVMOptions
+ * -XX:+UseClassLoaderResourceCache
+ * -XX:DumpClassLoaderResourceCacheFile=clrct.log
+ * ClassLoaderResourceCacheTest
+ * @run testng/othervm
+ * --add-opens=java.base/java.net=ALL-UNNAMED
+ * --add-opens=java.base/jdk.internal.loader=ALL-UNNAMED
+ * -XX:+UnlockExperimentalVMOptions
+ * -XX:+UseClassLoaderResourceCache
+ * -XX:LoadClassLoaderResourceCacheFile=clrct.log
+ * ClassLoaderResourceCacheTest
+ */
+public class ClassLoaderResourceCacheTest {
+ private URL[] urls;
+ private URLClassLoader loader;
+ private Object loaderCache;
+
+ @BeforeMethod
+ public void initLoader() {
+ String classpath = System.getProperty("java.class.path");
+ String[] paths = classpath.split(File.pathSeparator);
+ urls = Arrays.stream(paths).map(s -> {
+ if (s.endsWith(".jar")) {
+ s = "jar:file:" + s + "!/";
+ } else {
+ s = "file:" + s + "/";
+ }
+ try {
+ return new URL(s);
+ } catch (MalformedURLException e) {
+ e.printStackTrace();
+ }
+ return null;
+ }).filter(Objects::nonNull).sorted(Comparator.comparing(URL::toExternalForm)).toArray(URL[]::new);
+ if (urls.length >= 2 && urls[0].toExternalForm().endsWith("ClassLoaderResourceCacheTest.d/")) {
+ URL tmp = urls[0];
+ urls[0] = urls[1];
+ urls[1] = tmp;
+ }
+ loader = new URLClassLoader(ClassLoaderResourceCacheTest.class.getSimpleName(), urls, null);
+ loaderCache = Access.getClassLoaderResourceCache(loader);
+ }
+
+ @Test
+ public void testIsFeatureOn() {
+ Assert.assertTrue(Boolean.getBoolean("jdk.jbooster.clrcache.enable"));
+ String dumpFilePath = System.getProperty("jdk.jbooster.clrcache.dump");
+ String loadFilePath = System.getProperty("jdk.jbooster.clrcache.load");
+ if (dumpFilePath != null) {
+ Assert.assertFalse(new File(dumpFilePath).isFile());
+ }
+ if (loadFilePath != null) {
+ Assert.assertTrue(new File(loadFilePath).isFile());
+ }
+ }
+
+ @Test
+ public void testLoaderURLs() {
+ Assert.assertNotNull(loaderCache);
+ Arrays.stream(urls).forEach(url -> System.out.println("URLClassLoader url: " + url));
+ Assert.assertTrue(urls[0].toExternalForm().endsWith("URLClassLoader/"));
+ Assert.assertTrue(urls[1].toExternalForm().endsWith("ClassLoaderResourceCacheTest.d/"));
+ int i;
+ for (i = 2; i < urls.length; ++i) {
+ if (urls[i].toExternalForm().contains("testng")) {
+ break;
+ }
+ }
+ Assert.assertTrue(i < urls.length, "\"testng-xxx.jar\" must be in the paths!");
+ }
+
+ @Test
+ public void testCacheResource() {
+ String cs1 = ClassLoaderResourceCacheTest.class.getName().replace('.', '/') + ".class";
+ String cs2 = "com/huawei/Nonexistent.class";
+ String cs3 = "org/testng/Assert.class";
+ URL res;
+ Object entry;
+
+ // Try to access three resources.
+
+ Assert.assertEquals(Access.getResourceUrlCacheMap(loaderCache).size(), 0);
+
+ res = loader.getResource(cs1);
+ Assert.assertNotNull(res);
+ Assert.assertTrue(res.toExternalForm().contains("ClassLoaderResourceCacheTest.d"));
+
+ res = loader.getResource(cs2);
+ Assert.assertNull(res);
+
+ res = loader.getResource(cs3);
+ Assert.assertNotNull(res);
+ Assert.assertTrue(res.toExternalForm().contains("lib/testng-"));
+
+ // Check cache entries.
+
+ Assert.assertEquals(Access.getResourceUrlCacheMap(loaderCache).size(), 3);
+
+ entry = Access.getResourceCacheEntry(loaderCache, cs1);
+ Assert.assertNotNull(entry);
+ Assert.assertTrue(Access.getResourceCacheEntryURL(entry).toExternalForm().contains("ClassLoaderResourceCacheTest.d"));
+ Assert.assertTrue(Access.getResourceCacheEntryIndex(entry) >= 1);
+
+ entry = Access.getResourceCacheEntry(loaderCache, cs2);
+ Assert.assertNotNull(entry);
+ Assert.assertNull(Access.getResourceCacheEntryURL(entry));
+ Assert.assertEquals(Access.getResourceCacheEntryIndex(entry), -1);
+
+ entry = Access.getResourceCacheEntry(loaderCache, cs3);
+ Assert.assertNotNull(entry);
+ Assert.assertTrue(Access.getResourceCacheEntryURL(entry).toExternalForm().contains("lib/testng-"));
+ Assert.assertTrue(Access.getResourceCacheEntryIndex(entry) >= 2);
+
+ // Try to access the three resources again.
+
+ res = loader.getResource(cs1);
+ Assert.assertNotNull(res);
+ Assert.assertTrue(res.toExternalForm().contains("ClassLoaderResourceCacheTest.d"));
+
+ res = loader.getResource(cs2);
+ Assert.assertNull(res);
+
+ res = loader.getResource(cs3);
+ Assert.assertNotNull(res);
+ Assert.assertTrue(res.toExternalForm().contains("lib/testng-"));
+
+ // Recheck cache entries.
+
+ Assert.assertEquals(Access.getResourceUrlCacheMap(loaderCache).size(), 3);
+ }
+
+ @Test
+ public void testLoadClassFastException() {
+ String cs1 = ClassLoaderResourceCacheTest.class.getName();
+ String cs2 = "com.huawei.Nonexistent";
+ String cs3 = "org.testng.Assert";
+ Object entry;
+
+ Class<?> c1 = null;
+ Class<?> c2 = null;
+ Class<?> c3 = null;
+
+ // Try to load three classes.
+
+ Assert.assertEquals(Access.getClassNotFoundExceptionCacheMap(loaderCache).size(), 0);
+
+ try {
+ c1 = loader.loadClass(cs1);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ Assert.fail();
+ }
+
+ try {
+ c2 = loader.loadClass(cs2);
+ Assert.fail();
+ } catch (ClassNotFoundException ignored) {
+ }
+
+ try {
+ c3 = loader.loadClass(cs3);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ Assert.fail();
+ }
+
+ Assert.assertNotNull(c1);
+ Assert.assertNull(c2);
+ Assert.assertNotNull(c3);
+
+ Assert.assertEquals(Access.getClassNotFoundExceptionCacheMap(loaderCache).size(), 1);
+
+ // Retry to load three classes.
+
+ try {
+ c1 = loader.loadClass(cs1);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ Assert.fail();
+ }
+
+ try {
+ c2 = loader.loadClass(cs2);
+ Assert.fail();
+ } catch (ClassNotFoundException ignored) {
+ }
+
+ try {
+ c3 = loader.loadClass(cs3);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ Assert.fail();
+ }
+
+ Assert.assertEquals(Access.getClassNotFoundExceptionCacheMap(loaderCache).size(), 1);
+ Assert.assertEquals(Access.getResourceUrlCacheMap(loaderCache).size(), 0);
+ }
+}
+
+class Access {
+ private static final Field loaderCacheGetter;
+ private static final Field resourceUrlCacheMapGetter;
+ private static final Field classNotFoundExceptionCacheMapGetter;
+ private static final MethodHandle resourceCacheGetter;
+ private static final MethodHandle resourceCacheEntryURLGetter;
+ private static final MethodHandle resourceCacheEntryIndexGetter;
+
+ static {
+ try {
+ MethodHandles.Lookup lookup = MethodHandles.lookup();
+ Class<?> clrClass = Class.forName("java.net.ClassLoaderResourceCache");
+ Class<?> rceClass = Class.forName("java.net.ClassLoaderResourceCache$ResourceCacheEntry");
+
+ loaderCacheGetter = URLClassLoader.class.getDeclaredField("loaderCache");
+ loaderCacheGetter.setAccessible(true);
+
+ resourceUrlCacheMapGetter = clrClass.getDeclaredField("resourceUrlCache");
+ resourceUrlCacheMapGetter.setAccessible(true);
+
+ classNotFoundExceptionCacheMapGetter = clrClass.getDeclaredField("classNotFoundExceptionCache");
+ classNotFoundExceptionCacheMapGetter.setAccessible(true);
+
+ Method m;
+
+ m = clrClass.getDeclaredMethod("getResourceCache", String.class);
+ m.setAccessible(true);
+ resourceCacheGetter = lookup.unreflect(m);
+
+ m = rceClass.getMethod("getURL");
+ m.setAccessible(true);
+ resourceCacheEntryURLGetter = lookup.unreflect(m);
+
+ m = rceClass.getMethod("getIndex");
+ m.setAccessible(true);
+ resourceCacheEntryIndexGetter = lookup.unreflect(m);
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Object getClassLoaderResourceCache(URLClassLoader loader) {
+ try {
+ return loaderCacheGetter.get(loader);
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Map<String, Object> getResourceUrlCacheMap(Object loaderCache) {
+ try {
+ @SuppressWarnings("unchecked")
+ Map<String, Object> res = (Map<String, Object>) resourceUrlCacheMapGetter.get(loaderCache);
+ return res;
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Map<String, ClassNotFoundException> getClassNotFoundExceptionCacheMap(Object loaderCache) {
+ try {
+ @SuppressWarnings("unchecked")
+ Map<String, ClassNotFoundException> res = (Map<String, ClassNotFoundException>) classNotFoundExceptionCacheMapGetter.get(loaderCache);
+ return res;
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Object getResourceCacheEntry(Object loaderCache, String name) {
+ try {
+ return resourceCacheGetter.invoke(loaderCache, name);
+ } catch (Throwable throwable) {
+ throwable.printStackTrace();
+ throw new RuntimeException(throwable);
+ }
+ }
+
+ public static URL getResourceCacheEntryURL(Object resourceCache) {
+ try {
+ return (URL) resourceCacheEntryURLGetter.invoke(resourceCache);
+ } catch (Throwable throwable) {
+ throwable.printStackTrace();
+ throw new RuntimeException(throwable);
+ }
+ }
+
+ public static int getResourceCacheEntryIndex(Object resourceCache) {
+ try {
+ return (int) resourceCacheEntryIndexGetter.invoke(resourceCache);
+ } catch (Throwable throwable) {
+ throwable.printStackTrace();
+ throw new RuntimeException(throwable);
+ }
+ }
+}
--
2.19.1
Reference in New Issue Copy Permalink