Introduce a constantPool cache v2

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

@@ -631,6 +631,11 @@ public static int markCurrentThreadAsSystem()
  * constantpool associated with clazz
  */
 public static ConstantPool getConstantPoolFromAnnotationBytes(Class<?> clazz, byte[] array) {
+	/* Check the cp cache on the Class object first. */
+	ConstantPool cp = VM.getVMLangAccess().getConstantPoolCache(clazz);
+	if (null != cp) {
+		return cp;
+	}
 	if (null == array) {
 		return getVMLangAccess().getConstantPool(clazz);
 	}
@@ -642,7 +647,7 @@ public static ConstantPool getConstantPoolFromAnnotationBytes(Class<?> clazz, by
 	} else {
 		ramCPAddr = Unsafe.getUnsafe().getLong(array, offset);
 	}
-	Object internalCP = getVMLangAccess().createInternalConstantPool(ramCPAddr);
+	Object internalCP = getVMLangAccess().createInternalConstantPool(ramCPAddr, clazz);
 	return getVMLangAccess().getConstantPool(internalCP);
 }
 

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

@@ -131,9 +131,10 @@ public interface VMLangAccess {
 	 * Returns an InternalConstantPool object.
 	 *
 	 * @param addr - the native addr of the J9ConstantPool
+	 * @param clazz - the clazz object of the J9Class associated with the constantPool
 	 * @return An InternalConstantPool object
 	 */
-	public Object createInternalConstantPool(long addr);
+	public Object createInternalConstantPool(long addr, Class<?> clazz);
 
 	/**
 	 * Returns a ConstantPool object
@@ -148,9 +149,10 @@ public interface VMLangAccess {
 	 * natives expect an InternalConstantPool as the constantPoolOop parameter.
 	 *
 	 * @param j9class the native address of the J9Class
+	 * @param clazz the class object
 	 * @return InternalConstantPool a wrapper for a j9constantpool
 	 */
-	public Object getInternalConstantPoolFromJ9Class(long j9class);
+	public Object getInternalConstantPoolFromJ9Class(long j9class, Class<?> clazz);
 
 	/**
 	 * Returns an InternalConstantPool object from a Class. The ConstantPool
@@ -210,4 +212,14 @@ public interface VMLangAccess {
 	 */
 	public boolean getIncludeModuleVersion(StackTraceElement element);
 	/*[ENDIF] JAVA_SPEC_VERSION >= 11*/
+
+	/**
+	 * Returns a cached constantPool Object from a given java.lang.Class.
+	 *
+	 * @param clazz
+	 *
+	 * @return cpObject
+	 */
+	public ConstantPool getConstantPoolCache(Class<?> clazz);
+
 }

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

@@ -181,6 +181,8 @@ public final class Class<T> implements java.io.Serializable, GenericDeclaration,
 	private transient long vmRef;
 	private transient ClassLoader classLoader;
 
+	transient ConstantPool constantPoolObject;
+
 	/*[IF JAVA_SPEC_VERSION >= 9]*/
 	private transient Module module;
 	/*[ENDIF] JAVA_SPEC_VERSION >= 9 */

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

@@ -22,15 +22,20 @@
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
  */
 
+import com.ibm.oti.vm.VM;
+
 /**
  * Represents the internal J9ConstantPool
  *
  */
 final class InternalConstantPool {
 	@SuppressWarnings("unused")
 	private final long vmRef;
+	private final Class<?> clazz;
 
-	public InternalConstantPool(long addr) {
-		vmRef = addr;
+	public InternalConstantPool(long addr, Class<?> clazz) {
+		this.vmRef = addr;
+		this.clazz = clazz;
+		VM.dumpString("addr: " + addr + " clazz: " + clazz.getName());
 	}
 }

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

@@ -189,8 +189,8 @@ public Package getSystemPackage(String name) {
 	 * @return An InternalConstantPool reference object
 	 */
 	@Override
-	public Object createInternalConstantPool(long addr) {
-		return new InternalConstantPool(addr);
+	public Object createInternalConstantPool(long addr, Class<?> clazz) {
+		return new InternalConstantPool(addr, clazz);
 	}
 
 	/**
@@ -208,11 +208,12 @@ public ConstantPool getConstantPool(Object internalConstantPool) {
 	 * natives expect an InternalConstantPool as the constantPoolOop parameter.
 	 *
 	 * @param j9class the native address of the J9Class
+	 * @param clazz the class object
 	 * @return InternalConstantPool a wrapper for a j9constantpool
 	 */
-	public Object getInternalConstantPoolFromJ9Class(long j9class) {
+	public Object getInternalConstantPoolFromJ9Class(long j9class, Class<?> clazz) {
 		long j9constantpool = VM.getJ9ConstantPoolFromJ9Class(j9class);
-		return createInternalConstantPool(j9constantpool);
+		return createInternalConstantPool(j9constantpool, clazz);
 	}
 
 	/**
@@ -230,7 +231,7 @@ public Object getInternalConstantPoolFromClass(Class clazz) {
 		} else {
 			j9class = helpers.getJ9ClassFromClass64(clazz);
 		}
-		return getInternalConstantPoolFromJ9Class(j9class);
+		return getInternalConstantPoolFromJ9Class(j9class, clazz);
 	}
 
 	/*[IF JAVA_SPEC_VERSION >= 9]*/
@@ -276,5 +277,16 @@ public boolean getIncludeClassLoaderName(StackTraceElement element) {
 	public boolean getIncludeModuleVersion(StackTraceElement element) {
 		return element.getIncludeModuleVersion();
 	}
+
+	/**
+	 * Returns a cached constantPool Object from a given java.lang.Class
+	 *
+	 * @param clazz
+	 *
+	 * @return cpObject
+	 */
+	public ConstantPool getConstantPoolCache(Class<?> clazz) {
+		return clazz.constantPoolObject;
+	}
 	/*[ENDIF] JAVA_SPEC_VERSION >= 11 */
 }

jcl/src/java.base/share/classes/java/lang/invoke/MethodHandleResolver.java

@@ -115,8 +115,8 @@ private static final Object resolveConstantDynamic(long j9class, String name, St
 		Object result = null;
 
 		VMLangAccess access = VM.getVMLangAccess();
-		Object internalConstantPool = access.getInternalConstantPoolFromJ9Class(j9class);
 		Class<?> classObject = getClassFromJ9Class(j9class);
+		Object internalConstantPool = access.getInternalConstantPoolFromJ9Class(j9class, classObject);
 
 		Class<?> typeClass = fromFieldDescriptorString(fieldDescriptor, access.getClassloader(classObject));
 
@@ -241,8 +241,8 @@ private static final Object invokeBsm(MethodHandle bsm, Object[] staticArgs) thr
 	private static final Object resolveInvokeDynamic(long j9class, String name, String methodDescriptor, long bsmData) throws Throwable {
 /*[IF OPENJDK_METHODHANDLES]*/
 		VMLangAccess access = VM.getVMLangAccess();
-		Object internalConstantPool = access.getInternalConstantPoolFromJ9Class(j9class);
 		Class<?> classObject = getClassFromJ9Class(j9class);
+		Object internalConstantPool = access.getInternalConstantPoolFromJ9Class(j9class, classObject);
 
 		MethodType type = null;
 		Object[] result = new Object[2];
@@ -340,8 +340,8 @@ private static final Object resolveInvokeDynamic(long j9class, String name, Stri
 		try {
 /*[ENDIF] JAVA_SPEC_VERSION < 11 */
 			VMLangAccess access = VM.getVMLangAccess();
-			Object internalConstantPool = access.getInternalConstantPoolFromJ9Class(j9class);
 			Class<?> classObject = getClassFromJ9Class(j9class);
+			Object internalConstantPool = access.getInternalConstantPoolFromJ9Class(j9class, classObject);
 
 			type = MethodTypeHelper.vmResolveFromMethodDescriptorString(methodDescriptor, access.getClassloader(classObject), null);
 			final MethodHandles.Lookup lookup = new MethodHandles.Lookup(classObject, false);

runtime/gc_include/ObjectAllocationAPI.hpp

@@ -346,6 +346,10 @@ class MM_ObjectAllocationAPI
 			allocateSize = J9_GC_MINIMUM_OBJECT_SIZE;
 		}
 
+		if (J9VMJAVALANGINTERNALCONSTANTPOOL_OR_NULL(currentThread->javaVM) == clazz) {
+			return NULL;
+		}
+
 		/* Allocate the object */
 		switch(_gcAllocationType) {
 #if defined(J9VM_GC_THREAD_LOCAL_HEAP)
@@ -441,6 +445,7 @@ class MM_ObjectAllocationAPI
 			VM_AtomicSupport::writeBarrier();
 		}
 #endif /* J9VM_GC_THREAD_LOCAL_HEAP || J9VM_GC_SEGREGATED_HEAP */
+
 		return instance;
 	}