Merge pull request #22289 from lzhou2025/moduleClassLoader

RCP: Restore immortal classloaders using persisted state

Author: gacholio

jcl/src/java.base/share/classes/com/ibm/oti/vm/VM.java

@@ -119,6 +119,7 @@ public final class VM {
 	public static final int J9_CLASSLOADER_TYPE_OTHERS;
 	public static final int J9_CLASSLOADER_TYPE_BOOT;
 	public static final int J9_CLASSLOADER_TYPE_PLATFORM;
+	public static final int J9_CLASSLOADER_TYPE_APP;
 
 	/* Lock reservation */
 	public static final int J9CLASS_RESERVABLE_LOCK_WORD_INIT;
@@ -201,6 +202,7 @@ public final class VM {
 		J9_CLASSLOADER_TYPE_OTHERS = 0;
 		J9_CLASSLOADER_TYPE_BOOT = 0;
 		J9_CLASSLOADER_TYPE_PLATFORM = 0;
+		J9_CLASSLOADER_TYPE_APP = 0;
 
 		J9CLASS_RESERVABLE_LOCK_WORD_INIT = 0;
 		OBJECT_HEADER_LOCK_RESERVED = 0;
@@ -262,12 +264,29 @@ private VM() {
  * @param loaderType
  *            J9_CLASSLOADER_TYPE_BOOT     - bootstrap classloader
  *            J9_CLASSLOADER_TYPE_PLATFORM - platform classloader
- *            J9_CLASSLOADER_TYPE_OTHERS   - other classloader
+ *            J9_CLASSLOADER_TYPE_APP      - application classloader
+ *            J9_CLASSLOADER_TYPE_OTHERS   - other classloaders
  * @param parallelCapable
  *            true if the loader has registered as parallel capable
  */
 public final static native void initializeClassLoader(ClassLoader loader, int loaderType, boolean parallelCapable);
 
+/*[IF RAM_CLASS_CACHE_SUPPORT] */
+/**
+ * RCP: Link java Classloader to the internal VM classloader.
+ * Currently, only Boot, Platform and App classloaders are supported.
+ *
+ * @param loader
+ *            ClassLoader the ClassLoader instance
+ * @param id
+ *            J9_CLASSLOADER_TYPE_BOOT     - bootstrap classloader
+ *            J9_CLASSLOADER_TYPE_PLATFORM - platform classloader
+ *            J9_CLASSLOADER_TYPE_APP      - application classloader
+ *            J9_CLASSLOADER_TYPE_OTHERS   - other classloaders
+ */
+public final static native void rcpAssignClassLoader(ClassLoader loader, int id);
+/*[ENDIF] RAM_CLASS_CACHE_SUPPORT */
+
 public final static native long getProcessId();
 public final static native long getUid();
 /**
@@ -588,6 +607,15 @@ public static int markCurrentThreadAsSystem()
  */
 public static native boolean isJVMInSingleThreadedMode();
 
+/*[IF RAM_CLASS_CACHE_SUPPORT] */
+/**
+ * Queries whether the JVM is running in RCP restore run.
+ *
+ * @return true if JVM is in RCP restore run, false otherwise
+ */
+public static native boolean isRCPRestoreRun();
+/*[ENDIF] RAM_CLASS_CACHE_SUPPORT */
+
 /**
  * A J9ConstantPool* is appended to anntation parameter byte arrays
  * so it will be consistent with annotation data if the class is redefined.

jcl/src/java.base/share/classes/java/lang/ClassLoader.java

@@ -102,6 +102,9 @@ public abstract class ClassLoader {
 	private final static String DELEGATING_CL = "sun.reflect.DelegatingClassLoader"; //$NON-NLS-1$
 	/*[ENDIF] JAVA_SPEC_VERSION >= 9 */
 	private boolean isDelegatingCL = false;
+	/*[IF JAVA_SPEC_VERSION > 8]*/
+	private static boolean applicationClassLoaderInited;
+	/*[ENDIF] JAVA_SPEC_VERSION > 8 */
 
 	/*
 	 * This is the application ClassLoader
@@ -163,7 +166,9 @@ private static final class ClassNameBasedLock { ClassNameBasedLock() {} }
 	private NativeLibraries nativelibs = null;
 /*[ENDIF] JAVA_SPEC_VERSION >= 15 */
 	private static native void initAnonClassLoader(InternalAnonymousClassLoader anonClassLoader);
-
+/*[IF RAM_CLASS_CACHE_SUPPORT] */
+	private static final boolean isRCPRestoreRun = VM.isRCPRestoreRun();
+/*[ENDIF] RAM_CLASS_CACHE_SUPPORT */
 	/*[PR JAZZ 73143]: ClassLoader incorrectly discards class loading locks*/
 	static final class ClassNameLockRef extends WeakReference<Object> implements Runnable {
 		private static final ReferenceQueue<Object> queue = new ReferenceQueue<>();
@@ -425,8 +430,21 @@ private ClassLoader(Void staticMethodHolder, String classLoaderName, ClassLoader
 	specialLoaderInited = (bootstrapClassLoader != null);
 /*[ENDIF] JAVA_SPEC_VERSION == 8 */
 	if (specialLoaderInited) {
-		if (!lazyClassLoaderInit) {
-			VM.initializeClassLoader(this, VM.J9_CLASSLOADER_TYPE_OTHERS, isParallelCapable);
+/*[IF JAVA_SPEC_VERSION > 8]*/
+		/*
+		 * Assuming the 3rd classloader initialized is application class loader as the order
+		 * to initialize builtin class loaders is defined in the static block of
+		 * openjdk/src/java.base/share/classes/jdk/internal/loader/ClassLoaders.java.
+		 */
+		if (!applicationClassLoaderInited) {
+			assignImmortalClassLoader(VM.J9_CLASSLOADER_TYPE_APP, isParallelCapable);
+			applicationClassLoaderInited = true;
+		} else
+/*[ENDIF] JAVA_SPEC_VERSION > 8 */
+		{
+			if (!lazyClassLoaderInit) {
+				VM.initializeClassLoader(this, VM.J9_CLASSLOADER_TYPE_OTHERS, isParallelCapable);
+			}
 		}
 /*[IF JAVA_SPEC_VERSION > 8]*/
 		unnamedModule = new Module(this);
@@ -438,10 +456,10 @@ private ClassLoader(Void staticMethodHolder, String classLoaderName, ClassLoader
 			// BootstrapClassLoader.unnamedModule is set by JVM_SetBootLoaderUnnamedModule
 			unnamedModule = null;
 			bootstrapClassLoader = this;
-			VM.initializeClassLoader(bootstrapClassLoader, VM.J9_CLASSLOADER_TYPE_BOOT, false);
+			assignImmortalClassLoader(VM.J9_CLASSLOADER_TYPE_BOOT, false);
 		} else {
 			// Assuming the second classloader initialized is platform classloader
-			VM.initializeClassLoader(this, VM.J9_CLASSLOADER_TYPE_PLATFORM, false);
+			assignImmortalClassLoader(VM.J9_CLASSLOADER_TYPE_PLATFORM, false);
 			specialLoaderInited = true;
 			unnamedModule = new Module(this);
 		}
@@ -2646,4 +2664,24 @@ static NativeLibraries nativeLibrariesFor(ClassLoader loader) {
 	return (loader == null) ? BootLoader.getNativeLibraries() : loader.nativelibs;
 }
 /*[ENDIF] JAVA_SPEC_VERSION >= 24 */
+
+/*[IF JAVA_SPEC_VERSION > 8]*/
+/**
+ * Assign immortal class loaders for restore run.
+ *
+ * @param id   class loader type
+ * @param isParallelCapable   true if the loader has registered as parallel capable
+ */
+private final void assignImmortalClassLoader(int id, boolean isParallelCapable) {
+/*[IF RAM_CLASS_CACHE_SUPPORT] */
+	if (isRCPRestoreRun) {
+		VM.rcpAssignClassLoader(this, id);
+	} else
+/*[ENDIF] RAM_CLASS_CACHE_SUPPORT */
+	{
+		VM.initializeClassLoader(this, id, isParallelCapable);
+	}
+}
+/*[ENDIF] JAVA_SPEC_VERSION > 8 */
+
 }

runtime/jcl/common/jclcinit.c

@@ -416,6 +416,7 @@ static const J9IntConstantMapping intVMConstants[] = {
 		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_J9_CLASSLOADER_TYPE_OTHERS, J9_CLASSLOADER_TYPE_OTHERS },
 		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_J9_CLASSLOADER_TYPE_BOOT, J9_CLASSLOADER_TYPE_BOOT },
 		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_J9_CLASSLOADER_TYPE_PLATFORM, J9_CLASSLOADER_TYPE_PLATFORM },
+		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_J9_CLASSLOADER_TYPE_APP, J9_CLASSLOADER_TYPE_APP },
 		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_J9CLASS_RESERVABLE_LOCK_WORD_INIT, J9ClassReservableLockWordInit },
 		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_OBJECT_HEADER_LOCK_RESERVED, OBJECT_HEADER_LOCK_RESERVED },
 		{ J9VMCONSTANTPOOL_COMIBMOTIVMVM_OBJECT_HEADER_LOCK_LEARNING, OBJECT_HEADER_LOCK_LEARNING },

runtime/jcl/common/jclvm.c

@@ -582,3 +582,22 @@ Java_com_ibm_oti_vm_VM_getjfrCMDLineOption(JNIEnv *env, jclass clazz)
 	return jfrOption;
 }
 #endif /* defined(J9VM_OPT_JFR) */
+
+/*
+ * Check if VM is RCP restore run.
+ *
+ * @return JNI_TRUE: restore run, otherwise JNI_FALSE
+ */
+jboolean JNICALL
+Java_com_ibm_oti_vm_VM_isRCPRestoreRun(JNIEnv *env, jclass clazz)
+{
+	jboolean result = JNI_FALSE;
+#if defined(J9VM_OPT_SNAPSHOTS)
+	J9VMThread *currentThread = (J9VMThread *)env;
+	J9JavaVM *vm = currentThread->javaVM;
+	if (IS_RESTORE_RUN(vm)) {
+		result = JNI_TRUE;
+	}
+#endif /* defined(J9VM_OPT_SNAPSHOTS) */
+	return result;
+}

runtime/jcl/common/stdinit.c

@@ -468,7 +468,9 @@ internalInitializeJavaLangClassLoader(JNIEnv * env)
 #if defined(J9VM_OPT_SNAPSHOTS)
 	/* Always use the persisted applicationClassLoader in restore runs. */
 	if (IS_RESTORE_RUN(vm)) {
+#if JAVA_SPEC_VERSION == 8
 		vmFuncs->initializeSnapshotClassLoaderObject(vm, vm->applicationClassLoader, J9_JNI_UNWRAP_REFERENCE(appClassLoader));
+#endif /* JAVA_SPEC_VERSION == 8 */
 	} else
 #endif /* defined(J9VM_OPT_SNAPSHOTS) */
 	{
@@ -503,7 +505,9 @@ internalInitializeJavaLangClassLoader(JNIEnv * env)
 #if defined(J9VM_OPT_SNAPSHOTS)
 		/* Always use the persisted extensionClassLoader in restore runs. */
 		if (IS_RESTORE_RUN(vm)) {
+#if JAVA_SPEC_VERSION == 8
 			vmFuncs->initializeSnapshotClassLoaderObject(vm, vm->extensionClassLoader, classLoaderObject);
+#endif /* JAVA_SPEC_VERSION == 8 */
 		} else
 #endif /* defined(J9VM_OPT_SNAPSHOTS) */
 		if (NULL == vm->extensionClassLoader) {

runtime/jcl/exports.cmake

@@ -304,6 +304,7 @@ omr_add_exports(jclse
 	Java_com_ibm_oti_vm_VM_setCommonData
 	Java_com_ibm_oti_vm_VM_getJ9ConstantPoolFromJ9Class
 	Java_com_ibm_oti_vm_VM_isJVMInSingleThreadedMode
+	Java_com_ibm_oti_vm_VM_isRCPRestoreRun
 	Java_com_ibm_rmi_io_IIOPInputStream_00024LUDCLStackWalkOptimizer_LUDCLMarkFrame
 	Java_com_ibm_rmi_io_IIOPInputStream_00024LUDCLStackWalkOptimizer_LUDCLUnmarkFrameImpl
 	Java_com_ibm_virtualization_management_internal_GuestOS_retrieveMemoryUsageImpl

runtime/oti/VMHelpers.hpp

@@ -2301,6 +2301,44 @@ class VM_VMHelpers
 #endif /* JAVA_SPEC_VERSION >= 19 */
 		return oldState;
 	}
+
+	/**
+	 * Common function to initialize boot class loader.
+	 *
+	 * @param[in] currentThread the current J9VMThread
+	 * @param[in] classLoaderObject class loader object
+	 * @param[in] parallelCapable if true parallel capable, default false not capable (or ignored)
+	 * @return true if successful, false if failed
+	 */
+	static VMINLINE bool
+	initializeBootClassLoader(J9VMThread *currentThread, j9object_t classLoaderObject, bool parallelCapable = false)
+	{
+		J9JavaVM *vm = currentThread->javaVM;
+
+		/* If called with bootLoader, assign the system one to this instance. */
+		J9ClassLoader *classLoaderStruct = vm->systemClassLoader;
+		j9object_t loaderObject = J9CLASSLOADER_CLASSLOADEROBJECT(currentThread, classLoaderStruct);
+		if (NULL != loaderObject) {
+			return false;
+		}
+		J9CLASSLOADER_SET_CLASSLOADEROBJECT(currentThread, classLoaderStruct, classLoaderObject);
+		if (parallelCapable) {
+			classLoaderStruct->flags |= J9CLASSLOADER_PARALLEL_CAPABLE;
+		}
+		VM_AtomicSupport::writeBarrier();
+		J9VMJAVALANGCLASSLOADER_SET_VMREF(currentThread, classLoaderObject, classLoaderStruct);
+		TRIGGER_J9HOOK_VM_CLASS_LOADER_INITIALIZED(vm->hookInterface, currentThread, classLoaderStruct);
+
+		J9ClassWalkState classWalkState;
+		J9Class *clazz = allClassesStartDo(&classWalkState, vm, classLoaderStruct);
+		while (NULL != clazz) {
+			J9VMJAVALANGCLASS_SET_CLASSLOADER(currentThread, clazz->classObject, classLoaderObject);
+			clazz = allClassesNextDo(&classWalkState);
+		}
+		allClassesEndDo(&classWalkState);
+		return true;
+	}
+
 };
 
 #endif /* VMHELPERS_HPP_ */

runtime/oti/j9consts.h

@@ -884,6 +884,7 @@ extern "C" {
 #define J9_CLASSLOADER_TYPE_OTHERS		0
 #define J9_CLASSLOADER_TYPE_BOOT		1
 #define J9_CLASSLOADER_TYPE_PLATFORM	2
+#define J9_CLASSLOADER_TYPE_APP			3
 
 /* Flag for Nestmates invokeVirtual on private methods */
 #define J9_VTABLE_INDEX_DIRECT_METHOD_FLAG 0x1

runtime/oti/vmconstantpool.xml

@@ -582,6 +582,7 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 	<staticfieldref class="com/ibm/oti/vm/VM" name="J9_CLASSLOADER_TYPE_OTHERS" signature="I"/>
 	<staticfieldref class="com/ibm/oti/vm/VM" name="J9_CLASSLOADER_TYPE_BOOT" signature="I"/>
 	<staticfieldref class="com/ibm/oti/vm/VM" name="J9_CLASSLOADER_TYPE_PLATFORM" signature="I"/>
+	<staticfieldref class="com/ibm/oti/vm/VM" name="J9_CLASSLOADER_TYPE_APP" signature="I"/>
 
 	<staticfieldref class="com/ibm/oti/vm/VM" name="J9CLASS_RESERVABLE_LOCK_WORD_INIT" signature="I"/>
 	<staticfieldref class="com/ibm/oti/vm/VM" name="OBJECT_HEADER_LOCK_RESERVED" signature="I"/>

runtime/vm/BytecodeInterpreter.hpp

@@ -4937,45 +4937,22 @@ class INTERPRETER_CLASS
 			goto done;
 		}
 		if (J9_CLASSLOADER_TYPE_BOOT == loaderType) {
-			/* if called with bootLoader, assign the system one to this instance */
-			J9ClassLoader *classLoaderStruct = _vm->systemClassLoader;
-			j9object_t loaderObject = J9CLASSLOADER_CLASSLOADEROBJECT(_currentThread, classLoaderStruct);
-			if (NULL != loaderObject) {
+			if (!VM_VMHelpers::initializeBootClassLoader(_currentThread, classLoaderObject, 0 != parallelCapable)) {
 				goto internalError;
 			}
-			J9CLASSLOADER_SET_CLASSLOADEROBJECT(_currentThread, classLoaderStruct, classLoaderObject);
-			if (parallelCapable) {
-				classLoaderStruct->flags |= J9CLASSLOADER_PARALLEL_CAPABLE;
-			}
-			VM_AtomicSupport::writeBarrier();
-			J9VMJAVALANGCLASSLOADER_SET_VMREF(_currentThread, classLoaderObject, classLoaderStruct);
-			TRIGGER_J9HOOK_VM_CLASS_LOADER_INITIALIZED(_vm->hookInterface, _currentThread, classLoaderStruct);
-
-			J9ClassWalkState classWalkState;
-			J9Class* clazz = allClassesStartDo(&classWalkState, _vm, classLoaderStruct);
-			while (NULL != clazz) {
-				J9VMJAVALANGCLASS_SET_CLASSLOADER(_currentThread, clazz->classObject, classLoaderObject);
-				clazz = allClassesNextDo(&classWalkState);
-			}
-			allClassesEndDo(&classWalkState);
 		} else {
 			updateVMStruct(REGISTER_ARGS);
-#if defined(J9VM_OPT_SNAPSHOTS)
-			if (IS_RESTORE_RUN(_vm) && (J9_CLASSLOADER_TYPE_PLATFORM == loaderType)) {
-				_vm->internalVMFunctions->initializeSnapshotClassLoaderObject(_vm, _vm->extensionClassLoader, classLoaderObject);
-			} else
-#endif /* defined(J9VM_OPT_SNAPSHOTS) */
-			{
-				J9ClassLoader *result = internalAllocateClassLoader(_vm, classLoaderObject);
-				VMStructHasBeenUpdated(REGISTER_ARGS); // likely unnecessary - no code runs in internalAllocateClassLoader
-				if (NULL == result) {
-					rc = GOTO_THROW_CURRENT_EXCEPTION;
-					goto done;
-				}
-				if (J9_CLASSLOADER_TYPE_PLATFORM == loaderType) {
-					/* extensionClassLoader holds the platform class loader in Java 11+ */
-					_vm->extensionClassLoader = result;
-				}
+			J9ClassLoader *result = internalAllocateClassLoader(_vm, classLoaderObject);
+			VMStructHasBeenUpdated(REGISTER_ARGS);
+			if (NULL == result) {
+				rc = GOTO_THROW_CURRENT_EXCEPTION;
+				goto done;
+			}
+			if (J9_CLASSLOADER_TYPE_PLATFORM == loaderType) {
+				/* extensionClassLoader holds the platform class loader in Java 11+. */
+				_vm->extensionClassLoader = result;
+			} else if (J9_CLASSLOADER_TYPE_APP == loaderType) {
+				_vm->applicationClassLoader = result;
 			}
 		}
 		restoreInternalNativeStackFrame(REGISTER_ARGS);