[GR-41301] Introduce MultiMethod concept.

PullRequest: graal/12753

Author: teshull

substratevm/mx.substratevm/suite.py

@@ -1569,6 +1569,7 @@
                 "name" : "org.graalvm.nativeimage.base",
                 "exports" : [
                     "com.oracle.svm.util                   to org.graalvm.nativeimage.pointsto,org.graalvm.nativeimage.builder,org.graalvm.nativeimage.librarysupport,org.graalvm.nativeimage.driver,org.graalvm.nativeimage.llvm,org.graalvm.nativeimage.agent.jvmtibase,org.graalvm.nativeimage.agent.tracing,org.graalvm.nativeimage.agent.diagnostics,org.graalvm.nativeimage.junitsupport,com.oracle.svm.svm_enterprise",
+                    "com.oracle.svm.common.meta            to org.graalvm.nativeimage.pointsto,org.graalvm.nativeimage.builder",
                     "com.oracle.svm.common.option          to org.graalvm.nativeimage.pointsto,org.graalvm.nativeimage.builder,org.graalvm.nativeimage.driver",
                 ],
             }

substratevm/src/com.oracle.svm.common/src/com/oracle/svm/common/meta/MultiMethod.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2022, 2022, 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 com.oracle.svm.common.meta;
+
+import java.util.Collection;
+
+/**
+ * Multi-methods can have multiple implementations of the original Java method. This functionality
+ * is used to create the different variants needed for different compilation scenarios.
+ */
+public interface MultiMethod {
+
+    /**
+     * Key for accessing a multi-method.
+     */
+    interface MultiMethodKey {
+    }
+
+    MultiMethodKey ORIGINAL_METHOD = new MultiMethodKey() {
+        @Override
+        public String toString() {
+            return "Original_Method_Key";
+        }
+    };
+
+    /**
+     * Each method is assigned a unique key which denotes the purpose of the method.
+     */
+    MultiMethodKey getMultiMethodKey();
+
+    /**
+     * @return method implementation with the requested key, creating it if necessary.
+     */
+    MultiMethod getOrCreateMultiMethod(MultiMethodKey key);
+
+    /**
+     * @return method implementation with the requested key, or null if it does not exist.
+     */
+    MultiMethod getMultiMethod(MultiMethodKey key);
+
+    /**
+     * @return all implementations of this method.
+     */
+    Collection<MultiMethod> getAllMultiMethods();
+}

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompilationInfo.java

@@ -35,6 +35,7 @@
 import org.graalvm.compiler.options.OptionValues;
 
 import com.oracle.graal.pointsto.flow.AnalysisParsedGraph;
+import com.oracle.svm.common.meta.MultiMethod;
 import com.oracle.svm.core.deopt.DeoptTest;
 import com.oracle.svm.core.deopt.Specialize;
 import com.oracle.svm.hosted.code.CompileQueue.CompileFunction;
@@ -65,20 +66,6 @@ public class CompilationInfo {
      */
     protected ConstantNode[] specializedArguments;
 
-    /**
-     * A link to the deoptimization target method if this method can deoptimize.
-     */
-    protected HostedMethod deoptTarget;
-
-    /**
-     * A link to the regular compiled method if this method is a deoptimization target.
-     *
-     * Note that it is important that this field is final: the {@link HostedMethod#getName() method
-     * name} depends on this field (to distinguish a regular method from a deoptimization target
-     * method), so mutating this field would mutate the name of a method.
-     */
-    protected final HostedMethod deoptOrigin;
-
     /* Custom parsing and compilation code that is executed instead of that of CompileQueue */
     protected ParseFunction customParseFunction;
     protected CompileFunction customCompileFunction;
@@ -95,41 +82,28 @@ public class CompilationInfo {
     protected final AtomicLong numVirtualCalls = new AtomicLong();
     protected final AtomicLong numEntryPointCalls = new AtomicLong();
 
-    public CompilationInfo(HostedMethod method, HostedMethod deoptOrigin) {
+    public CompilationInfo(HostedMethod method) {
         this.method = method;
-        this.deoptOrigin = deoptOrigin;
-
-        if (deoptOrigin != null) {
-            assert deoptOrigin.compilationInfo.deoptTarget == null;
-            deoptOrigin.compilationInfo.deoptTarget = method;
-        }
-    }
-
-    public boolean isDeoptTarget() {
-        return deoptOrigin != null;
     }
 
     public boolean isDeoptEntry(int bci, boolean duringCall, boolean rethrowException) {
-        return isDeoptTarget() && (deoptOrigin.compilationInfo.canDeoptForTesting || SubstrateCompilationDirectives.singleton().isDeoptEntry(method, bci, duringCall, rethrowException));
+        return method.isDeoptTarget() && (method.getMultiMethod(MultiMethod.ORIGINAL_METHOD).compilationInfo.canDeoptForTesting ||
+                        SubstrateCompilationDirectives.singleton().isDeoptEntry(method, bci, duringCall, rethrowException));
     }
 
     /**
      * Returns whether this bci was registered as a potential deoptimization entrypoint via
      * {@link SubstrateCompilationDirectives#registerDeoptEntry}.
      */
     public boolean isRegisteredDeoptEntry(int bci, boolean duringCall, boolean rethrowException) {
-        return isDeoptTarget() && SubstrateCompilationDirectives.singleton().isDeoptTarget(method) &&
+        return method.isDeoptTarget() && SubstrateCompilationDirectives.singleton().isDeoptTarget(method) &&
                         SubstrateCompilationDirectives.singleton().isDeoptEntry(method, bci, duringCall, rethrowException);
     }
 
     public boolean canDeoptForTesting() {
         return canDeoptForTesting;
     }
 
-    public HostedMethod getDeoptTargetMethod() {
-        return deoptTarget;
-    }
-
     public CompilationGraph getCompilationGraph() {
         return compilationGraph;
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java

@@ -24,6 +24,8 @@
  */
 package com.oracle.svm.hosted.code;
 
+import static com.oracle.svm.hosted.code.SubstrateCompilationDirectives.DEOPT_TARGET_METHOD;
+
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -32,7 +34,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Objects;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -102,9 +103,10 @@
 import com.oracle.graal.pointsto.phases.SubstrateIntrinsicGraphBuilder;
 import com.oracle.graal.pointsto.util.CompletionExecutor;
 import com.oracle.graal.pointsto.util.CompletionExecutor.DebugContextRunnable;
+import com.oracle.svm.common.meta.MultiMethod;
 import com.oracle.svm.core.SubstrateOptions;
-import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.SubstrateOptions.OptimizationLevel;
+import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.deopt.DeoptTest;
 import com.oracle.svm.core.deopt.Specialize;
 import com.oracle.svm.core.graal.code.SubstrateBackend;
@@ -511,18 +513,19 @@ private void printMethodHistogram() {
             CompilationResult result = task.result;
 
             CompilationInfo ci = method.compilationInfo;
-            if (!ci.isDeoptTarget()) {
+            if (!method.isDeoptTarget()) {
                 numberOfMethods += 1;
                 sizeAllMethods += result.getTargetCodeSize();
                 System.out.format("%8d; %5d; %5d; %5d; %s;", result.getTargetCodeSize(), ci.numNodesAfterParsing, ci.numNodesBeforeCompilation, ci.numNodesAfterCompilation,
                                 ci.isTrivialMethod ? "T" : " ");
 
                 int deoptMethodSize = 0;
-                if (ci.deoptTarget != null) {
-                    CompilationInfo dci = ci.deoptTarget.compilationInfo;
+                HostedMethod deoptTargetMethod = method.getMultiMethod(DEOPT_TARGET_METHOD);
+                if (deoptTargetMethod != null) {
+                    CompilationInfo dci = deoptTargetMethod.compilationInfo;
 
                     numberOfDeopt += 1;
-                    deoptMethodSize = compilations.get(ci.deoptTarget).result.getTargetCodeSize();
+                    deoptMethodSize = compilations.get(deoptTargetMethod).result.getTargetCodeSize();
                     sizeDeoptMethods += deoptMethodSize;
                     sizeDeoptMethodsInNonDeopt += result.getTargetCodeSize();
                     totalNumDeoptEntryPoints += dci.numDeoptEntryPoints;
@@ -607,7 +610,7 @@ private void parseDeoptimizationTargetMethods() {
          */
         universe.getMethods().stream()
                         .filter(method -> SubstrateCompilationDirectives.singleton().isDeoptTarget(method))
-                        .forEach(method -> ensureParsed(universe.createDeoptTarget(method), null, new EntryPointReason()));
+                        .forEach(method -> ensureParsed(method.getOrCreateMultiMethod(DEOPT_TARGET_METHOD), null, new EntryPointReason()));
 
         /*
          * Deoptimization target code for deoptimization testing: all methods that are not
@@ -616,12 +619,10 @@ private void parseDeoptimizationTargetMethods() {
          */
         universe.getMethods().stream()
                         .filter(method -> method.getWrapped().isImplementationInvoked() && DeoptimizationUtils.canDeoptForTesting(universe, method, deoptimizeAll))
-                        .forEach(this::ensureParsedForDeoptTesting);
-    }
-
-    private void ensureParsedForDeoptTesting(HostedMethod method) {
-        method.compilationInfo.canDeoptForTesting = true;
-        ensureParsed(universe.createDeoptTarget(method), null, new EntryPointReason());
+                        .forEach(method -> {
+                            method.compilationInfo.canDeoptForTesting = true;
+                            ensureParsed(method.getOrCreateMultiMethod(DEOPT_TARGET_METHOD), null, new EntryPointReason());
+                        });
     }
 
     private static boolean checkTrivial(HostedMethod method, StructuredGraph graph) {
@@ -643,12 +644,15 @@ protected void inlineTrivialMethods(DebugContext debug) throws InterruptedExcept
             try (Indent ignored = debug.logAndIndent("==== Trivial Inlining  round %d\n", round)) {
 
                 executor.init();
-                universe.getMethods().stream()
-                                .filter(method -> method.compilationInfo.getCompilationGraph() != null)
-                                .forEach(method -> executor.execute(new TrivialInlineTask(method)));
-                universe.getMethods().stream()
-                                .map(method -> method.compilationInfo.getDeoptTargetMethod()).filter(Objects::nonNull)
-                                .forEach(deoptTargetMethod -> executor.execute(new TrivialInlineTask(deoptTargetMethod)));
+                universe.getMethods().forEach(method -> {
+                    assert method.getMultiMethodKey() == MultiMethod.ORIGINAL_METHOD;
+                    for (MultiMethod multiMethod : method.getAllMultiMethods()) {
+                        HostedMethod hMethod = (HostedMethod) multiMethod;
+                        if (hMethod.compilationInfo.getCompilationGraph() != null) {
+                            executor.execute(new TrivialInlineTask(hMethod));
+                        }
+                    }
+                });
                 executor.start();
                 executor.complete();
                 executor.shutdown();
@@ -799,7 +803,7 @@ public void scheduleEntryPoints() {
                     ensureCompiled(impl, new EntryPointReason());
                 }
             }
-            HostedMethod deoptTargetMethod = method.compilationInfo.getDeoptTargetMethod();
+            HostedMethod deoptTargetMethod = method.getMultiMethod(DEOPT_TARGET_METHOD);
             if (deoptTargetMethod != null) {
                 ensureCompiled(deoptTargetMethod, new EntryPointReason());
             }
@@ -1011,7 +1015,7 @@ protected boolean canBeUsedForInlining(Invoke invoke) {
     }
 
     private static void handleSpecialization(final HostedMethod method, CallTargetNode targetNode, HostedMethod invokeTarget, HostedMethod invokeImplementation) {
-        if (method.getAnnotation(Specialize.class) != null && !method.compilationInfo.isDeoptTarget() && invokeTarget.getAnnotation(DeoptTest.class) != null) {
+        if (method.getAnnotation(Specialize.class) != null && !method.isDeoptTarget() && invokeTarget.getAnnotation(DeoptTest.class) != null) {
             /*
              * Collect the constant arguments to a method which should be specialized.
              */
@@ -1138,8 +1142,8 @@ private CompilationResult defaultCompileFunction(DebugContext debug, HostedMetho
                                 .filter(invoke -> method.compilationInfo.isDeoptEntry(invoke.bci(), true, false))
                                 .count();
 
-                Suites suites = method.compilationInfo.isDeoptTarget() ? deoptTargetSuites : regularSuites;
-                LIRSuites lirSuites = method.compilationInfo.isDeoptTarget() ? deoptTargetLIRSuites : regularLIRSuites;
+                Suites suites = method.isDeoptTarget() ? deoptTargetSuites : regularSuites;
+                LIRSuites lirSuites = method.isDeoptTarget() ? deoptTargetLIRSuites : regularLIRSuites;
 
                 CompilationResult result = backend.newCompilationResult(compilationIdentifier, method.format("%H.%n(%p)"));
 
@@ -1149,7 +1153,7 @@ private CompilationResult defaultCompileFunction(DebugContext debug, HostedMetho
                 }
                 method.compilationInfo.numNodesAfterCompilation = graph.getNodeCount();
 
-                if (method.compilationInfo.isDeoptTarget()) {
+                if (method.isDeoptTarget()) {
                     assert DeoptimizationUtils.verifyDeoptTarget(method, graph, result);
                 }
                 ensureCalleesCompiled(method, reason, result);

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SubstrateCompilationDirectives.java

@@ -33,6 +33,7 @@
 import org.graalvm.nativeimage.ImageSingletons;
 
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.svm.common.meta.MultiMethod;
 import com.oracle.svm.core.code.FrameInfoEncoder;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton;
 import com.oracle.svm.core.util.VMError;
@@ -44,6 +45,20 @@
 @AutomaticallyRegisteredImageSingleton
 public class SubstrateCompilationDirectives {
 
+    public static final MultiMethod.MultiMethodKey DEOPT_TARGET_METHOD = new MultiMethod.MultiMethodKey() {
+        @Override
+        public String toString() {
+            return "Deopt_Target_Method_Key";
+        }
+    };
+
+    public static final MultiMethod.MultiMethodKey RUNTIME_COMPILED_METHOD = new MultiMethod.MultiMethodKey() {
+        @Override
+        public String toString() {
+            return "Runtime_Compiled_Method_Key";
+        }
+    };
+
     /**
      * Stores the value kinds present at a deoptimization point's (deoptimization source)
      * FrameState. This information is used to validate the deoptimization point's target
@@ -180,7 +195,7 @@ public boolean isDeoptTarget(ResolvedJavaMethod method) {
         return deoptEntries.containsKey(toAnalysisMethod(method));
     }
 
-    protected boolean isDeoptEntry(ResolvedJavaMethod method, int bci, boolean duringCall, boolean rethrowException) {
+    public boolean isDeoptEntry(ResolvedJavaMethod method, int bci, boolean duringCall, boolean rethrowException) {
         assert seal();
         Map<Long, DeoptSourceFrameInfo> bciMap = deoptEntries.get(toAnalysisMethod(method));
         assert bciMap != null : "can only query for deopt entries for methods registered as deopt targets";

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/LIRNativeImageCodeCache.java

@@ -190,7 +190,7 @@ public void layoutMethods(DebugContext debug, BigBang bb, ForkJoinPool threadPoo
                          * Need to have snapshot of trampoline key set since we update their
                          * positions.
                          */
-                        for (HostedMethod callTarget : trampolines.keySet().toArray(new HostedMethod[0])) {
+                        for (HostedMethod callTarget : trampolines.keySet().toArray(HostedMethod.EMPTY_ARRAY)) {
                             position = NumUtil.roundUp(position, trampolineSupport.getTrampolineAlignment());
                             trampolines.put(callTarget, position);
                             sortedTrampolines.add(Pair.create(callTarget, position));

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProvider.java

@@ -1081,7 +1081,7 @@ public boolean isDeoptTarget() {
             if (method instanceof HostedMethod) {
                 return ((HostedMethod) method).isDeoptTarget();
             }
-            return name().endsWith(HostedMethod.METHOD_NAME_DEOPT_SUFFIX);
+            return name().endsWith(HostedMethod.MULTI_METHOD_KEY_SEPARATOR);
         }
 
         @Override