Mix function optimization.

Mix function optimization, found in GLSL shaders.

Author: mtargows

IGC/Compiler/CustomSafeOptPass.cpp

@@ -1194,6 +1194,144 @@ void CustomSafeOptPass::matchDp4a(BinaryOperator &I) {
     I.replaceAllUsesWith(Res);
 }
 
+// Optimize mix operation if detected.
+// Mix is computed as x*(1 - a) + y*a
+// Replace it with a*(y - x) + x to save one instruction ('add' ISA, 'sub' in IR).
+// This pattern also optimizes a similar operation:
+// x*(a - 1) + y*a which can be replaced with a(x + y) - x
+void CustomSafeOptPass::matchMixOperation(BinaryOperator &I)
+{
+    // Pattern Mix check step 1: find a FSub instruction with a constant value of 1.
+    if (I.getOpcode() == BinaryOperator::FSub)
+    {
+        unsigned int fSubOpIdx = 0;
+        while (fSubOpIdx < 2 && !llvm::isa<llvm::ConstantFP>(I.getOperand(fSubOpIdx)))
+        {
+            fSubOpIdx++;
+        }
+        if ((fSubOpIdx == 1) ||
+            ((fSubOpIdx == 0) && !llvm::isa<llvm::ConstantFP>(I.getOperand(1))))
+        {
+            llvm::ConstantFP* fSubOpConst = llvm::dyn_cast<llvm::ConstantFP>(I.getOperand(fSubOpIdx));
+            const APFloat& APF = fSubOpConst->getValueAPF();
+            bool isInf = APF.isInfinity();
+            bool isNaN = APF.isNaN();
+            double val = 0.0;
+            if (!isInf && !isNaN)
+            {
+                if (&APF.getSemantics() == &APFloat::IEEEdouble())
+                {
+                    val = APF.convertToDouble();
+                }
+                else if (&APF.getSemantics() == &APFloat::IEEEsingle())
+                {
+                    val = (double)APF.convertToFloat();
+                }
+            }
+            if (val == 1.0)
+            {
+                bool doNotOptimize = false;
+                bool matchFound = false;
+                SmallVector<std::pair<Instruction*, Instruction*>, 3> fMulInsts;
+
+                // Pattern Mix check step 2: there should be only FMul users of this FSub instruction
+                for (User* U : I.users())
+                {
+                    Instruction* fMul = cast<Instruction>(U);
+                    matchFound = false;
+                    if (fMul->getOpcode() == BinaryOperator::FMul)
+                    {
+                        // Pattern Mix check step 3: there should be only one fAdd user for such an FMul instruction
+                        if ((int)std::distance(fMul->users().begin(), fMul->users().end()) == 1)
+                        {
+                            Instruction* fAdd = dyn_cast<Instruction>(*fMul->users().begin());
+                            if (fAdd->getOpcode() == BinaryOperator::FAdd)
+                            {
+                                // Pattern Mix check step 4: fAdd should be a user of two FMul instructions
+                                unsigned int opIdx = 0;
+                                while (opIdx < 2 && cast<Value>(fMul) != fAdd->getOperand(opIdx))
+                                {
+                                    opIdx++;
+                                }
+
+                                if (opIdx < 2)
+                                {
+                                    opIdx = (opIdx + 1) % 2; // 0 -> 1 or 1 -> 0
+                                    Instruction* fMul2nd = cast<Instruction>(fAdd->getOperand(opIdx));
+                                    if (fMul2nd->getOpcode() == BinaryOperator::FMul)
+                                    {
+                                        fMulInsts.push_back(std::make_pair(fMul, fMul2nd));
+                                        matchFound = true;  // Pattern Mix (partially) detected.
+                                    }
+                                }
+                            }
+                        }
+
+                    }
+
+                    if (!matchFound)
+                    {
+                        doNotOptimize = true; // To optimize both FMul instructions and FAdd must be found
+                    }
+                }
+
+                if (!doNotOptimize && !fMulInsts.empty() && I.users().begin() != I.users().end())
+                {
+                    // Pattern Mix fully detected. Replace sequence of detected instructions with new ones.
+                    IGC_ASSERT_MESSAGE(
+                        fMulInsts.size() == (int)std::distance(I.users().begin(), I.users().end()),
+                        "Incorrect pattern match data");
+                    // If Pattern Mix with 1-a in the first instruction was detected then create
+                    // this sequence of new instructions: FSub, FMul, FAdd.
+                    // But if Pattern Mix with a-1 in the first instruction was detected then create
+                    // this sequence of new instructions: FAdd, FMul, FSub.
+                    Instruction::BinaryOps newFirstInstOp = (fSubOpIdx == 0) ? Instruction::FSub : Instruction::FAdd;
+                    Instruction::BinaryOps newLastInstOp = (fSubOpIdx == 0) ? Instruction::FAdd : Instruction::FSub;
+
+                    fSubOpIdx = (fSubOpIdx + 1) % 2; // 0 -> 1 or 1 -> 0, i.e. get another FSub operand
+                    Value* r = I.getOperand(fSubOpIdx);
+
+                    for (std::pair<Instruction*, Instruction*> fMulPair : fMulInsts)
+                    {
+                        Instruction* fAdd = dyn_cast<Instruction>(*fMulPair.first->users().begin());
+
+                        unsigned int fMul2OpToFirstInstIdx = (r == fMulPair.second->getOperand(0)) ? 1 : 0;
+                        Value* newFirstInstOp1 = fMulPair.second->getOperand(fMul2OpToFirstInstIdx);
+                        Value* fSubVal = cast<Value>(&I);
+
+                        unsigned int fMul1OpToTakeIdx = (fSubVal == fMulPair.first->getOperand(0)) ? 1 : 0;
+                        Instruction* newFirstInst = BinaryOperator::Create(
+                            newFirstInstOp, fMulPair.first->getOperand(fMul1OpToTakeIdx), newFirstInstOp1, "", &I);
+                        DILocation* DL1st = I.getDebugLoc();
+                        if (DL1st)
+                        {
+                            newFirstInst->setDebugLoc(DL1st);
+                        }
+
+                        Instruction* newFMul = BinaryOperator::CreateFMul(
+                            fMulPair.second->getOperand((fMul2OpToFirstInstIdx + 1) % 2), newFirstInst, "", fMulPair.second);
+                        DILocation* DL2nd = fMulPair.second->getDebugLoc();
+                        if (DL2nd)
+                        {
+                            newFMul->setDebugLoc(DL2nd);
+                        }
+
+                        Instruction* newLastInst = BinaryOperator::Create(
+                            newLastInstOp, newFMul, fMulPair.first->getOperand(fMul1OpToTakeIdx), "", fAdd);
+                        DILocation* DL3rd = fMulPair.second->getDebugLoc();
+                        if (DL3rd)
+                        {
+                            newLastInst->setDebugLoc(DL3rd);
+                        }
+
+                        fAdd->replaceAllUsesWith(newLastInst);
+                    }
+                }
+            }
+        }
+    }
+}
+
 void CustomSafeOptPass::hoistDp3(BinaryOperator& I)
 {
     if (I.getOpcode() != Instruction::BinaryOps::FAdd)
@@ -1569,6 +1707,10 @@ void CustomSafeOptPass::visitBinaryOperator(BinaryOperator& I)
 {
     matchDp4a(I);
 
+    // Optimize mix operation if detected.
+    // Mix is computed as x*(1 - a) + y*a
+    matchMixOperation(I);
+
     // move immediate value in consecutive integer adds to the last added value.
     // this can allow more chance of doing CSE and memopt.
     //    a = b + 8

IGC/Compiler/CustomSafeOptPass.hpp

@@ -91,6 +91,7 @@ namespace IGC
         void visitBitCast(llvm::BitCastInst& BC);
 
         void matchDp4a(llvm::BinaryOperator& I);
+        void matchMixOperation(llvm::BinaryOperator& I);
         void hoistDp3(llvm::BinaryOperator& I);
 
         template <typename MaskType> void matchReverse(llvm::BinaryOperator& I);