Subzero: Automatically infer regalloc preferences and overlap.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LinearScan class, which performs the
 // linear-scan register allocation after liveness analysis has been
 // performed.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceCfg.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceRegAlloc.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
+namespace {
+
+// Returns true if Var has any definitions within Item's live range.
+bool overlapsDefs(const Cfg *Func, const LiveRangeWrapper &Item,
+                  const Variable *Var) {
+  VariablesMetadata *VMetadata = Func->getVMetadata();
+  const InstDefList &Defs = VMetadata->getDefinitions(Var);
+  for (size_t i = 0; i < Defs.size(); ++i) {
+    if (Item.range().overlaps(Defs[i]->getNumber()))
+      return true;
+  }
+  return false;
+}
+
+} // end of anonymous namespace
+
 // Implements the linear-scan algorithm.  Based on "Linear Scan
 // Register Allocation in the Context of SSA Form and Register
 // Constraints" by Hanspeter Mössenböck and Michael Pfeiffer,
 // ftp://ftp.ssw.uni-linz.ac.at/pub/Papers/Moe02.PDF .  This
 // implementation is modified to take affinity into account and allow
 // two interfering variables to share the same register in certain
 // cases.
 //
 // Requires running Cfg::liveness(Liveness_Intervals) in
 // preparation.  Results are assigned to Variable::RegNum for each
 // Variable.
 void LinearScan::scan(const llvm::SmallBitVector &RegMaskFull) {
   assert(RegMaskFull.any()); // Sanity check
   Unhandled.clear();
   Handled.clear();
   Inactive.clear();
   Active.clear();
   Ostream &Str = Func->getContext()->getStrDump();
   Func->resetCurrentNode();
+  VariablesMetadata *VMetadata = Func->getVMetadata();
 
   // Gather the live ranges of all variables and add them to the
   // Unhandled set.  TODO: Unhandled is a set<> which is based on a
   // balanced binary tree, so inserting live ranges for N variables is
   // O(N log N) complexity.  N may be proportional to the number of
   // instructions, thanks to temporary generation during lowering.  As
   // a result, it may be useful to design a better data structure for
   // storing Func->getVariables().
   const VarList &Vars = Func->getVariables();
   for (VarList::const_iterator I = Vars.begin(), E = Vars.end(); I != E; ++I) {
@@ skipping 125 matching lines @@
       }
     }
 
     // Calculate available registers into Free[].
     llvm::SmallBitVector Free = RegMask;
     for (SizeT i = 0; i < RegMask.size(); ++i) {
       if (RegUses[i] > 0)
         Free[i] = false;
     }
 
+    // Infer register preference and allowable overlap.  Only form a
+    // preference when the current Variable has an unambiguous "first"
+    // definition.  The preference is some source Variable of the
+    // defining instruction that either is assigned a register that is
+    // currently free, or that is assigned a register that is not free
+    // but overlap is allowed.  Overlap is allowed when the Variable
+    // under consideration is single-definition, and its definition is
+    // a simple assignment - i.e., the register gets copied/aliased
+    // but is never modified.  Furthermore, overlap is only allowed
+    // when preferred Variable definition instructions do not appear
+    // within the current Variable's live range.
+    Variable *Prefer = NULL;
+    bool AllowedToOverlap = false;
+    if (const Inst *DefInst = VMetadata->getSingleDefinition(Cur.Var)) {

[jvoung (off chromium), 2014/09/25 16:42:11]

Was this meant to be getFirstDefinition() (based on the above comment "has an
unambiguous "first" defining instruction).

On the other hand, the check below requires Cur.Var to be singledef.

[Jim Stichnoth, 2014/09/25 18:13:55]

Yeah, fixed.
 
The Overlap check requires single-def, but not for the Prefer hint.

+      assert(DefInst->getDest() == Cur.Var);
+      bool IsAssign = DefInst->isSimpleAssign();
+      bool IsSingleDef = !VMetadata->isMultiDef(Cur.Var);
+      for (SizeT i = 0; i < DefInst->getSrcSize(); ++i) {
+        if (Variable *SrcVar = llvm::dyn_cast<Variable>(DefInst->getSrc(i))) {
+          // The NoConflictingDefs condition is supposed to accurately
+          // represent this requirement: "overlap is only allowed when
+          // preferred Variable definition instructions do not appear
+          // within the current Variable's live range."
+          bool NoConflictingDefs = !overlapsDefs(Func, Cur, SrcVar);
+          int32_t SrcReg = SrcVar->getRegNumTmp();
+          if (SrcReg != Variable::NoRegister && RegMask[SrcReg]) {

[jvoung (off chromium), 2014/09/25 16:42:11]

Would it be better to check SrcReg != Variable::NoRegister && RegMask[SrcReg]
first, before calling overlapsDefs()? Seems like it could be cheaper.

[Jim Stichnoth, 2014/09/25 18:13:55]

Yes.  That should be fixed in the latest patchset.

+            AllowedToOverlap = IsSingleDef && NoConflictingDefs && IsAssign;
+            if (AllowedToOverlap || Free[SrcReg])

[jvoung (off chromium), 2014/09/25 16:42:11]

Similar, would it be cheaper to check for Free[SrcReg] earlier, before calling
overlapsDefs to determine AllowedToOverlap?

[Jim Stichnoth, 2014/09/25 18:13:55]

Hmm, I think you're right.  The logs do show a lot of cases where Overlap is set
to true yet the variable is listed as free.  Changed.

+              Prefer = SrcVar;
+          }
+        }
+      }
+    }
+    if (Func->getContext()->isVerbose(IceV_LinearScan)) {
+      if (Prefer) {
+        Str << "Initial Prefer=" << *Prefer << " R=" << Prefer->getRegNumTmp()
+            << " LIVE=" << Prefer->getLiveRange()
+            << " Overlap=" << AllowedToOverlap << "\n";
+      }
+    }
+
     // Remove registers from the Free[] list where an Inactive range
     // overlaps with the current range.
     for (UnorderedRanges::const_iterator I = Inactive.begin(),
                                          E = Inactive.end();
          I != E; ++I) {
       LiveRangeWrapper Item = *I;
       if (Item.overlaps(Cur)) {
         int32_t RegNum = Item.Var->getRegNumTmp();
         // Don't assert(Free[RegNum]) because in theory (though
         // probably never in practice) there could be two inactive
         // variables that were allowed marked with
         // AllowRegisterOverlap.
         Free[RegNum] = false;
+        // If there is a variable on the inactive list, which is not
+        // Prefer, and overlaps with Cur, and shares Prefer's
+        // register, then disallow overlap.
+        if (AllowedToOverlap && Item.Var != Prefer &&
+            RegNum == Prefer->getRegNumTmp() && Item.overlaps(Cur)) {
+          AllowedToOverlap = false;
+          if (Func->getContext()->isVerbose(IceV_LinearScan)) {
+            Str << "Disabling Overlap due to Inactive " << *Item.Var
+                << " LIVE=" << Item.Var->getLiveRange() << "\n";
+          }
+        }
       }
     }
 
+    // Disable AllowOverlap if the preferred register is already used
+    // in an Active range (which by definition overlaps) that is not
+    // Prefer.  TODO(stichnot): Actually only disable AllowOverlap if
+    // an Active variable with the preferred register has a definition
+    // within the current variable's live range.
+
+    // If there is a variable on the active list, which is not Prefer,
+    // and shares Prefer's register, and has a definition within Cur's
+    // live range, then disallow overlap.
+    for (UnorderedRanges::iterator I = Active.begin(), E = Active.end();
+         AllowedToOverlap && I != E; ++I) {
+      LiveRangeWrapper Item = *I;
+      int32_t RegNum = Item.Var->getRegNumTmp();
+      if (Item.Var != Prefer && RegNum == Prefer->getRegNumTmp() &&
+          overlapsDefs(Func, Cur, Item.Var)) {
+        AllowedToOverlap = false;
+        if (Func->getContext()->isVerbose(IceV_LinearScan)) {
+          Str << "Disabling Overlap due to Active " << *Item.Var
+              << " LIVE=" << Item.Var->getLiveRange() << "\n";
+        }
+      }
+    }
+
     // Remove registers from the Free[] list where an Unhandled range
     // overlaps with the current range and is precolored.
     // Cur.endsBefore(*I) is an early exit check that turns a
     // guaranteed O(N^2) algorithm into expected linear complexity.
     llvm::SmallBitVector PrecoloredUnhandled(RegMask.size());
     for (OrderedRanges::const_iterator I = Unhandled.begin(),
                                        E = Unhandled.end();
          I != E && !Cur.endsBefore(*I); ++I) {
       LiveRangeWrapper Item = *I;
       if (Item.Var->hasReg() && Item.overlaps(Cur)) {
         Free[Item.Var->getRegNum()] = false; // Note: getRegNum not getRegNumTmp
         PrecoloredUnhandled[Item.Var->getRegNum()] = true;
+        // Disallow overlap if the preferred register is one of these
+        // precolored unhandled overlapping ranges.
+        if (AllowedToOverlap && Prefer &&

[jvoung (off chromium), 2014/09/25 16:42:11]

nit: I think technically, the "&& Prefer" check isn't needed after checking
AllowedToOverlap -- otherwise, some of the loops above seem to assume that
AllowedToOverlap => Prefer != NULL.

Also, Item.overlaps(Cur) so Cur.overlaps(Item) shouldn't be needed either?

[Jim Stichnoth, 2014/09/25 18:13:54]

Done.  I think I originally had that just to be absolutely sure the following
Prefer->getRegNumTmp() wasn't a null pointer dereference, but I've changed that
to use PreferReg so that issue is gone.
Nice, done.

+            Item.Var->getRegNum() == Prefer->getRegNumTmp() &&
+            Cur.overlaps(Item)) {
+          AllowedToOverlap = false;
+          if (Func->getContext()->isVerbose(IceV_LinearScan)) {
+            Str << "Disabling Overlap due to UnhandledPrecolored " << *Item.Var
+                << " LIVE=" << Item.Var->getLiveRange() << "\n";
+          }
+        }
       }
     }
 
     // Print info about physical register availability.
     if (Func->getContext()->isVerbose(IceV_LinearScan)) {
       for (SizeT i = 0; i < RegMask.size(); ++i) {
         if (RegMask[i]) {
           Str << Func->getTarget()->getRegName(i, IceType_i32)
               << "(U=" << RegUses[i] << ",F=" << Free[i]
               << ",P=" << PrecoloredUnhandled[i] << ") ";
         }
       }
       Str << "\n";
     }
 
-    Variable *Prefer = Cur.Var->getPreferredRegister();
-    int32_t PreferReg = Prefer && Prefer->hasRegTmp() ? Prefer->getRegNumTmp()
-                                                      : Variable::NoRegister;
-    bool AllowedToOverlap = Cur.Var->getRegisterOverlap() &&
-                            PreferReg != Variable::NoRegister &&
-                            RegMask[PreferReg] &&
-                            !PrecoloredUnhandled[PreferReg];

[jvoung (off chromium), 2014/09/25 16:42:11]

It now seems like PrecoloredUnhandled is no longer read (except in the debug
printing)?

[Jim Stichnoth, 2014/09/25 18:13:54]

True.  It's worth keeping for the diagnostics, so I added a comment.

+    int32_t PreferReg = Variable::NoRegister;
+    if (Prefer && Prefer->hasRegTmp())
+      PreferReg = Prefer->getRegNumTmp();
     if (PreferReg != Variable::NoRegister &&
         (AllowedToOverlap || Free[PreferReg])) {
       // First choice: a preferred register that is either free or is
       // allowed to overlap with its linked variable.
       Cur.Var->setRegNumTmp(PreferReg);
       if (Func->getContext()->isVerbose(IceV_LinearScan)) {
         Str << "Preferring   ";
         Cur.dump(Func);
         Str << "\n";
       }
@@ skipping 221 matching lines @@
   }
   Str << "++++++ Inactive:\n";
   for (UnorderedRanges::const_iterator I = Inactive.begin(), E = Inactive.end();
        I != E; ++I) {
     I->dump(Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice