remove AnnotatedObjectAccess caches

Author: dougxc

common.json

@@ -4,7 +4,7 @@
     "Jsonnet files should not include this file directly but use ci/common.jsonnet instead."
   ],
 
-  "mx_version": "7.65.3",
+  "mx_version": "7.66.1",
 
   "COMMENT.jdks": "When adding or removing JDKs keep in sync with JDKs in ci/common.jsonnet",
   "jdks": {

compiler/mx.compiler/mx_compiler.py

@@ -252,6 +252,7 @@ def _ctw_jvmci_export_args(arg_prefix='--'):
         'add-exports=java.base/jdk.internal.module=ALL-UNNAMED',
         'add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot=ALL-UNNAMED',
         'add-exports=jdk.internal.vm.ci/jdk.vm.ci.meta=ALL-UNNAMED',
+        'add-exports=jdk.internal.vm.ci/jdk.vm.ci.meta.annotation=ALL-UNNAMED',
         'add-exports=jdk.internal.vm.ci/jdk.vm.ci.services=ALL-UNNAMED',
         'add-exports=jdk.internal.vm.ci/jdk.vm.ci.runtime=ALL-UNNAMED',
         'add-exports=jdk.graal.compiler/jdk.graal.compiler.hotspot=ALL-UNNAMED',

compiler/mx.compiler/mx_graal_benchmark.py

@@ -414,6 +414,7 @@ def extraVmArgs(self):
                  '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.services=ALL-UNNAMED',
                  '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.runtime=ALL-UNNAMED',
                  '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.meta=ALL-UNNAMED',
+                 '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.meta.annotation=ALL-UNNAMED',
                  '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code=ALL-UNNAMED',
                  '--add-exports=jdk.graal.compiler/jdk.graal.compiler.graph=ALL-UNNAMED',
                  '--add-exports=org.graalvm.truffle/com.oracle.truffle.api.benchmark=ALL-UNNAMED',

compiler/mx.compiler/suite.py

@@ -314,6 +314,7 @@
         "GRAAL_PROCESSOR",
       ],
       "javaCompliance" : "21+",
+      "spotbugs": "false",
       "workingSets" : "Graal,HotSpot",
     },
 
@@ -328,6 +329,7 @@
       "requiresConcealed" : {
         "jdk.internal.vm.ci" : [
           "jdk.vm.ci.meta",
+          "jdk.vm.ci.meta.annotation",
           "jdk.vm.ci.code"
         ],
       },
@@ -398,6 +400,7 @@
       "checkstyle" : "jdk.graal.compiler",
       "javaCompliance" : "21+",
       "jacoco" : "exclude",
+      "spotbugs": "false",
       "graalCompilerSourceEdition": "ignore",
     },
 

compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleHostEnvironment.java

@@ -107,7 +107,7 @@ protected HostMethodInfo computeValue(ResolvedJavaMethod method) {
             boolean isBytecodeInterpreterSwitch = annotations.containsKey(hostTypes.BytecodeInterpreterSwitch);
             boolean isBytecodeInterpreterSwitchBoundary = annotations.containsKey(hostTypes.BytecodeInterpreterSwitchBoundary);
             boolean isInliningCutoff = annotations.containsKey(hostTypes.InliningCutoff);
-            boolean isInliningRoot = annotations.containsKey(hostTypes.InliningRoot);
+            boolean isInliningRoot = hostTypes.InliningRoot != null && annotations.containsKey(hostTypes.InliningRoot);
             return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff, isInliningRoot);
         }
 

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/replaycomp/test/CompilationProxyTest.java

@@ -91,7 +91,7 @@ public void checkProxyMethods() throws IllegalAccessException, InvocationTargetE
                         assertTrue("protected method should throw UnsupportedOperationException", e.getTargetException() instanceof UnsupportedOperationException);
                         continue;
                     }
-                    Assert.fail("expected the protected method to throw");
+                    Assert.fail("expected the protected method to throw: " + method);
                 }
 
                 Object returnValue = createValue(method.getReturnType());

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/annotation/AnnotationValue.java

@@ -30,6 +30,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.function.BiFunction;
 
 import jdk.graal.compiler.util.CollectionsUtil;
 import jdk.vm.ci.meta.ResolvedJavaType;
@@ -375,4 +376,28 @@ public int hashCode() {
         }
         return type.hashCode() ^ elements.hashCode();
     }
+
+    /**
+     * Result of last call to {@link #toAnnotation}.
+     */
+    private volatile Annotation annotationCache;
+
+    /**
+     * Converts this to an {@link Annotation} of type {@code annotationType}, utilizing the provided
+     * converter function. The result is cached to improve performance by reducing redundant
+     * conversions.
+     *
+     * @param <T> the type of the annotation to be created
+     * @param annotationType the desired annotation type
+     * @param converter a function that does the conversion
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends Annotation> T toAnnotation(Class<T> annotationType, BiFunction<AnnotationValue, Class<T>, T> converter) {
+        Annotation res = annotationCache;
+        if (res == null || res.annotationType() != annotationType) {
+            res = converter.apply(this, annotationType);
+            annotationCache = res;
+        }
+        return (T) res;
+    }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/annotation/AnnotationValueSupport.java

@@ -32,13 +32,13 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.RecordComponent;
 import java.nio.ByteBuffer;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
 
 import jdk.graal.compiler.core.common.LibGraalSupport;
 import jdk.graal.compiler.debug.GraalError;
+import jdk.graal.compiler.util.CollectionsUtil;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 import jdk.vm.ci.meta.UnresolvedJavaType;
@@ -77,12 +77,26 @@ public static AnnotationValue getDeclaredAnnotationValue(ResolvedJavaType annota
      *         present on this element
      */
     public static Map<ResolvedJavaType, AnnotationValue> getDeclaredAnnotationValues(Annotated annotated) {
-        AnnotationsInfo info = annotated.getDeclaredAnnotationInfo();
+        return annotated.getDeclaredAnnotationInfo(ANNOTATIONS_INFO_PARSER).values;
+    }
+
+    /**
+     * Result type returned by {@link AnnotationValueSupport#ANNOTATIONS_INFO_PARSER}.
+     *
+     * @param values the parsed annotations
+     * @param container used to resolve type names in the annotations
+     */
+    public record ParsedDeclaredAnnotationValues(Map<ResolvedJavaType, AnnotationValue> values, ResolvedJavaType container) {
+        public static ParsedDeclaredAnnotationValues NONE = new ParsedDeclaredAnnotationValues(CollectionsUtil.mapOf(), null);
+    }
+
+    public static final Function<AnnotationsInfo, ParsedDeclaredAnnotationValues> ANNOTATIONS_INFO_PARSER = info -> {
         if (info == null) {
-            return Collections.emptyMap();
+            return ParsedDeclaredAnnotationValues.NONE;
         }
-        return AnnotationValueParser.parseAnnotations(info.bytes(), info.constPool(), info.container());
-    }
+        ResolvedJavaType container = info.container();
+        return new ParsedDeclaredAnnotationValues(AnnotationValueParser.parseAnnotations(info.bytes(), info.constPool(), container), container);
+    };
 
     /**
      * Gets the type annotations for {@code annotated} that back the implementation of
@@ -122,9 +136,9 @@ public static List<List<AnnotationValue>> getParameterAnnotationValues(ResolvedJ
      * null if no default is associated with {@code method}, or if {@code method} does not represent
      * a declared member of an annotation type.
      *
-     * @see Method#getDefaultValue()
      * @return the default value for the annotation member represented by this object. The type of
      *         the returned value is specified by {@link AnnotationValue#get}
+     * @see Method#getDefaultValue()
      */
     public static Object getAnnotationDefaultValue(ResolvedJavaMethod method) {
         AnnotationsInfo info = method.getAnnotationDefaultInfo();
@@ -150,47 +164,14 @@ public static AnnotationValue getAnnotationValue(Annotated annotated, Class<? ex
         return getAnnotationValue0(annotated, annotationType, inherited);
     }
 
-    /**
-     * Cache for {@link #getAnnotationValue}. Building libgraal-ee shows that this cache grows to
-     * about 3K entries so the LRU cache is sized just above that (4096). This cache must not grow
-     * too large as there are Native Image tests that build numerous images in the one JVM process.
-     */
-    @LibGraalSupport.HostedOnly //
-    private static final Map<Annotated, Map<ResolvedJavaType, AnnotationValue>> declaredAnnotations;
-    static {
-        final int cacheMaxSize = 4096;
-        if (LibGraalSupport.INSTANCE == null) {
-            declaredAnnotations = Collections.synchronizedMap(new java.util.LinkedHashMap<>(cacheMaxSize, 0.75f, true) {
-                @Override
-                protected boolean removeEldestEntry(Map.Entry<Annotated, Map<ResolvedJavaType, AnnotationValue>> eldest) {
-                    return size() > cacheMaxSize;
-                }
-            });
-        } else {
-            declaredAnnotations = null;
-        }
-    }
-
     @LibGraalSupport.HostedOnly
     private static AnnotationValue getAnnotationValue0(Annotated annotated, Class<? extends Annotation> annotationType, boolean inherited) {
-        AnnotationsInfo info = annotated.getDeclaredAnnotationInfo();
-        if (info == null && !inherited) {
+        ParsedDeclaredAnnotationValues parsed = annotated.getDeclaredAnnotationInfo(ANNOTATIONS_INFO_PARSER);
+        if (parsed.values == null && !inherited) {
             return null;
         }
-        Map<ResolvedJavaType, AnnotationValue> map = declaredAnnotations.get(annotated);
-        if (map == null) {
-            /*
-             * Do not use Map#computeIfAbsent as Collections.SynchronizedMap#computeIfAbsent blocks
-             * readers during the creation of the cached value.
-             */
-            map = AnnotationValueParser.parseAnnotations(info.bytes(), info.constPool(), info.container());
-            var existing = declaredAnnotations.putIfAbsent(annotated, map);
-            if (existing != null) {
-                map = existing;
-            }
-        }
 
-        AnnotationValue res = lookup(annotationType, map, info);
+        AnnotationValue res = lookup(annotationType, parsed.values, parsed.container);
         if (res != null) {
             return res;
         }
@@ -201,19 +182,22 @@ private static AnnotationValue getAnnotationValue0(Annotated annotated, Class<?
         return null;
     }
 
-    @LibGraalSupport.HostedOnly //
-    private static final Map<Class<? extends Annotation>, ResolvedJavaType> resolvedAnnotationTypeCache = LibGraalSupport.INSTANCE != null ? null
-                    : new ConcurrentHashMap<>();
-
+    /**
+     * Looks up the annotation value of type {@code annotationType} in {@code map}.
+     *
+     * @param annotationType the type of annotation to look up
+     * @param map the map of annotation values to search
+     * @param container used to resolve the annotation type
+     * @return the annotation value if found, or null if not found
+     */
     @LibGraalSupport.HostedOnly
-    private static AnnotationValue lookup(Class<? extends Annotation> annotationType, Map<ResolvedJavaType, AnnotationValue> map, AnnotationsInfo info) {
+    private static AnnotationValue lookup(Class<? extends Annotation> annotationType, Map<ResolvedJavaType, AnnotationValue> map, ResolvedJavaType container) {
         String internalName = "L" + annotationType.getName().replace(".", "/") + ";";
         for (var e : map.entrySet()) {
             ResolvedJavaType type = e.getKey();
             if (type.getName().equals(internalName)) {
                 // The name matches so now double-check the resolved type matches
-                ResolvedJavaType resolved = resolvedAnnotationTypeCache.computeIfAbsent(annotationType, a -> UnresolvedJavaType.create(internalName).resolve(info.container()));
-                if (resolved.equals(type)) {
+                if (UnresolvedJavaType.create(internalName).resolve(container).equals(type)) {
                     return e.getValue();
                 }
             }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/JVMCIVersionCheck.java

@@ -58,8 +58,8 @@ public final class JVMCIVersionCheck {
     // Checkstyle: stop stable iteration order check
     private static final Map<String, Map<String, Version>> JVMCI_MIN_VERSIONS = Map.of(
                     "25", Map.of(
-                                    "Oracle Corporation", createLabsJDKVersion("25.0.1+8", "25.1", 8),
-                                    DEFAULT_VENDOR_ENTRY, createLabsJDKVersion("25.0.1+8", "25.1", 8)));
+                                    "Oracle Corporation", createLabsJDKVersion("25.0.1+8", "25.1", 9),
+                                    DEFAULT_VENDOR_ENTRY, createLabsJDKVersion("25.0.1+8", "25.1", 9)));
     // Checkstyle: resume stable iteration order check
 
     private static final int NA = 0;

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/SnippetResolvedJavaMethod.java

@@ -27,6 +27,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.Objects;
+import java.util.function.Function;
 
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.ConstantPool;
@@ -38,6 +39,7 @@
 import jdk.vm.ci.meta.ResolvedJavaType;
 import jdk.vm.ci.meta.Signature;
 import jdk.vm.ci.meta.SpeculationLog;
+import jdk.vm.ci.meta.annotation.AnnotationsInfo;
 
 /**
  * A minimal implementation of {@link ResolvedJavaMethod} for use by libgraal.
@@ -225,6 +227,16 @@ public Annotation[] getDeclaredAnnotations() {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public <T> T getDeclaredAnnotationInfo(Function<AnnotationsInfo, T> parser) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public AnnotationsInfo getTypeAnnotationInfo() {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public int getModifiers() {
         return modifiers;