All CS retry with simd mode forced by driver

fftzeng · sys_zuul · commit 10319e902f1c · 2020-01-23T09:29:23.000-08:00
Change-Id: I4757c74973ee1a99ce4c9232de9f24d516105a1d
diff --git a/IGC/Compiler/CISACodeGen/ComputeShaderCodeGen.cpp b/IGC/Compiler/CISACodeGen/ComputeShaderCodeGen.cpp
@@ -220,7 +220,7 @@ namespace IGC
         ComputeShaderContext* pctx =
             static_cast<ComputeShaderContext*>(GetContext());
         RetryManager& retryMgr = GetContext()->m_retryManager;
-        bool isLastTry = retryMgr.IsLastTry(pctx);
+        bool isLastTry = retryMgr.IsLastTry();
 
         float spillThreshold = pctx->GetSpillThreshold();
 
diff --git a/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp b/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp
@@ -1906,7 +1906,7 @@ namespace IGC
 
         if (pOutput->m_scratchSpaceUsedBySpills == 0 ||
             noRetry ||
-            ctx->m_retryManager.IsLastTry(ctx) ||
+            ctx->m_retryManager.IsLastTry() ||
             fullDebugInfo)
         {
             // Save the shader program to the state processor to be handled later
diff --git a/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp b/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp
@@ -795,11 +795,11 @@ namespace IGC
         if (IsStage1BestPerf(ctx->m_CgFlag, ctx->m_StagingCtx))
         {
             // don't retry SIMD16 for ForcePSBestSIMD
-            if( SimdEarlyCheck( ctx ) && ( !ctx->m_retryManager.IsLastTry( ctx ) ) )
+            if( SimdEarlyCheck( ctx ) && ( !ctx->m_retryManager.IsLastTry() ) )
             {
                 AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD16, true, ShaderDispatchMode::NOT_APPLICABLE, pSignature);
             }
-            AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(ctx), ShaderDispatchMode::NOT_APPLICABLE, pSignature);
+            AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(), ShaderDispatchMode::NOT_APPLICABLE, pSignature);
             useRegKeySimd = true;
         }
         else if (IsStage1FastCompile(ctx->m_CgFlag, ctx->m_StagingCtx))
@@ -849,7 +849,7 @@ namespace IGC
 
             // for versioned loop, in general SIMD16 with spill has better perf
             bool earlyExit16 = psInfo.hasVersionedLoop ? false : earlyExit;
-            AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(ctx), ShaderDispatchMode::NOT_APPLICABLE, pSignature);
+            AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(), ShaderDispatchMode::NOT_APPLICABLE, pSignature);
 
             if (enableSimd32 || IGC_GET_FLAG_VALUE(SkipTREarlyExitCheck))
             {
@@ -947,7 +947,7 @@ namespace IGC
                 if (ctx->m_enableSubroutine || !cgSimd16)
                 {
                     AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8,
-                        !ctx->m_retryManager.IsLastTry(ctx));
+                        !ctx->m_retryManager.IsLastTry());
                     setEarlyExit16Stat = true;
                 }
                 else
@@ -962,15 +962,15 @@ namespace IGC
                         AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD32, true);
 
                     AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8,
-                        !ctx->m_retryManager.IsLastTry(ctx));
+                        !ctx->m_retryManager.IsLastTry());
                 }
                 break;
             }
 
             case SIMDMode::SIMD16:
             {
                 AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD16,
-                    !ctx->m_retryManager.IsLastTry(ctx));
+                    !ctx->m_retryManager.IsLastTry());
                 if (!ctx->m_enableSubroutine && maxSimdMode == SIMDMode::SIMD32)
                 {
                     AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD32, true);
@@ -981,7 +981,7 @@ namespace IGC
             case SIMDMode::SIMD32:
             {
                 AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD32,
-                    !ctx->m_retryManager.IsLastTry(ctx));
+                    !ctx->m_retryManager.IsLastTry());
                 break;
             }
 
diff --git a/IGC/Compiler/CodeGenContext.cpp b/IGC/Compiler/CodeGenContext.cpp
@@ -93,11 +93,10 @@ namespace IGC
     bool RetryManager::IsFirstTry() {
         return (stateId == firstStateId);
     }
-    bool RetryManager::IsLastTry(CodeGenContext* cgCtx) {
+    bool RetryManager::IsLastTry() {
         return (!enabled ||
             IGC_IS_FLAG_ENABLED(DisableRecompilation) ||
             lastSpillSize < IGC_GET_FLAG_VALUE(AllowedSpillRegCount) ||
-            (cgCtx->getModuleMetaData()->csInfo.forcedSIMDSize != 0) ||
             (stateId < getStateCnt() && RetryTable[stateId].nextState >= getStateCnt()));
     }
     unsigned RetryManager::GetRetryId() const { return stateId; }
@@ -181,20 +180,31 @@ namespace IGC
 
     CShader* RetryManager::PickCSEntryForcedFromDriver(SIMDMode& simdMode, unsigned char forcedSIMDModeFromDriver)
     {
-        switch (forcedSIMDModeFromDriver)
+        if (forcedSIMDModeFromDriver == 8)
         {
-        case 8: simdMode = SIMDMode::SIMD8;
-            simdMode = SIMDMode::SIMD8;
-            return m_simdEntries[0];
-        case 16:simdMode = SIMDMode::SIMD16;
-            simdMode = SIMDMode::SIMD16;
-            return m_simdEntries[1];
-        case 32:simdMode = SIMDMode::SIMD32;
-            simdMode = SIMDMode::SIMD32;
-            return m_simdEntries[2];
-        default: simdMode = SIMDMode::UNKNOWN;
-            return nullptr;
+            if ((m_simdEntries[0] && m_simdEntries[0]->m_spillSize == 0) || IsLastTry())
+            {
+                simdMode = SIMDMode::SIMD8;
+                return m_simdEntries[0];
+            }
         }
+        else if (forcedSIMDModeFromDriver == 16)
+        {
+            if ((m_simdEntries[1] && m_simdEntries[1]->m_spillSize == 0) || IsLastTry())
+            {
+                simdMode = SIMDMode::SIMD16;
+                return m_simdEntries[1];
+            }
+        }
+        else if (forcedSIMDModeFromDriver == 32)
+        {
+            if ((m_simdEntries[2] && m_simdEntries[2]->m_spillSize == 0) || IsLastTry())
+            {
+                simdMode = SIMDMode::SIMD32;
+                return m_simdEntries[2];
+            }
+        }
+        return nullptr;
     }
 
     CShader* RetryManager::PickCSEntryByRegKey(SIMDMode& simdMode)
@@ -349,12 +359,15 @@ namespace IGC
 
     bool RetryManager::PickupCS(ComputeShaderContext* cgCtx)
     {
-        SIMDMode simdMode;
+        SIMDMode simdMode = SIMDMode::UNKNOWN;
         CComputeShader* shader = nullptr;
         SComputeShaderKernelProgram* pKernelProgram = &cgCtx->programOutput;
 
-        shader = static_cast<CComputeShader*>(
-            PickCSEntryForcedFromDriver(simdMode, cgCtx->getModuleMetaData()->csInfo.forcedSIMDSize));
+        if (cgCtx->getModuleMetaData()->csInfo.forcedSIMDSize != 0)
+        {
+            shader = static_cast<CComputeShader*>(
+                PickCSEntryForcedFromDriver(simdMode, cgCtx->getModuleMetaData()->csInfo.forcedSIMDSize));
+        }
         if (!shader)
         {
             shader = static_cast<CComputeShader*>(
@@ -365,7 +378,7 @@ namespace IGC
             shader = static_cast<CComputeShader*>(
                 PickCSEntryEarly(simdMode, cgCtx));
         }
-        if (!shader && IsLastTry(cgCtx))
+        if (!shader && IsLastTry())
         {
             shader = static_cast<CComputeShader*>(
                 PickCSEntryFinally(simdMode));
diff --git a/IGC/Compiler/CodeGenPublic.h b/IGC/Compiler/CodeGenPublic.h
@@ -627,7 +627,7 @@ namespace IGC
         bool AllowSimd32Slicing();
         bool AllowLargeURBWrite();
         bool IsFirstTry();
-        bool IsLastTry(CodeGenContext* cgCtx);
+        bool IsLastTry();
         unsigned GetRetryId() const;
 
         void Enable();

Original file line number	Diff line number	Diff line change
`@@ -1906,7 +1906,7 @@ namespace IGC`
`1906`	`1906`
`1907`	`1907`	`if (pOutput->m_scratchSpaceUsedBySpills == 0 \|\|`
`1908`	`1908`	`noRetry \|\|`
`1909`		`- ctx->m_retryManager.IsLastTry(ctx) \|\|`
	`1909`	`+ ctx->m_retryManager.IsLastTry() \|\|`
`1910`	`1910`	`fullDebugInfo)`
`1911`	`1911`	`{`
`1912`	`1912`	`// Save the shader program to the state processor to be handled later`
Original file line number	Diff line number	Diff line change
`@@ -795,11 +795,11 @@ namespace IGC`
`795`	`795`	`if (IsStage1BestPerf(ctx->m_CgFlag, ctx->m_StagingCtx))`
`796`	`796`	`{`
`797`	`797`	`// don't retry SIMD16 for ForcePSBestSIMD`
`798`		`- if( SimdEarlyCheck( ctx ) && ( !ctx->m_retryManager.IsLastTry( ctx ) ) )`
	`798`	`+ if( SimdEarlyCheck( ctx ) && ( !ctx->m_retryManager.IsLastTry() ) )`
`799`	`799`	`{`
`800`	`800`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD16, true, ShaderDispatchMode::NOT_APPLICABLE, pSignature);`
`801`	`801`	`}`
`802`		`- AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(ctx), ShaderDispatchMode::NOT_APPLICABLE, pSignature);`
	`802`	`+ AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(), ShaderDispatchMode::NOT_APPLICABLE, pSignature);`
`803`	`803`	`useRegKeySimd = true;`
`804`	`804`	`}`
`805`	`805`	`else if (IsStage1FastCompile(ctx->m_CgFlag, ctx->m_StagingCtx))`
`@@ -849,7 +849,7 @@ namespace IGC`
`849`	`849`
`850`	`850`	`// for versioned loop, in general SIMD16 with spill has better perf`
`851`	`851`	`bool earlyExit16 = psInfo.hasVersionedLoop ? false : earlyExit;`
`852`		`- AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(ctx), ShaderDispatchMode::NOT_APPLICABLE, pSignature);`
	`852`	`+ AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8, !ctx->m_retryManager.IsLastTry(), ShaderDispatchMode::NOT_APPLICABLE, pSignature);`
`853`	`853`
`854`	`854`	`if (enableSimd32 \|\| IGC_GET_FLAG_VALUE(SkipTREarlyExitCheck))`
`855`	`855`	`{`
`@@ -947,7 +947,7 @@ namespace IGC`
`947`	`947`	`if (ctx->m_enableSubroutine \|\| !cgSimd16)`
`948`	`948`	`{`
`949`	`949`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8,`
`950`		`- !ctx->m_retryManager.IsLastTry(ctx));`
	`950`	`+ !ctx->m_retryManager.IsLastTry());`
`951`	`951`	`setEarlyExit16Stat = true;`
`952`	`952`	`}`
`953`	`953`	`else`
`@@ -962,15 +962,15 @@ namespace IGC`
`962`	`962`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD32, true);`
`963`	`963`
`964`	`964`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD8,`
`965`		`- !ctx->m_retryManager.IsLastTry(ctx));`
	`965`	`+ !ctx->m_retryManager.IsLastTry());`
`966`	`966`	`}`
`967`	`967`	`break;`
`968`	`968`	`}`
`969`	`969`
`970`	`970`	`case SIMDMode::SIMD16:`
`971`	`971`	`{`
`972`	`972`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD16,`
`973`		`- !ctx->m_retryManager.IsLastTry(ctx));`
	`973`	`+ !ctx->m_retryManager.IsLastTry());`
`974`	`974`	`if (!ctx->m_enableSubroutine && maxSimdMode == SIMDMode::SIMD32)`
`975`	`975`	`{`
`976`	`976`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD32, true);`
`@@ -981,7 +981,7 @@ namespace IGC`
`981`	`981`	`case SIMDMode::SIMD32:`
`982`	`982`	`{`
`983`	`983`	`AddCodeGenPasses(*ctx, shaders, PassMgr, SIMDMode::SIMD32,`
`984`		`- !ctx->m_retryManager.IsLastTry(ctx));`
	`984`	`+ !ctx->m_retryManager.IsLastTry());`
`985`	`985`	`break;`
`986`	`986`	`}`
`987`	`987`