Update default limits for profiling interpreter to prevent jitting too aggressively

Also move all the code to get default configs into their own functions to abstract away differences in defaults between normal functions and coroutines

Author: nhat-nguyen

lib/Runtime/Base/FunctionExecutionStateMachine.cpp

@@ -33,6 +33,32 @@ namespace Js
     {
     }
 
+    uint16 FunctionExecutionStateMachine::GetDefaultAutoProfilingInterpreter0Limit(bool isCoroutine) const {
+        return isCoroutine ? 0 : static_cast<uint16>(Configuration::Global.flags.AutoProfilingInterpreter0Limit);
+    }
+
+    uint16 FunctionExecutionStateMachine::GetDefaultProfilingInterpreter0Limit(bool isCoroutine) const {
+        if (isCoroutine)
+        {
+            return static_cast<uint16>(Configuration::Global.flags.AutoProfilingInterpreter0Limit) +
+                static_cast<uint16>(Configuration::Global.flags.AutoProfilingInterpreter1Limit);
+        }
+
+        return static_cast<uint16>(Configuration::Global.flags.ProfilingInterpreter0Limit);
+    }
+
+    uint16 FunctionExecutionStateMachine::GetDefaultAutoProfilingInterpreter1Limit(bool isCoroutine) const {
+        return isCoroutine ? 0 : static_cast<uint16>(Configuration::Global.flags.AutoProfilingInterpreter1Limit);
+    }
+
+    uint16 FunctionExecutionStateMachine::GetDefaultSimpleJitLimit(bool isCoroutine) const {
+        return static_cast<uint16>(Configuration::Global.flags.SimpleJitLimit);
+    }
+
+    uint16 FunctionExecutionStateMachine::GetDefaultProfilingInterpreter1Limit(bool isCoroutine) const {
+        return static_cast<uint16>(Configuration::Global.flags.ProfilingInterpreter1Limit);
+    }
+
     void FunctionExecutionStateMachine::InitializeExecutionModeAndLimits(FunctionBody* functionBody)
     {
 #if DBG
@@ -48,20 +74,17 @@ namespace Js
         Assert(owner == nullptr || owner == functionBody);
         owner = functionBody;
 
-        const ConfigFlagsTable &configFlags = Configuration::Global.flags;
-
         // AutoProfilingInterpreter might decide to not profile on the first run. For generator
         // functions, that means we will miss the profiling information on the first run when we resume
-        // back to the function. This might result in lots of BailOnNoProfile even though we should have
-        // profiling information. So always collect profile data for generators
-        const bool skipAutoProfileForGenerator = functionBody->SkipAutoProfileForCoroutine();
+        // back to the function.
+        const bool isCoroutine = functionBody->SkipAutoProfileForCoroutine();
 
-        interpreterLimit = 0;
-        autoProfilingInterpreter0Limit = skipAutoProfileForGenerator ? 0 : static_cast<uint16>(configFlags.AutoProfilingInterpreter0Limit);
-        profilingInterpreter0Limit = static_cast<uint16>(configFlags.ProfilingInterpreter0Limit);
-        autoProfilingInterpreter1Limit = skipAutoProfileForGenerator ? 0 : static_cast<uint16>(configFlags.AutoProfilingInterpreter1Limit);
-        simpleJitLimit = static_cast<uint16>(configFlags.SimpleJitLimit);
-        profilingInterpreter1Limit = static_cast<uint16>(configFlags.ProfilingInterpreter1Limit);
+        interpreterLimit               = 0;
+        autoProfilingInterpreter0Limit = GetDefaultAutoProfilingInterpreter0Limit(isCoroutine);
+        profilingInterpreter0Limit     = GetDefaultProfilingInterpreter0Limit(isCoroutine);
+        autoProfilingInterpreter1Limit = GetDefaultAutoProfilingInterpreter1Limit(isCoroutine);
+        simpleJitLimit                 = GetDefaultSimpleJitLimit(isCoroutine);
+        profilingInterpreter1Limit     = GetDefaultProfilingInterpreter1Limit(isCoroutine);
 
         // Based on which execution modes are disabled, calculate the number of additional iterations that need to be covered by
         // the execution mode that will scale with the full JIT threshold
@@ -109,14 +132,8 @@ namespace Js
             profilingInterpreter1Limit = 0;
         }
 
-        uint16 fullJitThresholdConfig =
-            static_cast<uint16>(
-                (skipAutoProfileForGenerator ? 0 : configFlags.AutoProfilingInterpreter0Limit) +
-                configFlags.ProfilingInterpreter0Limit +
-                (skipAutoProfileForGenerator ? 0 : configFlags.AutoProfilingInterpreter1Limit) +
-                configFlags.SimpleJitLimit +
-                configFlags.ProfilingInterpreter1Limit);
-        if (!configFlags.EnforceExecutionModeLimits)
+        uint16 fullJitThresholdConfig = GetDefaultFullJitThreshold(isCoroutine);
+        if (!Configuration::Global.flags.EnforceExecutionModeLimits)
         {
             /*
             Scale the full JIT threshold based on some heuristics:
@@ -166,6 +183,15 @@ namespace Js
         TryTransitionToNextInterpreterExecutionMode();
     }
 
+    uint16 FunctionExecutionStateMachine::GetDefaultFullJitThreshold(bool isCoroutine) const
+    {
+        return GetDefaultAutoProfilingInterpreter0Limit(isCoroutine) +
+            GetDefaultProfilingInterpreter0Limit(isCoroutine) +
+            GetDefaultAutoProfilingInterpreter1Limit(isCoroutine) +
+            GetDefaultSimpleJitLimit(isCoroutine) +
+            GetDefaultProfilingInterpreter1Limit(isCoroutine);
+    }
+
     void FunctionExecutionStateMachine::ReinitializeExecutionModeAndLimits(FunctionBody* functionBody)
     {
 #if DBG

lib/Runtime/Base/FunctionExecutionStateMachine.h

@@ -115,6 +115,14 @@ namespace Js
         // Used to detect when interpretedCount changed from a particular call
         FieldWithBarrier(uint32) lastInterpretedCount;
 
+        inline uint16 GetDefaultAutoProfilingInterpreter0Limit(bool isCoroutine) const;
+        inline uint16 GetDefaultProfilingInterpreter0Limit(bool isCoroutine) const;
+        inline uint16 GetDefaultAutoProfilingInterpreter1Limit(bool isCoroutine) const;
+        inline uint16 GetDefaultSimpleJitLimit(bool isCoroutine) const;
+        inline uint16 GetDefaultProfilingInterpreter1Limit(bool isCoroutine) const;
+
+        inline uint16 GetDefaultFullJitThreshold(bool isCoroutine) const;
+
 #if DBG
         FieldWithBarrier(bool) initializedExecutionModeAndLimits;
         // Temporary debug flags for automation