Add pass which removes unnecessary operations on local memory

Change-Id: I2e368633230ead722741552f4aa72212ad4c6a67

Author: mnaczk

IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp

@@ -1473,6 +1473,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

@@ -1028,6 +1028,148 @@ 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;
+        }
+    }
+    m_LocalStoresToRemove.clear();
+    m_LocalLoadsToRemove.clear();
+    m_LocalFencesBariersToRemove.clear();
+
+
+    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"

IGC/Compiler/CustomSafeOptPass.hpp

@@ -31,6 +31,7 @@ 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
@@ -99,6 +100,40 @@ namespace IGC
         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>
     {
     public:

IGC/Compiler/InitializePasses.h

@@ -133,6 +133,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&);