[GR-40746] Report loop counts for and in OSR targets and prioritize them with a bonus.

Author: FelixPSch

truffle/docs/Options.md

@@ -171,6 +171,7 @@ These are internal options for debugging language implementations and tools.
 - `--engine.TraversingQueueFirstTierBonus=[0.0, inf)` : Controls how much of a priority should be given to first tier compilations (default 15.0).
 - `--engine.TraversingQueueFirstTierPriority` : Traversing queue gives first tier compilations priority.
 - `--engine.TraversingQueueInvalidatedBonus=[0.0, inf)` : Controls how much of a priority should be given to compilations after invalidations (default: 1.0, no bonus).
+- `--engine.TraversingQueueOSRBonus=[0.0, inf)` : Controls how much of a priority should be given to OSR compilations (default: 1.0, no bonus).
 - `--engine.TraversingQueueWeightingBothTiers=true|false` : Traversing queue uses rate as priority for both tier. (default: true)
 - `--compiler.DiagnoseFailure` : Forces diagnostics for compilation failures (default: false).
 - `--compiler.ExcludeAssertions` : Exclude assertion code from Truffle compilations (default: true)

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/BytecodeOSRMetadata.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -264,13 +264,19 @@ Object tryOSR(long target, Object interpreterState, Runnable beforeTransfer, Vir
                         requestOSRCompilation(target, lockedTarget, (FrameWithoutBoxing) parentFrame);
                         stage = HOT_STAGE;
                     }
+                    // Set the OSR target's loop count to the count of the non OSR call target
+                    OptimizedCallTarget nonOSRCallTarget = (OptimizedCallTarget) ((Node) osrNode).getRootNode().getCallTarget();
+                    lockedTarget.onLoopCount(nonOSRCallTarget.getCallAndLoopCount());
                 }
                 return lockedTarget;
             });
         }
 
         // Case 1: code is still being compiled
         if (callTarget.isCompiling()) {
+            // Report loop count to the OSR target. Since this function is called every
+            // OSR_POLL_INTERVAL times, OSR_POLL_INTERVAL is reported as a loop count
+            callTarget.onLoopCount(OSR_POLL_INTERVAL);
             return null;
         }
         // Case 2: code is compiled and valid

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/CompilationTask.java

@@ -256,10 +256,6 @@ boolean isHigherPriorityThan(CompilationTask other) {
             // Any non-compilation action (e.g. compiler init) is higher priority.
             return action != COMPILATION_ACTION;
         }
-        if ((this.isOSR ^ other.isOSR) && this.isLastTier() && other.isLastTier()) {
-            // Any OSR task has higher priority than any non-OSR last tier task
-            return this.isOSR;
-        }
         int tier = tier();
         if (engineData.traversingFirstTierPriority && tier != other.tier()) {
             return tier < other.tier();
@@ -319,20 +315,34 @@ private double bonus() {
             // This bonus is 1.0 by default, i.e. it has no effect.
             bonus *= engineData.traversingInvalidatedBonus;
         }
+        if (isOSR) {
+            // Boost OSR tasks' priority. This bonus is 1.0 by default, i.e. it has no effect.
+            bonus *= engineData.traversingOSRBonus;
+        }
         return bonus;
     }
 
     public List<String> bonusDescriptors() {
-        List<String> bonuses = new ArrayList<>(2);
-        if (!engineData.traversingFirstTierPriority && isFirstTier()) {
+        List<String> bonuses = new ArrayList<>(3);
+        if (!engineData.traversingFirstTierPriority && isFirstTier() && hasEffect(engineData.traversingFirstTierBonus)) {
             bonuses.add("first tier");
         }
-        if (targetHighestCompiledTier() >= tier()) {
+        if (targetHighestCompiledTier() >= tier() && hasEffect(engineData.traversingInvalidatedBonus)) {
             bonuses.add("invalidation");
         }
+        if (isOSR && hasEffect(engineData.traversingOSRBonus)) {
+            bonuses.add("OSR");
+        }
         return bonuses;
     }
 
+    private static final double EPSILON = 1E-6;
+
+    private static boolean hasEffect(double bonus) {
+        // Checks if the given bonus differs from 1.
+        return Math.abs(bonus - 1.0) > EPSILON;
+    }
+
     private double rate(int count, long elapsed) {
         // Divide by a minimum of 1000 to prevent division by zero/very small numbers.
         return lastRate = ((double) count - lastCount) / Math.max(elapsed, 1000);

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/EngineData.java

@@ -79,6 +79,7 @@
 import static com.oracle.truffle.runtime.OptimizedRuntimeOptions.TraversingQueueFirstTierBonus;
 import static com.oracle.truffle.runtime.OptimizedRuntimeOptions.TraversingQueueFirstTierPriority;
 import static com.oracle.truffle.runtime.OptimizedRuntimeOptions.TraversingQueueInvalidatedBonus;
+import static com.oracle.truffle.runtime.OptimizedRuntimeOptions.TraversingQueueOSRBonus;
 import static com.oracle.truffle.runtime.OptimizedRuntimeOptions.TraversingQueueWeightingBothTiers;
 import static com.oracle.truffle.runtime.OptimizedTruffleRuntime.getRuntime;
 
@@ -160,6 +161,7 @@ public final class EngineData {
     @CompilationFinal public boolean traversingFirstTierPriority;
     @CompilationFinal public double traversingFirstTierBonus;
     @CompilationFinal public double traversingInvalidatedBonus;
+    @CompilationFinal public double traversingOSRBonus;
     @CompilationFinal public boolean propagateCallAndLoopCount;
     @CompilationFinal public int propagateCallAndLoopCountMaxDepth;
     @CompilationFinal public int maximumCompilations;
@@ -322,6 +324,7 @@ private void loadOptions(OptionValues options, SandboxPolicy sandboxPolicy) {
         traversingFirstTierBonus = options.get(TraversingQueueFirstTierBonus) * options.get(LastTierCompilationThreshold) / options.get(FirstTierCompilationThreshold);
         maximumCompilations = options.get(MaximumCompilations);
         traversingInvalidatedBonus = options.get(TraversingQueueInvalidatedBonus);
+        traversingOSRBonus = options.get(TraversingQueueOSRBonus);
 
         this.returnTypeSpeculation = options.get(ReturnTypeSpeculation);
         this.argumentTypeSpeculation = options.get(ArgumentTypeSpeculation);

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedRuntimeOptions.java

@@ -336,6 +336,9 @@ public EngineModeEnum apply(String s) {
     @Option(help = "Controls how much of a priority should be given to compilations after invalidations (default: 1.0, no bonus).", usageSyntax = "[0.0, inf)", category = OptionCategory.INTERNAL) //
     public static final OptionKey<Double> TraversingQueueInvalidatedBonus = new OptionKey<>(1.0);
 
+    @Option(help = "Controls how much of a priority should be given to OSR compilations (default: 1.0, no bonus).", usageSyntax = "[0.0, inf)", category = OptionCategory.INTERNAL) //
+    public static final OptionKey<Double> TraversingQueueOSRBonus = new OptionKey<>(1.0);
+
     @Option(help = "Traversing queue uses rate as priority for both tier. (default: true)", usageSyntax = "true|false", category = OptionCategory.INTERNAL) //
     public static final OptionKey<Boolean> TraversingQueueWeightingBothTiers = new OptionKey<>(true);