Add -minimum-slang-optimization to favor compile time. (#4186)

csyonghe · web-flow · commit 62b7219e715b · 2024-05-17T23:07:36.000-07:00
diff --git a/slang.h b/slang.h
@@ -862,6 +862,7 @@ extern "C"
             SourceEmbedName,
             SourceEmbedLanguage,
             DisableShortCircuit,   // bool
+            MinimumSlangOptimization, // bool
 
             // Target
 
@@ -1709,6 +1710,17 @@ extern "C"
         int targetIndex,
         bool forceScalarLayout);
 
+    /*! @see slang::ICompileRequest::setTargetUseMinimumSlangOptimization */
+    SLANG_API void spSetTargetUseMinimumSlangOptimization(
+        slang::ICompileRequest* request,
+        int targetIndex,
+        bool val);
+
+    /*! @see slang::ICompileRequest::setIngoreCapabilityCheck */
+    SLANG_API void spSetIgnoreCapabilityCheck(
+        slang::ICompileRequest* request,
+        bool val);
+
     /*! @see slang::ICompileRequest::setCodeGenTarget */
     SLANG_API void spSetCodeGenTarget(
         SlangCompileRequest*    request,
@@ -4403,6 +4415,10 @@ namespace slang
 
         virtual SLANG_NO_THROW void SLANG_MCALL setSkipSPIRVValidation(bool value) = 0;
 
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetUseMinimumSlangOptimization(int targetIndex, bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setIgnoreCapabilityCheck(bool value) = 0;
+
     };
 
     #define SLANG_UUID_ICompileRequest ICompileRequest::getTypeGuid()
diff --git a/source/slang/slang-api.cpp b/source/slang/slang-api.cpp
@@ -304,6 +304,18 @@ SLANG_API void spSetTargetForceGLSLScalarBufferLayout(
     request->setTargetForceGLSLScalarBufferLayout(targetIndex, forceScalarLayout);
 }
 
+SLANG_API void spSetTargetUseMinimumSlangOptimization(slang::ICompileRequest* request, int targetIndex, bool val)
+{
+    SLANG_ASSERT(request);
+    request->setTargetUseMinimumSlangOptimization(targetIndex, val);
+}
+
+SLANG_API void spSetIgnoreCapabilityCheck(slang::ICompileRequest* request, bool ignore)
+{
+    SLANG_ASSERT(request);
+    request->setIgnoreCapabilityCheck(ignore);
+}
+
 SLANG_API void spSetTargetLineDirectiveMode(
     slang::ICompileRequest* request,
     int targetIndex,
diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp
@@ -9125,8 +9125,10 @@ namespace Slang
             break;
 
         case DeclCheckState::CapabilityChecked:
-            if(!shared.getOptionSet().getBoolOption(CompilerOptionName::IgnoreCapabilities))
+            if (!shared.getOptionSet().getBoolOption(CompilerOptionName::IgnoreCapabilities))
+            {
                 SemanticsDeclCapabilityVisitor(shared).dispatch(decl);
+            }
             break;
         }
     }
diff --git a/source/slang/slang-compiler-options.h b/source/slang/slang-compiler-options.h
@@ -361,6 +361,11 @@ namespace Slang
             return getBoolOption(CompilerOptionName::Obfuscate);
         }
 
+        bool shouldPerformMinimumOptimizations()
+        {
+            return getBoolOption(CompilerOptionName::MinimumSlangOptimization);
+        }
+
         FloatingPointMode getFloatingPointMode()
         {
             return getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode);
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
@@ -2778,6 +2778,8 @@ namespace Slang
         virtual SLANG_NO_THROW void SLANG_MCALL setReportDownstreamTime(bool value) SLANG_OVERRIDE;
         virtual SLANG_NO_THROW void SLANG_MCALL setReportPerfBenchmark(bool value) SLANG_OVERRIDE;
         virtual SLANG_NO_THROW void SLANG_MCALL setSkipSPIRVValidation(bool value) SLANG_OVERRIDE;
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetUseMinimumSlangOptimization(int targetIndex, bool value) SLANG_OVERRIDE;
+        virtual SLANG_NO_THROW void SLANG_MCALL setIgnoreCapabilityCheck(bool value) SLANG_OVERRIDE;
 
         void setTrackLiveness(bool v);
 
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
@@ -255,7 +255,8 @@ Result linkAndOptimizeIR(
     if(!isKhronosTarget(targetRequest))
         lowerGLSLShaderStorageBufferObjectsToStructuredBuffers(irModule, sink);
 
-    translateGLSLGlobalVar(codeGenContext, irModule);
+    if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
+        translateGLSLGlobalVar(codeGenContext, irModule);
 
     // Replace any global constants with their values.
     //
@@ -379,7 +380,11 @@ Result linkAndOptimizeIR(
     // Lower all the LValue implict casts (used for out/inout/ref scenarios)
     lowerLValueCast(targetProgram, irModule);
 
-    simplifyIR(targetProgram, irModule, IRSimplificationOptions::getDefault(), sink);
+    IRSimplificationOptions defaultIRSimplificationOptions = IRSimplificationOptions::getDefault(targetProgram);
+    IRSimplificationOptions fastIRSimplificationOptions = IRSimplificationOptions::getFast(targetProgram);
+    fastIRSimplificationOptions.minimalOptimization = defaultIRSimplificationOptions.minimalOptimization;
+
+    simplifyIR(targetProgram, irModule, defaultIRSimplificationOptions, sink);
 
     if (targetProgram->getOptionSet().getBoolOption(CompilerOptionName::ValidateUniformity))
     {
@@ -389,12 +394,13 @@ Result linkAndOptimizeIR(
     }
 
     // Fill in default matrix layout into matrix types that left layout unspecified.
-    specializeMatrixLayout(codeGenContext->getTargetProgram(), irModule);
+    specializeMatrixLayout(targetProgram, irModule);
 
     // It's important that this takes place before defunctionalization as we
     // want to be able to easily discover the cooperate and fallback funcitons
     // being passed to saturated_cooperation
-    fuseCallsToSaturatedCooperation(irModule);
+    if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
+        fuseCallsToSaturatedCooperation(irModule);
 
     // Generate any requested derivative wrappers
     generateDerivativeWrappers(irModule, sink);
@@ -451,7 +457,8 @@ Result linkAndOptimizeIR(
         // which do.
         // Specialize away these parameters
         // TODO: We should implement a proper defunctionalization pass
-        changed |= specializeHigherOrderParameters(codeGenContext, irModule);
+        if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
+            changed |= specializeHigherOrderParameters(codeGenContext, irModule);
 
         dumpIRIfEnabled(codeGenContext, irModule, "BEFORE-AUTODIFF");
         enableIRValidationAtInsert();
@@ -484,7 +491,9 @@ Result linkAndOptimizeIR(
         break;
     }
 
-    checkForRecursiveTypes(irModule, sink);
+    if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
+        checkForRecursiveTypes(irModule, sink);
+
     if (sink->getErrorCount() != 0)
         return SLANG_FAIL;
 
@@ -509,7 +518,7 @@ Result linkAndOptimizeIR(
     // do unnecessary work to lower them.
     unpinWitnessTables(irModule);
 
-    simplifyIR(targetProgram, irModule, IRSimplificationOptions::getFast(), sink);
+    simplifyIR(targetProgram, irModule, fastIRSimplificationOptions, sink);
 
     if (!ArtifactDescUtil::isCpuLikeTarget(artifactDesc))
     {
@@ -538,7 +547,7 @@ Result linkAndOptimizeIR(
     // up downstream passes like type legalization, so we
     // will run a DCE pass to clean up after the specialization.
     //
-    simplifyIR(targetProgram, irModule, IRSimplificationOptions::getDefault(), sink);
+    simplifyIR(targetProgram, irModule, defaultIRSimplificationOptions, sink);
 
     validateIRModuleIfEnabled(codeGenContext, irModule);
 
@@ -643,7 +652,7 @@ Result linkAndOptimizeIR(
     // to see if we can clean up any temporaries created by legalization.
     // (e.g., things that used to be aggregated might now be split up,
     // so that we can work with the individual fields).
-    simplifyIR(targetProgram, irModule, IRSimplificationOptions::getFast(), sink);
+    simplifyIR(targetProgram, irModule, fastIRSimplificationOptions, sink);
 
 #if 0
     dumpIRIfEnabled(codeGenContext, irModule, "AFTER SSA");
@@ -945,7 +954,7 @@ Result linkAndOptimizeIR(
     {
         // As a fallback, if the above specialization steps failed to remove resource type parameters, we will
         // inline the functions in question to make sure we can produce valid GLSL.
-        performGLSLResourceReturnFunctionInlining(irModule);
+        performGLSLResourceReturnFunctionInlining(targetProgram, irModule);
     }
 #if 0
     dumpIRIfEnabled(codeGenContext, irModule, "AFTER DCE");
@@ -1005,8 +1014,9 @@ Result linkAndOptimizeIR(
     }
     eliminateMultiLevelBreak(irModule);
 
+    if (!fastIRSimplificationOptions.minimalOptimization)
     {
-        IRSimplificationOptions simplificationOptions = IRSimplificationOptions::getFast();
+        IRSimplificationOptions simplificationOptions = fastIRSimplificationOptions;
         simplificationOptions.cfgOptions.removeTrivialSingleIterationLoops = true;
         simplifyIR(targetProgram, irModule, simplificationOptions, sink);
     }
@@ -1085,11 +1095,15 @@ Result linkAndOptimizeIR(
         }
     }
 
-    replaceLocationIntrinsicsWithRaytracingObject(targetProgram, irModule, sink);
+    if (isKhronosTarget(targetRequest) && emitSpirvDirectly)
+    {
+        replaceLocationIntrinsicsWithRaytracingObject(targetProgram, irModule, sink);
+    }
+
     validateIRModuleIfEnabled(codeGenContext, irModule);
 
     // Run a final round of simplifications to clean up unused things after phi-elimination.
-    simplifyNonSSAIR(targetProgram, irModule, IRSimplificationOptions::getFast());
+    simplifyNonSSAIR(targetProgram, irModule, fastIRSimplificationOptions);
 
     // We include one final step to (optionally) dump the IR and validate
     // it after all of the optimization passes are complete. This should
@@ -1119,7 +1133,8 @@ Result linkAndOptimizeIR(
 
     outLinkedIR.metadata = metadata;
 
-    checkUnsupportedInst(codeGenContext->getTargetReq(), irModule, sink);
+    if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
+        checkUnsupportedInst(codeGenContext->getTargetReq(), irModule, sink);
 
     return sink->getErrorCount() == 0 ? SLANG_OK : SLANG_FAIL;
 }
diff --git a/source/slang/slang-ir-autodiff-fwd.cpp b/source/slang/slang-ir-autodiff-fwd.cpp
@@ -1655,7 +1655,7 @@ SlangResult ForwardDiffTranscriber::prepareFuncForForwardDiff(IRFunc* func)
     if (SLANG_SUCCEEDED(result))
     {
         disableIRValidationAtInsert();
-        simplifyFunc(autoDiffSharedContext->targetProgram, func, IRSimplificationOptions::getDefault());
+        simplifyFunc(autoDiffSharedContext->targetProgram, func, IRSimplificationOptions::getDefault(autoDiffSharedContext->targetProgram));
         enableIRValidationAtInsert();
     }
     return result;
diff --git a/source/slang/slang-ir-inline.cpp b/source/slang/slang-ir-inline.cpp
@@ -942,15 +942,15 @@ struct GLSLResourceReturnFunctionInliningPass : InliningPassBase
     }
 };
 
-void performGLSLResourceReturnFunctionInlining(IRModule* module)
+void performGLSLResourceReturnFunctionInlining(TargetProgram* targetProgram, IRModule* module)
 {
     GLSLResourceReturnFunctionInliningPass pass(module);
     bool changed = true;
 
     while (changed)
     {
         changed = pass.considerAllCallSites();
-        simplifyIR(nullptr, module, IRSimplificationOptions::getFast());
+        simplifyIR(nullptr, module, IRSimplificationOptions::getFast(targetProgram));
     }
 }
 
diff --git a/source/slang/slang-ir-inline.h b/source/slang/slang-ir-inline.h
@@ -9,6 +9,7 @@ namespace Slang
     struct IRCall;
     struct IRGlobalValueWithCode;
     class DiagnosticSink;
+    class TargetProgram;
 
         /// Any call to a function that takes or returns a string/RefType parameter is inlined
     Result performTypeInlining(IRModule* module, DiagnosticSink* sink);
@@ -29,7 +30,7 @@ namespace Slang
     bool performPreAutoDiffForceInlining(IRModule* module);
 
         /// Inline calls to functions that returns a resource/sampler via either return value or output parameter.
-    void performGLSLResourceReturnFunctionInlining(IRModule* module);
+    void performGLSLResourceReturnFunctionInlining(TargetProgram* targetProgram, IRModule* module);
 
         /// Inline simple intrinsic functions whose definition is a single asm block.
     void performIntrinsicFunctionInlining(IRModule* module);
diff --git a/source/slang/slang-ir-lower-generics.cpp b/source/slang/slang-ir-lower-generics.cpp
@@ -255,7 +255,7 @@ namespace Slang
         // real RTTI objects and witness tables.
         specializeRTTIObjects(&sharedContext, sink);
 
-        simplifyIR(sharedContext.targetProgram, module, IRSimplificationOptions::getFast());
+        simplifyIR(sharedContext.targetProgram, module, IRSimplificationOptions::getFast(sharedContext.targetProgram));
 
         lowerTuples(module, sink);
         if (sink->getErrorCount() != 0)
diff --git a/source/slang/slang-ir-simplify-cfg.cpp b/source/slang/slang-ir-simplify-cfg.cpp
@@ -900,6 +900,7 @@ static bool processFunc(IRGlobalValueWithCode* func, CFGSimplificationOptions op
                 branch->removeAndDeallocate();
                 assert(!successor->hasUses());
                 successor->removeAndDeallocate();
+
                 break;
             }
             for (auto successor : block->getSuccessors())
diff --git a/source/slang/slang-ir-specialize-function-call.cpp b/source/slang/slang-ir-specialize-function-call.cpp
@@ -891,7 +891,7 @@ struct FunctionParameterSpecializationContext
         //
         addCallsToWorkListRec(newFunc);
 
-        simplifyFunc(codeGenContext->getTargetProgram(), newFunc, IRSimplificationOptions::getFast());
+        simplifyFunc(codeGenContext->getTargetProgram(), newFunc, IRSimplificationOptions::getFast(codeGenContext->getTargetProgram()));
 
         return newFunc;
     }
diff --git a/source/slang/slang-ir-specialize-resources.cpp b/source/slang/slang-ir-specialize-resources.cpp
@@ -1189,7 +1189,8 @@ bool specializeResourceUsage(
             // and turned into SSA temporaries. Such optimization may enable
             // the following passes to "see" and specialize more cases.
             //
-            simplifyIR(codeGenContext->getTargetProgram(), irModule, IRSimplificationOptions::getFast());
+            simplifyIR(codeGenContext->getTargetProgram(), irModule,
+                IRSimplificationOptions::getFast(codeGenContext->getTargetProgram()));
             result |= changed;
         }
         if (unspecializableFuncs.getCount() == 0)
@@ -1209,7 +1210,8 @@ bool specializeResourceUsage(
                 inlineCall(call);
             });
         }
-        simplifyIR(codeGenContext->getTargetProgram(), irModule, IRSimplificationOptions::getFast());
+        simplifyIR(codeGenContext->getTargetProgram(), irModule,
+            IRSimplificationOptions::getFast(codeGenContext->getTargetProgram()));
     }
     return result;
 }
diff --git a/source/slang/slang-ir-specialize.cpp b/source/slang/slang-ir-specialize.cpp
@@ -1546,7 +1546,7 @@ struct SpecializationContext
         //
         addToWorkList(newFunc);
 
-        simplifyFunc(targetProgram, newFunc, IRSimplificationOptions::getFast());
+        simplifyFunc(targetProgram, newFunc, IRSimplificationOptions::getFast(targetProgram));
 
         return newFunc;
     }
@@ -2407,7 +2407,7 @@ IRInst* specializeGenericImpl(
                 {
                     if (auto func = as<IRFunc>(specializedVal))
                     {
-                        simplifyFunc(context->targetProgram, func, IRSimplificationOptions::getFast());
+                        simplifyFunc(context->targetProgram, func, IRSimplificationOptions::getFast(context->targetProgram));
                     }
                 }
 
diff --git a/source/slang/slang-ir-ssa-simplification.cpp b/source/slang/slang-ir-ssa-simplification.cpp
@@ -15,6 +15,27 @@
 
 namespace Slang
 {
+    IRSimplificationOptions IRSimplificationOptions::getDefault(TargetProgram* targetProgram)
+    {
+        IRSimplificationOptions result;
+        result.minimalOptimization = targetProgram->getOptionSet().shouldPerformMinimumOptimizations();
+        if (result.minimalOptimization)
+            result.cfgOptions = CFGSimplificationOptions::getFast();
+        else
+            result.cfgOptions = CFGSimplificationOptions::getDefault();
+        result.peepholeOptions = PeepholeOptimizationOptions();
+        return result;
+    }
+
+    IRSimplificationOptions IRSimplificationOptions::getFast(TargetProgram* targetProgram)
+    {
+        IRSimplificationOptions result;
+        result.minimalOptimization = targetProgram->getOptionSet().shouldPerformMinimumOptimizations();
+        result.cfgOptions = CFGSimplificationOptions::getFast();
+        result.peepholeOptions = PeepholeOptimizationOptions();
+        return result;
+    }
+
     // Run a combination of SSA, SCCP, SimplifyCFG, and DeadCodeElimination pass
     // until no more changes are possible.
     void simplifyIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options, DiagnosticSink* sink)
@@ -50,7 +71,8 @@ namespace Slang
                     funcChanged = false;
                     funcChanged |= applySparseConditionalConstantPropagation(func, sink);
                     funcChanged |= peepholeOptimize(target, func);
-                    funcChanged |= removeRedundancyInFunc(func);
+                    if (!options.minimalOptimization)
+                        funcChanged |= removeRedundancyInFunc(func);
                     funcChanged |= simplifyCFG(func, options.cfgOptions);
                     eliminateDeadCode(func);
                     funcChanged |= constructSSA(func);
@@ -78,7 +100,8 @@ namespace Slang
             changed = false;
             changed |= peepholeOptimize(target, module, options.peepholeOptions);
 
-            changed |= removeRedundancy(module);
+            if (!options.minimalOptimization)
+                changed |= removeRedundancy(module);
             changed |= simplifyCFG(module, options.cfgOptions);
 
             // Note: we disregard the `changed` state from dead code elimination pass since
@@ -103,7 +126,8 @@ namespace Slang
             changed = false;
             changed |= applySparseConditionalConstantPropagation(func, sink);
             changed |= peepholeOptimize(target, func);
-            changed |= removeRedundancyInFunc(func);
+            if (!options.minimalOptimization)
+                changed |= removeRedundancyInFunc(func);
             changed |= simplifyCFG(func, options.cfgOptions);
 
             // Note: we disregard the `changed` state from dead code elimination pass since
diff --git a/source/slang/slang-ir-ssa-simplification.h b/source/slang/slang-ir-ssa-simplification.h
diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp

Original file line number	Diff line number	Diff line change
`@@ -9125,8 +9125,10 @@ namespace Slang`
`9125`	`9125`	`break;`
`9126`	`9126`
`9127`	`9127`	`case DeclCheckState::CapabilityChecked:`
`9128`		`- if(!shared.getOptionSet().getBoolOption(CompilerOptionName::IgnoreCapabilities))`
	`9128`	`+ if (!shared.getOptionSet().getBoolOption(CompilerOptionName::IgnoreCapabilities))`
	`9129`	`+ {`
`9129`	`9130`	`SemanticsDeclCapabilityVisitor(shared).dispatch(decl);`
	`9131`	`+ }`
`9130`	`9132`	`break;`
`9131`	`9133`	`}`
`9132`	`9134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -361,6 +361,11 @@ namespace Slang`
`361`	`361`	`return getBoolOption(CompilerOptionName::Obfuscate);`
`362`	`362`	`}`
`363`	`363`
	`364`	`+ bool shouldPerformMinimumOptimizations()`
	`365`	`+ {`
	`366`	`+ return getBoolOption(CompilerOptionName::MinimumSlangOptimization);`
	`367`	`+ }`
	`368`	`+`
`364`	`369`	`FloatingPointMode getFloatingPointMode()`
`365`	`370`	`{`
`366`	`371`	`return getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode);`
Original file line number	Diff line number	Diff line change
`@@ -1655,7 +1655,7 @@ SlangResult ForwardDiffTranscriber::prepareFuncForForwardDiff(IRFunc* func)`
`1655`	`1655`	`if (SLANG_SUCCEEDED(result))`
`1656`	`1656`	`{`
`1657`	`1657`	`disableIRValidationAtInsert();`
`1658`		`- simplifyFunc(autoDiffSharedContext->targetProgram, func, IRSimplificationOptions::getDefault());`
	`1658`	`+ simplifyFunc(autoDiffSharedContext->targetProgram, func, IRSimplificationOptions::getDefault(autoDiffSharedContext->targetProgram));`
`1659`	`1659`	`enableIRValidationAtInsert();`
`1660`	`1660`	`}`
`1661`	`1661`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -942,15 +942,15 @@ struct GLSLResourceReturnFunctionInliningPass : InliningPassBase`
`942`	`942`	`}`
`943`	`943`	`};`
`944`	`944`
`945`		`-void performGLSLResourceReturnFunctionInlining(IRModule* module)`
	`945`	`+void performGLSLResourceReturnFunctionInlining(TargetProgram* targetProgram, IRModule* module)`
`946`	`946`	`{`
`947`	`947`	`GLSLResourceReturnFunctionInliningPass pass(module);`
`948`	`948`	`bool changed = true;`
`949`	`949`
`950`	`950`	`while (changed)`
`951`	`951`	`{`
`952`	`952`	`changed = pass.considerAllCallSites();`
`953`		`- simplifyIR(nullptr, module, IRSimplificationOptions::getFast());`
	`953`	`+ simplifyIR(nullptr, module, IRSimplificationOptions::getFast(targetProgram));`
`954`	`954`	`}`
`955`	`955`	`}`
`956`	`956`