Resolve conflicts, address feedback

src/coreclr/inc/clrconfigvalues.h

@@ -619,9 +619,8 @@ RETAIL_CONFIG_DWORD_INFO(EXTERNAL_TieredPGO, W("TieredPGO"), 0, "Instrument Tier
 //  1 -              Use InstrumentedTier for non-R2R code as the initial tier, promote hot R2R to InstrumentedTier
 //  2 - [Not tested] Use InstrumentedTier for non-R2R code as the initial tier, promote hot R2R to InstrumentedTierOptimized
 //  3 -              Promote hot Tier0/R2R to InstrumentedTier
-//  4 - [Not tested] Promote hot Tier0/R2R to InstrumentedTierOptimized
 //
-// Pros & cons of using optimizations inside the instrumented tiers (modes '2' and '4')
+// Pros & cons of using optimizations inside the instrumented tiers (mode '2')
 // Pros:
 //    * Lower overhead from instrumentation (and thanks to optimizations we _can_ optimize probes and emit less of those)
 //    * Optimized code is able to inline methods so we won't be producing new Compilation units for even small methods

src/coreclr/vm/eeconfig.cpp

@@ -239,6 +239,7 @@ HRESULT EEConfig::Init()
 
 #if defined(FEATURE_PGO)
     fTieredPGO = false;
+    tieredPGO_Strategy = (TieredPGOStrategy)0;
 #endif
 
 #if defined(FEATURE_READYTORUN)
@@ -701,6 +702,26 @@ HRESULT EEConfig::sync()
 
 #if defined(FEATURE_PGO)
     fTieredPGO = Configuration::GetKnobBooleanValue(W("System.Runtime.TieredPGO"), CLRConfig::EXTERNAL_TieredPGO);
+    tieredPGO_Strategy = (TieredPGOStrategy)CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_TieredPGO_Strategy);
+
+    // We need quick jit for TieredPGO
+    if (!fTieredCompilation_QuickJit)
+    {
+        fTieredPGO = false;
+    }
+    else
+    {
+        if (tieredPGO_Strategy == UseInstrumentedTierForILOnly_PromoteHotR2RToInstrumentedTier ||
+            tieredPGO_Strategy == PromoteHotTier0ToInstrumentedTier)
+        {
+            // When we're not using optimizations in the instrumented tiers we produce a lot of new first-time compilation 
+            // due to disabled inlining even for very small methods - such first-time compilations delay promotions by
+            // tieredCompilation_CallCountingDelayMs
+            tieredCompilation_CallCountingDelayMs /= 3;
+            tieredCompilation_CallCountingDelayMs = max(1, tieredCompilation_CallCountingDelayMs);
+        }
+        _ASSERTE(tieredPGO_Strategy >= 0 && tieredPGO_Strategy <= 4);
+    }
 #endif
 
 #if defined(FEATURE_TIERED_COMPILATION)

src/coreclr/vm/eeconfig.h

@@ -70,7 +70,6 @@ enum TieredPGOStrategy
     // In these modes we never instrument Tier0 and only promote hot Tier0 and R2R
     // code to intermediate tiers with instrumentation
     PromoteHotTier0ToInstrumentedTier = 3,
-    PromoteHotTier0ToInstrumentedTierOptimized = 4,
 };
 
 class EEConfig
@@ -114,7 +113,7 @@ class EEConfig
 
 #if defined(FEATURE_PGO)
     bool              TieredPGO(void) const { LIMITED_METHOD_CONTRACT;  return fTieredPGO; }
-    TieredPGOStrategy TieredPGO_Strategy(void) const { LIMITED_METHOD_CONTRACT;  return fTieredPGO_Strategy; }
+    TieredPGOStrategy TieredPGO_Strategy(void) const { LIMITED_METHOD_CONTRACT;  return tieredPGO_Strategy; }
 #endif
 
 #if defined(FEATURE_READYTORUN)
@@ -681,7 +680,7 @@ class EEConfig
 
 #if defined(FEATURE_PGO)
     bool fTieredPGO;
-    TieredPGOStrategy fTieredPGO_Strategy;
+    TieredPGOStrategy tieredPGO_Strategy;
 #endif
 
 #if defined(FEATURE_READYTORUN)

src/coreclr/vm/prestub.cpp

@@ -364,9 +364,9 @@ PCODE MethodDesc::PrepareILBasedCode(PrepareCodeConfig* pConfig)
         if (codeVersion.IsDefaultVersion())
         {
             pConfig->GetMethodDesc()->GetLoaderAllocator()->GetCallCountingManager()->DisableCallCounting(codeVersion);
-            _ASSERTE(codeVersion.GetOptimizationTier() != NativeCodeVersion::OptimizationTier0);
+            _ASSERTE(codeVersion.IsFinalTier());
         }
-        else if (codeVersion.GetOptimizationTier() == NativeCodeVersion::OptimizationTier0)
+        else if (!codeVersion.IsFinalTier())
         {
             codeVersion.SetOptimizationTier(NativeCodeVersion::OptimizationTierOptimized);
         }
@@ -457,7 +457,7 @@ PCODE MethodDesc::GetPrecompiledCode(PrepareCodeConfig* pConfig, bool shouldTier
 #ifdef FEATURE_TIERED_COMPILATION
             if (shouldCountCalls)
             {
-                _ASSERTE(pConfig->GetCodeVersion().GetOptimizationTier() == NativeCodeVersion::OptimizationTier0);
+                _ASSERTE(!pConfig->GetCodeVersion().IsFinalTier());
                 pConfig->SetShouldCountCalls();
             }
 #endif
@@ -1225,6 +1225,12 @@ PrepareCodeConfig::JitOptimizationTier PrepareCodeConfig::GetJitOptimizationTier
                 case NativeCodeVersion::OptimizationTierOptimized:
                     return JitOptimizationTier::Optimized;
 
+                case NativeCodeVersion::OptimizationTierInstrumented:
+                    return JitOptimizationTier::InstrumentedTier;
+
+                case NativeCodeVersion::OptimizationTierInstrumentedOptimized:
+                    return JitOptimizationTier::InstrumentedTierOptimized;
+
                 default:
                     UNREACHABLE();
             }
@@ -1247,6 +1253,8 @@ const char *PrepareCodeConfig::GetJitOptimizationTierStr(PrepareCodeConfig *conf
         case JitOptimizationTier::QuickJitted: return "QuickJitted";
         case JitOptimizationTier::OptimizedTier1: return "OptimizedTier1";
         case JitOptimizationTier::OptimizedTier1OSR: return "OptimizedTier1OSR";
+        case JitOptimizationTier::InstrumentedTier: return "InstrumentedTier";
+        case JitOptimizationTier::InstrumentedTierOptimized: return "InstrumentedTierOptimized";
 
         default:
             UNREACHABLE();
@@ -1293,10 +1301,7 @@ bool PrepareCodeConfig::FinalizeOptimizationTierForTier0LoadOrJit()
         // native code version of a method. The current optimization tier should be consistent with the change being made
         // (Tier 0 to Optimized), such that the tier is not changed in an unexpected way or at an unexpected time. Since changes
         // to the optimization tier are unlocked, this assertion is just a speculative check on possible values.
-        NativeCodeVersion::OptimizationTier previousOptimizationTier = GetCodeVersion().GetOptimizationTier();
-        _ASSERTE(
-            previousOptimizationTier == NativeCodeVersion::OptimizationTier0 ||
-            previousOptimizationTier == NativeCodeVersion::OptimizationTierOptimized);
+        _ASSERTE(!GetCodeVersion().IsFinalTier());
     #endif // _DEBUG
 
         // Update the tier in the code version. The JIT may have decided to switch from tier 0 to optimized, in which case

src/coreclr/vm/tieredcompilation.cpp

@@ -290,6 +290,7 @@ void TieredCompilationManager::AsyncPromoteToTier1(
 
     NativeCodeVersion::OptimizationTier nextTier = NativeCodeVersion::OptimizationTier1;
 
+#ifdef FEATURE_PGO
     // If TieredPGO is enabled, follow TieredPGO_Strategy, see comments in clrconfigvalues.h around it
     if (g_pConfig->TieredPGO() && pMethodDesc->IsEligibleForTieredCompilation())
     {
@@ -303,15 +304,15 @@ void TieredCompilationManager::AsyncPromoteToTier1(
                     nextTier = NativeCodeVersion::OptimizationTierInstrumented;
                     break;
 
-                    // 1: Promote hot R2R code to TierInstrumented
+                // 1: Promote hot R2R code to TierInstrumented
                 case UseInstrumentedTierForILOnly_PromoteHotR2RToInstrumentedTier:
                     if (ExecutionManager::IsReadyToRunCode(tier0NativeCodeVersion.GetNativeCode()))
                     {
                         nextTier = NativeCodeVersion::OptimizationTierInstrumented;
                     }
                     break;
 
-                    // 2: Promote hot R2R code to TierInstrumentedOptimized
+                // 2: Promote hot R2R code to TierInstrumentedOptimized
                 case UseInstrumentedTierForILOnly_PromoteHotR2RToInstrumentedTierOptimized:
                     if (ExecutionManager::IsReadyToRunCode(tier0NativeCodeVersion.GetNativeCode()))
                     {
@@ -324,16 +325,12 @@ void TieredCompilationManager::AsyncPromoteToTier1(
                     nextTier = NativeCodeVersion::OptimizationTierInstrumented;
                     break;
 
-                // 4: Promote hot Tier0/R2R code to TierInstrumentedOptimized
-                case PromoteHotTier0ToInstrumentedTierOptimized:
-                    nextTier = NativeCodeVersion::OptimizationTierInstrumentedOptimized;
-                    break;
-
                 default:
-                    _ASSERT("Unknown TieredPGO_Strategy");
+                    UNREACHABLE_MSG("Unknown TieredPGO_Strategy");
             }
         }
     }
+#endif
 
     ILCodeVersion ilCodeVersion = tier0NativeCodeVersion.GetILCodeVersion();
     _ASSERTE(!ilCodeVersion.HasAnyOptimizedNativeCodeVersion(tier0NativeCodeVersion));