IGA: updated dpas macro rules

Updated 2 rules in DpasMacroBuilder:
- src2 read suppression can allow dp dpas as long as the rep-count is 4
- WAW and WAR dependency are allowed between dpas within the same macro

Author: DianaChen

visa/iga/IGALibrary/IR/RegDeps.cpp

@@ -469,6 +469,7 @@ size_t DepSetBuilder::DpasMacroBuilder::getNumberOfSuppresionGroups(uint32_t src
     return 0;
 }
 
+
 size_t DepSetBuilder::DpasMacroBuilder::formSrcSuppressionBlock(
     InstListIterator startIt, uint32_t srcIdx) {
     // get the candidate block
@@ -553,9 +554,10 @@ DepSetBuilder::DpasMacroBuilder::SuppressBlockPtrTy
 DepSetBuilder::DpasMacroBuilder::getSuppressionBlockCandidate(
     InstListIterator startIt, uint32_t srcIdx,
     BitSet<>& allDstBits, BitSet<>& allSrcBits,
-    BitSet<>& allDstNoLastBits, BitSet<>& allSrcNoLastBits) const {
+    BitSet<>& allDstNoLastBits, BitSet<>& allSrcNoLastBits,
+    int forceGroupNum) const {
     assert(srcIdx == 1 || srcIdx == 2);
-    size_t maxGroupNum = getNumberOfSuppresionGroups(srcIdx);
+    size_t maxGroupNum = forceGroupNum < 0 ? getNumberOfSuppresionGroups(srcIdx) : forceGroupNum;
     // return null if the given src can't be suppressed
     if (!maxGroupNum)
         return nullptr;
@@ -612,13 +614,12 @@ bool DepSetBuilder::DpasMacroBuilder::srcIsSuppressCandidate(const Instruction&
     if (srcIdx == 1)
         return true;
     if (srcIdx == 2) {
-        // can't be DP dpas
+        // DP dpas must have rep count 4
         if (inst.isDF())
-            return false;
+            return GetDpasRepeatCount(inst.getDpasFc()) == 4;
 
-        if (GetDpasRepeatCount(inst.getDpasFc()) != 8)
-            return false;
-        return true;
+        // allow only rep count 8 for non-DP dpase
+        return GetDpasRepeatCount(inst.getDpasFc()) == 8;
     }
     return false;
 }
@@ -631,10 +632,8 @@ bool DepSetBuilder::DpasMacroBuilder::hasProducerConsumerDep(
     BitSet<> new_dstbits(m_dsBuilder.getGRF_LEN());
     setDstSrcBits(src_range, dst_range, new_srcbits, new_dstbits);
 
-    // check if there is WAR/RAW/WAW dependency
-    if (target_src_bits.intersects(new_dstbits) ||
-        target_dst_bits.intersects(new_srcbits) ||
-        target_dst_bits.intersects(new_dstbits))
+    // check if there is RAW dependency
+    if (target_dst_bits.intersects(new_srcbits))
         return true;
     return false;
 }
@@ -663,13 +662,16 @@ const Instruction& DepSetBuilder::DpasMacroBuilder::formMacro(size_t& dpasCnt) {
     m_inps.getDpasDstDependency(**cur, dst_range);
     InstListIterator next = cur;
     next++;
-    // early exit if there is no following instructions
-    if (next == m_instList.end()) {
+    // early exit if there is no following instructions or dpas depth is not 8
+    if (next == m_instList.end() || GetDpasSystolicDepth((*cur)->getDpasFc()) != 8) {
         updateRegFootprintsToDepSets(src_range, src_extra_range, dst_range);
         return **cur;
     }
 
-    dpasCnt = std::max(dpasCnt, formSrcSuppressionBlock(m_firstDpasIt, 1));
+    bool formMacroForSrc1 = false;
+
+    if (!formMacroForSrc1)
+        dpasCnt = std::max(dpasCnt, formSrcSuppressionBlock(m_firstDpasIt, 1));
     dpasCnt = std::max(dpasCnt, formSrcSuppressionBlock(m_firstDpasIt, 2));
 
     if (dpasCnt == 1) {

visa/iga/IGALibrary/IR/RegDeps.hpp

@@ -414,12 +414,18 @@ class DepSetBuilder {
     // 1. consecutive DPAS instructions of the same opcode
     // 2. same datatype of the same operand across all instructions
     // 3. same execution mask across all instructions
-    // 4. same depth
-    // 5. has no internal dependency within the instruction
-    //    with an exception that for depth 8 dpas, src0and dst dependency is allowed if they are completely the same
-    // 6. One of below conditions is met:
-    //    a) src1 read suppression is fulfilled
-    //    b) src2 read suppression is fulfilled
+    // 4. depth is 8
+    // 5. has no internal dependency within each instruction
+    //    - with an exception that for depth 8 dpas, src0 and dst dependency is allowed if they are completely the same
+    // 6. no producer-consumer relationships (RAW) within the macro
+    //    - WAW and WAR are allowed since dpas are in ordered within the dpas pipe
+    // 7. For a DPAS 8xN sequence, where N !=8, a macro has to have at least two dpas b2b instructions that share the same
+    //    src1 and that the sum of the number of either Src0 or Src2 registers they read is 8 or more after the same macro
+    //    can change to another sequence of dpas instructions with different Src1
+    //    (** Note that violating this rule causes functional issue)
+    // 8. One of below conditions is met:
+    //    a) for src1 read suppression
+    //    b) for src2 read suppression
     class DpasMacroBuilder {
     public:
         DpasMacroBuilder(
@@ -569,18 +575,22 @@ class DepSetBuilder {
         // to srcIdx suppression. Return number of 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
+        // * 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) const;
+            BitSet<>& allDstNoLastBits, BitSet<>& allSrcNoLastBits,
+            int forceGroupNum = -1) const;
 
         bool srcIsSuppressCandidate(const Instruction& inst, uint32_t srcIdx) const;