Add pass which removes unnecessary operations on local memory

Change-Id: Ib546b804ce389af29d75c14719077cddbc4142f3

Author: mnaczk

IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp

@@ -1376,6 +1376,7 @@ void OptimizeIR(CodeGenContext* pContext)
             }
             mpm.add(llvm::createCFGSimplificationPass());
             mpm.add(llvm::createEarlyCSEPass());
+
             if(pContext->m_instrTypes.hasNonPrimitiveAlloca)
             {
                 mpm.add(createSROAPass());
@@ -1461,6 +1462,9 @@ void OptimizeIR(CodeGenContext* pContext)
                 mpm.add(createSROAPass());
             }
         }
+#if LLVM_VERSION_MAJOR >= 7
+        mpm.add(new TrivialLocalMemoryOpsElimination());
+#endif
         mpm.add(createGenSimplificationPass());
 
         if (pContext->m_instrTypes.hasLoadStore)

IGC/Compiler/CustomSafeOptPass.cpp

@@ -924,6 +924,146 @@ void CustomSafeOptPass::visitExtractElementInst(ExtractElementInst &I)
     }
 }
 
+#if LLVM_VERSION_MAJOR >= 7 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// This pass removes dead local memory loads and stores. If we remove all such loads and stores, we also 
+// remove all local memory fences together with barriers that follow.
+//
+IGC_INITIALIZE_PASS_BEGIN(TrivialLocalMemoryOpsElimination, "TrivialLocalMemoryOpsElimination", "TrivialLocalMemoryOpsElimination", false, false)
+IGC_INITIALIZE_PASS_END(TrivialLocalMemoryOpsElimination, "TrivialLocalMemoryOpsElimination", "TrivialLocalMemoryOpsElimination", false, false)
+
+char TrivialLocalMemoryOpsElimination::ID = 0;
+
+TrivialLocalMemoryOpsElimination::TrivialLocalMemoryOpsElimination() : FunctionPass(ID)
+{
+    initializeTrivialLocalMemoryOpsEliminationPass(*PassRegistry::getPassRegistry());
+}
+
+
+
+bool TrivialLocalMemoryOpsElimination::runOnFunction(Function &F)
+{
+    bool change = false;
+    visit(F);
+    if (!abortPass && (m_LocalLoadsToRemove.empty() || m_LocalStoresToRemove.empty()))
+    {
+        for (StoreInst *Inst : m_LocalStoresToRemove)
+        {
+            Inst->eraseFromParent();
+            change = true;
+        }
+
+        for (LoadInst *Inst : m_LocalLoadsToRemove)
+        {
+            if (Inst->use_empty())
+            {
+                Inst->eraseFromParent();
+                change = true;
+            }
+        }
+
+        for (CallInst *Inst : m_LocalFencesBariersToRemove)
+        {
+            Inst->eraseFromParent();
+            change = true;
+        }
+    }
+
+    return change;
+}
+
+/*
+OCL instruction barrier(CLK_LOCAL_MEM_FENCE); is translate to two instructions
+call void @llvm.genx.GenISA.memoryfence(i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true)
+call void @llvm.genx.GenISA.threadgroupbarrier()
+
+if we remove call void @llvm.genx.GenISA.memoryfence(i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true)
+we must remove next instruction if it is call void @llvm.genx.GenISA.threadgroupbarrier()
+*/
+void TrivialLocalMemoryOpsElimination::findNextThreadGroupBarrierInst(Instruction &I)
+{
+    auto nextInst = I.getNextNonDebugInstruction();
+    if (isa<GenIntrinsicInst>(nextInst))
+    {
+        GenIntrinsicInst *II = dyn_cast<GenIntrinsicInst>(nextInst);
+        if (II->getIntrinsicID() == GenISAIntrinsic::GenISA_threadgroupbarrier)
+        {
+            m_LocalFencesBariersToRemove.push_back(dyn_cast<CallInst>(nextInst));
+        }
+    }
+}
+
+void TrivialLocalMemoryOpsElimination::visitLoadInst(LoadInst &I)
+{
+    if (I.getPointerAddressSpace() == ADDRESS_SPACE_LOCAL)
+    {
+        m_LocalLoadsToRemove.push_back(&I);
+    }
+}
+
+void TrivialLocalMemoryOpsElimination::visitStoreInst(StoreInst &I)
+{
+    if (I.getPointerAddressSpace() == ADDRESS_SPACE_LOCAL)
+    {
+        m_LocalStoresToRemove.push_back(&I);
+    }
+}
+
+bool TrivialLocalMemoryOpsElimination::isLocalBarrier(CallInst &I)
+{
+    //check arguments in call void @llvm.genx.GenISA.memoryfence(i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true) if match to
+    // (i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true) it is local barrier
+    std::vector<bool> argumentsOfMemoryBarrier;
+
+    for (auto arg = I.arg_begin(); arg != I.arg_end(); ++arg)
+    {
+        ConstantInt* ci = dyn_cast<ConstantInt>(arg);
+        argumentsOfMemoryBarrier.push_back(ci->getValue().getBoolValue());
+    }
+
+    return argumentsOfMemoryBarrier == m_argumentsOfLocalMemoryBarrier;
+}
+
+// If any call instruction use pointer to local memory abort pass execution
+void TrivialLocalMemoryOpsElimination::anyCallInstUseLocalMemory(CallInst &I)
+{
+    Function* fn = I.getCalledFunction();
+
+    if (fn != NULL)
+    {
+        for (auto arg = fn->arg_begin(); arg != fn->arg_end(); ++arg)
+        {
+            if (arg->getType()->isPointerTy())
+            {
+                if (arg->getType()->getPointerAddressSpace() == ADDRESS_SPACE_LOCAL || arg->getType()->getPointerAddressSpace() == ADDRESS_SPACE_GENERIC) abortPass = true;
+            }
+        }
+    }
+}
+
+void TrivialLocalMemoryOpsElimination::visitCallInst(CallInst &I)
+{
+    // detect only: llvm.genx.GenISA.memoryfence(i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true)
+    // (note: the first and last arguments are true)
+    // and add them with immediately following barriers to m_LocalFencesBariersToRemove  
+    anyCallInstUseLocalMemory(I);
+
+    if (isa<GenIntrinsicInst>(I)) 
+    {
+        GenIntrinsicInst *II = dyn_cast<GenIntrinsicInst>(&I);
+        if (II->getIntrinsicID() == GenISAIntrinsic::GenISA_memoryfence)
+        {
+            if (isLocalBarrier(I))
+            {
+                m_LocalFencesBariersToRemove.push_back(&I);
+                findNextThreadGroupBarrierInst(I);
+            }
+        }    
+    }
+  
+}
+#endif
+
 // Register pass to igc-opt
 #define PASS_FLAG2 "igc-gen-specific-pattern"
 #define PASS_DESCRIPTION2 "LastPatternMatch Pass"
@@ -3471,6 +3611,8 @@ bool FlattenSmallSwitch::runOnFunction(Function &F)
 IGC_INITIALIZE_PASS_BEGIN(FlattenSmallSwitch, "flattenSmallSwitch", "flattenSmallSwitch", false, false)
 IGC_INITIALIZE_PASS_END(FlattenSmallSwitch, "flattenSmallSwitch", "flattenSmallSwitch", false, false)
 
+
+
 ////////////////////////////////////////////////////////////////////////
 // LogicalAndToBranch trying to find logical AND like below:
 //    res = simpleCond0 && complexCond1

IGC/Compiler/CustomSafeOptPass.hpp

@@ -31,8 +31,10 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <llvm/IR/InstVisitor.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
 #include <llvm/Analysis/LoopPass.h>
+#include <llvm/IR/Instructions.h>
 #include "common/LLVMWarningsPop.hpp"
 
+
 namespace llvm
 {
     // Forward declare:
@@ -97,6 +99,40 @@ namespace IGC
     private:
         bool psHasSideEffect;
     };
+#if LLVM_VERSION_MAJOR >= 7 
+    class TrivialLocalMemoryOpsElimination : public llvm::FunctionPass, public llvm::InstVisitor<TrivialLocalMemoryOpsElimination>
+    {
+    public:
+        static char ID;
+
+        TrivialLocalMemoryOpsElimination();
+
+        ~TrivialLocalMemoryOpsElimination() {}
+
+        virtual bool runOnFunction(llvm::Function &F) override;
+
+        virtual llvm::StringRef getPassName() const override
+        {
+            return "TrivialLocalMemoryOpsElimination";
+        }
+
+        void visitLoadInst(llvm::LoadInst &I);
+        void visitStoreInst(llvm::StoreInst &I);
+        void visitCallInst(llvm::CallInst &I);
+        bool isLocalBarrier(llvm::CallInst &I);
+        void findNextThreadGroupBarrierInst(llvm::Instruction &I);
+        void anyCallInstUseLocalMemory(llvm::CallInst &I);
+
+    private:
+        llvm::SmallVector<llvm::LoadInst*, 16> m_LocalLoadsToRemove;
+        llvm::SmallVector<llvm::StoreInst*, 16> m_LocalStoresToRemove;
+        llvm::SmallVector<llvm::CallInst*, 16> m_LocalFencesBariersToRemove;
+
+        bool abortPass = false;
+        const std::vector<bool> m_argumentsOfLocalMemoryBarrier{ true, false, false, false, false, false, true };
+    };
+
+#endif
 
     class GenSpecificPattern : public llvm::FunctionPass, public llvm::InstVisitor<GenSpecificPattern>
     {
@@ -180,5 +216,7 @@ namespace IGC
     llvm::FunctionPass *createBlendToDiscardPass();
     llvm::FunctionPass *createMarkReadOnlyLoadPass();
     llvm::FunctionPass *createLogicalAndToBranchPass();
+ 
+
 
 } // namespace IGC

IGC/Compiler/InitializePasses.h

@@ -132,6 +132,9 @@ void initializeRegisterEstimatorPass(llvm::PassRegistry&);
 void initializeVariableReuseAnalysisPass(llvm::PassRegistry&);
 void initializeTransformBlocksPass(llvm::PassRegistry&);
 void initializeTranslationTablePass(llvm::PassRegistry&);
+#if LLVM_VERSION_MAJOR >= 7
+void initializeTrivialLocalMemoryOpsEliminationPass(llvm::PassRegistry&);
+#endif
 void initializeSLMConstPropPass(llvm::PassRegistry&);
 void initializeBlendToDiscardPass(llvm::PassRegistry&);
 void initializeCheckInstrTypesPass(llvm::PassRegistry&);