Updated jit stage to account for OSR.

timcassell · timcassell · commit a9458f11792c · 2025-07-19T20:24:20.000-04:00
Don't jit overhead methods if the job is configured to not measure it.
Remove extra call counting delay for in-process benchmarks.
Set CallCountingDelayMs env var if DisassemblyDiagnoser is not used.
Added a test for very long first invocation time.
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
@@ -120,6 +120,8 @@ internal ImmutableConfig(
 
         internal bool HasPerfCollectProfiler() => diagnosers.OfType<PerfCollectProfiler>().Any();
 
+        internal bool HasDisassemblyDiagnoser() => diagnosers.OfType<DisassemblyDiagnoser>().Any();
+
         public bool HasExtraStatsDiagnoser() => HasMemoryDiagnoser() || HasThreadingDiagnoser() || HasExceptionDiagnoser();
 
         public IDiagnoser? GetCompositeDiagnoser(BenchmarkCase benchmarkCase, RunMode runMode)
diff --git a/src/BenchmarkDotNet/Engines/Engine.cs b/src/BenchmarkDotNet/Engines/Engine.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using BenchmarkDotNet.Characteristics;
 using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Reports;
@@ -213,12 +214,9 @@ private ClockSpan Measure(Action<long> action, long invokeCount)
             ForceGcCollect();
 
             // #1542
-            if (JitInfo.BackgroundCompilationDelay > TimeSpan.Zero)
-            {
-                // We put the current thread to sleep so tiered jit can kick in, compile its stuff,
-                // and NOT allocate anything on the background thread when we are measuring allocations.
-                Thread.Sleep(JitInfo.BackgroundCompilationDelay);
-            }
+            // If the jit is tiered, we put the current thread to sleep so it can kick in, compile its stuff,
+            // and NOT allocate anything on the background thread when we are measuring allocations.
+            SleepHelper.SleepIfPositive(JitInfo.BackgroundCompilationDelay);
 
             GcStats gcStats;
             using (FinalizerBlocker.MaybeStart())
diff --git a/src/BenchmarkDotNet/Engines/EngineJitStage.cs b/src/BenchmarkDotNet/Engines/EngineJitStage.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Threading;
+using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Reports;
@@ -27,27 +28,35 @@ internal sealed class EngineFirstJitStage : EngineJitStage
         // It is not worth spending a long time in jit stage for macro-benchmarks.
         private static readonly TimeInterval MaxTieringTime = TimeInterval.FromSeconds(10);
 
+        // Jit call counting delay is only for when the app starts up. We don't need to wait for every benchmark if multiple benchmarks are ran in-process.
+        private static TimeSpan tieredDelay = JitInfo.TieredDelay;
+
         internal bool didStopEarly = false;
         internal Measurement lastMeasurement;
 
         private readonly IEnumerator<IterationData> enumerator;
+        private readonly bool evaluateOverhead;
 
-        internal EngineFirstJitStage(EngineParameters parameters) : base(parameters)
+        internal EngineFirstJitStage(bool evaluateOverhead, EngineParameters parameters) : base(parameters)
         {
             enumerator = EnumerateIterations();
+            this.evaluateOverhead = evaluateOverhead;
         }
 
         internal override List<Measurement> GetMeasurementList() => new(GetMaxMeasurementCount());
 
-        private static int GetMaxMeasurementCount()
+        private int GetMaxMeasurementCount()
         {
-            int tieredCallCountThreshold = JitInfo.TieredCallCountThreshold;
-            if (JitInfo.IsDPGO)
+            if (!JitInfo.IsTiered)
             {
-                tieredCallCountThreshold *= 2;
+                return 1;
             }
-            // +1 for first jit, x2 for overhead + workload
-            return (tieredCallCountThreshold + 1) * 2;
+            int count = JitInfo.MaxTierPromotions* JitInfo.TieredCallCountThreshold + 2;
+            if (evaluateOverhead)
+            {
+                count *= 2;
+            }
+            return count;
         }
 
         internal override bool GetShouldRunIteration(List<Measurement> measurements, out IterationData iterationData)
@@ -73,8 +82,11 @@ internal override bool GetShouldRunIteration(List<Measurement> measurements, out
         private IEnumerator<IterationData> EnumerateIterations()
         {
             ++iterationIndex;
-            yield return GetDummyIterationData(dummy1Action);
-            yield return GetOverheadIterationData();
+            if (evaluateOverhead)
+            {
+                yield return GetDummyIterationData(dummy1Action);
+                yield return GetOverheadIterationData();
+            }
             yield return GetDummyIterationData(dummy2Action);
             yield return GetWorkloadIterationData();
             yield return GetDummyIterationData(dummy3Action);
@@ -86,12 +98,14 @@ private IEnumerator<IterationData> EnumerateIterations()
             }
 
             // Wait enough time for jit call counting to begin.
-            MaybeSleep(JitInfo.TieredDelay);
+            SleepHelper.SleepIfPositive(tieredDelay);
+            // Don't make the next jit stage wait if it's ran in the same process.
+            tieredDelay = TimeSpan.Zero;
 
             // Attempt to promote methods to tier1, but don't spend too much time in jit stage.
             StartedClock startedClock = parameters.TargetJob.ResolveValue(InfrastructureMode.ClockCharacteristic, parameters.Resolver).Start();
 
-            int remainingTiers = JitInfo.IsDPGO ? 2 : 1;
+            int remainingTiers = JitInfo.MaxTierPromotions;
             while (remainingTiers > 0)
             {
                 --remainingTiers;
@@ -100,7 +114,10 @@ private IEnumerator<IterationData> EnumerateIterations()
                 {
                     --remainingCalls;
                     ++iterationIndex;
-                    yield return GetOverheadIterationData();
+                    if (evaluateOverhead)
+                    {
+                        yield return GetOverheadIterationData();
+                    }
                     yield return GetWorkloadIterationData();
 
                     if ((remainingTiers + remainingCalls) > 0
@@ -111,13 +128,16 @@ private IEnumerator<IterationData> EnumerateIterations()
                     }
                 }
 
-                MaybeSleep(JitInfo.BackgroundCompilationDelay);
+                SleepHelper.SleepIfPositive(JitInfo.BackgroundCompilationDelay);
             }
 
-            // Empirical evidence shows that the first call after the method is tiered up takes longer,
+            // Empirical evidence shows that the first call after the method is tiered up may take longer,
             // so we run an extra iteration to ensure the next stage gets a stable measurement.
             ++iterationIndex;
-            yield return GetOverheadIterationData();
+            if (evaluateOverhead)
+            {
+                yield return GetOverheadIterationData();
+            }
             yield return GetWorkloadIterationData();
         }
 
@@ -126,32 +146,22 @@ private IterationData GetOverheadIterationData()
 
         private IterationData GetWorkloadIterationData()
             => new(IterationMode.Workload, IterationStage.Jitting, iterationIndex, 1, 1, parameters.IterationSetupAction, parameters.IterationCleanupAction, parameters.WorkloadActionNoUnroll);
-
-        private static void MaybeSleep(TimeSpan timeSpan)
-        {
-            if (timeSpan > TimeSpan.Zero)
-            {
-                Thread.Sleep(timeSpan);
-            }
-        }
     }
 
-    internal sealed class EngineSecondJitStage(int unrollFactor, EngineParameters parameters) : EngineJitStage(parameters)
+    internal sealed class EngineSecondJitStage : EngineJitStage
     {
-        private readonly int unrollFactor = unrollFactor;
+        private readonly int unrollFactor;
+        private readonly bool evaluateOverhead;
 
-        internal override List<Measurement> GetMeasurementList() => new(GetMaxCallCount());
-
-        private static int GetMaxCallCount()
+        public EngineSecondJitStage(int unrollFactor, bool evaluateOverhead, EngineParameters parameters) : base(parameters)
         {
-            int tieredCallCountThreshold = JitInfo.TieredCallCountThreshold;
-            if (JitInfo.IsDPGO)
-            {
-                tieredCallCountThreshold *= 2;
-            }
-            return tieredCallCountThreshold + 1;
+            this.unrollFactor = unrollFactor;
+            this.evaluateOverhead = evaluateOverhead;
+            iterationIndex = evaluateOverhead ? 0 : 2;
         }
 
+        internal override List<Measurement> GetMeasurementList() => new(evaluateOverhead ? 5 : 3);
+
         // The benchmark method has already been jitted via *NoUnroll, we only need to jit the *Unroll methods here, which aren't tiered.
         internal override bool GetShouldRunIteration(List<Measurement> measurements, out IterationData iterationData)
         {
diff --git a/src/BenchmarkDotNet/Engines/EngineStage.cs b/src/BenchmarkDotNet/Engines/EngineStage.cs
@@ -33,7 +33,7 @@ internal static IEnumerable<EngineStage> EnumerateStages(EngineParameters parame
                     int minInvokeCount = parameters.TargetJob.ResolveValue(AccuracyMode.MinInvokeCountCharacteristic, parameters.Resolver);
 
                     // AOT technically doesn't have a JIT, but we run jit stage regardless because of static constructors. #2004
-                    var jitStage = new EngineFirstJitStage(parameters);
+                    var jitStage = new EngineFirstJitStage(evaluateOverhead, parameters);
                     yield return jitStage;
 
                     bool hasUnrollFactor = parameters.TargetJob.HasValue(RunMode.UnrollFactorCharacteristic);
@@ -62,7 +62,7 @@ internal static IEnumerable<EngineStage> EnumerateStages(EngineParameters parame
                     // TODO: This stage can be removed after we refactor the engine/codegen to pass the clock into the delegates.
                     if (!RuntimeInformation.IsAot && unrollFactor != 1)
                     {
-                        yield return new EngineSecondJitStage(unrollFactor, parameters);
+                        yield return new EngineSecondJitStage(unrollFactor, evaluateOverhead, parameters);
                     }
 
                     if (!skipPilotStage)
diff --git a/src/BenchmarkDotNet/Extensions/ProcessExtensions.cs b/src/BenchmarkDotNet/Extensions/ProcessExtensions.cs
@@ -150,8 +150,11 @@ internal static void SetEnvironmentVariables(this ProcessStartInfo start, Benchm
             // disable ReSharper's Dynamic Program Analysis (see https://github.com/dotnet/BenchmarkDotNet/issues/1871 for details)
             start.EnvironmentVariables["JETBRAINS_DPA_AGENT_ENABLE"] = "0";
 
-            // TODO: set CallCountingDelayMs without breaking DisassemblyDiagnoser. https://github.com/dotnet/runtime/issues/117339
-            //SetClrEnvironmentVariables(start, JitInfo.CallCountingDelayMsEnv, "0");
+            // CallCountingDelayMs=0 breaks DisassemblyDiagnoser, so we only set it if the job doesn't need disassembly. https://github.com/dotnet/runtime/issues/117339
+            if (!benchmarkCase.Config.HasDisassemblyDiagnoser())
+            {
+                SetClrEnvironmentVariables(start, JitInfo.EnvCallCountingDelayMs, "0");
+            }
 
             if (!benchmarkCase.Job.HasValue(EnvironmentMode.EnvironmentVariablesCharacteristic))
                 return;
diff --git a/src/BenchmarkDotNet/Helpers/SleepHelper.cs b/src/BenchmarkDotNet/Helpers/SleepHelper.cs
@@ -0,0 +1,16 @@
+﻿using System;
+using System.Threading;
+
+namespace BenchmarkDotNet.Helpers
+{
+    internal static class SleepHelper
+    {
+        public static void SleepIfPositive(TimeSpan timeSpan)
+        {
+            if (timeSpan > TimeSpan.Zero)
+            {
+                Thread.Sleep(timeSpan);
+            }
+        }
+    }
+}
diff --git a/src/BenchmarkDotNet/Portability/JitInfo.cs b/src/BenchmarkDotNet/Portability/JitInfo.cs
@@ -7,15 +7,25 @@ namespace BenchmarkDotNet.Portability
 {
     // Implementation is based on article https://medium.com/@meriffa/net-core-concepts-tiered-compilation-10f7da3a29c7
     // documentation https://learn.microsoft.com/en-us/dotnet/core/runtime-config/compilation
-    // and source https://github.com/dotnet/runtime/blob/71c30b405516b1fe774a1bfdbc43cd804468568f/src/coreclr/vm/eeconfig.cpp
+    // and source https://github.com/dotnet/runtime/blob/3fb6fbb3efaa7f2ae5e76bf235615d7f70005201/src/coreclr/vm/eeconfig.cpp
+    // https://github.com/dotnet/runtime/blob/3fb6fbb3efaa7f2ae5e76bf235615d7f70005201/src/coreclr/jit/jitconfigvalues.h
     internal static class JitInfo
     {
-        public const string MinOptsEnv = "JITMinOpts";
-        public const string TieredCompilationEnv = "TieredCompilation";
-        public const string DynamicPGOEnv = "TieredPGO";
-        public const string AggressiveTieringEnv = "TC_AggressiveTiering";
-        public const string CallCountThresholdEnv = "TC_CallCountThreshold";
-        public const string CallCountingDelayMsEnv = "TC_CallCountingDelayMs";
+        public const string EnvCallCountingDelayMs = "TC_CallCountingDelayMs";
+
+        private const string EnvMinOpts = "JITMinOpts";
+        private const string EnvTieredCompilation = "TieredCompilation";
+        private const string EnvQuickJit = "TC_QuickJit";
+        private const string EnvPGO = "TieredPGO";
+        private const string EnvCallCountThreshold = "TC_CallCountThreshold";
+        private const string EnvAggressiveTiering = "TC_AggressiveTiering";
+        private const string EnvOSR = "TC_OnStackReplacement";
+
+        private const string KnobTieredCompilation = "System.Runtime.TieredCompilation";
+        private const string KnobQuickJit = "System.Runtime.TieredCompilation.QuickJit";
+        private const string KnobPGO = "System.Runtime.TieredPGO";
+        private const string KnobCallCountThreshold = "System.Runtime.TieredCompilation.CallCountThreshold";
+        private const string KnobCallCountingDelayMs = "System.Runtime.TieredCompilation.CallCountingDelayMs";
 
         // .Net 5 and older uses COMPlus_ prefix,
         // .Net 6+ uses DOTNET_ prefix, but still supports legacy COMPlus_.
@@ -40,34 +50,71 @@ private static bool IsKnobDisabled(string name)
         private static bool TryParseKnob(string name, out int value)
             => int.TryParse(AppContext.GetData(name) as string, out value);
 
+        private static bool IsEnabled(string envName, string knobName)
+            => IsEnvVarEnabled(envName) || IsKnobEnabled(knobName);
+
+        private static bool IsDisabled(string envName, string knobName)
+            => IsEnvVarDisabled(envName) || IsKnobDisabled(knobName);
+
         /// <summary>
         /// Is tiered JIT enabled?
         /// </summary>
         public static readonly bool IsTiered =
             IsNetCore
             // JITMinOpts disables tiered compilation (all methods are effectively tier0 instead of tier1).
-            && !IsEnvVarEnabled(MinOptsEnv)
+            && !IsEnvVarEnabled(EnvMinOpts)
             && ((CoreRuntime.TryGetVersion(out var version) && version.Major >= 3)
                 // Enabled by default in netcoreapp3.0+, check if it's disabled.
-                ? !IsEnvVarDisabled(TieredCompilationEnv) && !IsKnobDisabled("System.Runtime.TieredCompilation")
+                ? !IsDisabled(EnvTieredCompilation, KnobTieredCompilation)
                 // Disabled by default in netcoreapp2.X, check if it's enabled.
-                : IsEnvVarEnabled(TieredCompilationEnv) || IsKnobEnabled("System.Runtime.TieredCompilation"));
+                : IsEnabled(EnvTieredCompilation, KnobTieredCompilation));
 
         /// <summary>
-        /// Is tiered JIT enabled with dynamic profile-guided optimization (tier0 instrumented)?
+        /// The maximum numbers of jit tiers that a method may be promoted through. This is the maximum number of jit tiers - 1.
         /// </summary>
-        public static readonly bool IsDPGO =
-            IsTiered
-            // Added experimentally in .Net 6
-            && Environment.Version.Major >= 6
-            // Disabled if QuickJit is disabled in .Net 7+.
-            && (Environment.Version.Major < 7 || (!IsEnvVarDisabled("TC_QuickJit") && !IsKnobDisabled("System.Runtime.TieredCompilation.QuickJit")))
-            && (Environment.Version.Major >= 8
-                // Enabled by default in .Net 8, check if it's disabled
-                ? !IsEnvVarDisabled(DynamicPGOEnv) && !IsKnobDisabled("System.Runtime.TieredPGO")
-                // Disabled by default in earlier versions, check if it's enabled.
-                : IsEnvVarEnabled(DynamicPGOEnv) || IsKnobEnabled("System.Runtime.TieredPGO"));
+        public static readonly int MaxTierPromotions = GetMaxTierPromotions();
 
+        private static int GetMaxTierPromotions()
+        {
+            if (!IsTiered)
+            {
+                return 0;
+            }
+            // Tier1
+            int maxPromotions = 1;
+            if (GetIsDPGO())
+            {
+                // Tier0 instrumented
+                ++maxPromotions;
+            }
+            if (GetIsOSR())
+            {
+                // On-stack-replacement *shouldn't* interfere with promotion velocity, but there is a bug where OSR may cause a method to be tier0 instrumented twice.
+                // https://github.com/dotnet/runtime/issues/117787#issuecomment-3090771091
+                ++maxPromotions;
+            }
+            return maxPromotions;
+
+            static bool GetIsDPGO() =>
+                // Added experimentally in .Net 6.
+                Environment.Version.Major >= 6
+                // Disabled if QuickJit is disabled in .Net 7+.
+                && (Environment.Version.Major < 7 || !IsDisabled(EnvQuickJit, KnobQuickJit))
+                && (Environment.Version.Major >= 8
+                    // Enabled by default in .Net 8, check if it's disabled.
+                    ? !IsDisabled(EnvPGO, KnobPGO)
+                    // Disabled by default in earlier versions, check if it's enabled.
+                    : IsEnabled(EnvPGO, KnobPGO));
+
+            static bool GetIsOSR() =>
+                // Added experimentally in .Net 5.
+                Environment.Version.Major >= 5
+                && (Environment.Version.Major >= 7
+                    // Enabled by default in .Net 7, check if it's disabled.
+                    ? !IsEnvVarDisabled(EnvOSR)
+                    // Disabled by default in earlier versions, check if it's enabled.
+                    : IsEnvVarEnabled(EnvOSR));
+        }
 
         /// <summary>
         /// The number of times a method must be called before it will be eligible for the next JIT tier.
@@ -81,16 +128,16 @@ private static int GetTieredCallCountThreshold()
                 return 0;
             }
             // AggressiveTiering was added in .Net 5.
-            if (Environment.Version.Major >= 5 && IsEnvVarEnabled(AggressiveTieringEnv))
+            if (Environment.Version.Major >= 5 && IsEnvVarEnabled(EnvAggressiveTiering))
             {
                 return 1;
             }
-            if (TryParseEnvVar(CallCountThresholdEnv, out int callCountThreshold))
+            if (TryParseEnvVar(EnvCallCountThreshold, out int callCountThreshold))
             {
                 return callCountThreshold;
             }
             // CallCountThreshold was added as a knob in .Net 8.
-            if (Environment.Version.Major >= 8 && TryParseKnob("System.Runtime.TieredCompilation.CallCountThreshold", out callCountThreshold))
+            if (Environment.Version.Major >= 8 && TryParseKnob(KnobCallCountThreshold, out callCountThreshold))
             {
                 return callCountThreshold;
             }
@@ -110,16 +157,16 @@ private static TimeSpan GetTieredDelay()
                 return TimeSpan.Zero;
             }
             // AggressiveTiering was added in .Net 5.
-            if (Environment.Version.Major >= 5 && IsEnvVarEnabled(AggressiveTieringEnv))
+            if (Environment.Version.Major >= 5 && IsEnvVarEnabled(EnvAggressiveTiering))
             {
                 return TimeSpan.Zero;
             }
-            if (TryParseEnvVar(CallCountingDelayMsEnv, out int callCountDelay))
+            if (TryParseEnvVar(EnvCallCountingDelayMs, out int callCountDelay))
             {
                 return TimeSpan.FromMilliseconds(callCountDelay);
             }
             // CallCountingDelayMs was added as a knob in .Net 8.
-            if (Environment.Version.Major >= 8 && TryParseKnob("System.Runtime.TieredCompilation.CallCountingDelayMs", out callCountDelay))
+            if (Environment.Version.Major >= 8 && TryParseKnob(KnobCallCountingDelayMs, out callCountDelay))
             {
                 return TimeSpan.FromMilliseconds(callCountDelay);
             }
diff --git a/tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs b/tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ internal static IEnumerable<EngineStage> EnumerateStages(EngineParameters parame`
`33`	`33`	`int minInvokeCount = parameters.TargetJob.ResolveValue(AccuracyMode.MinInvokeCountCharacteristic, parameters.Resolver);`
`34`	`34`
`35`	`35`	`// AOT technically doesn't have a JIT, but we run jit stage regardless because of static constructors. #2004`
`36`		`- var jitStage = new EngineFirstJitStage(parameters);`
	`36`	`+ var jitStage = new EngineFirstJitStage(evaluateOverhead, parameters);`
`37`	`37`	`yield return jitStage;`
`38`	`38`
`39`	`39`	`bool hasUnrollFactor = parameters.TargetJob.HasValue(RunMode.UnrollFactorCharacteristic);`
`@@ -62,7 +62,7 @@ internal static IEnumerable<EngineStage> EnumerateStages(EngineParameters parame`
`62`	`62`	`// TODO: This stage can be removed after we refactor the engine/codegen to pass the clock into the delegates.`
`63`	`63`	`if (!RuntimeInformation.IsAot && unrollFactor != 1)`
`64`	`64`	`{`
`65`		`- yield return new EngineSecondJitStage(unrollFactor, parameters);`
	`65`	`+ yield return new EngineSecondJitStage(unrollFactor, evaluateOverhead, parameters);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`if (!skipPilotStage)`