Cache Modularity Structures in the Snapshot

[babsingh]

The goal is to cache modularity related structures in the snapshot. From a high level, this requires us to save and restore instances of J9Module, J9Package and J9ModuleExtraInfo.

openj9/runtime/oti/j9nonbuilder.h

Lines 1845 to 1855 in efaa4f6

	typedef struct J9Module {
	j9object_t moduleName;
	j9object_t moduleObject;
	j9object_t version;
	struct J9ClassLoader* classLoader;
	struct J9HashTable* readAccessHashTable;
	struct J9HashTable* removeAccessHashTable;
	struct J9HashTable* removeExportsHashTable;
	BOOLEAN isLoose;
	BOOLEAN isOpen;
	} J9Module;

openj9/runtime/oti/j9nonbuilder.h

Lines 1857 to 1864 in efaa4f6

	typedef struct J9Package {
	struct J9UTF8* packageName;
	U_32 exportToAll;
	U_32 exportToAllUnnamed;
	struct J9Module* module;
	struct J9HashTable* exportsHashTable;
	struct J9ClassLoader* classLoader;
	} J9Package;

openj9/runtime/oti/j9nonbuilder.h

Lines 1866 to 1871 in efaa4f6

	typedef struct J9ModuleExtraInfo {
	struct J9Module* j9module;
	struct J9UTF8* jrtURL;
	struct J9ClassPathEntry** patchPathEntries;
	UDATA patchPathCount;
	} J9ModuleExtraInfo;

Implementation

1. Add new fields in SavedJ9JavaVMStructures to save and restore J9JavaVM->modularityPool, J9JavaVM->javaBaseModule and J9JavaVM->unnamedModuleForSystemLoader.

openj9/runtime/oti/j9nonbuilder.h

Lines 6129 to 6131 in efaa4f6

	struct J9Pool* modularityPool;
	struct J9Module *javaBaseModule;
	struct J9Module *unnamedModuleForSystemLoader;

openj9/runtime/oti/SnapshotFileFormat.h

Lines 35 to 36 in efaa4f6

	typedef struct SavedJ9JavaVMStructures {
	J9Pool *classLoaderBlocks;

openj9/runtime/vm/VMSnapshotImpl.cpp

Lines 804 to 806 in efaa4f6

	VMSnapshotImpl::saveJ9JavaVMStructures()
	{
	saveClassLoaderBlocks();

openj9/runtime/vm/VMSnapshotImpl.cpp

Lines 816 to 823 in efaa4f6

	VMSnapshotImpl::restoreJ9JavaVMStructures()
	{
	bool success = true;
	fixupVMStructures();
	restoreClassLoaderBlocks();
	restoreMemorySegments();
	restorePrimitiveAndArrayClasses();

2. Make sure that the restored fields are not re-initialized during the restore run through proper macros (e.g. IS_RESTORE_RUN).

3. Use the snapshot port library to allocate J9JavaVM->modularityPool similar to the existing logic that is used for J9JavaVM->classLoaderBlocks.
   

   openj9/runtime/vm/jvminit.c

   Lines 2641 to 2644 in efaa4f6

   	vm->modularityPool = pool_new(OMR_MAX(sizeof(J9Package),sizeof(J9Module)), 0, 0, 0, J9_GET_CALLSITE(), J9MEM_CATEGORY_MODULES, POOL_FOR_PORT(vm->portLibrary));
   	if (NULL == vm->modularityPool) {
   	goto _error;
   	}

4. Use the snapshot port library to allocate the related hashtables. We already do this for hashPackageTableNew and hashModuleNameTableNew. We want to extend this to hashModuleExtraInfoTableNew and hashModulePointerTableNew.

openj9/runtime/vm/ModularityHashTables.c

Lines 154 to 159 in efaa4f6

	hashModulePointerTableNew(J9JavaVM *javaVM, U_32 initialSize)
	{
	U_32 flags = J9HASH_TABLE_ALLOW_SIZE_OPTIMIZATION;
	return hashTableNew(
	OMRPORT_FROM_J9PORT(javaVM->portLibrary),

openj9/runtime/vm/ModularityHashTables.c

Lines 199 to 204 in efaa4f6

	hashModuleExtraInfoTableNew(J9JavaVM *javaVM, U_32 initialSize)
	{
	U_32 flags = J9HASH_TABLE_ALLOW_SIZE_OPTIMIZATION;
	return hashTableNew(
	OMRPORT_FROM_J9PORT(javaVM->portLibrary),

5. Similarly, make sure that all the memory, for the internal fields of the above three native structures, is allocated using the snapshot port library. This will allow them to be successfully cached in the snapshot.

6. If the fields cannot be cached (e.g. the object fields moduleName/moduleObject/version in J9Module), add appropriate code to initialize them during every run once the cached data is loaded.

7. During the creation paths, add logic to restore the native structures from the snapshot, and then initialize the required fields.

   • For J9Module, createModule will need to be updated to load the cached J9Module during the restore phase. J9ClassLoader->moduleHashTable will be used to find the cached J9Module. J9Module->moduleName will be cleared during shutdown before the snapshot is written, and it is needed for comparisons to resolve hashtable collisions. Since objects can't persist across runs, the module name will need to be stored as a string in J9Module. The moduleName pointer and other GC code to persist the object pointer can be removed. The usage of J9Module->moduleName will need to be replaced by the string that is stored in J9Module. If the moduleName object is needed, it can be accessed through J9Module->moduleObject (via vmconstantpool.xml).
   • The remaining object fields in J9Module will need to be cleared during shutdown and reinitialized once a J9Module entry is restored from the snapshot in createModule.
     

     openj9/runtime/j9vm/java11vmi.c

     Lines 272 to 276 in efaa4f6

     	createModule(J9VMThread * currentThread, j9object_t moduleObject, J9ClassLoader * classLoader, j9object_t moduleName)
     	{
     	J9JavaVM * const vm = currentThread->javaVM;
     	J9InternalVMFunctions const * const vmFuncs = vm->internalVMFunctions;
     	J9Module * j9mod = NULL;

     
     

     openj9/runtime/vm/classsupport.c

     Lines 378 to 385 in efaa4f6

     	J9Module module = {0};
     	J9Module *modulePtr = &module;
     	modulePtr->moduleName = moduleName;
     	findResult = hashTableFind(classLoader->moduleHashTable, &modulePtr);
     	if (NULL != findResult) {
     	j9module = *findResult;
     	}

   • For J9Package, createPackage will need to be updated similarly, and the cached value can be found using J9ClassLoader->packageHashTable.
     

     openj9/runtime/j9vm/java11vmi.c

     Lines 218 to 222 in efaa4f6

     	createPackage(J9VMThread * currentThread, J9Module * fromModule, const char *package)
     	{
     	J9JavaVM * const vm = currentThread->javaVM;
     	J9InternalVMFunctions const * const vmFuncs = vm->internalVMFunctions;
     	J9Package * retval = NULL;

     
     

     openj9/runtime/util/modularityHelper.c

     Lines 106 to 110 in efaa4f6

     	J9Package*
     	hashPackageTableAt(J9VMThread *currentThread, J9ClassLoader *classLoader, const char *packageName)
     	{
     	J9Package package = {0};
     	J9Package *packagePtr = &package;

     
     

     openj9/runtime/util/modularityHelper.c

     Lines 153 to 157 in efaa4f6

     	hashPackageTableAtWithUTF8Name(J9VMThread *currentThread, J9ClassLoader *classLoader, J9UTF8 *packageName)
     	{
     	J9Package package = {0};
     	J9Package *packagePtr = &package;
     	J9Package **targetPtr = NULL;

   • For J9ModuleExtraInfo, caching the hashtable should be sufficient. The current code checks in the hashtable before creating a new J9ModuleExtraInfo.
   • Memory, for the J9UTF8 strings and other native memory for the fields within these structs, will need to be allocated using the vmsnapshot_allocate_memory.

8. Make sure that pointers to J9Module stored in other structs are valid and if needed fixed: J9Package->module, J9ModuleExtraInfo->j9module and J9Class->module. No pointers to J9Package and J9ModuleExtraInfo exist in other structs.

9. Check the exit paths (e.g. where freeJ9Module, freePackage, freeClassLoader are being invoked) to make sure that entities are written to the snapshot and not being freed early.

[github-actions]

Issue Number: 20612
Status: Open
Recommended Components: comp:vm, comp:test, comp:jvmti

[babsingh]

fyi @ThanHenderson @TobiAjila @hangshao0 @gacholio

[ThanHenderson]

I've made some pretty good progress towards this last week. I'll have the implementation done this week.