rewrite get_local_size() on -cl-uniform-work-group-size to get_enqueued_local_size(). This, in combination with reqd_work_group_size, allows for compile time known values that can be further optimized (e.g., mul -> shl

Change-Id: I70f34ae607fb229bbef6ef624d1931337d97c372

Author: scottp101

IGC/AdaptorOCL/UnifyIROCL.cpp

@@ -100,6 +100,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "Compiler/Legalizer/TypeLegalizerPass.h"
 #include "Compiler/Optimizer/OpenCLPasses/ClampLoopUnroll/ClampLoopUnroll.hpp"
 #include "Compiler/Optimizer/OpenCLPasses/Image3dToImage2darray/Image3dToImage2darray.hpp"
+#include "Compiler/Optimizer/OpenCLPasses/RewriteLocalSize/RewriteLocalSize.hpp"
 #include "Compiler/MetaDataApi/PurgeMetaDataUtils.hpp"
 #include "Compiler/MetaDataUtilsWrapper.h"
 #include "Compiler/SPIRMetaDataTranslation.h"
@@ -216,25 +217,32 @@ static void CommonOCLBasedPasses(
     //extracting OCL version major before SPIRMetadataTranslation pass deletes its metadata node
     const SPIRMD::SpirMetaDataUtils spirMDUtils(&(*pContext->getModule()));
     int OCLMajor = getOCLMajorVersion(spirMDUtils);
+
+    CompOptions &CompilerOpts = pContext->getModuleMetaData()->compOpt;
 
     // check OpenCL build options
-    assert((pContext->type == ShaderType::OPENCL_SHADER) && "Trying to use OCL common passes on non-OCL context");
-    bool shouldForceCR = static_cast<OpenCLProgramContext*>(pContext)->m_Options.CorrectlyRoundedSqrt;
+    bool shouldForceCR = pContext->m_Options.CorrectlyRoundedSqrt;
+
+    CompilerOpts.replaceGlobalOffsetsByZero =
+        pContext->m_InternalOptions.replaceGlobalOffsetsByZero;
 
-    pContext->getModuleMetaData()->compOpt.replaceGlobalOffsetsByZero =
-        static_cast<OpenCLProgramContext*>(pContext)->m_InternalOptions.replaceGlobalOffsetsByZero;
+    CompilerOpts.SubgroupIndependentForwardProgressRequired =
+        (pContext->m_Options.NoSubgroupIFP == false);
 
-    pContext->getModuleMetaData()->compOpt.SubgroupIndependentForwardProgressRequired =
-        (static_cast<OpenCLProgramContext*>(pContext)->m_Options.NoSubgroupIFP == false);
+    if (OCLMajor >= 2)
+    {
+        CompilerOpts.UniformWGS =
+            pContext->m_Options.UniformWGS;
+    }
 
-    pContext->getModuleMetaData()->compOpt.GreaterThan2GBBufferRequired =
-        !static_cast<OpenCLProgramContext*>(pContext)->m_InternalOptions.Use32BitPtrArith;
+    CompilerOpts.GreaterThan2GBBufferRequired =
+        !pContext->m_InternalOptions.Use32BitPtrArith;
 
-    pContext->getModuleMetaData()->compOpt.GreaterThan4GBBufferRequired =
-        static_cast<OpenCLProgramContext*>(pContext)->m_InternalOptions.IntelGreaterThan4GBBufferRequired;
+    CompilerOpts.GreaterThan4GBBufferRequired =
+        pContext->m_InternalOptions.IntelGreaterThan4GBBufferRequired;
 
-    pContext->getModuleMetaData()->compOpt.HasBufferOffsetArg =
-        static_cast<OpenCLProgramContext*>(pContext)->m_InternalOptions.IntelHasBufferOffsetArg;
+    CompilerOpts.HasBufferOffsetArg =
+        pContext->m_InternalOptions.IntelHasBufferOffsetArg;
 
     // right now we don't support any standard function in the code gen
     // maybe we want to support some at some point to take advantage of LLVM optimizations
@@ -277,7 +285,7 @@ static void CommonOCLBasedPasses(
         mpm.add(createBIFTransformsPass());
     }
 
-    if(static_cast<OpenCLProgramContext*>(pContext)->m_InternalOptions.KernelDebugEnable)
+    if(pContext->m_InternalOptions.KernelDebugEnable)
     {
         IF_DEBUG_INFO(mpm.add(new ImplicitGlobalId());)
     }
@@ -297,17 +305,14 @@ static void CommonOCLBasedPasses(
     // OCL has built-ins so it always need to run inlining
     {
         mpm.add(createProcessFuncAttributesPass());
-        if((pContext->m_instrTypes.hasSubroutines) || (pContext->type == ShaderType::OPENCL_SHADER))
+        if (IGC_GET_FLAG_VALUE(FunctionControl) != FLAG_FCALL_FORCE_INLINE)
         {
-            if (IGC_GET_FLAG_VALUE(FunctionControl) != FLAG_FCALL_FORCE_INLINE)
-            {
-                int Threshold = IGC_GET_FLAG_VALUE(OCLInlineThreshold);
-                mpm.add(createFunctionInliningPass(Threshold));
-            }
-            else
-            {
-                mpm.add(createAlwaysInlinerLegacyPass());
-            }
+            int Threshold = IGC_GET_FLAG_VALUE(OCLInlineThreshold);
+            mpm.add(createFunctionInliningPass(Threshold));
+        }
+        else
+        {
+            mpm.add(createAlwaysInlinerLegacyPass());
         }
         // The inliner sometimes fails to delete unused functions, this cleans up the remaining mess.
         mpm.add(createGlobalDCEPass());
@@ -342,6 +347,8 @@ static void CommonOCLBasedPasses(
         mpm.add(new BreakConstantExpr());
     }
 
+    if (CompilerOpts.UniformWGS)
+        mpm.add(new RewriteLocalSize());
 
     mpm.add(CreateFoldKnownWorkGroupSizes());
 
@@ -430,7 +437,7 @@ static void CommonOCLBasedPasses(
     mpm.add(new SetFastMathFlags());
     mpm.add(new FixResourcePtr());
 
-    bool isOptDisabled = pContext->getModuleMetaData()->compOpt.OptDisable;
+    bool isOptDisabled = CompilerOpts.OptDisable;
     if(isOptDisabled)
     {
         // Run additional predefined constant resolving when optimization is

IGC/Compiler/CISACodeGen/FoldKnownWorkGroupSizes.cpp

@@ -24,6 +24,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ======================= end_copyright_notice ==================================*/
 
+#include "Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncsAnalysis.hpp"
 #include "FoldKnownWorkGroupSizes.h"
 #include "../IGCPassSupport.h"
 #include "../CodeGenPublic.h"
@@ -82,16 +83,19 @@ void FoldKnownWorkGroupSizes::visitCallInst(llvm::CallInst &I)
     CodeGenContext* ctx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
 
 
-    if (funcName.equals("__builtin_IB_get_global_offset") && ctx->getModuleMetaData()->compOpt.replaceGlobalOffsetsByZero)
+    if (funcName.equals(WIFuncsAnalysis::GET_GLOBAL_OFFSET) &&
+        ctx->getModuleMetaData()->compOpt.replaceGlobalOffsetsByZero)
     {
         if (calledFunction->getReturnType() == Type::getInt32Ty(module->getContext()))
         {
             ConstantInt* IntZero = ConstantInt::get(Type::getInt32Ty(module->getContext()), 0);
             I.replaceAllUsesWith(IntZero);
+            // TODO: erase when patch token is not required
+            //I.eraseFromParent();
             m_changed = true;
         }
     }
-    else if (funcName.equals("__builtin_IB_get_enqueued_local_size"))
+    else if (funcName.equals(WIFuncsAnalysis::GET_ENQUEUED_LOCAL_SIZE))
     {
         auto itr = ctx->getMetaDataUtils()->findFunctionsInfoItem(I.getFunction());
 
@@ -119,6 +123,8 @@ void FoldKnownWorkGroupSizes::visitCallInst(llvm::CallInst &I)
         auto *EE = IRB.CreateExtractElement(CV, Dim, "enqueuedLocalSize");
 
         I.replaceAllUsesWith(EE);
+        // TODO: erase when patch token is not required
+        //I.eraseFromParent();
         m_changed = true;
     }
 }

IGC/Compiler/CodeGenPublic.h

@@ -975,7 +975,8 @@ namespace IGC
         public:
             Options(const TC::STB_TranslateInputArgs* pInputArgs) :
                 CorrectlyRoundedSqrt(false),
-                NoSubgroupIFP(false)
+                NoSubgroupIFP(false),
+                UniformWGS(false)
             {
                 if (pInputArgs == nullptr)
                     return;
@@ -994,10 +995,18 @@ namespace IGC
                     NoSubgroupIFP = true;
                 }
 
+                if (strstr(options, "-cl-uniform-work-group-size"))
+                {
+                    // Note that this is only available for -cl-std >= 2.0.
+                    // This will be checked before we place this into the
+                    // the module metadata.
+                    UniformWGS = true;
+                }
             }
 
             bool CorrectlyRoundedSqrt;
             bool NoSubgroupIFP;
+            bool UniformWGS;
         };
 
         // output: shader information

IGC/Compiler/Optimizer/OpenCLPasses/CMakeLists.txt

@@ -27,6 +27,7 @@ add_subdirectory(WGFuncs)
 add_subdirectory(WIFuncs)
 add_subdirectory(ClampLoopUnroll)
 add_subdirectory(Image3dToImage2darray)
+add_subdirectory(RewriteLocalSize)
 
 
 #
@@ -68,6 +69,7 @@ set(IGC_BUILD__SRC__Optimizer_OpenCLPasses_All
     ${IGC_BUILD__SRC__OpenCLPasses_WIFuncs}
     ${IGC_BUILD__SRC__OpenCLPasses_ClampLoopUnroll}
     ${IGC_BUILD__SRC__OpenCLPasses_Image3dToImage2darray}
+    ${IGC_BUILD__SRC__OpenCLPasses_RewriteLocalSize}
   )
 
 
@@ -112,6 +114,7 @@ set(IGC_BUILD__HDR__Optimizer_OpenCLPasses_All
     ${IGC_BUILD__HDR__OpenCLPasses_WIFuncs}
     ${IGC_BUILD__HDR__OpenCLPasses_ClampLoopUnroll}
     ${IGC_BUILD__HDR__OpenCLPasses_Image3dToImage2darray}
+    ${IGC_BUILD__HDR__OpenCLPasses_RewriteLocalSize}
   )
 
 
@@ -150,6 +153,7 @@ set(IGC_BUILD_Compiler_OpenCLPasses_Groups
     Compiler__OpenCLPasses_WIFuncs
     Compiler__OpenCLPasses_ClampLoopUnroll
     Compiler__OpenCLPasses_Image3dToImage2darray
+    Compiler__OpenCLPasses_RewriteLocalSize
   )
 
 

IGC/Compiler/Optimizer/OpenCLPasses/RewriteLocalSize/CMakeLists.txt

@@ -0,0 +1,21 @@
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+
+
+set(IGC_BUILD__SRC__RewriteLocalSize
+    "${CMAKE_CURRENT_SOURCE_DIR}/RewriteLocalSize.cpp"
+  )
+set(IGC_BUILD__SRC__OpenCLPasses_RewriteLocalSize ${IGC_BUILD__SRC__RewriteLocalSize} PARENT_SCOPE)
+
+set(IGC_BUILD__HDR__RewriteLocalSize
+    "${CMAKE_CURRENT_SOURCE_DIR}/RewriteLocalSize.hpp"
+  )
+set(IGC_BUILD__HDR__OpenCLPasses_RewriteLocalSize ${IGC_BUILD__HDR__RewriteLocalSize} PARENT_SCOPE)
+
+
+igc_sg_register(
+    Compiler__OpenCLPasses_RewriteLocalSize
+    "RewriteLocalSize"
+    FILES
+      ${IGC_BUILD__SRC__RewriteLocalSize}
+      ${IGC_BUILD__HDR__RewriteLocalSize}
+  )

IGC/Compiler/Optimizer/OpenCLPasses/RewriteLocalSize/RewriteLocalSize.cpp

@@ -0,0 +1,81 @@
+/*===================== begin_copyright_notice ==================================
+
+Copyright (c) 2017 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+======================= end_copyright_notice ==================================*/
+//
+// As per the OCL 2.0 spec for get_enqueued_local_size:
+//
+// "Returns the same value as that returned by get_local_size(dimindx) if
+//  the kernel is executed
+//  with a uniform work-group size."
+//
+// This pass is only invoked when -cl-uniform-work-group-size is present.
+// In that case, get_local_size(x) == get_enqueued_local_size(x).
+//
+// So we will rewrite all of the get_local_size(x) so that we only have
+// get_enqueued_local_size(x).  Those calls may further be folded for kernels
+// that utilize __attribute__((reqd_work_group_size(X,Y,Z))).
+//
+
+#include "Compiler/Optimizer/OpenCLPasses/RewriteLocalSize/RewriteLocalSize.hpp"
+#include "Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncsAnalysis.hpp"
+#include "Compiler/IGCPassSupport.h"
+
+#include "common/LLVMWarningsPush.hpp"
+#include <llvmWrapper/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include "common/LLVMWarningsPop.hpp"
+
+using namespace llvm;
+using namespace IGC;
+
+// Register pass to igc-opt
+#define PASS_FLAG "igc-rewrite-local-size"
+#define PASS_DESCRIPTION "converts get_local_size() to get_enqueued_local_size()"
+#define PASS_CFG_ONLY false
+#define PASS_ANALYSIS false
+IGC_INITIALIZE_PASS_BEGIN(RewriteLocalSize, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
+IGC_INITIALIZE_PASS_END(RewriteLocalSize, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
+
+char RewriteLocalSize::ID = 0;
+
+RewriteLocalSize::RewriteLocalSize() : ModulePass(ID)
+{
+    initializeRewriteLocalSizePass(*PassRegistry::getPassRegistry());
+}
+
+bool RewriteLocalSize::runOnModule(Module &M)
+{
+    Function *LS = M.getFunction(WIFuncsAnalysis::GET_LOCAL_SIZE);
+    if (!LS)
+        return false;
+
+    Function *ELS = M.getFunction(WIFuncsAnalysis::GET_ENQUEUED_LOCAL_SIZE);
+    if (!ELS)
+        LS->setName(WIFuncsAnalysis::GET_ENQUEUED_LOCAL_SIZE);
+    else
+        LS->replaceAllUsesWith(ELS);
+
+    return true;
+}

IGC/Compiler/Optimizer/OpenCLPasses/RewriteLocalSize/RewriteLocalSize.hpp

@@ -0,0 +1,61 @@
+/*===================== begin_copyright_notice ==================================
+
+Copyright (c) 2017 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+======================= end_copyright_notice ==================================*/
+#pragma once
+
+#include "common/LLVMWarningsPush.hpp"
+#include <llvm/Pass.h>
+#include "common/LLVMWarningsPop.hpp"
+
+namespace IGC
+{
+    class RewriteLocalSize : public llvm::ModulePass
+    {
+    public:
+        // Pass identification, replacement for typeid
+        static char ID;
+
+        /// @brief  Constructor
+        RewriteLocalSize();
+
+        /// @brief  Destructor
+        ~RewriteLocalSize() {}
+
+        /// @brief  Provides name of pass
+        llvm::StringRef getPassName() const override
+        {
+            return "RewriteLocalSize";
+        }
+
+        void getAnalysisUsage(llvm::AnalysisUsage &AU) const override
+        {
+            AU.setPreservesCFG();
+        }
+
+        bool runOnModule(llvm::Module &M) override;
+    };
+
+} // namespace IGC
+

IGC/common/MDFrameWork.h

@@ -198,6 +198,7 @@ namespace IGC
         bool replaceGlobalOffsetsByZero                 = false;
         unsigned forcePixelShaderSIMDMode               = 0;
         bool pixelShaderDoNotAbortOnSpill               = false;
+        bool UniformWGS                                 = false;
     };
 
     struct ComputeShaderInfo