add cache to avoid synchronization

Author: dougxc

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/graph/NodeClass.java

@@ -44,6 +44,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Stream;
 
+import jdk.graal.compiler.nodes.NodeClassMap;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.Equivalence;
 
@@ -1487,4 +1488,37 @@ private static void unregisterAtInputsAsUsageHelperMany(Node node, NodeList<Node
         }
         list.clearWithoutUpdate();
     }
+
+    /**
+     * The cached id for a {@link NodeClass} object in a specific {@link NodeClassMap}.
+     *
+     * @param map an object whose identity uniquely identifies a {@link NodeClassMap}
+     */
+    record CachedId(Object map, Integer id) {
+    }
+
+    private CachedId cachedId;
+
+    /**
+     * Sets the cache for this object's {@code id} in {@code map}.
+     *
+     * @param map an object whose identity uniquely identifies a {@link NodeClassMap}
+     */
+    public void setCachedId(Object map, Integer id) {
+        cachedId = new CachedId(map, id);
+    }
+
+    /**
+     * Gets the cache for this object's id in {@code map}.
+     *
+     * @param map an object whose identity uniquely identifies a {@link NodeClassMap}
+     * @return null if no cached id for this object in {@code map} is available
+     */
+    public Integer getCachedId(Object map) {
+        var c = cachedId;
+        if (c != null && c.map == map) {
+            return c.id;
+        }
+        return null;
+    }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/NodeClassMap.java

@@ -57,19 +57,35 @@ public NodeClassMap() {
         this.values = new NodeClass<?>[INITIAL_CONCRETE_CAPACITY];
     }
 
+    /**
+     * An object that is a proxy for this {@link NodeClassMap} in a cache. Using a proxy prevents a
+     * reference from a {@link NodeClass} to all other entries in a {@link NodeClassMap}. This is
+     * important in the context of Native Image as some {@link NodeClassMap}s can contain
+     * hosted-only node classes.
+     */
+    private final Object cacheToken = new Object();
+
     /**
      * Gets an id for {@code nc}, creating it first if necessary.
      */
-    public synchronized int getId(NodeClass<?> nc) {
-        Integer id = valueToId.get(nc);
+    public int getId(NodeClass<?> nc) {
+        // Using a cache entry in `nc` mostly avoids going
+        // into the synchronized block below.
+        Integer id = nc.getCachedId(cacheToken);
         if (id == null) {
-            if (size == values.length) {
-                int growth = (size + 1) >> 1;
-                values = Arrays.copyOf(values, size + growth);
+            synchronized (this) {
+                id = valueToId.get(nc);
+                if (id == null) {
+                    if (size == values.length) {
+                        int growth = (size + 1) >> 1;
+                        values = Arrays.copyOf(values, size + growth);
+                    }
+                    id = size++;
+                    valueToId.put(nc, id);
+                    values[id] = nc;
+                }
             }
-            id = size++;
-            valueToId.put(nc, id);
-            values[id] = nc;
+            nc.setCachedId(cacheToken, id);
         }
         return id;
     }