[GR-39024] Add API to access global self time for StructuredGraph.

PullRequest: graal/13623

Author: boris-spas

compiler/src/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/CompilationWatchDogTest.java

@@ -69,16 +69,19 @@ public static int snippet(int value) {
         return value;
     }
 
+    /**
+     * Access to this list is synchronized to avoid a ConcurrentModificationException.
+     */
     private List<String> events = new ArrayList<>();
 
     private long firstEvent = System.currentTimeMillis();
 
-    private void event(String label) {
+    private synchronized void event(String label) {
         long when = System.currentTimeMillis() - firstEvent;
         events.add(String.format("after %d ms: %s", when, label));
     }
 
-    private String eventLog() {
+    private synchronized String eventLog() {
         return events.stream().collect(Collectors.joining(System.lineSeparator()));
     }
 
@@ -138,10 +141,19 @@ public void onStuckCompilation(CompilationWatchDog watchDog, Thread watched, Com
             event("start compiling");
             return super.getCode(installedCodeOwner, graph, forceCompile, installAsDefault, options);
         } finally {
-            Assert.assertTrue(eventLog(), !longCompilations.isEmpty());
-            Assert.assertTrue(eventLog(), longCompilations.stream().allMatch(id -> id == compilation));
-            Assert.assertTrue(eventLog(), !stuckCompilations.isEmpty());
-            Assert.assertTrue(eventLog(), longCompilations.stream().allMatch(id -> id == compilation));
+            check(!longCompilations.isEmpty());
+            check(longCompilations.stream().allMatch(id -> id == compilation));
+            check(!stuckCompilations.isEmpty());
+            check(longCompilations.stream().allMatch(id -> id == compilation));
+        }
+    }
+
+    /**
+     * Factored out to only fetch the event log if the condition fails.
+     */
+    private void check(boolean condition) {
+        if (!condition) {
+            Assert.fail(eventLog());
         }
     }
 }

compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StructuredGraph.java

@@ -32,6 +32,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.concurrent.atomic.AtomicLong;
@@ -1123,4 +1124,71 @@ public NodeSourcePosition getCallerContext() {
     public OptimizationLog getOptimizationLog() {
         return optimizationLog;
     }
+
+    /**
+     * Implementers of this interface should provide <empf>global</empf> profile-related information
+     * about the {@link StructuredGraph} i.e. global profiling information about the
+     * <empf>compilation unit</empf>.
+     *
+     * Unlike the {@link ProfileProvider} which represents the profile in isolation and relating to
+     * a single method, implementers of this interface provide data in the context of a global
+     * system and relating to a compilation unit (including e.g. inlined methods).
+     */
+    public interface GlobalProfileProvider {
+
+        GlobalProfileProvider DEFAULT = new GlobalProfileProvider() {
+
+            public static final int DEFAULT_TIME = -1;
+
+            /**
+             * The default time provider always returns -1, i.e. the self time is unknown by
+             * default.
+             */
+            @Override
+            public double getGlobalSelfTimePercent() {
+                return DEFAULT_TIME;
+            }
+        };
+
+        /**
+         * This method provides an approximation of what percentage of run time is spent executing
+         * this compilation unit (a.k.a. self time - the time spent executing the compilation unit).
+         * Since the value is meant to represent a percentage, this method should return a value
+         * between 0 and 1 (inclusive) for {@link StructuredGraph graphs} for which the data is
+         * available. If no data is available, this method should return -1 as a way to disambiguate
+         * compilation units that are known to have a self time of 0 and compilation units for which
+         * the data is not present.
+         *
+         * This source of this information could, for example, be gathered through profiling the
+         * application with a sampling based profiler, or just a heuristic-based estimation.
+         *
+         * This data can be used for aggressive optimizations, applying more or less optimization
+         * budget to individual compilation units based on this estimate of how much run time is
+         * spent in that particular compilation unit.
+         *
+         * @return A value between 0 and 1 If self time data is available, -1 otherwise.
+         */
+        double getGlobalSelfTimePercent();
+
+    }
+
+    private GlobalProfileProvider globalProfileProvider = GlobalProfileProvider.DEFAULT;
+
+    /**
+     * Set a {@link GlobalProfileProvider global profile provider} for this {@link StructuredGraph
+     * graph}.
+     */
+    public void setGlobalProfileProvider(GlobalProfileProvider globalProfileProvider) {
+        Objects.requireNonNull(globalProfileProvider);
+        this.globalProfileProvider = globalProfileProvider;
+    }
+
+    /**
+     * See {@link GlobalProfileProvider#getGlobalSelfTimePercent()}.
+     *
+     * @return The current {@link GlobalProfileProvider#getGlobalSelfTimePercent() global self time}
+     */
+    public double getSelfTimePercent() {
+        return globalProfileProvider.getGlobalSelfTimePercent();
+    }
 }

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

@@ -1163,6 +1163,7 @@ private CompilationResult defaultCompileFunction(DebugContext debug, HostedMetho
 
             VMError.guarantee(method.compilationInfo.getCompilationGraph() != null, "The following method is reachable during compilation, but was not seen during Bytecode parsing: %s", method);
             StructuredGraph graph = method.compilationInfo.createGraph(debug, compilationIdentifier, true);
+            customizeGraph(graph);
 
             GraalError.guarantee(graph.getGraphState().getGuardsStage() == GuardsStage.FIXED_DEOPTS,
                             "Hosted compilations must have explicit exceptions [guard stage] %s=%s", graph, graph.getGraphState().getGuardsStage());
@@ -1224,6 +1225,16 @@ private CompilationResult defaultCompileFunction(DebugContext debug, HostedMetho
         }
     }
 
+    /**
+     * Allows subclasses to customize the {@link StructuredGraph graph} after its creation.
+     *
+     * @param graph A newly created {@link StructuredGraph graph} for one particular compilation
+     *            unit.
+     */
+    protected void customizeGraph(StructuredGraph graph) {
+        // Hook for subclasses
+    }
+
     protected void ensureCalleesCompiled(HostedMethod method, CompileReason reason, CompilationResult result) {
         for (Infopoint infopoint : result.getInfopoints()) {
             if (infopoint instanceof Call) {