Implement SIMD compile info for OCL shaders

iwwu · sys_zuul · commit bd27da736ed7 · 2020-07-31T10:14:23.000-07:00
Change-Id: Ia61060afb49c7e4df6325f2643f747ca73f56509
diff --git a/IGC/AdaptorOCL/OCL/KernelAnnotations.hpp b/IGC/AdaptorOCL/OCL/KernelAnnotations.hpp
@@ -324,6 +324,7 @@ struct ExecutionEnivronment
     DWORD  WorkgroupWalkOrder[3]                      = {};
     bool   HasGlobalAtomics                           = false;
     bool   UseBindlessMode                            = false;
+    uint64_t SIMDInfo                                 = 0;
 };
 
 struct KernelTypeProgramBinaryInfo
diff --git a/IGC/AdaptorOCL/OCL/Patch/patch_parser.cpp b/IGC/AdaptorOCL/OCL/Patch/patch_parser.cpp
@@ -911,6 +911,9 @@ void DebugPatchList(
                 ICBE_DPF_STR(output, GFXDBG_HARDWARE,
                     "\tUseBindlessMode = %d\n",
                     pPatchItem->UseBindlessMode);
+                ICBE_DPF_STR(output, GFXDBG_HARDWARE,
+                    "\tSIMDInfo = %lld\n",
+                    pPatchItem->SIMDInfo);
             }
             break;
 
diff --git a/IGC/AdaptorOCL/OCL/sp/sp_g8.cpp b/IGC/AdaptorOCL/OCL/sp/sp_g8.cpp
@@ -2036,6 +2036,7 @@ RETVAL CGen8OpenCLStateProcessor::CreatePatchList(
 
 
         patch.UseBindlessMode = annotations.m_executionEnivronment.UseBindlessMode;
+        patch.SIMDInfo = annotations.m_executionEnivronment.SIMDInfo;
 
         retValue = AddPatchItem(
             patch,
diff --git a/IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_list.h b/IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_list.h
@@ -33,7 +33,7 @@ Abstract:   Contains common patch structure definitions
 
 namespace iOpenCL
 {
-const uint32_t CURRENT_ICBE_VERSION = 1067;
+const uint32_t CURRENT_ICBE_VERSION = 1068;
 const uint32_t MAGIC_CL = 0x494E5443;      // 'I', 'N', 'T', 'C'
 const uint32_t INVALID_INDEX = 0xFFFFFFFF;
 
diff --git a/IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_shared.h b/IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_shared.h
@@ -214,10 +214,11 @@ struct SPatchExecutionEnvironment :
     uint32_t    reserved3;
     uint32_t    StatelessWritesCount;
     uint32_t    UseBindlessMode;
+    uint64_t    SIMDInfo;
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchExecutionEnvironment) == (112 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
+static_assert(sizeof(SPatchExecutionEnvironment) == (120 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchString
diff --git a/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp b/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp
@@ -2054,7 +2054,7 @@ namespace IGC
         }
     }
 
-    static bool SetKernelProgram(COpenCLKernel* shader, DWORD simdMode)
+    static bool SetKernelProgram(OpenCLProgramContext* ctx, COpenCLKernel* shader, DWORD simdMode)
     {
         if (shader && shader->ProgramOutput()->m_programSize > 0)
         {
@@ -2065,16 +2065,20 @@ namespace IGC
                 //shader->m_kernelInfo.m_executionEnivronment.PerThreadSpillFillSize =
                 //    shader->ProgramOutput()->m_scratchSpaceUsedBySpills;
                 shader->m_kernelInfo.m_kernelProgram.simd32 = *shader->ProgramOutput();
+                ctx->SetSIMDInfo(SIMD_SELECTED, SIMDMode::SIMD32, ShaderDispatchMode::NOT_APPLICABLE);
             }
             else if (simdMode == 16)
             {
                 shader->m_kernelInfo.m_kernelProgram.simd16 = *shader->ProgramOutput();
+                ctx->SetSIMDInfo(SIMD_SELECTED, SIMDMode::SIMD16, ShaderDispatchMode::NOT_APPLICABLE);
             }
             else if (simdMode == 8)
             {
                 shader->m_kernelInfo.m_kernelProgram.simd8 = *shader->ProgramOutput();
+                ctx->SetSIMDInfo(SIMD_SELECTED, SIMDMode::SIMD8, ShaderDispatchMode::NOT_APPLICABLE);
             }
             shader->m_kernelInfo.m_executionEnivronment.CompiledSIMDSize = simdMode;
+            shader->m_kernelInfo.m_executionEnivronment.SIMDInfo = ctx->GetSIMDInfo();
             return true;
         }
         return false;
@@ -2145,21 +2149,21 @@ namespace IGC
             if (ctx->m_DriverInfo.sendMultipleSIMDModes() && (ctx->getModuleMetaData()->csInfo.forcedSIMDSize == 0))
             {
                 //Gather the kernel binary for each compiled kernel
-                if (SetKernelProgram(simd32Shader, 32))
+                if (SetKernelProgram(ctx, simd32Shader, 32))
                     GatherDataForDriver(ctx, simd32Shader, pKernel, pFunc, pMdUtils);
-                if (SetKernelProgram(simd16Shader, 16))
+                if (SetKernelProgram(ctx, simd16Shader, 16))
                     GatherDataForDriver(ctx, simd16Shader, pKernel, pFunc, pMdUtils);
-                if (SetKernelProgram(simd8Shader, 8))
+                if (SetKernelProgram(ctx, simd8Shader, 8))
                     GatherDataForDriver(ctx, simd8Shader, pKernel, pFunc, pMdUtils);
             }
             else
             {
                 //Gather the kernel binary only for 1 SIMD mode of the kernel
-                if (SetKernelProgram(simd32Shader, 32))
+                if (SetKernelProgram(ctx, simd32Shader, 32))
                     GatherDataForDriver(ctx, simd32Shader, pKernel, pFunc, pMdUtils);
-                else if (SetKernelProgram(simd16Shader, 16))
+                else if (SetKernelProgram(ctx, simd16Shader, 16))
                     GatherDataForDriver(ctx, simd16Shader, pKernel, pFunc, pMdUtils);
-                else if (SetKernelProgram(simd8Shader, 8))
+                else if (SetKernelProgram(ctx, simd8Shader, 8))
                     GatherDataForDriver(ctx, simd8Shader, pKernel, pFunc, pMdUtils);
             }
         }
@@ -2195,6 +2199,12 @@ namespace IGC
         if (!CompileSIMDSizeInCommon())
             return false;
 
+        if (!m_Context->m_retryManager.IsFirstTry())
+        {
+            m_Context->ClearSIMDInfo(simdMode, ShaderDispatchMode::NOT_APPLICABLE);
+            m_Context->SetSIMDInfo(SIMD_RETRY, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
+        }
+
 
 
         //If forced SIMD Mode (by driver or regkey), then:
@@ -2275,11 +2285,14 @@ namespace IGC
             {
                 if (simdMode == SIMDMode::SIMD32)
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_HW, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_FUNC_FAIL;
                 }
             }
             else if (simdMode != SIMDMode::SIMD8)
             {
+                pCtx->SetSIMDInfo(SIMD_SKIP_HW, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
+
                 // default simd8
                 return SIMDStatus::SIMD_FUNC_FAIL;
             }
@@ -2307,19 +2320,22 @@ namespace IGC
             case 8:
                 if (simdMode == SIMDMode::SIMD16 || simdMode == SIMDMode::SIMD32)
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_FUNC_FAIL;
                 }
                 break;
             case 16:
                 if (simdMode == SIMDMode::SIMD8 || simdMode == SIMDMode::SIMD32)
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_FUNC_FAIL;
                 }
                 EP.m_canAbortOnSpill = false;
                 break;
             case 32:
                 if (simdMode == SIMDMode::SIMD8 || simdMode == SIMDMode::SIMD16)
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_FUNC_FAIL;
                 }
                 EP.m_canAbortOnSpill = false;
@@ -2355,6 +2371,7 @@ namespace IGC
                 if (simdMode == SIMDMode::SIMD32 ||
                     (groupSize <= 8 && simdMode != SIMDMode::SIMD8))
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_FUNC_FAIL;
                 }
             }
@@ -2373,6 +2390,7 @@ namespace IGC
                 Simd32ProfitabilityAnalysis& PA = EP.getAnalysis<Simd32ProfitabilityAnalysis>();
                 if (!PA.isSimd16Profitable())
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_PERF, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_PERF_FAIL;
                 }
             }
@@ -2389,6 +2407,7 @@ namespace IGC
                 Simd32ProfitabilityAnalysis& PA = EP.getAnalysis<Simd32ProfitabilityAnalysis>();
                 if (!PA.isSimd32Profitable())
                 {
+                    pCtx->SetSIMDInfo(SIMD_SKIP_HW, simdMode, ShaderDispatchMode::NOT_APPLICABLE);
                     return SIMDStatus::SIMD_PERF_FAIL;
                 }
             }
diff --git a/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp b/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp
@@ -1136,10 +1136,15 @@ void CodeGen(OpenCLProgramContext* ctx, CShaderProgram::KernelShaderMap& kernels
         {
             AddCodeGenPasses(*ctx, kernels, Passes, SIMDMode::SIMD16, false);
             AddCodeGenPasses(*ctx, kernels, Passes, SIMDMode::SIMD32, (ctx->getModuleMetaData()->csInfo.forcedSIMDSize != 32));
+
+            ctx->SetSIMDInfo(SIMD_SKIP_HW, SIMDMode::SIMD8, ShaderDispatchMode::NOT_APPLICABLE);
         }
         else
         {
             AddCodeGenPasses(*ctx, kernels, Passes, SIMDMode::SIMD32, false);
+
+            ctx->SetSIMDInfo(SIMD_SKIP_HW, SIMDMode::SIMD8, ShaderDispatchMode::NOT_APPLICABLE);
+            ctx->SetSIMDInfo(SIMD_SKIP_HW, SIMDMode::SIMD16, ShaderDispatchMode::NOT_APPLICABLE);
         }
     }
     else

Original file line number	Diff line number	Diff line change
`@@ -911,6 +911,9 @@ void DebugPatchList(`
`911`	`911`	`ICBE_DPF_STR(output, GFXDBG_HARDWARE,`
`912`	`912`	`"\tUseBindlessMode = %d\n",`
`913`	`913`	`pPatchItem->UseBindlessMode);`
	`914`	`+ ICBE_DPF_STR(output, GFXDBG_HARDWARE,`
	`915`	`+ "\tSIMDInfo = %lld\n",`
	`916`	`+ pPatchItem->SIMDInfo);`
`914`	`917`	`}`
`915`	`918`	`break;`
`916`	`919`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ Abstract: Contains common patch structure definitions`
`33`	`33`
`34`	`34`	`namespace iOpenCL`
`35`	`35`	`{`
`36`		`-const uint32_t CURRENT_ICBE_VERSION = 1067;`
	`36`	`+const uint32_t CURRENT_ICBE_VERSION = 1068;`
`37`	`37`	`const uint32_t MAGIC_CL = 0x494E5443; // 'I', 'N', 'T', 'C'`
`38`	`38`	`const uint32_t INVALID_INDEX = 0xFFFFFFFF;`
`39`	`39`
Original file line number	Diff line number	Diff line change
`@@ -2054,7 +2054,7 @@ namespace IGC`
`2054`	`2054`	`}`
`2055`	`2055`	`}`
`2056`	`2056`
`2057`		`- static bool SetKernelProgram(COpenCLKernel* shader, DWORD simdMode)`
	`2057`	`+ static bool SetKernelProgram(OpenCLProgramContext* ctx, COpenCLKernel* shader, DWORD simdMode)`
`2058`	`2058`	`{`
`2059`	`2059`	`if (shader && shader->ProgramOutput()->m_programSize > 0)`
`2060`	`2060`	`{`
`@@ -2065,16 +2065,20 @@ namespace IGC`
`2065`	`2065`	`//shader->m_kernelInfo.m_executionEnivronment.PerThreadSpillFillSize =`
`2066`	`2066`	`// shader->ProgramOutput()->m_scratchSpaceUsedBySpills;`
`2067`	`2067`	`shader->m_kernelInfo.m_kernelProgram.simd32 = *shader->ProgramOutput();`
	`2068`	`+ ctx->SetSIMDInfo(SIMD_SELECTED, SIMDMode::SIMD32, ShaderDispatchMode::NOT_APPLICABLE);`
`2068`	`2069`	`}`
`2069`	`2070`	`else if (simdMode == 16)`
`2070`	`2071`	`{`
`2071`	`2072`	`shader->m_kernelInfo.m_kernelProgram.simd16 = *shader->ProgramOutput();`
	`2073`	`+ ctx->SetSIMDInfo(SIMD_SELECTED, SIMDMode::SIMD16, ShaderDispatchMode::NOT_APPLICABLE);`
`2072`	`2074`	`}`
`2073`	`2075`	`else if (simdMode == 8)`
`2074`	`2076`	`{`
`2075`	`2077`	`shader->m_kernelInfo.m_kernelProgram.simd8 = *shader->ProgramOutput();`
	`2078`	`+ ctx->SetSIMDInfo(SIMD_SELECTED, SIMDMode::SIMD8, ShaderDispatchMode::NOT_APPLICABLE);`
`2076`	`2079`	`}`
`2077`	`2080`	`shader->m_kernelInfo.m_executionEnivronment.CompiledSIMDSize = simdMode;`
	`2081`	`+ shader->m_kernelInfo.m_executionEnivronment.SIMDInfo = ctx->GetSIMDInfo();`
`2078`	`2082`	`return true;`
`2079`	`2083`	`}`
`2080`	`2084`	`return false;`
`@@ -2145,21 +2149,21 @@ namespace IGC`
`2145`	`2149`	`if (ctx->m_DriverInfo.sendMultipleSIMDModes() && (ctx->getModuleMetaData()->csInfo.forcedSIMDSize == 0))`
`2146`	`2150`	`{`
`2147`	`2151`	`//Gather the kernel binary for each compiled kernel`
`2148`		`- if (SetKernelProgram(simd32Shader, 32))`
	`2152`	`+ if (SetKernelProgram(ctx, simd32Shader, 32))`
`2149`	`2153`	`GatherDataForDriver(ctx, simd32Shader, pKernel, pFunc, pMdUtils);`
`2150`		`- if (SetKernelProgram(simd16Shader, 16))`
	`2154`	`+ if (SetKernelProgram(ctx, simd16Shader, 16))`
`2151`	`2155`	`GatherDataForDriver(ctx, simd16Shader, pKernel, pFunc, pMdUtils);`
`2152`		`- if (SetKernelProgram(simd8Shader, 8))`
	`2156`	`+ if (SetKernelProgram(ctx, simd8Shader, 8))`
`2153`	`2157`	`GatherDataForDriver(ctx, simd8Shader, pKernel, pFunc, pMdUtils);`
`2154`	`2158`	`}`
`2155`	`2159`	`else`
`2156`	`2160`	`{`
`2157`	`2161`	`//Gather the kernel binary only for 1 SIMD mode of the kernel`
`2158`		`- if (SetKernelProgram(simd32Shader, 32))`
	`2162`	`+ if (SetKernelProgram(ctx, simd32Shader, 32))`
`2159`	`2163`	`GatherDataForDriver(ctx, simd32Shader, pKernel, pFunc, pMdUtils);`
`2160`		`- else if (SetKernelProgram(simd16Shader, 16))`
	`2164`	`+ else if (SetKernelProgram(ctx, simd16Shader, 16))`
`2161`	`2165`	`GatherDataForDriver(ctx, simd16Shader, pKernel, pFunc, pMdUtils);`
`2162`		`- else if (SetKernelProgram(simd8Shader, 8))`
	`2166`	`+ else if (SetKernelProgram(ctx, simd8Shader, 8))`
`2163`	`2167`	`GatherDataForDriver(ctx, simd8Shader, pKernel, pFunc, pMdUtils);`
`2164`	`2168`	`}`
`2165`	`2169`	`}`
`@@ -2195,6 +2199,12 @@ namespace IGC`
`2195`	`2199`	`if (!CompileSIMDSizeInCommon())`
`2196`	`2200`	`return false;`
`2197`	`2201`
	`2202`	`+ if (!m_Context->m_retryManager.IsFirstTry())`
	`2203`	`+ {`
	`2204`	`+ m_Context->ClearSIMDInfo(simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
	`2205`	`+ m_Context->SetSIMDInfo(SIMD_RETRY, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
	`2206`	`+ }`
	`2207`	`+`
`2198`	`2208`
`2199`	`2209`
`2200`	`2210`	`//If forced SIMD Mode (by driver or regkey), then:`
`@@ -2275,11 +2285,14 @@ namespace IGC`
`2275`	`2285`	`{`
`2276`	`2286`	`if (simdMode == SIMDMode::SIMD32)`
`2277`	`2287`	`{`
	`2288`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_HW, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2278`	`2289`	`return SIMDStatus::SIMD_FUNC_FAIL;`
`2279`	`2290`	`}`
`2280`	`2291`	`}`
`2281`	`2292`	`else if (simdMode != SIMDMode::SIMD8)`
`2282`	`2293`	`{`
	`2294`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_HW, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
	`2295`	`+`
`2283`	`2296`	`// default simd8`
`2284`	`2297`	`return SIMDStatus::SIMD_FUNC_FAIL;`
`2285`	`2298`	`}`
`@@ -2307,19 +2320,22 @@ namespace IGC`
`2307`	`2320`	`case 8:`
`2308`	`2321`	`if (simdMode == SIMDMode::SIMD16 \|\| simdMode == SIMDMode::SIMD32)`
`2309`	`2322`	`{`
	`2323`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2310`	`2324`	`return SIMDStatus::SIMD_FUNC_FAIL;`
`2311`	`2325`	`}`
`2312`	`2326`	`break;`
`2313`	`2327`	`case 16:`
`2314`	`2328`	`if (simdMode == SIMDMode::SIMD8 \|\| simdMode == SIMDMode::SIMD32)`
`2315`	`2329`	`{`
	`2330`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2316`	`2331`	`return SIMDStatus::SIMD_FUNC_FAIL;`
`2317`	`2332`	`}`
`2318`	`2333`	`EP.m_canAbortOnSpill = false;`
`2319`	`2334`	`break;`
`2320`	`2335`	`case 32:`
`2321`	`2336`	`if (simdMode == SIMDMode::SIMD8 \|\| simdMode == SIMDMode::SIMD16)`
`2322`	`2337`	`{`
	`2338`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2323`	`2339`	`return SIMDStatus::SIMD_FUNC_FAIL;`
`2324`	`2340`	`}`
`2325`	`2341`	`EP.m_canAbortOnSpill = false;`
`@@ -2355,6 +2371,7 @@ namespace IGC`
`2355`	`2371`	`if (simdMode == SIMDMode::SIMD32 \|\|`
`2356`	`2372`	`(groupSize <= 8 && simdMode != SIMDMode::SIMD8))`
`2357`	`2373`	`{`
	`2374`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_THGRPSIZE, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2358`	`2375`	`return SIMDStatus::SIMD_FUNC_FAIL;`
`2359`	`2376`	`}`
`2360`	`2377`	`}`
`@@ -2373,6 +2390,7 @@ namespace IGC`
`2373`	`2390`	`Simd32ProfitabilityAnalysis& PA = EP.getAnalysis<Simd32ProfitabilityAnalysis>();`
`2374`	`2391`	`if (!PA.isSimd16Profitable())`
`2375`	`2392`	`{`
	`2393`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_PERF, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2376`	`2394`	`return SIMDStatus::SIMD_PERF_FAIL;`
`2377`	`2395`	`}`
`2378`	`2396`	`}`
`@@ -2389,6 +2407,7 @@ namespace IGC`
`2389`	`2407`	`Simd32ProfitabilityAnalysis& PA = EP.getAnalysis<Simd32ProfitabilityAnalysis>();`
`2390`	`2408`	`if (!PA.isSimd32Profitable())`
`2391`	`2409`	`{`
	`2410`	`+ pCtx->SetSIMDInfo(SIMD_SKIP_HW, simdMode, ShaderDispatchMode::NOT_APPLICABLE);`
`2392`	`2411`	`return SIMDStatus::SIMD_PERF_FAIL;`
`2393`	`2412`	`}`
`2394`	`2413`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1136,10 +1136,15 @@ void CodeGen(OpenCLProgramContext* ctx, CShaderProgram::KernelShaderMap& kernels`
`1136`	`1136`	`{`
`1137`	`1137`	`AddCodeGenPasses(*ctx, kernels, Passes, SIMDMode::SIMD16, false);`
`1138`	`1138`	`AddCodeGenPasses(*ctx, kernels, Passes, SIMDMode::SIMD32, (ctx->getModuleMetaData()->csInfo.forcedSIMDSize != 32));`
	`1139`	`+`
	`1140`	`+ ctx->SetSIMDInfo(SIMD_SKIP_HW, SIMDMode::SIMD8, ShaderDispatchMode::NOT_APPLICABLE);`
`1139`	`1141`	`}`
`1140`	`1142`	`else`
`1141`	`1143`	`{`
`1142`	`1144`	`AddCodeGenPasses(*ctx, kernels, Passes, SIMDMode::SIMD32, false);`
	`1145`	`+`
	`1146`	`+ ctx->SetSIMDInfo(SIMD_SKIP_HW, SIMDMode::SIMD8, ShaderDispatchMode::NOT_APPLICABLE);`
	`1147`	`+ ctx->SetSIMDInfo(SIMD_SKIP_HW, SIMDMode::SIMD16, ShaderDispatchMode::NOT_APPLICABLE);`
`1143`	`1148`	`}`
`1144`	`1149`	`}`
`1145`	`1150`	`else`