[Autobackout][FunctionalRegression]Revert of change: b3e1d9a: IGA SWSB: Refactor dpas macro builder

Removed DpasMacroBuilder::getSuppressionBlockCandidate. Now the dpas
    macro is formed until a dpas is seen that cannot be in a macro, even
    if there is no suppression opportunity, i.e. no sources are the same
    within the macro. There is no performance drawback doing so. This also
    aligns with vISA's dpas macro logic.

Author: sys-igc

visa/iga/IGALibrary/IR/RegDeps.cpp

@@ -589,12 +589,19 @@ size_t DepSetBuilder::DpasMacroBuilder::formSrcSuppressionBlock(
   BitSet<> allSrcBits(m_dsBuilder.getGRF_LEN());
   BitSet<> allDstNoLastBits(m_dsBuilder.getGRF_LEN());
   BitSet<> allSrcNoLastBits(m_dsBuilder.getGRF_LEN());
-
-  SuppressBlock bptr(
-      getNumberOfSuppresionGroups(srcIdx), srcIdx == 1 ? 8 : 4);
+  SuppressBlockPtrTy bptr =
+      getSuppressionBlockCandidate(startIt, srcIdx, allDstBits, allSrcBits,
+                                   allDstNoLastBits, allSrcNoLastBits);
+  if (!bptr)
+    return 0;
 
   size_t numSuppressed = 0;
   InstListIterator it = startIt;
+  // advance inst iterator to the next instruction following the block
+  // Note that this instruction must be a macro candidate, otherwise the
+  // suppression block won't formed
+  std::advance(it, bptr->size());
+  assert(it != m_instList.end());
 
 
   // find until the last instruction that can be suppressed
@@ -615,14 +622,18 @@ size_t DepSetBuilder::DpasMacroBuilder::formSrcSuppressionBlock(
     if (srcOp.getDirRegName() != RegName::GRF_R)
       break;
 
+    // found the first instruction that can't be suppressed. Stop looking.
+    if (!bptr->contains(srcOp.getDirRegRef().regNum))
+      break;
+
     bool skipSetLastBits = false;
     if (hasProducerConsumerDep(dst_range, src_range, allDstBits)) {
         break;
     }
 
     // at this point, we can add this DPAS into the macro
     ++numSuppressed;
-    bptr.addRegRanges(src_range, src_extra_range, dst_range);
+    bptr->addRegRanges(src_range, src_extra_range, dst_range);
     if (!skipSetLastBits) {
       allSrcNoLastBits = allSrcBits;
       allDstNoLastBits = allDstBits;
@@ -639,15 +650,76 @@ size_t DepSetBuilder::DpasMacroBuilder::formSrcSuppressionBlock(
   if (numSuppressed) {
     // at least one instruction can be suppressed, the candidate block can be in
     // the macro udpate register footprint into DepSet
-    updateRegFootprintsToDepSets(bptr.allSrcRange, bptr.allExtraSrcRange,
-                                 bptr.allDstRange);
+    updateRegFootprintsToDepSets(bptr->allSrcRange, bptr->allExtraSrcRange,
+                                 bptr->allDstRange);
 
     // return the total instructions found can be in the macro
-    return bptr.size() + numSuppressed;
+    return bptr->size() + numSuppressed;
   }
   return 0;
 }
 
+DepSetBuilder::DpasMacroBuilder::SuppressBlockPtrTy
+DepSetBuilder::DpasMacroBuilder::getSuppressionBlockCandidate(
+    InstListIterator startIt, uint32_t srcIdx, BitSet<> &allDstBits,
+    BitSet<> &allSrcBits, BitSet<> &allDstNoLastBits,
+    BitSet<> &allSrcNoLastBits, int forceGroupNum) const {
+  assert(srcIdx == 1 || srcIdx == 2);
+  size_t maxGroupNum =
+      forceGroupNum < 0 ? getNumberOfSuppresionGroups(srcIdx) : forceGroupNum;
+  // return null if the given src can't be suppressed
+  if (!maxGroupNum)
+    return nullptr;
+
+  SuppressBlockPtrTy sb(new SuppressBlock(maxGroupNum, srcIdx == 1 ? 8 : 4));
+  // try from the startIt to see if there are dpas sequence that can form the
+  // suppression block check number of maxGroupSize to find the first one block
+  // those can potentially be suppressed
+  InstListIterator it = startIt;
+  for (size_t i = 0; i < maxGroupNum; ++i) {
+    InstListIterator nextIt = it;
+    ++nextIt;
+    // if next instruction is not a suppression candidate, there's no chance to
+    // form a suppression block, return nullptr directly
+    if (nextIt == m_instList.end())
+      return nullptr;
+    if (nextIsNotMacroCandidate(**it, **nextIt))
+      return nullptr;
+    if (!srcIsSuppressCandidate(**it, srcIdx))
+      return nullptr;
+    SrcRegRangeType src_range, src_extra_range;
+    DstRegRangeType dst_range;
+    m_inps.getDpasSrcDependency(**it, src_range, src_extra_range, m_model);
+    m_inps.getDpasDstDependency(**it, dst_range);
+    if (hasInternalDep(**it, dst_range, src_range,
+                       GetDpasSystolicDepth((*it)->getDpasFc()) == 8))
+      return nullptr;
+
+    bool skipSetLastBits = false;
+    if (hasProducerConsumerDep(dst_range, src_range, allDstBits)) {
+        return nullptr;
+    }
+    uint16_t reg = (*it)->getSource(srcIdx).getDirRegRef().regNum;
+    if (sb->partialOverlapped(reg))
+      return nullptr;
+
+    // found the first duplicated register, the block is formed
+    if (sb->contains(reg))
+      break;
+    sb->addRegs(reg);
+    sb->addRegRanges(src_range, src_extra_range, dst_range);
+    if (!skipSetLastBits) {
+      allSrcNoLastBits = allSrcBits;
+      allDstNoLastBits = allDstBits;
+    }
+    setDstSrcBits(src_range, dst_range, allSrcBits, allDstBits);
+    ++it;
+  }
+
+  assert(sb->size());
+  return sb;
+}
+
 bool DepSetBuilder::DpasMacroBuilder::srcIsSuppressCandidate(
     const Instruction &inst, uint32_t srcIdx) const {
   // src1 always can be the candidate since all dpas depth must be the same

visa/iga/IGALibrary/IR/RegDeps.hpp

@@ -596,6 +596,7 @@ class DepSetBuilder {
       }
 
     }; // SuppressionBlock
+    typedef std::unique_ptr<SuppressBlock> SuppressBlockPtrTy;
 
     // get the max number of suppression groups according to srcIdx and platform
     size_t getNumberOfSuppresionGroups(uint32_t srcIdx) const;
@@ -605,6 +606,25 @@ class DepSetBuilder {
     // instructions found
     size_t formSrcSuppressionBlock(InstListIterator startIt, uint32_t srcIdx);
 
+    // return the candidate SuppressBlock that is found fulfilling read
+    // suppression requirement of given src index, start from the give
+    // instruction. This block is the first candidate block of instructions
+    // register those can be suppressed. Will need to check if the following
+    // instructions having the same registers so that they can actually being
+    // suppressed.
+    // * return nullptr if there is no chance to suppress the given src
+    // * allDstBits, allSrcBits - all used grf bits in the return suppressBlock
+    // * allDstNoLastBits, allSrcNoLastBits - all used grf in the return
+    // suppressBlock except the
+    //   last instruction's
+    // * forceGroupNum - force to use the given value as maximum number of
+    // suppression groups instead of
+    //   getting it from getNumberOfSuppresionGroups
+    SuppressBlockPtrTy getSuppressionBlockCandidate(
+        InstListIterator startIt, uint32_t srcIdx, BitSet<> &allDstBits,
+        BitSet<> &allSrcBits, BitSet<> &allDstNoLastBits,
+        BitSet<> &allSrcNoLastBits, int forceGroupNum = -1) const;
+
     bool srcIsSuppressCandidate(const Instruction &inst, uint32_t srcIdx) const;
 
   private: