localization for acc

bcheng0127 · sys_zuul · commit af2c7ad40c1c · 2020-01-07T12:44:00.000-08:00
Change-Id: I1cf6be5ed7f3ada6ec90d542980c374ac28dfdbe
diff --git a/visa/HWConformity.cpp b/visa/HWConformity.cpp
@@ -298,6 +298,47 @@ G4_SrcRegRegion* HWConformity::insertCopyBefore(INST_LIST_ITER it, uint32_t srcN
     return newSrc;
 }
 
+G4_SrcRegRegion* HWConformity::insertCopyAtBBEntry(G4_BB *bb, uint8_t execSize, G4_Operand *src)
+{
+    MUST_BE_TRUE(src != nullptr && src->isSrcRegRegion(), "source must be a SrcRegRegion");
+    G4_SrcRegRegion* origSrc = src->asSrcRegRegion();
+    auto lb = src->getLinearizedStart();
+    auto rb = src->getLinearizedEnd();
+
+    unsigned int regNum = lb / G4_GRF_REG_NBYTES;
+    unsigned int numRegs = (rb + G4_GRF_REG_NBYTES - 1 - lb) / G4_GRF_REG_NBYTES;
+    if (regNum == -1 || numRegs == 0)
+    {
+        return nullptr;
+    }
+
+    G4_Declare* dcl = builder.createTempVar(execSize, origSrc->getType(), GRFALIGN);
+    dcl->getRegVar()->setPhyReg(builder.phyregpool.getGreg(regNum), 0);
+    G4_SrcModifier modifier = origSrc->getModifier();
+    origSrc->setModifier(Mod_src_undef);
+    G4_DstRegRegion* dst = builder.Create_Dst_Opnd_From_Dcl(dcl, 1);
+    dst->computePReg();
+
+    G4_INST* movInst = builder.createMov(execSize, dst, origSrc, InstOpt_WriteEnable, false);
+
+    for (auto it = bb->begin();
+        it != bb->end();
+        it++)
+    {
+        if (!(*it)->isLabel())
+        {
+            bb->insert(it, movInst);
+            break;
+        }
+    }
+
+    G4_SrcRegRegion* newSrc = builder.createSrcRegRegion(modifier, Direct, dcl->getRegVar(),
+        0, 0, execSize == 1 ? builder.getRegionScalar() : builder.getRegionStride1(),
+        dcl->getElemType());
+    newSrc->asSrcRegRegion()->computePReg();
+    return newSrc;
+}
+
 /*
  *  create a new mov instruction
  *  mov (esize) tmp<1>:type src
@@ -4222,6 +4263,7 @@ struct AccInterval
     int assignedAcc = -1;
     int bundleConflictTimes = 0;
     int bankConflictTimes = 0;
+    int suppressionTimes = 0;
 
     AccInterval(G4_INST* inst_, int lastUse_, bool preAssigned = false) :
         inst(inst_), lastUse(lastUse_), isPreAssigned(preAssigned)
@@ -4543,6 +4585,31 @@ static bool replaceDstWithAcc(G4_INST* inst, int accNum, IR_Builder& builder)
     return true;
 }
 
+static bool isAccCandidate(G4_INST* inst, Gen4_Operand_Number opndNum, G4_Kernel& kernel)
+
+{
+    if (!kernel.fg.builder->canMadHaveSrc0Acc())
+    {
+        return false;
+    }
+
+    switch (opndNum)
+    {
+        case Opnd_src0:
+        case Opnd_src1:
+            break;
+        default:
+            return false;
+    }
+
+    if (!inst->canSrcBeAcc(opndNum))
+    {
+        return false;
+    }
+
+    return true;
+}
+
 struct AccAssignment
 {
     std::vector<bool> freeAccs;
@@ -4677,13 +4744,15 @@ void HWConformity::multiAccSubstitution(G4_BB* bb)
             bool mustBeAcc0 = false;
             int bundleBCTimes = 0;
             int bankBCTimes = 0;
+            int readSuppressionSrcs = 0;
             if (isAccCandidate(inst, kernel, lastUseId, mustBeAcc0))
             {
                 // this is a potential candidate for acc substitution
                 AccInterval *newInterval = new AccInterval(inst, lastUseId);
                 newInterval->mustBeAcc0 = mustBeAcc0;
                 newInterval->bankConflictTimes = bankBCTimes;
                 newInterval->bundleConflictTimes = bundleBCTimes;
+                newInterval->suppressionTimes = readSuppressionSrcs;
 
                 intervals.push_back(newInterval);
             }
@@ -4788,7 +4857,126 @@ void HWConformity::multiAccSubstitution(G4_BB* bb)
     {
         delete intervals[i];
     }
+
+    return;
+}
+
+struct LiveNode
+{
+    G4_INST* Inst;
+    Gen4_Operand_Number OpNum;
+    LiveNode(G4_INST* Inst, Gen4_Operand_Number OpNum)
+        : Inst(Inst)
+        , OpNum(OpNum)
+    {
+    }
+};
+
+#define GLOBAL_USE_NUM 15
+
+static bool isSameOperand(G4_Operand *srcOpnd, struct LiveNode *ln)
+{
+    G4_Operand *opnd = ln->Inst->getOperand(ln->OpNum);
+
+    if (opnd->compareOperand(srcOpnd) == Rel_eq)
+    {
+        return true;
+    }
+
+    return false;
 }
+
+// substitute local operands with acc when possible
+void HWConformity::localizeForAcc(G4_BB* bb)
+{
+    std::map<const G4_Declare*, G4_Operand*> replacedOperand;
+    std::unordered_map<const G4_Declare*, vector<struct LiveNode>> useNodes;
+    std::vector<const G4_Declare*> erasedCandidates;
+
+    for (auto instIter = bb->begin(), instEnd = bb->end(); instIter != instEnd; ++instIter)
+    {
+        G4_INST* inst = *instIter;
+
+        //Not defined in current BB
+        G4_Operand* dst = inst->getOperand(Opnd_dst);
+        if (dst && dst->isGreg() && kernel.fg.globalOpndHT.isOpndGlobal(dst))
+        {
+            const G4_Declare *dcl = dst->getTopDcl();
+            if (useNodes.find(dcl) != useNodes.end())
+            {
+                useNodes.erase(dcl);
+                erasedCandidates.emplace_back(dcl);
+            }
+        }
+
+        //Source operand
+        for (auto OpNum :
+            { Gen4_Operand_Number::Opnd_src0, Gen4_Operand_Number::Opnd_src1,
+              Gen4_Operand_Number::Opnd_src2})
+        {
+            G4_Operand* src = inst->getOperand(OpNum);
+            if (src && src->isGreg() && kernel.fg.globalOpndHT.isOpndGlobal(src))
+            {
+                const G4_Declare* dcl = src->getTopDcl();
+                if ((OpNum != Opnd_src0 &&  //Acc can be used only for src0 and src1
+                    OpNum != Opnd_src1) ||
+                    !isAccCandidate(inst, OpNum, kernel)) //The operand is can be replaced with ACC
+                {
+                    auto dclIter = std::find(erasedCandidates.begin(), erasedCandidates.end(), dcl);
+                    if (dclIter == erasedCandidates.end())
+                    {
+                        erasedCandidates.emplace_back(dcl);
+                    }
+                }
+                else
+                {
+                    if (useNodes[dcl].empty() ||
+                        isSameOperand(src, &(useNodes[dcl][0])))
+                    {
+                        useNodes[dcl].emplace_back(inst, OpNum);
+                    }
+                }
+            }
+        }
+    }
+
+    for (auto& Nodes : useNodes)
+    {
+        const G4_Declare* dcl = Nodes.first;
+        auto dclIter = std::find(erasedCandidates.begin(), erasedCandidates.end(), dcl);
+        if (dclIter != erasedCandidates.end())
+        {
+            continue;
+        }
+        if (Nodes.second.size() >= GLOBAL_USE_NUM)
+        {
+            for (auto& LN : Nodes.second)
+            {
+                G4_INST* inst = LN.Inst;
+                Gen4_Operand_Number opNum = LN.OpNum;
+                int i = inst->getSrcNum(opNum);
+                G4_Operand* src = inst->getSrc(i);
+                G4_Operand* tmpOpnd = nullptr;
+
+                auto itR = replacedOperand.find(dcl);
+                if (itR != replacedOperand.end())
+                {
+                    tmpOpnd = builder.duplicateOperand(itR->second);
+                }
+                else
+                {
+                    tmpOpnd = insertCopyAtBBEntry(bb, inst->getExecSize(), src);
+                    replacedOperand[dcl] = tmpOpnd;
+                }
+                inst->setSrc(tmpOpnd, i);
+            }
+        }
+    }
+
+    return;
+}
+
+
 // substitute local operands with acc when possible
 void HWConformity::accSubstitution(G4_BB* bb)
 {
diff --git a/visa/HWConformity.h b/visa/HWConformity.h
@@ -82,6 +82,7 @@ namespace vISA
         G4_Operand* insertMovBefore(INST_LIST_ITER it, uint32_t srcNum, G4_Type type, G4_BB *bb,
             G4_SubReg_Align tmpAlign = Any);
         G4_SrcRegRegion* insertCopyBefore(INST_LIST_ITER it, uint32_t srcNum, G4_SubReg_Align tmpAlign, G4_BB *bb);
+        G4_SrcRegRegion* insertCopyAtBBEntry(G4_BB* bb, uint8_t newExecSize, G4_Operand* src);
         void broadcast(G4_BB* bb, INST_LIST_ITER it, int srcPos, G4_SubReg_Align subAlign);
 
         G4_INST *splitInstWithByteDst(G4_INST *expand_op);
@@ -216,7 +217,7 @@ namespace vISA
         int getNumAccSubDef() const { return numAccSubDef; }
         int getNumAccSubUse() const { return numAccSubUse; }
         void accSubstitution(G4_BB* bb);
-
+        void localizeForAcc(G4_BB* bb);
     };
 }
 //single entry point for HW conformity checks
diff --git a/visa/Optimizer.cpp b/visa/Optimizer.cpp
@@ -952,6 +952,18 @@ void Optimizer::accSubPostSchedule()
     kernel.fg.localDataFlowAnalysis();
 
     HWConformity hwConf(builder, kernel, mem);
+
+    if (builder.getOption(vISA_localizationForAccSub))
+    {
+        for (auto bb : kernel.fg)
+        {
+            hwConf.localizeForAcc(bb);
+        }
+
+        kernel.fg.resetLocalDataFlowData();
+        kernel.fg.localDataFlowAnalysis();
+    }
+
     for (auto bb : kernel.fg)
     {
         hwConf.accSubstitution(bb);
@@ -12404,4 +12416,4 @@ void Optimizer::replaceNoMaskWithAnyhWA()
             }
         }
     }
-}
+}
diff --git a/visa/include/VISAOptions.def b/visa/include/VISAOptions.def
@@ -58,6 +58,7 @@ DEF_VISA_OPTION(vISA_EnableSplitVariables,  ET_BOOL, "-noSplitVariables", UNUSED
 DEF_VISA_OPTION(vISA_ChangeMoveType,        ET_BOOL, "-ALTMode",         UNUSED, true)
 DEF_VISA_OPTION(vISA_accSubstitution,       ET_BOOL, "-noAccSub",          UNUSED, true)
 DEF_VISA_OPTION(vISA_doAccSubAfterSchedule, ET_BOOL, "-accSubPostSchedule",    UNUSED, true)
+DEF_VISA_OPTION(vISA_localizationForAccSub, ET_BOOL, "-localizeForACC",    UNUSED, false)
 DEF_VISA_OPTION(vISA_ifCvt,                 ET_BOOL, "-noifcvt",     UNUSED, true)
 DEF_VISA_OPTION(vISA_LVN,                   ET_BOOL, "-nolvn",       UNUSED, true)
 // only affects acc substitution for now

Original file line number	Diff line number	Diff line change
`@@ -952,6 +952,18 @@ void Optimizer::accSubPostSchedule()`
`952`	`952`	`kernel.fg.localDataFlowAnalysis();`
`953`	`953`
`954`	`954`	`HWConformity hwConf(builder, kernel, mem);`
	`955`	`+`
	`956`	`+ if (builder.getOption(vISA_localizationForAccSub))`
	`957`	`+ {`
	`958`	`+ for (auto bb : kernel.fg)`
	`959`	`+ {`
	`960`	`+ hwConf.localizeForAcc(bb);`
	`961`	`+ }`
	`962`	`+`
	`963`	`+ kernel.fg.resetLocalDataFlowData();`
	`964`	`+ kernel.fg.localDataFlowAnalysis();`
	`965`	`+ }`
	`966`	`+`
`955`	`967`	`for (auto bb : kernel.fg)`
`956`	`968`	`{`
`957`	`969`	`hwConf.accSubstitution(bb);`
`@@ -12404,4 +12416,4 @@ void Optimizer::replaceNoMaskWithAnyhWA()`
`12404`	`12416`	`}`
`12405`	`12417`	`}`
`12406`	`12418`	`}`
`12407`		`-}`
	`12419`	`+}`