compiler test option reuse - support content equal maps

Author: davleopo

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/CacheResetTest.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.graal.compiler.core.test;
+
+import java.util.HashMap;
+
+import org.graalvm.collections.Pair;
+import org.junit.Assert;
+import org.junit.Test;
+
+import jdk.graal.compiler.core.phases.HighTier;
+import jdk.graal.compiler.options.OptionValues;
+import jdk.vm.ci.code.InstalledCode;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
+/**
+ * Tests that the cache used by the compiler tests properly handles different options.
+ */
+public class CacheResetTest extends GraalCompilerTest {
+
+    public static void snippet() {
+        // do nothing
+    }
+
+    private static final String SNIPPET_NAME = "snippet";
+
+    @Test
+    public void testSameOptionsReuse() {
+        final ResolvedJavaMethod installedCodeOwner = getResolvedJavaMethod(SNIPPET_NAME);
+
+        OptionValues opt = new OptionValues(getInitialOptions(), HighTier.Options.Inline, true);
+
+        test(opt, SNIPPET_NAME);
+        InstalledCode firstInstalled = getCachedCode(installedCodeOwner);
+
+        test(opt, SNIPPET_NAME);
+        InstalledCode secondInstalled = getCachedCode(installedCodeOwner);
+
+        assert firstInstalled.isValid();
+        assert secondInstalled.isValid();
+
+        Assert.assertEquals(firstInstalled.getStart(), secondInstalled.getStart());
+    }
+
+    @Test
+    public void testSameOptionsDeepReuse() {
+        final ResolvedJavaMethod installedCodeOwner = getResolvedJavaMethod(SNIPPET_NAME);
+
+        OptionValues opt = new OptionValues(getInitialOptions(), HighTier.Options.Inline, true);
+        test(opt, SNIPPET_NAME);
+        InstalledCode firstInstalled = getCachedCode(installedCodeOwner);
+
+        OptionValues opt1 = new OptionValues(getInitialOptions(), HighTier.Options.Inline, true);
+        test(opt1, SNIPPET_NAME);
+        InstalledCode secondInstalled = getCachedCode(installedCodeOwner);
+
+        assert firstInstalled.isValid();
+        assert secondInstalled.isValid();
+
+        Assert.assertEquals(firstInstalled.getStart(), secondInstalled.getStart());
+    }
+
+    private static InstalledCode getCachedCode(ResolvedJavaMethod method) {
+        HashMap<ResolvedJavaMethod, Pair<OptionValues, InstalledCode>> tlCache = cache.get();
+        Pair<OptionValues, InstalledCode> cached = tlCache.get(method);
+        return cached.getRight();
+    }
+
+    @Test
+    public void testDifferentOptionsNoReuse() {
+        final ResolvedJavaMethod installedCodeOwner = getResolvedJavaMethod(SNIPPET_NAME);
+
+        OptionValues opt = new OptionValues(getInitialOptions(), HighTier.Options.Inline, true);
+        test(opt, SNIPPET_NAME);
+        InstalledCode firstInstalled = getCachedCode(installedCodeOwner);
+
+        OptionValues opt1 = new OptionValues(getInitialOptions(), HighTier.Options.Inline, false);
+        test(opt1, SNIPPET_NAME);
+        InstalledCode secondInstalled = getCachedCode(installedCodeOwner);
+
+        assert firstInstalled.isValid();
+        assert secondInstalled.isValid();
+
+        Assert.assertNotEquals(firstInstalled.getStart(), secondInstalled.getStart());
+    }
+}

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/GraalCompilerTest.java

@@ -60,6 +60,7 @@
 import java.util.function.Supplier;
 
 import org.graalvm.collections.Pair;
+import org.graalvm.collections.UnmodifiableEconomicMap;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -130,6 +131,7 @@
 import jdk.graal.compiler.nodes.spi.ProfileProvider;
 import jdk.graal.compiler.nodes.spi.Replacements;
 import jdk.graal.compiler.nodes.virtual.VirtualObjectNode;
+import jdk.graal.compiler.options.OptionKey;
 import jdk.graal.compiler.options.OptionValues;
 import jdk.graal.compiler.phases.BasePhase;
 import jdk.graal.compiler.phases.OptimisticOptimizations;
@@ -396,7 +398,7 @@ protected LIRSuites createLIRSuites(OptionValues opts) {
         return ret;
     }
 
-    private static final ThreadLocal<HashMap<ResolvedJavaMethod, Pair<OptionValues, InstalledCode>>> cache = ThreadLocal.withInitial(HashMap::new);
+    protected static final ThreadLocal<HashMap<ResolvedJavaMethod, Pair<OptionValues, InstalledCode>>> cache = ThreadLocal.withInitial(HashMap::new);
 
     /**
      * Reset the entire {@linkplain #cache} of {@linkplain InstalledCode}. Additionally, invalidate
@@ -1138,9 +1140,9 @@ protected InstalledCode getCode(final ResolvedJavaMethod installedCodeOwner, Str
             Pair<OptionValues, InstalledCode> cached = tlCache.get(installedCodeOwner);
             if (cached != null) {
                 // Reuse the cached code is the it's still valid and the same options were used for
-                // the compilation.
-                if (cached.getRight().isValid() && options.getMap().equals(cached.getLeft().getMap())) {
-                    GraalError.unimplemented("map value compare");
+                // the compilation. We use a deep equals for the option values to catch cases where
+                // users create new option values but with the same values.
+                if (cached.getRight().isValid() && (options.getMap().equals(cached.getLeft().getMap()) || optionsMapDeepEquals(options.getMap(), cached.getLeft().getMap()))) {
                     return cached.getRight();
                 } else {
                     tlCache.remove(installedCodeOwner);
@@ -1195,6 +1197,28 @@ protected InstalledCode getCode(final ResolvedJavaMethod installedCodeOwner, Str
         throw GraalError.shouldNotReachHere("Bailout limit reached"); // ExcludeFromJacocoGeneratedReport
     }
 
+    private static boolean optionsMapDeepEquals(UnmodifiableEconomicMap<OptionKey<?>, Object> map1, UnmodifiableEconomicMap<OptionKey<?>, Object> map2) {
+        if (map1.size() != map2.size()) {
+            return false;
+        }
+        var c1 = map1.getEntries();
+        var c2 = map2.getEntries();
+        while (c1.advance() && c2.advance()) {
+            Object c1Key = c1.getKey();
+            Object c2Key = c2.getKey();
+            if (!c1Key.equals(c2Key)) {
+                return false;
+            }
+            Object c1Val = c1.getValue();
+            Object c2Val = c2.getValue();
+            if (!c1Val.equals(c2Val)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Used to produce a graph for a method about to be compiled by
      * {@link #compile(ResolvedJavaMethod, StructuredGraph)} if the second parameter to that method