Add support to dump GRF usage chart per instruction. Fix some bugs with

pratikashar · sys_zuul · commit 64f443f7f45e · 2020-04-23T21:17:34.000-07:00
variable splitting.

Change-Id: Ie8c85fa2b33ef8887121a2f3e8c31ee30ee47913
diff --git a/visa/BuildIR.h b/visa/BuildIR.h
@@ -842,6 +842,7 @@ class IR_Builder {
         {
             G4_Declare *R0CopyDcl = createTempVar(8, Type_UD, GRFALIGN);
             builtinR0 = R0CopyDcl;
+            R0CopyDcl->setDoNotSpill();
         }
 
 
diff --git a/visa/GraphColor.cpp b/visa/GraphColor.cpp
@@ -4793,7 +4793,10 @@ void Augmentation::augmentIntfGraph()
             !liveAnalysis.livenessClass(G4_ADDRESS) &&
             kernel.fg.size() > 2))
         {
-            return;
+            if (!kernel.getOption(vISA_DumpRegChart))
+            {
+                return;
+            }
         }
     }
 
@@ -4813,6 +4816,12 @@ void Augmentation::augmentIntfGraph()
         // Sort live-intervals based on their start
         sortLiveIntervals();
 
+        if (kernel.getOption(vISA_DumpRegChart))
+        {
+            gra.regChart = new RegChartDump(gra);
+            gra.regChart->recordLiveIntervals(sortedIntervals);
+        }
+
         if (gra.verifyAugmentation)
         {
             gra.verifyAugmentation->loadAugData(sortedIntervals, lrs, intf.liveAnalysis->getNumSelectedVar(), &intf, gra);
@@ -5690,7 +5699,7 @@ void PhyRegUsage::updateRegUsage(LiveRange* lr)
     }
 }
 
-bool GraphColor::assignColors(ColorHeuristic colorHeuristicGRF, bool doBankConflict, bool highInternalConflict)
+bool GraphColor::assignColors(ColorHeuristic colorHeuristicGRF, bool doBankConflict, bool highInternalConflict, bool honorHints)
 {
     if (builder.getOption(vISA_RATrace))
     {
@@ -5758,7 +5767,7 @@ bool GraphColor::assignColors(ColorHeuristic colorHeuristicGRF, bool doBankConfl
             bool skipParentIntf = false;
             if (lr->hasAllocHint())
             {
-                parms.startGRFReg = lr->getAllocHint();
+                parms.startGRFReg = (lr->getAllocHint() >= maxGRFCanBeUsed ? 0 : lr->getAllocHint());
                 if (varSplitPass.isPartialDcl(lr->getDcl()))
                 {
                     parentDcl = varSplitPass.getParentDcl(lr->getDcl());
@@ -5966,7 +5975,19 @@ bool GraphColor::assignColors(ColorHeuristic colorHeuristicGRF, bool doBankConfl
         if (!ret)
             return false;
 
-        if (gra.getIterNo() < 3)
+        if (lr->getSpillCost() == MAXSPILLCOST &&
+            !lr->getPhyReg() &&
+            honorHints)
+        {
+            // infinite spill cost range spilled
+            // undo all allocations done to split vars
+            // and skip adhering to hints for preserving
+            // correctness.
+            resetTemporaryRegisterAssignments();
+            return assignColors(colorHeuristicGRF, doBankConflict, highInternalConflict, false);
+        }
+
+        if (honorHints && gra.getIterNo() < 3)
         {
             if (varSplitPass.isSplitDcl(lr->getDcl()))
             {
@@ -5982,6 +6003,25 @@ bool GraphColor::assignColors(ColorHeuristic colorHeuristicGRF, bool doBankConfl
                         {
                             auto isChildSpilled = childLR->isSpilled();
                             assignColor(childLR, false, !isChildSpilled);
+                            // if allocated GRF is different than hint, then
+                            // undo allocation and let coloring take its course.
+                            // this can be done only if the childLR wasnt
+                            // already processed in colorOrder.
+                            if (!isChildSpilled && childLR->getPhyReg())
+                            {
+                                auto hint = childLR->getAllocHint();
+                                if (childLR->getPhyReg()->asGreg()->getRegNum() != hint)
+                                {
+                                    // this is executed only if childLR is guaranteed to be
+                                    // processed later on in colorOrder.
+                                    childLR->resetPhyReg();
+                                }
+                            }
+                            else if (isChildSpilled && childLR->getPhyReg())
+                            {
+                                // was spilled earlier, got allocation now
+                                spilledLRs.remove(childLR);
+                            }
                         }
                         else
                         {
@@ -6070,6 +6110,12 @@ bool GraphColor::assignColors(ColorHeuristic colorHeuristicGRF, bool doBankConfl
     {
         MUST_BE_TRUE(lr->isSpilled(), "LR not marked as spilled, but inserted in spilledLRs list");
     }
+
+    // Verify if all LRs have either an allocation or are spilled
+    for (auto lr : colorOrder)
+    {
+        MUST_BE_TRUE(lr->isSpilled() || lr->getPhyReg() || lr->getDcl()->isSpilled(), "Range without allocation and not spilled");
+    }
 #endif
 
     return true;
@@ -6522,8 +6568,10 @@ void GraphColor::resetTemporaryRegisterAssignments()
         if (lrs[i]->getVar()->getPhyReg() == NULL) {
             lrs[i]->resetPhyReg();
             lrs[i]->resetAllocHint();
+            lrs[i]->setSpilled(false);
         }
     }
+    spilledLRs.clear();
 }
 
 void GraphColor::cleanupRedundantARFFillCode()
@@ -9524,6 +9572,15 @@ int GlobalRA::coloringRegAlloc()
                     coloring.addSaveRestoreCode(localSpillAreaOwordSize);
                 }
 
+                if (kernel.getOption(vISA_DumpRegChart))
+                {
+                    assignRegForAliasDcl();
+                    computePhyReg();
+                    // invoke before expanding spill/fill since
+                    // it modifies IR
+                    regChart->dumpRegChart(std::cerr);
+                }
+
                 expandSpillFillIntrinsics();
 
                 if (builder.getOption(vISA_OptReport))
@@ -12311,3 +12368,158 @@ void LiveRange::setAllocHint(unsigned int h)
     if((h + dcl->getNumRows()) <= gra.kernel.getNumRegTotal())
         allocHint = h;
 }
+
+// sortedIntervals comes from augmentation.
+// This can be invoked either post RA where phy regs are assigned to dcls,
+// or after assignColors with lrs and numLRs passed which makes this function
+// use temp allocations from lrs. Doesnt handle sub-routines yet.
+void RegChartDump::dumpRegChart(std::ostream& os, LiveRange** lrs, unsigned int numLRs)
+{
+    constexpr unsigned int N = 128;
+    std::unordered_map<G4_INST*, std::bitset<N>> busyGRFPerInst;
+    bool dumpHex = false;
+
+    auto getPhyReg = [&](G4_Declare* dcl)
+    {
+        auto preg = dcl->getRegVar()->getPhyReg();
+        if (preg)
+            return preg;
+
+        for (unsigned int i = 0; i != numLRs; i++)
+        {
+            LiveRange* lr = lrs[i];
+            if (lr->getDcl() == dcl)
+            {
+                preg = lr->getPhyReg();
+                break;
+            }
+        }
+
+        return preg;
+    };
+
+    for (auto dcl : sortedLiveIntervals)
+    {
+        if (dcl->getRegFile() != G4_RegFileKind::G4_GRF &&
+            dcl->getRegFile() != G4_RegFileKind::G4_INPUT)
+            continue;
+
+        auto phyReg = getPhyReg(dcl);
+        if (!phyReg)
+            continue;
+
+        if (!phyReg->isGreg())
+            continue;
+
+        auto GRFStart = phyReg->asGreg()->getRegNum();
+        auto numRows = dcl->getNumRows();
+
+        auto startInst = startEnd[dcl].first;
+        auto endInst = startEnd[dcl].second;
+
+        bool start = (dcl->getRegFile() == G4_RegFileKind::G4_INPUT);
+        bool done = false;
+        for (auto bb : gra.kernel.fg.getBBList())
+        {
+            for (auto inst : bb->getInstList())
+            {
+                if (inst == startInst)
+                {
+                    start = true;
+                    continue;
+                }
+
+                if (!start)
+                    continue;
+
+                for (unsigned int i = GRFStart; i != (GRFStart + numRows); i++)
+                {
+                    busyGRFPerInst[inst].set(i, true);
+                }
+
+                if (inst == endInst)
+                {
+                    done = true;
+                    break;
+                }
+            }
+
+            if (done)
+                break;
+        }
+    }
+
+    // Now emit instructions with GRFs
+    for (auto bb : gra.kernel.fg.getBBList())
+    {
+        for (auto inst : bb->getInstList())
+        {
+            constexpr unsigned int maxInstLen = 80;
+            auto item = busyGRFPerInst[inst];
+            std::stringstream ss;
+            inst->emit(ss);
+            auto len = ss.str().length();
+
+            if (len <= maxInstLen)
+            {
+                os << ss.str();
+                for (unsigned int i = 0; i != maxInstLen - ss.str().length(); i++)
+                    os << " ";
+            }
+            else
+            {
+                auto tmpStr = ss.str();
+                auto limitedStr = tmpStr.substr(0, maxInstLen);
+                os << std::string(limitedStr);
+            }
+
+            os << "        ";
+
+            if (!dumpHex)
+            {
+                // dump GRFs | - busy, * - free
+                for (unsigned int i = 0; i != N; i++)
+                {
+                    // emit in groups of 10 GRFs
+                    if (i > 0 && (i % 10) == 0)
+                        os << "  ";
+
+                    if (item[i] == true)
+                        os << "|"; // busy
+                    else
+                        os << "*"; // free
+                }
+            }
+            else
+            {
+                for (unsigned int i = 0; i != N; i+=sizeof(unsigned short)*8)
+                {
+                    unsigned short busyGRFs = 0;
+                    for (unsigned int j = 0; j != sizeof(unsigned short)*8; j++)
+                    {
+                        auto offset = i + j;
+                        if (offset < N)
+                        {
+                            if (item[offset])
+                                busyGRFs |= (1 << j);
+                        }
+                    }
+                    printf("r%d:%4x      ", i, busyGRFs);
+                }
+            }
+            os << std::endl;
+        }
+        os << std::endl;
+    }
+}
+
+void RegChartDump::recordLiveIntervals(std::vector<G4_Declare*>& dcls)
+{
+    sortedLiveIntervals = dcls;
+    for (auto dcl : dcls)
+    {
+        auto start = gra.getStartInterval(dcl);
+        auto end = gra.getEndInterval(dcl);
+        startEnd.insert(std::make_pair(dcl, std::make_pair(start, end)));
+    }
+}
diff --git a/visa/GraphColor.h b/visa/GraphColor.h
@@ -528,6 +528,20 @@ namespace vISA
         bool isStrongEdgeBetween(G4_Declare*, G4_Declare*);
     };
 
+    // Class to compute reg chart dump and dump it to ostream.
+    // Used only when -dumpregchart is passed.
+    class RegChartDump
+    {
+    public:
+        GlobalRA& gra;
+        std::vector<G4_Declare*> sortedLiveIntervals;
+        std::unordered_map<G4_Declare*, std::pair<G4_INST*, G4_INST*>> startEnd;
+        void recordLiveIntervals(std::vector<G4_Declare*>& dcls);
+        void dumpRegChart(std::ostream&, LiveRange** lrs = nullptr, unsigned int numLRs = 0);
+
+        RegChartDump(GlobalRA& g) : gra(g) {}
+    };
+
     class GraphColor
     {
         GlobalRA& gra;
@@ -573,7 +587,7 @@ namespace vISA
         void removeConstrained();
         void relaxNeighborDegreeGRF(LiveRange* lr);
         void relaxNeighborDegreeARF(LiveRange* lr);
-        bool assignColors(ColorHeuristic heuristicGRF, bool doBankConflict, bool highInternalConflict);
+        bool assignColors(ColorHeuristic heuristicGRF, bool doBankConflict, bool highInternalConflict, bool honorHints = true);
 
         void clearSpillAddrLocSignature()
         {
@@ -708,6 +722,7 @@ namespace vISA
     {
     public:
         VerifyAugmentation *verifyAugmentation = nullptr;
+        RegChartDump* regChart = nullptr;
         static bool useGenericAugAlign()
         {
             auto gen = getPlatformGeneration(getGenxPlatform());
@@ -1241,6 +1256,9 @@ namespace vISA
         {
             if (verifyAugmentation)
                 delete verifyAugmentation;
+
+            if (regChart)
+                delete regChart;
         }
 
         void emitFGWithLiveness(LivenessAnalysis& liveAnalysis);
diff --git a/visa/LocalRA.cpp b/visa/LocalRA.cpp
@@ -394,7 +394,8 @@ bool LocalRA::localRAPass(bool doRoundRobin, bool doSplitLLR)
     }
 
     if (needGlobalRA == true &&
-        !(kernel.fg.getHasStackCalls() || kernel.fg.getIsStackCallFunc()))
+        !(kernel.fg.getHasStackCalls() || kernel.fg.getIsStackCallFunc()) &&
+        !hasSplitInsts)
     {
         // Check whether unique physical registers can be assigned
         // to global ranges.
@@ -1521,6 +1522,18 @@ void LocalRA::calculateLiveIntervals(G4_BB* bb, std::vector<LocalLiveRange*>& li
 {
     int idx = 0;
     bool brk = false;
+    auto splitPass = gra.getVarSplitPass();
+
+    auto isSplitVarGlobal = [splitPass](G4_Declare* dcl)
+    {
+        if (!splitPass)
+            return false;
+
+        if (splitPass->isSplitDcl(dcl))
+            return !splitPass->isSplitVarLocal(dcl);
+
+        return false;
+    };
 
     for (INST_LIST_ITER inst_it = bb->begin(), bbend = bb->end();
         inst_it != bbend && !brk;
@@ -1603,7 +1616,8 @@ void LocalRA::calculateLiveIntervals(G4_BB* bb, std::vector<LocalLiveRange*>& li
                 {
                     // Check whether local LR is a candidate
                     if (lr->isLiveRangeLocal() &&
-                        lr->isGRFRegAssigned() == false)
+                        lr->isGRFRegAssigned() == false &&
+                        !isSplitVarGlobal(topdcl))
                     {
                         unsigned int startIdx;
 
diff --git a/visa/VarSplit.cpp b/visa/VarSplit.cpp
@@ -841,5 +841,12 @@ bool VarSplitPass::isParentChildRelation(G4_Declare* parent, G4_Declare* child)
 
     return false;
 }
+bool VarSplitPass::isSplitVarLocal(G4_Declare* dcl)
+{
+    auto it = splitVars.find(dcl);
+    MUST_BE_TRUE(it != splitVars.end(), "Not a split dcl");
+
+    return (*it).second.isDefUsesInSameBB();
+}
 
 };
diff --git a/visa/VarSplit.h b/visa/VarSplit.h
diff --git a/visa/include/VISAOptions.def b/visa/include/VISAOptions.def

Original file line number	Diff line number	Diff line change
`@@ -842,6 +842,7 @@ class IR_Builder {`
`842`	`842`	`{`
`843`	`843`	`G4_Declare *R0CopyDcl = createTempVar(8, Type_UD, GRFALIGN);`
`844`	`844`	`builtinR0 = R0CopyDcl;`
	`845`	`+ R0CopyDcl->setDoNotSpill();`
`845`	`846`	`}`
`846`	`847`
`847`	`848`