Restrict augmentation live-intervals to "home" function only

Consider following program:
main:
a =
call foo
= a
b =
call foo
= b

foo:
c = 1
return

a, b are both live in foo due to IPA. Howver, their liveness is
temporally disjoint so they shouldn't be marked as interfering. However,
a and c as well as b and c must be marked as interfering.

As per logic prior to this PR, 2 sub-intervals will be created for a
(b). First live-interval extends from definition of a (b) to use and
second on exists from start to end of foo() given that a (b) is
live-in/live-out of foo().

This PR introduces concept of "home" function. Each G4_Declare has a
"home" function that's either nullptr or pointer to an actual FuncInfo*
instance. When a G4_Declare is defined or used in a single function, its
"home" function is set to that function's FuncInfo instance. Whereas
when a G4_Declare is referenced in multiple functions (eg, kernel and sub),
its "home" function is not unique and is set to nullptr.

In augmentation, live-interval construction for a variable depends on its
"home" function. If "home" function is set to nullptr (ie, args, retval) then
live-intervals are constructed across functions. This means one sub-interval
may be in one function and another sub-interval may be in another function.
Whereas when "home" location contains a non-nullptr value, we restrict
live-intervals to only be contained in "home" function. It means that in above
example, variables a and b have their home location set to kernel and a single
non-overlapping live-interval is created for each. Since no live-interval is
created for these in function foo(), they don't overlap and therefore there's
no interference between them.

Author: pratikashar

visa/GraphColor.cpp

@@ -2770,6 +2770,56 @@ void GlobalRA::getBankAlignment(LiveRange *lr, BankAlign &align) {
   }
 }
 
+// Compute homeFunc for dcl.  Following rules are used:
+// 1. A variable that's defined or used in a single function has
+//    that function as its home function.
+// 2. A variable that's defined or used across functions (eg,
+//    args, retval) have their home function set to nullptr.
+// 3. homeFunc is set only on root G4_Declare.
+FuncInfo *Augmentation::computeHomeFunc(G4_Declare *dcl) {
+  vISA_ASSERT(!dcl->getAliasDeclare(), "root dcl expected");
+  // If there are no subroutines then all dcls have kernel as home function
+  if (!hasSubroutines)
+    return kernel.fg.kernelInfo;
+
+  if (hasUniqueFuncHome(dcl))
+    return getUniqueFuncHome(dcl);
+
+  FuncInfo *homeFunction = nullptr;
+  // Live-ins to kernel are modeled as being implicitly defined in kernel.
+  if (dcl->isInput())
+    homeFunction = kernel.fg.kernelInfo;
+  auto *defs = refs.getDefs(dcl);
+  if (defs) {
+    for (auto &def : *defs) {
+      auto *bb = std::get<1>(def);
+      auto *curDefFunc = bbToFunc.at(bb);
+      if (!homeFunction) {
+        homeFunction = curDefFunc;
+        continue;
+      } else if (homeFunction != curDefFunc) {
+        return nullptr;
+      }
+    }
+  }
+
+  auto *uses = refs.getUses(dcl);
+  if (uses) {
+    for (auto &use : *uses) {
+      auto *bb = std::get<1>(use);
+      auto *curUseFunc = bbToFunc.at(bb);
+      if (!homeFunction) {
+        homeFunction = curUseFunc;
+        continue;
+      } else if (homeFunction != curUseFunc) {
+        return nullptr;
+      }
+    }
+  }
+
+  return homeFunction;
+}
+
 void Augmentation::populateFuncMaps() {
   vISA_ASSERT(kernel.fg.getBBList().back()->size() > 0, "last BB empty");
   instToFunc.resize(kernel.fg.getBBList().back()->back()->getLexicalId() + 1);
@@ -2783,10 +2833,24 @@ void Augmentation::populateFuncMaps() {
   }
 }
 
+void Augmentation::populateHomeFunc() {
+  // Assume last G4_Declare has max declId
+  homeFunc.resize(kernel.Declares.back()->getDeclId() + 1);
+  for (auto dcl : kernel.Declares) {
+    if (dcl->getAliasDeclare())
+      dcl = dcl->getRootDeclare();
+    auto *func = computeHomeFunc(dcl);
+    vISA_ASSERT(!hasUniqueFuncHome(dcl) || getUniqueFuncHome(dcl) == func,
+                "different home func set");
+    homeFunc[dcl->getDeclId()] = func;
+  }
+}
+
 Augmentation::Augmentation(Interference &i, const LivenessAnalysis &l,
                            GlobalRA &g)
     : kernel(g.kernel), intf(i), gra(g), liveAnalysis(l), lrs(g.incRA.getLRs()),
-      fcallRetMap(g.fcallRetMap), refs(g.kernel, false, false, true),
+      fcallRetMap(g.fcallRetMap),
+      refs(g.kernel, false, false, true, &g.pointsToAnalysis),
       hasSubroutines(kernel.fg.sortedFuncTable.size() > 0 &&
                      g.kernel.getOption(vISA_NewAugmentation)) {
   useGenericAugAlign =
@@ -3813,6 +3877,16 @@ void Augmentation::buildUnknownArgRetval() {
   }
 }
 
+bool Augmentation::hasUniqueFuncHome(G4_Declare *dcl) const {
+  auto *homeFunction = homeFunc[dcl->getDeclId()];
+  return homeFunction != nullptr;
+}
+
+FuncInfo* Augmentation::getUniqueFuncHome(G4_Declare* dcl) const {
+  vISA_ASSERT(hasUniqueFuncHome(dcl), "expecting unique home func");
+  return homeFunc[dcl->getDeclId()];
+}
+
 void Augmentation::startIntervalForLiveIn(FuncInfo *funcInfo, G4_BB *bb) {
   // Start live-in intervals
   auto liveInBB = liveAnalysis.getLiveAtEntry(bb) & liveAnalysis.globalVars;
@@ -3821,6 +3895,9 @@ void Augmentation::startIntervalForLiveIn(FuncInfo *funcInfo, G4_BB *bb) {
     if (isUnknownArgOrRetval(dcl))
       continue;
 
+    if (hasUniqueFuncHome(dcl) && getUniqueFuncHome(dcl) != funcInfo)
+      continue;
+
     vISA_ASSERT(bb->size() > 0, "empty instlist");
     vISA_ASSERT(funcInfo == kernel.fg.kernelInfo ||
                     argsPerSub.count(funcInfo) > 0 ||
@@ -4022,7 +4099,7 @@ void Augmentation::handlePred(FuncInfo* funcInfo, G4_INST *inst) {
   }
 }
 
-void Augmentation::endIntervalForLiveOut(G4_BB *bb) {
+void Augmentation::endIntervalForLiveOut(FuncInfo* funcInfo, G4_BB *bb) {
   auto liveOutBB = liveAnalysis.getLiveAtExit(bb) & liveAnalysis.globalVars;
   if (bb->isEndWithCall() && liveAnalysis.livenessClass(G4_GRF)) {
     // reset bit for RET__loc as we handle it specially later to
@@ -4050,6 +4127,10 @@ void Augmentation::endIntervalForLiveOut(G4_BB *bb) {
     G4_Declare *dcl = lrs[i]->getDcl()->getRootDeclare();
     if (isUnknownArgOrRetval(dcl))
       continue;
+
+    if (hasUniqueFuncHome(dcl) && getUniqueFuncHome(dcl) != funcInfo)
+      continue;
+
     vISA_ASSERT(bb->size() > 0, "empty instlist");
     updateEndInterval(dcl, bb->back());
   }
@@ -4079,7 +4160,7 @@ void Augmentation::handleNonReducibleExtension(FuncInfo *funcInfo) {
       }
     }
     for (auto exitBB : SCCSucc) {
-      extendVarLiveness(exitBB, headBB->front());
+      extendVarLiveness(funcInfo, exitBB, headBB->front());
     }
   }
 }
@@ -4118,7 +4199,7 @@ void Augmentation::handleLoopExtension(FuncInfo *funcInfo) {
             std::cout << "==> Extend live-in for BB" << exitBB->getId() << "\n";
             exitBB->emit(std::cout);
           });
-          extendVarLiveness(exitBB, startInst);
+          extendVarLiveness(funcInfo, exitBB, startInst);
         }
       }
     }
@@ -4133,6 +4214,10 @@ void Augmentation::handleLoopExtension(FuncInfo *funcInfo) {
 
     for (auto i : globalsLiveInAndLiveOut) {
       auto *dcl = lrs[i]->getDcl()->getRootDeclare();
+      // If dcl has non-nullptr home function then extend liveness only
+      // in same function.
+      if (hasUniqueFuncHome(dcl) && getUniqueFuncHome(dcl) != funcInfo)
+        continue;
 
       updateEndInterval(dcl, endBB->back());
       VISA_DEBUG_VERBOSE({
@@ -4150,11 +4235,16 @@ void Augmentation::handleLoopExtension(FuncInfo *funcInfo) {
 }
 
 // Extend all variables that are live at bb entry to the given inst
-void Augmentation::extendVarLiveness(G4_BB *bb, G4_INST *inst) {
+void Augmentation::extendVarLiveness(FuncInfo *funcInfo, G4_BB *bb,
+                                     G4_INST *inst) {
   auto liveAtEntryBB =
       liveAnalysis.getLiveAtEntry(bb) & liveAnalysis.globalVars;
   for (auto i : liveAtEntryBB) {
     G4_Declare *dcl = lrs[i]->getDcl()->getRootDeclare();
+    // If dcl has non-nullptr home function then extend liveness only
+    // in same function.
+    if (hasUniqueFuncHome(dcl) && getUniqueFuncHome(dcl) != funcInfo)
+      continue;
 
     if (!kernel.fg.isPseudoDcl(dcl)) {
       // Extend ith live-interval
@@ -4181,7 +4271,7 @@ void Augmentation::buildLiveIntervals(FuncInfo* funcInfo) {
   for (G4_BB *curBB : funcInfo->getBBList()) {
     if (!curBB->empty()) {
       startIntervalForLiveIn(funcInfo, curBB);
-      endIntervalForLiveOut(curBB);
+      endIntervalForLiveOut(funcInfo, curBB);
     }
 
     for (G4_INST *inst : *curBB) {
@@ -5041,6 +5131,8 @@ void Augmentation::discoverRetVal(FuncInfo *func) {
     retValPerSub[func].insert(dcl);
     if (retValInfo.subroutines.size() > 1)
       retValInfo.retValType = RetValType::Unknown;
+    vISA_ASSERT(!hasUniqueFuncHome(dcl),
+                "retval cannot have non-nullptr home function");
   }
 
   if (kernel.getOption(vISA_VerifyAugmentation)) {
@@ -5057,7 +5149,8 @@ void Augmentation::discoverArgs(FuncInfo *func) {
 
   SparseBitVector subArgs;
   if (func == kernel.fg.kernelInfo)
-    subArgs = liveAnalysis.use_in[kernel.fg.getEntryBB()->getId()];
+    subArgs = liveAnalysis.use_in[kernel.fg.getEntryBB()->getId()] &
+              liveAnalysis.def_in[kernel.fg.getEntryBB()->getId()];
   else
     subArgs = liveAnalysis.args.at(func);
 
@@ -5074,6 +5167,10 @@ void Augmentation::discoverArgs(FuncInfo *func) {
     if (argInfo.subroutines.size() > 1 &&
         argInfo.argType == ArgType::DefBeforeEachCall)
       argInfo.argType = ArgType::Unknown;
+    vISA_ASSERT(
+        argInfo.argType != ArgType::DefBeforeEachCall ||
+            !hasUniqueFuncHome(dcl),
+        "def before each call arg cannot have non-nullptr home function");
   }
 
 
@@ -5113,6 +5210,16 @@ void Augmentation::dumpSortedIntervals() {
       std::cout << " (LiveThroughArg)";
     else if (isRegularRetVal(dcl))
       std::cout << " (RegularRetVal)";
+    if (dcl->getDeclId() >= homeFunc.size()) {
+      std::cout << " @ (new var)";
+    }
+    else {
+      auto *homeFunction = homeFunc[dcl->getDeclId()];
+      if (!homeFunction)
+        std::cout << " @ (global)";
+      else
+        std::cout << " @ (func " << (int)homeFunction->getId() << ")";
+    }
     std::cout << " - (" << gra.getIntervalStart(interval)->getLexicalId()
               << ", " << gra.getIntervalEnd(interval)->getLexicalId() << "]";
     if (intervalsPerVar[dcl].size() > 1) {
@@ -5572,16 +5679,17 @@ void Augmentation::augmentIntfGraph() {
   bool nonDefaultMaskDef = markNonDefaultMaskDef();
 
   if (nonDefaultMaskDef == true) {
-    if (augWithHoles && kernel.fg.getNumFuncs() > 0)
-      populateFuncMaps();
-
     if (augWithHoles) {
+      if (kernel.fg.getNumFuncs() > 0)
+        populateFuncMaps();
+
+      populateHomeFunc();
+
       // Atleast one definition with non-default mask was found so
       // perform steps to augment intf graph with such defs
 
       // Discover and store subroutine arguments
       if (hasSubroutines) {
-
         for (auto &subroutine : kernel.fg.sortedFuncTable) {
           discoverArgs(subroutine);
           discoverRetVal(subroutine);

visa/GraphColor.h

@@ -429,6 +429,17 @@ class Augmentation {
   std::unordered_map<G4_Declare *, std::unordered_set<FuncInfo *>> unknownArgRetvalRefs;
   std::unordered_map<G4_Declare *, std::unordered_set<FuncInfo *>> nonGRFRefs;
   std::unordered_map<G4_BB *, FuncInfo *> bbToFunc;
+  // Store home function for given variable. Home function is defined as
+  // function that contains explicit def or use of the variable. Each regular
+  // variable has a unique home function. Arg/retval don't have a unique home
+  // function as they're usually defined in caller and used in callee, ie
+  // they're referenced in different functions.
+  //
+  // This vector is indexed by G4_Declare's dclId.
+  //
+  // It's assumed that augmentation doesn't require resizing this vector
+  // despite inserting new SCALL dcls as they're all function local.
+  std::vector<FuncInfo *> homeFunc;
   // Sadly, we don't have a way to map G4_INST to containing G4_BB.
   // So we create it in Augmentation using below vector. To get
   // FuncInfo* for a G4_INST, we dereference instToFunc using
@@ -439,6 +450,7 @@ class Augmentation {
   const bool hasSubroutines = false;
 
   void populateFuncMaps();
+  void populateHomeFunc();
   bool isSubroutineArg(G4_Declare *dcl) const {
     auto it = argsRetVal.find(dcl);
     if (it == argsRetVal.end())
@@ -484,6 +496,11 @@ class Augmentation {
   bool isUnknownRetVal(G4_Declare *dcl) const;
   bool isRegularRetVal(G4_Declare *dcl) const;
   bool isUnknownArgOrRetval(G4_Declare *dcl) const;
+  FuncInfo *computeHomeFunc(G4_Declare *dcl);
+  bool hasUniqueFuncHome(G4_Declare *dcl) const;
+  FuncInfo *getUniqueFuncHome(G4_Declare *dcl) const;
+
+  void verifyHomeLocation();
 
   bool updateDstMaskForGather(G4_INST *inst, std::vector<unsigned char> &mask);
   bool updateDstMaskForGatherRaw(G4_INST *inst,
@@ -522,12 +539,12 @@ class Augmentation {
   void handleCallSite(G4_BB *curBB, unsigned int &funcCnt);
   void handleDstOpnd(FuncInfo *funcInfo, G4_BB *curBB, G4_INST *inst);
   void handleCondMod(FuncInfo* funcInfo, G4_INST *inst);
-  void endIntervalForLiveOut(G4_BB *bb);
+  void endIntervalForLiveOut(FuncInfo *funcInfo, G4_BB *bb);
   void handleSrcOpnd(FuncInfo *funcInfo, G4_BB *curBB, G4_Operand *src);
   void handlePred(FuncInfo* funcInfo, G4_INST *inst);
   void handleNonReducibleExtension(FuncInfo *funcInfo);
   void handleLoopExtension(FuncInfo *funcInfo);
-  void extendVarLiveness(G4_BB *bb, G4_INST *inst);
+  void extendVarLiveness(FuncInfo *funcInfo, G4_BB *bb, G4_INST *inst);
   unsigned getEnd(const G4_Declare *dcl) const;
   bool isNoMask(const G4_Declare *dcl, unsigned size) const;
   bool isConsecutiveBits(const G4_Declare *dcl, unsigned size) const;

visa/LoopAnalysis.cpp

@@ -11,6 +11,7 @@ SPDX-License-Identifier: MIT
 #include "BitSet.h"
 #include "G4_BB.hpp"
 #include "G4_Kernel.hpp"
+#include "PointsToAnalysis.h"
 
 using namespace vISA;
 
@@ -1032,6 +1033,17 @@ void VarReferences::run() {
           auto &Defs = VarRefs[topdcl].first;
           Defs.push_back(std::make_tuple(inst, bb, lb, rb));
         }
+
+        if (p2a && dst->isIndirect()) {
+          auto *pointees = p2a->getAllInPointsTo(topdcl->getRegVar());
+          vISA_ASSERT(pointees, "expecting valid pointee list");
+          for (const auto& pointee : *pointees) {
+            auto &Defs = VarRefs[pointee.var->getDeclare()->getRootDeclare()].first;
+            // lb, rb are both unknown for indirects
+            Defs.push_back(
+                std::make_tuple(inst, bb, UnknownBound, UnknownBound));
+          }
+        }
       }
 
       if (!onlyGRF) {
@@ -1057,6 +1069,16 @@ void VarReferences::run() {
             auto &Uses = VarRefs[topdcl].second;
             Uses.push_back(std::make_tuple(inst, bb));
           }
+
+          if (p2a && src->isIndirect()) {
+            auto *pointees = p2a->getAllInPointsTo(topdcl->getRegVar());
+            vISA_ASSERT(pointees, "expecting valid pointee list");
+            for (const auto &pointee : *pointees) {
+              auto &Uses =
+                  VarRefs[pointee.var->getDeclare()->getRootDeclare()].second;
+              Uses.push_back(std::make_tuple(inst, bb));
+            }
+          }
         }
       }
 

visa/LoopAnalysis.h

@@ -16,6 +16,7 @@ SPDX-License-Identifier: MIT
 namespace vISA {
 class G4_BB;
 class FlowGraph;
+class PointsToAnalysis;
 
 // Top level Analysis class that each analysis needs to inherit.
 // Each inherited class needs to implement their own reset() and
@@ -91,19 +92,24 @@ class PostDom : public Analysis {
 };
 
 // Computes and stores direct references of variables.
-// Indirects references are not computed here.
+// Indirects references are computed only if PointsToAnalysis instance
+// is valid.
 class VarReferences : public Analysis {
 public:
   VarReferences(G4_Kernel &k, bool GRF = false, bool bounds = true,
-                bool pseudoKills = false)
+                bool pseudoKills = false, PointsToAnalysis* p = nullptr)
       : kernel(k), onlyGRF(GRF), needBounds(bounds),
-        reportPseudoKill(pseudoKills) {}
+        reportPseudoKill(pseudoKills), p2a(p) {}
 
   // Defs -> vector[tuple<inst, bb, lb, rb>]
   // Uses -> vector[tuple<inst, bb>]
+  // TODO: Store G4_DstRegRegion instead of G4_INST* in Defs,
+  //             G4_SrcRegResion instead of G4_INST* in Uses
   using Defs =
       std::vector<std::tuple<G4_INST *, G4_BB *, unsigned int, unsigned int>>;
   using Uses = std::vector<std::tuple<G4_INST *, G4_BB *>>;
+  // Set to large enough number so its never a valid bound
+  const unsigned int UnknownBound = 0xffff;
 
   bool isUniqueDef(G4_Operand *dst);
   unsigned int getDefCount(G4_Declare *dcl);
@@ -120,6 +126,7 @@ class VarReferences : public Analysis {
   bool onlyGRF = false;
   bool needBounds = true;
   bool reportPseudoKill = false;
+  PointsToAnalysis *p2a = nullptr;
 
   void reset() override;
   void run() override;