FindInterestingConstants pass weights calculation changes

Change-Id: If946742c1299e2aedf28ffc79dca5ae7684cfc56

Author: srividyakarumuri

IGC/Compiler/CodeGenPublic.h

@@ -276,6 +276,7 @@ namespace IGC
         uint32_t loopCount = 0;
         uint32_t samplerCount = 0;
         uint32_t extendedMath = 0;
+        uint32_t selectCount = 0;
         uint32_t weight = 0;
     };
 

IGC/Compiler/FindInterestingConstants.cpp

@@ -39,7 +39,6 @@ using namespace IGC;
 #define PASS_DESCRIPTION "Find interesting constants"
 #define PASS_CFG_ONLY false
 #define PASS_ANALYSIS false
-#define UpdateInstCount(INST) IsExtendedMathInstruction(INST)? m_extendedMath++ : m_instCount++
 IGC_INITIALIZE_PASS_BEGIN(FindInterestingConstants, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
 IGC_INITIALIZE_PASS_END(FindInterestingConstants, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
 
@@ -52,6 +51,37 @@ FindInterestingConstants::FindInterestingConstants() : FunctionPass(ID)
     initializeFindInterestingConstantsPass(*PassRegistry::getPassRegistry());
 }
 
+void FindInterestingConstants::UpdateInstCount(Instruction* inst)
+{
+    if (IsExtendedMathInstruction(inst))
+    {
+        m_extendedMath++;
+    }
+    else if (SelectInst * selInst = dyn_cast<SelectInst>(inst))
+    {
+        if (dyn_cast<Constant>(selInst->getOperand(1)) && dyn_cast<Constant>(selInst->getOperand(2)))
+            m_instCount += 5;
+        else
+            m_selectCount++;
+    }
+    else
+        m_instCount++;
+}
+
+
+bool FindInterestingConstants::isReverseOpInstPair(llvm::Intrinsic::ID intr1, llvm::Intrinsic::ID intr2)
+{
+    std::map<llvm::Intrinsic::ID, llvm::Intrinsic::ID> reverseOpInstPair;
+    reverseOpInstPair[llvm::Intrinsic::exp] = llvm::Intrinsic::log;
+    reverseOpInstPair[llvm::Intrinsic::log] = llvm::Intrinsic::exp;
+    reverseOpInstPair[llvm::Intrinsic::exp2] = llvm::Intrinsic::log2;
+    reverseOpInstPair[llvm::Intrinsic::log2] = llvm::Intrinsic::exp2;
+
+    if ((reverseOpInstPair.find(intr1) != reverseOpInstPair.end()) && (reverseOpInstPair[intr1] == intr2))
+        return true;
+    return false;
+}
+
 bool FindInterestingConstants::FoldsToConst(Instruction* inst, Instruction* use, bool& propagate)
 {
     propagate = false;
@@ -178,7 +208,7 @@ bool FindInterestingConstants::allUsersVisitedForFolding(Instruction* inst, Inst
             //      as such instructions are currently added to visitedForFolding to avoid double counting in stats
             llvm::GenIntrinsicInst* pIntr = llvm::dyn_cast<llvm::GenIntrinsicInst>(anotherUse);
             SelectInst* selInst = dyn_cast<SelectInst>(anotherUse);
-            if (pIntr || selInst)
+            if ((pIntr && !IsMathIntrinsic(GetOpCode(anotherUseInst))) || selInst)
             {
                 return false;
             }
@@ -203,7 +233,7 @@ void FindInterestingConstants::CheckIfSampleBecomesDeadCode(Instruction* inst, I
             {
                 if (allUsersVisitedForFolding(inst, use))
                 {
-                    m_instCount++;
+                    m_instCount += IGC_GET_FLAG_VALUE(WeightSamplerScalarResult);
                     if (allUsersVisitedForFolding(pIntr, inst))
                     {
                         m_samplerCount++;
@@ -282,19 +312,53 @@ void FindInterestingConstants::FoldsToZeroPropagate(llvm::Instruction* I)
 
 bool FindInterestingConstants::FoldsToSource(llvm::Instruction* inst, llvm::Instruction* use)
 {
+    bool foldsToSource = false;
+    llvm::Value* binOperand = nullptr;
+
     if (BinaryOperator * binInst = dyn_cast<BinaryOperator>(use))
     {
         if (binInst->getOpcode() == Instruction::FMul)
         {
-            return true;
+            if (binInst->getOperand(0) == inst)
+            {
+                binOperand = binInst->getOperand(1);
+            }
+            else
+            {
+                binOperand = binInst->getOperand(0);
+            }
+            foldsToSource = true;
         }
         else if (binInst->getOpcode() == Instruction::FDiv &&
             inst == binInst->getOperand(1))
         {
-            return true;
+            binOperand = binInst->getOperand(0);
+            foldsToSource = true;
         }
     }
-    return false;
+
+    // Check for cases where folds to source triggers optimizations like showing up instruction sequence with exp-log/log-exp
+    if (foldsToSource)
+    {
+        // Figure out if binOperand is part of reverseOpInstPair (eg: log-exp/exp-log), update extended math count accordingly
+        if (llvm::IntrinsicInst * intr = dyn_cast<IntrinsicInst>(binOperand))
+        {
+            for (auto UI = use->user_begin(), UE = use->user_end(); UI != UE; ++UI)
+            {
+                if (llvm::IntrinsicInst * useIntr = dyn_cast<IntrinsicInst>(*UI))
+                {
+                    if (isReverseOpInstPair(intr->getIntrinsicID(), useIntr->getIntrinsicID()))
+                    {
+                        // Increment extended math count
+                        m_extendedMath += 2;
+                        visitedForFolding.insert(intr);
+                        visitedForFolding.insert(useIntr);
+                    }
+                }
+            }
+        }
+    }
+    return foldsToSource;
 }
 
 void FindInterestingConstants::FoldsToSourcePropagate(llvm::Instruction* I)
@@ -430,6 +494,7 @@ void FindInterestingConstants::addInterestingConstant(llvm::Type* loadTy, unsign
     interestingConst.branchCount = stats.branchCount;
     interestingConst.loopCount = stats.loopCount;
     interestingConst.samplerCount = stats.samplerCount;
+    interestingConst.selectCount = stats.selectCount;
     interestingConst.extendedMath = stats.extendedMath;
     interestingConst.weight = stats.weight;
     // For constant buffer accesses of size <= 32bit.
@@ -502,6 +567,7 @@ void FindInterestingConstants::ResetStatCounters()
     m_constFoldBranch = 0;
     m_constFoldLoopBranch = 0;
     m_samplerCount = 0;
+    m_selectCount = 0;
     m_extendedMath = 0;
     m_branchsize = 0;
     m_loopSize = 0;
@@ -552,7 +618,7 @@ void FindInterestingConstants::visitLoadInst(llvm::LoadInst& I)
             stats.extendedMath = m_extendedMath;
             stats.weight = (m_instCount * IGC_GET_FLAG_VALUE(WeightOtherInstruction)) + std::max(m_constFoldBranch * IGC_GET_FLAG_VALUE(BaseWeightBranch), m_branchsize * IGC_GET_FLAG_VALUE(WeightBranch)) +
                 std::max(m_constFoldLoopBranch * IGC_GET_FLAG_VALUE(BaseWeightLoop), m_loopSize * IGC_GET_FLAG_VALUE(WeightLoop)) + (m_samplerCount * IGC_GET_FLAG_VALUE(WeightSampler)) +
-                m_extendedMath *IGC_GET_FLAG_VALUE(WeightExtendedMath);
+                (m_extendedMath * IGC_GET_FLAG_VALUE(WeightExtendedMath)) + (m_selectCount * IGC_GET_FLAG_VALUE(WeightSelect));
             constValue = 0;
             // Get the ConstantAddress from LoadInst and log it in interesting constants
             addInterestingConstant(I.getType(), bufIdOrGRFOffset, eltId, size_in_bytes, true, constValue, stats);
@@ -568,8 +634,10 @@ void FindInterestingConstants::visitLoadInst(llvm::LoadInst& I)
             stats.loopCount = m_constFoldLoopBranch;
             stats.samplerCount = m_samplerCount;
             stats.extendedMath = m_extendedMath;
+            stats.selectCount = m_selectCount;
             stats.weight = (m_instCount * IGC_GET_FLAG_VALUE(WeightOtherInstruction)) + std::max(m_constFoldBranch * IGC_GET_FLAG_VALUE(BaseWeightBranch), m_branchsize * IGC_GET_FLAG_VALUE(WeightBranch)) +
-                std::max(m_constFoldLoopBranch * IGC_GET_FLAG_VALUE(BaseWeightLoop), m_loopSize * IGC_GET_FLAG_VALUE(WeightLoop)) + (m_samplerCount * IGC_GET_FLAG_VALUE(WeightSampler)) + m_extendedMath * IGC_GET_FLAG_VALUE(WeightExtendedMath);
+                std::max(m_constFoldLoopBranch * IGC_GET_FLAG_VALUE(BaseWeightLoop), m_loopSize * IGC_GET_FLAG_VALUE(WeightLoop)) + (m_samplerCount * IGC_GET_FLAG_VALUE(WeightSampler)) +
+                (m_extendedMath * IGC_GET_FLAG_VALUE(WeightExtendedMath)) + (m_selectCount * IGC_GET_FLAG_VALUE(WeightSelect));
             constValue = 0;
             // Zero value for this constant is interesting
             // Get the ConstantAddress from LoadInst and log it in interesting constants
@@ -586,7 +654,8 @@ void FindInterestingConstants::visitLoadInst(llvm::LoadInst& I)
             {
                 InstructionStats stats;
                 stats.instCount = m_instCount;
-                stats.weight = m_instCount * IGC_GET_FLAG_VALUE(WeightOtherInstruction);
+                stats.extendedMath = m_extendedMath;
+                stats.weight = (m_instCount * IGC_GET_FLAG_VALUE(WeightOtherInstruction)) + (m_extendedMath * IGC_GET_FLAG_VALUE(WeightExtendedMath));
                 // One value for this constant is interesting
                 // Get the ConstantAddress from LoadInst and log it in interesting constants
                 if (I.getType()->isIntegerTy())

IGC/Compiler/FindInterestingConstants.h

@@ -46,6 +46,7 @@ namespace IGC
         uint32_t loopCount = 0;
         uint32_t samplerCount = 0;
         uint32_t extendedMath = 0;
+        uint32_t selectCount = 0;
         uint32_t weight = 0;
     };
     class FindInterestingConstants : public llvm::FunctionPass, public llvm::InstVisitor<FindInterestingConstants>
@@ -77,12 +78,15 @@ namespace IGC
         unsigned int m_constFoldLoopBranch;
         unsigned int m_samplerCount;
         unsigned int m_extendedMath;
+        unsigned int m_selectCount;
         unsigned int m_branchsize;
         unsigned int m_loopSize;
         std::unordered_map<unsigned int, std::vector<SConstantAddrValue>> m_InterestingConstants;
         const llvm::DataLayout* m_DL;
         std::unordered_set<llvm::Instruction*> visitedForFolding;
         // Helper functions
+        bool isReverseOpInstPair(llvm::Intrinsic::ID intr1, llvm::Intrinsic::ID intr2);
+        void UpdateInstCount(llvm::Instruction* inst);
         bool getConstantAddress(llvm::LoadInst& I, unsigned& bufIdOrGRFOffset, int& eltId, int& size_in_bytes);
         bool FoldsToConst(llvm::Instruction* inst, llvm::Instruction* use, bool& propagate);
         bool FoldsToZero(llvm::Instruction* inst, llvm::Instruction* use);

IGC/common/igc_flags.def

@@ -161,8 +161,10 @@ DECLARE_IGC_REGKEY(bool, EnableGenUpdateCBResInfo,      false, "Enable derived c
 DECLARE_IGC_REGKEY(bool, EnableHighestSIMDForNoSpill,   false,   "When there is no spill choose highest SIMD (compute shader only).", false)
 DECLARE_IGC_REGKEY(bool, EnableFoldsToSourceCheck,      true,  "Enable the check for Folds To Source Propagate for finding interesting constant. This is for the number of instructions that translate to a mov. i.e., Multiplication or Division by 1", false)
 DECLARE_IGC_REGKEY(DWORD, WeightSampler,                10,     "Set the weight for Sampler instruction for finding interesting constant", false)
+DECLARE_IGC_REGKEY(DWORD, WeightSamplerScalarResult,    5,      "Set the weight for scalar of a Sampler instruction for finding interesting constant", false)
 DECLARE_IGC_REGKEY(DWORD, WeightOtherInstruction,       1,      "Set the weight for instruction for finding interesting constant", false)
 DECLARE_IGC_REGKEY(DWORD, WeightExtendedMath,           5,      "Set the weight for Extended math instruction for finding interesting constant ", false)
+DECLARE_IGC_REGKEY(DWORD, WeightSelect,                 10,      "Set the weight for Select instruction for finding interesting constant ", false)
 DECLARE_IGC_REGKEY(DWORD, BaseWeightBranch,             200,     "Set the Base weight for Branch instruction found in finding interesting constant", false)
 DECLARE_IGC_REGKEY(DWORD, WeightBranch,                 20,      "Set the weight for Branch instruction found in finding interesting constant", false)
 DECLARE_IGC_REGKEY(DWORD, BaseWeightLoop,               300,     "Set the Base weight for Loop instruction found in finding interesting constant", false)