[Autobackout][FuncReg]Revert of change: 932be31

 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,56 +2770,6 @@ 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);
@@ -2833,24 +2783,10 @@ 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, &g.pointsToAnalysis),
+      fcallRetMap(g.fcallRetMap), refs(g.kernel, false, false, true),
       hasSubroutines(kernel.fg.sortedFuncTable.size() > 0 &&
                      g.kernel.getOption(vISA_NewAugmentation)) {
   useGenericAugAlign =
@@ -3877,16 +3813,6 @@ 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;
@@ -3895,9 +3821,6 @@ 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 ||
@@ -4099,7 +4022,7 @@ void Augmentation::handlePred(FuncInfo* funcInfo, G4_INST *inst) {
   }
 }
 
-void Augmentation::endIntervalForLiveOut(FuncInfo* funcInfo, G4_BB *bb) {
+void Augmentation::endIntervalForLiveOut(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
@@ -4127,10 +4050,6 @@ void Augmentation::endIntervalForLiveOut(FuncInfo* funcInfo, 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());
   }
@@ -4160,7 +4079,7 @@ void Augmentation::handleNonReducibleExtension(FuncInfo *funcInfo) {
       }
     }
     for (auto exitBB : SCCSucc) {
-      extendVarLiveness(funcInfo, exitBB, headBB->front());
+      extendVarLiveness(exitBB, headBB->front());
     }
   }
 }
@@ -4199,7 +4118,7 @@ void Augmentation::handleLoopExtension(FuncInfo *funcInfo) {
             std::cout << "==> Extend live-in for BB" << exitBB->getId() << "\n";
             exitBB->emit(std::cout);
           });
-          extendVarLiveness(funcInfo, exitBB, startInst);
+          extendVarLiveness(exitBB, startInst);
         }
       }
     }
@@ -4214,10 +4133,6 @@ 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({
@@ -4235,16 +4150,11 @@ void Augmentation::handleLoopExtension(FuncInfo *funcInfo) {
 }
 
 // Extend all variables that are live at bb entry to the given inst
-void Augmentation::extendVarLiveness(FuncInfo *funcInfo, G4_BB *bb,
-                                     G4_INST *inst) {
+void Augmentation::extendVarLiveness(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
@@ -4271,7 +4181,7 @@ void Augmentation::buildLiveIntervals(FuncInfo* funcInfo) {
   for (G4_BB *curBB : funcInfo->getBBList()) {
     if (!curBB->empty()) {
       startIntervalForLiveIn(funcInfo, curBB);
-      endIntervalForLiveOut(funcInfo, curBB);
+      endIntervalForLiveOut(curBB);
     }
 
     for (G4_INST *inst : *curBB) {
@@ -5131,8 +5041,6 @@ 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)) {
@@ -5149,8 +5057,7 @@ void Augmentation::discoverArgs(FuncInfo *func) {
 
   SparseBitVector subArgs;
   if (func == kernel.fg.kernelInfo)
-    subArgs = liveAnalysis.use_in[kernel.fg.getEntryBB()->getId()] &
-              liveAnalysis.def_in[kernel.fg.getEntryBB()->getId()];
+    subArgs = liveAnalysis.use_in[kernel.fg.getEntryBB()->getId()];
   else
     subArgs = liveAnalysis.args.at(func);
 
@@ -5167,10 +5074,6 @@ 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");
   }
 
 
@@ -5210,16 +5113,6 @@ 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) {
@@ -5679,17 +5572,16 @@ void Augmentation::augmentIntfGraph() {
   bool nonDefaultMaskDef = markNonDefaultMaskDef();
 
   if (nonDefaultMaskDef == true) {
-    if (augWithHoles) {
-      if (kernel.fg.getNumFuncs() > 0)
-        populateFuncMaps();
-
-      populateHomeFunc();
+    if (augWithHoles && kernel.fg.getNumFuncs() > 0)
+      populateFuncMaps();
 
+    if (augWithHoles) {
       // 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,17 +429,6 @@ 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
@@ -450,7 +439,6 @@ 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())
@@ -496,11 +484,6 @@ 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,
@@ -539,12 +522,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(FuncInfo *funcInfo, G4_BB *bb);
+  void endIntervalForLiveOut(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(FuncInfo *funcInfo, G4_BB *bb, G4_INST *inst);
+  void extendVarLiveness(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,7 +11,6 @@ SPDX-License-Identifier: MIT
 #include "BitSet.h"
 #include "G4_BB.hpp"
 #include "G4_Kernel.hpp"
-#include "PointsToAnalysis.h"
 
 using namespace vISA;
 
@@ -1033,17 +1032,6 @@ 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) {
@@ -1069,16 +1057,6 @@ 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,7 +16,6 @@ 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
@@ -92,24 +91,19 @@ class PostDom : public Analysis {
 };
 
 // Computes and stores direct references of variables.
-// Indirects references are computed only if PointsToAnalysis instance
-// is valid.
+// Indirects references are not computed here.
 class VarReferences : public Analysis {
 public:
   VarReferences(G4_Kernel &k, bool GRF = false, bool bounds = true,
-                bool pseudoKills = false, PointsToAnalysis* p = nullptr)
+                bool pseudoKills = false)
       : kernel(k), onlyGRF(GRF), needBounds(bounds),
-        reportPseudoKill(pseudoKills), p2a(p) {}
+        reportPseudoKill(pseudoKills) {}
 
   // 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);
@@ -126,7 +120,6 @@ class VarReferences : public Analysis {
   bool onlyGRF = false;
   bool needBounds = true;
   bool reportPseudoKill = false;
-  PointsToAnalysis *p2a = nullptr;
 
   void reset() override;
   void run() override;