Remove condition from hot path

When 4GRF align is supported, a different edge weight computation
function is used. This change reduces cost of dynamic check for flag in
boilerplate code.

Author: pratikashar

visa/GraphColor.cpp

@@ -5940,6 +5940,7 @@ void GraphColor::createLiveRanges() {
   }
 }
 
+template<bool Support4GRFAlign>
 void GraphColor::computeDegreeForGRF() {
   for (unsigned i = 0; i < numVar; i++) {
     unsigned degree = 0;
@@ -5954,7 +5955,7 @@ void GraphColor::computeDegreeForGRF() {
 
       auto computeDegree = [&](LiveRange *lr1) {
         if (!lr1->getIsPartialDcl()) {
-          unsigned edgeDegree = edgeWeightGRF(lrs[i], lr1);
+          unsigned edgeDegree = edgeWeightGRF<Support4GRFAlign>(lrs[i], lr1);
 
           degree += edgeDegree;
 
@@ -6286,60 +6287,61 @@ void GraphColor::computeSpillCosts(bool useSplitLLRHeuristic, const RPE *rpe) {
 // subtract lr's neighbors that are still in work list
 //
 void GraphColor::relaxNeighborDegreeGRF(LiveRange *lr) {
-  if (!(lr->getIsPseudoNode()) && !(lr->getIsPartialDcl())) {
-    unsigned lr_id = lr->getVar()->getId();
-    bool lr2EvenAlign = gra.isEvenAligned(lr->getDcl());
-    unsigned int lr2AugAlign = gra.getAugAlign(lr->getDcl());
-    unsigned lr2_nreg = lr->getNumRegNeeded();
+  if (lr->getIsPseudoNode() || lr->getIsPartialDcl())
+    return;
 
-    // relax degree between 2 nodes
-    auto relaxDegree = [&](LiveRange *lr1) {
+  unsigned lr_id = lr->getVar()->getId();
+  unsigned lr2_nreg = lr->getNumRegNeeded();
+
+  const std::vector<unsigned> &intfs = intf.getSparseIntfForVar(lr_id);
+  if (gra.use4GRFAlign) {
+    unsigned int lr2AugAlign = gra.getAugAlign(lr->getDcl());
+    for (auto it : intfs) {
+      LiveRange *lr1 = lrs[it];
       if (lr1->getActive() && !lr1->getIsPseudoNode() &&
           !(lr1->getIsPartialDcl())) {
         unsigned lr1_nreg = lr1->getNumRegNeeded();
-        unsigned w = 0;
-        if (gra.use4GRFAlign) {
-          unsigned int lr1AugAlign = gra.getAugAlign(lr1->getDcl());
-          w = edgeWeightWith4GRF(lr1AugAlign, lr2AugAlign, lr1_nreg, lr2_nreg);
-        } else {
-          bool lr1EvenAlign = gra.isEvenAligned(lr1->getDcl());
-          w = edgeWeightGRF(lr1EvenAlign, lr2EvenAlign, lr1_nreg, lr2_nreg);
-        }
-        VISA_DEBUG_VERBOSE({
-          std::cout << "\t relax ";
-          lr1->dump();
-          std::cout << " degree(" << lr1->getDegree() << ") - " << w << "\n";
-        });
-        lr1->subtractDegree(w);
-
-        unsigned availColor = numColor;
-        availColor = numColor - lr1->getNumForbidden();
-
-        if (lr1->getDegree() + lr1->getNumRegNeeded() <= availColor) {
-          unconstrainedWorklist.push_back(lr1);
-          lr1->setActive(false);
-        }
+        unsigned int lr1AugAlign = gra.getAugAlign(lr1->getDcl());
+        auto w =
+            edgeWeightWith4GRF(lr1AugAlign, lr2AugAlign, lr1_nreg, lr2_nreg);
+        relax(lr1, w);
       }
-    };
-
-    const std::vector<unsigned> &intfs = intf.getSparseIntfForVar(lr_id);
-    for (auto it : intfs) {
-      LiveRange *lrs_it = lrs[it];
+    }
+    return;
+  }
 
-      relaxDegree(lrs_it);
+  // Handle case where 4GRF align is unsupported
+  bool lr2EvenAlign = gra.isEvenAligned(lr->getDcl());
+  for (auto it : intfs) {
+    LiveRange *lr1 = lrs[it];
+    if (lr1->getActive() && !lr1->getIsPseudoNode() &&
+        !(lr1->getIsPartialDcl())) {
+      unsigned lr1_nreg = lr1->getNumRegNeeded();
+      unsigned w = 0;
+      bool lr1EvenAlign = gra.isEvenAligned(lr1->getDcl());
+      w = edgeWeightGRF(lr1EvenAlign, lr2EvenAlign, lr1_nreg, lr2_nreg);
+      relax(lr1, w);
     }
+  }
 
-    auto *weakEdges = intf.getCompatibleSparseIntf(lr->getDcl());
-    if (weakEdges) {
-      for (auto weakNeighbor : *weakEdges) {
-        if (!weakNeighbor->getRegVar()->isRegAllocPartaker())
-          continue;
-        auto lr1 = lrs[weakNeighbor->getRegVar()->getId()];
-        relaxDegree(lr1);
+  // Weak edges are supported only when 4GRF align is unsupported
+  auto *weakEdges = intf.getCompatibleSparseIntf(lr->getDcl());
+  if (weakEdges) {
+    for (auto weakNeighbor : *weakEdges) {
+      if (!weakNeighbor->getRegVar()->isRegAllocPartaker())
+        continue;
+      auto lr1 = lrs[weakNeighbor->getRegVar()->getId()];
+      if (lr1->getActive() && !lr1->getIsPseudoNode() &&
+          !(lr1->getIsPartialDcl())) {
+        unsigned lr1_nreg = lr1->getNumRegNeeded();
+        bool lr1EvenAlign = gra.isEvenAligned(lr1->getDcl());
+        auto w = edgeWeightGRF(lr1EvenAlign, lr2EvenAlign, lr1_nreg, lr2_nreg);
+        relax(lr1, w);
       }
     }
   }
 }
+
 void GraphColor::relaxNeighborDegreeARF(LiveRange *lr) {
   if (!(lr->getIsPseudoNode())) {
     unsigned lr_id = lr->getVar()->getId();
@@ -7273,7 +7275,10 @@ bool GraphColor::regAlloc(bool doBankConflictReduction,
   // compute degree and spill costs for each live range
   //
   if (liveAnalysis.livenessClass(G4_GRF)) {
-    computeDegreeForGRF();
+    if (gra.use4GRFAlign)
+      computeDegreeForGRF<true>();
+    else
+      computeDegreeForGRF<false>();
   } else {
     computeDegreeForARF();
   }
@@ -11812,18 +11817,19 @@ void GlobalRA::insertRestoreAddr(G4_BB *bb) {
 // weight computation and later during simplification is necessary for
 // correctness.
 //
+template <bool Support4GRFAlign>
 unsigned GraphColor::edgeWeightGRF(const LiveRange *lr1, const LiveRange *lr2) {
   unsigned lr1_nreg = lr1->getNumRegNeeded();
   unsigned lr2_nreg = lr2->getNumRegNeeded();
 
-  if (gra.use4GRFAlign) {
+  if constexpr (Support4GRFAlign) {
     auto lr1Align = gra.getAugAlign(lr1->getDcl());
     auto lr2Align = gra.getAugAlign(lr2->getDcl());
 
     return edgeWeightWith4GRF(lr1Align, lr2Align, lr1_nreg, lr2_nreg);
   } else {
-    bool lr1EvenAlign = gra.isEvenAligned(lr1->getDcl());
-    bool lr2EvenAlign = gra.isEvenAligned(lr2->getDcl());
+    bool lr1EvenAlign = gra.isEvenAligned<false>(lr1->getDcl());
+    bool lr2EvenAlign = gra.isEvenAligned<false>(lr2->getDcl());
 
     return edgeWeightGRF(lr1EvenAlign, lr2EvenAlign, lr1_nreg, lr2_nreg);
   }

visa/GraphColor.h

@@ -1036,15 +1036,16 @@ class GraphColor {
   // Reserved GRF count for fail-safe RA
   unsigned reserveSpillGRFCount = 0;
 
+  template<bool Support4GRFAlign>
   unsigned edgeWeightGRF(const LiveRange *lr1, const LiveRange *lr2);
   unsigned edgeWeightARF(const LiveRange *lr1, const LiveRange *lr2);
   static unsigned edgeWeightGRF(bool lr1EvenAlign, bool lr2EvenAlign,
                                 unsigned lr1_nreg, unsigned lr2_nreg) {
+    unsigned sum = lr1_nreg + lr2_nreg;
     if (!lr1EvenAlign) {
-      return lr1_nreg + lr2_nreg - 1;
+      return sum - 1;
     }
 
-    unsigned sum = lr1_nreg + lr2_nreg;
     if (!lr2EvenAlign)
       return sum + 1 - ((sum) % 2);
 
@@ -1086,6 +1087,25 @@ class GraphColor {
     return edgeWeightWith4GRF(lr2Align, lr1Align, lr2_nreg, lr1_nreg);
   }
 
+  void inline relax(LiveRange *lr1, unsigned int w) {
+    // relax degree between 2 nodes
+    VISA_DEBUG_VERBOSE({
+      std::cout << "\t relax ";
+      lr1->dump();
+      std::cout << " degree(" << lr1->getDegree() << ") - " << w << "\n";
+    });
+    lr1->subtractDegree(w);
+
+    unsigned availColor = numColor;
+    availColor = numColor - lr1->getNumForbidden();
+
+    if (lr1->getDegree() + lr1->getNumRegNeeded() <= availColor) {
+      unconstrainedWorklist.push_back(lr1);
+      lr1->setActive(false);
+    }
+  }
+
+  template <bool Support4GRFAlign>
   void computeDegreeForGRF();
   void computeDegreeForARF();
   void computeSpillCosts(bool useSplitLLRHeuristic, const RPE *rpe);
@@ -1269,7 +1289,6 @@ class ForbiddenRegs {
 };
 
 class GlobalRA {
-
 private:
   std::unordered_set<G4_INST *> EUFusionCallWAInsts;
   bool m_EUFusionCallWANeeded;
@@ -1843,9 +1862,13 @@ class GlobalRA {
     return augAlign == 4;
   }
 
+  template <bool Support4GRFAlign = true>
   bool isEvenAligned(const G4_Declare* dcl) const {
     auto augAlign = getAugAlign(dcl);
-    return augAlign > 0 && augAlign % 2 == 0;
+    if constexpr (Support4GRFAlign)
+      return augAlign > 0 && augAlign % 2 == 0;
+    else
+      return (augAlign > 0);
   }
 
   int getAugAlign(const G4_Declare *dcl) const {