MachineScheduler: Integrate RegisterPressure classes into PressureTracker

[MatzeB]

Summary

Instead of forcing user to either instantiate a IntervalPressure object
or a RegionPressure object and then using a reference to it in the
PressureTracker constructor, simply integrate both into a union inside
the PressureTracker removing confusion from the interface.

It may even be a good idea to simply remove the variant working with MBB
iterators, as I couldn't find any users of that.

[atrick]

OK other than the strange spelling.

I don't really understand how this is better but the original code wasn't great, so if it makes future work easier than go for it.

include/llvm/CodeGen/RegisterPressure.h

204

Indices not Indizes.

include/llvm/CodeGen/MachineScheduler.h

protected:
 
   // Map each SU to its summary of pressure changes. This array is updated for
   // liveness during bottom-up scheduling. Top-down scheduling may proceed but
   // has no affect on the pressure diffs.
   PressureDiffs SUPressureDiffs;
 
   /// Register pressure in this region computed by initRegPressure.
   bool ShouldTrackPressure;
-  IntervalPressure RegPressure;
   RegPressureTracker RPTracker;
 
   /// List of pressure sets that exceed the target's pressure limit before
   /// scheduling, listed in increasing set ID order. Each pressure set is paired
   /// with its max pressure in the currently scheduled regions.
   std::vector<PressureChange> RegionCriticalPSets;
 
   /// The top of the unscheduled zone.
-  IntervalPressure TopPressure;
   RegPressureTracker TopRPTracker;
 
   /// The bottom of the unscheduled zone.
-  IntervalPressure BotPressure;
   RegPressureTracker BotRPTracker;
 
 public:
   ScheduleDAGMILive(MachineSchedContext *C,
                     std::unique_ptr<MachineSchedStrategy> S)
       : ScheduleDAGMI(C, std::move(S), /*IsPostRA=*/false),
         RegClassInfo(C->RegClassInfo), DFSResult(nullptr),
-        ShouldTrackPressure(false), RPTracker(RegPressure),
-        TopRPTracker(TopPressure), BotRPTracker(BotPressure) {}
+        ShouldTrackPressure(false), RPTracker(true), TopRPTracker(true),
+        BotRPTracker(true) {}
 
   ~ScheduleDAGMILive() override;
 
   /// Return true if this DAG supports VReg liveness and RegPressure.
   bool hasVRegLiveness() const override { return true; }
 
   /// \brief Return true if register pressure tracking is enabled.
   bool isTrackingPressure() const { return ShouldTrackPressure; }
 
   /// Get current register pressure for the top scheduled instructions.
-  const IntervalPressure &getTopPressure() const { return TopPressure; }
   const RegPressureTracker &getTopRPTracker() const { return TopRPTracker; }
 
   /// Get current register pressure for the bottom scheduled instructions.
-  const IntervalPressure &getBotPressure() const { return BotPressure; }
   const RegPressureTracker &getBotRPTracker() const { return BotRPTracker; }
 
   /// Get register pressure for the entire scheduling region before scheduling.
   ArrayRef<unsigned> getMaxSetPressure() const {
     return RPTracker.getMaxSetPressure();
   }
 
   const std::vector<PressureChange> &getRegionCriticalPSets() const {

include/llvm/CodeGen/RegisterPressure.h

 
 namespace llvm {
 
 class LiveIntervals;
 class LiveRange;
 class RegisterClassInfo;
 class MachineInstr;
 
-/// Base class for register pressure results.
-struct RegisterPressure {
-};
-
-/// RegisterPressure computed within a region of instructions delimited by
-/// TopIdx and BottomIdx.  During pressure computation, the maximum pressure per
-/// register pressure set is increased. Once pressure within a region is fully
-/// computed, the live-in and live-out sets are recorded.
-///
-/// This is preferable to RegionPressure when LiveIntervals are available,
-/// because delimiting regions by SlotIndex is more robust and convenient than
-/// holding block iterators. The block contents can change without invalidating
-/// the pressure result.
-struct IntervalPressure : RegisterPressure {
-  /// Record the boundary of the region being tracked.
-  SlotIndex TopIdx;
-  SlotIndex BottomIdx;
-
-  void reset();
-
-  void openTop(SlotIndex NextTop);
-
-  void openBottom(SlotIndex PrevBottom);
-};
-
-/// RegisterPressure computed within a region of instructions delimited by
-/// TopPos and BottomPos. This is a less precise version of IntervalPressure for
-/// use when LiveIntervals are unavailable.
-struct RegionPressure : RegisterPressure {
-  /// Record the boundary of the region being tracked.
-  MachineBasicBlock::const_iterator TopPos;
-  MachineBasicBlock::const_iterator BottomPos;
-
-  void reset();
-
-  void openTop(MachineBasicBlock::const_iterator PrevTop);
-
-  void openBottom(MachineBasicBlock::const_iterator PrevBottom);
-};
-
 /// Capture a change in pressure for a single pressure set. UnitInc may be
 /// expressed in terms of upward or downward pressure depending on the client
 /// and will be dynamically adjusted for current liveness.
 ///
 /// Pressure increments are tiny, typically 1-2 units, and this is only for
 /// heuristics, so we don't check UnitInc overflow. Instead, we may have a
 /// higher level assert that pressure is consistent within a region. We also
 /// effectively ignore dead defs which don't affect heuristics much.
class RegPressureTracker {
   const TargetRegisterInfo  *TRI;
   const RegisterClassInfo   *RCI;
   const MachineRegisterInfo *MRI;
   const LiveIntervals       *LIS;
 
   /// We currently only allow pressure tracking within a block.
   const MachineBasicBlock *MBB;
 
-  /// Track the max pressure within the region traversed so far.
-  RegisterPressure &P;
+  /// Boundary of the region being tracked.
+  union Boundary {
+    struct {
+      SlotIndex TopIdx;
+      SlotIndex BottomIdx;
+    } Indizes;
+    struct {
+      MachineBasicBlock::const_iterator TopPos;
+      MachineBasicBlock::const_iterator BottomPos;
+    } Iters;
+    Boundary() {}
+  } Boundary;
 
-  /// Run in two modes dependending on whether constructed with IntervalPressure
-  /// or RegisterPressure. If requireIntervals is false, LIS are ignored.
+  /// Run in two modes dependending on whether live intervals are available.
   bool RequireIntervals;
 
   /// True if UntiedDefs will be populated.
   bool TrackUntiedDefs;
 
   /// Register pressure corresponds to liveness before this instruction
   /// iterator. It may point to the end of the block or a DebugValue rather than
   /// an instruction.
class RegPressureTracker {
   /// List of live in virtual registers or physical register units.
   SmallVector<unsigned,8> LiveInRegs;
   /// List of live out virtual registers or physical register units.
   SmallVector<unsigned,8> LiveOutRegs;
   /// Live-through pressure.
   std::vector<unsigned> LiveThruPressure;
 
 public:
-  RegPressureTracker(IntervalPressure &rp) :
-    MF(nullptr), TRI(nullptr), RCI(nullptr), LIS(nullptr), MBB(nullptr), P(rp),
-    RequireIntervals(true), TrackUntiedDefs(false) {}
-
-  RegPressureTracker(RegionPressure &rp) :
-    MF(nullptr), TRI(nullptr), RCI(nullptr), LIS(nullptr), MBB(nullptr), P(rp),
-    RequireIntervals(false), TrackUntiedDefs(false) {}
+  RegPressureTracker(bool RequireIntervals) :
+    MF(nullptr), TRI(nullptr), RCI(nullptr), LIS(nullptr), MBB(nullptr),
+    RequireIntervals(RequireIntervals), TrackUntiedDefs(false) {}
 
   void reset();
 
   void init(const MachineFunction *mf, const RegisterClassInfo *rci,
             const LiveIntervals *lis, const MachineBasicBlock *mbb,
             MachineBasicBlock::const_iterator pos,
             bool ShouldTrackUntiedDefs = false);
 
public:
   /// @{
   ArrayRef<unsigned> getLiveIn() const { return LiveInRegs; }
   ArrayRef<unsigned> getLiveOut() const { return LiveOutRegs; }
   ArrayRef<unsigned> getLiveThru() const { return LiveThruPressure; }
   /// Get the maximum register set pressure for the traversed region.
   ArrayRef<unsigned> getMaxSetPressure() const { return MaxSetPressure; }
   /// @}
 
-  /// Get the resulting register pressure over the traversed region.
-  /// This result is complete if either advance() or recede() has returned true,
-  /// or if closeRegion() was explicitly invoked.
-  RegisterPressure &getPressure() { return P; }
-  const RegisterPressure &getPressure() const { return P; }
-
   /// Get the register set pressure at the current position, which may be less
   /// than the pressure across the traversed region.
   std::vector<unsigned> &getRegSetPressureAtPos() { return CurrSetPressure; }
 
   void discoverLiveOut(unsigned Reg);
   void discoverLiveIn(unsigned Reg);
 
   bool isTopClosed() const;

lib/CodeGen/RegisterPressure.cpp

 }
 
 /// Simply decrease the current pressure as impacted by these registers.
 void RegPressureTracker::decreaseRegPressure(ArrayRef<unsigned> RegUnits) {
   for (unsigned I = 0, E = RegUnits.size(); I != E; ++I)
     decreaseSetPressure(CurrSetPressure, MRI->getPressureSets(RegUnits[I]));
 }
 
-/// Clear the result so it can be used for another round of pressure tracking.
-void IntervalPressure::reset() {
-  TopIdx = BottomIdx = SlotIndex();
-}
-
-/// Clear the result so it can be used for another round of pressure tracking.
-void RegionPressure::reset() {
-  TopPos = BottomPos = MachineBasicBlock::const_iterator();
-}
-
-/// If the current top is not less than or equal to the next index, open it.
-/// We happen to need the SlotIndex for the next top for pressure update.
-void IntervalPressure::openTop(SlotIndex NextTop) {
-  if (TopIdx <= NextTop)
-    return;
-  TopIdx = SlotIndex();
-}
-
-/// If the current top is the previous instruction (before receding), open it.
-void RegionPressure::openTop(MachineBasicBlock::const_iterator PrevTop) {
-  if (TopPos != PrevTop)
-    return;
-  TopPos = MachineBasicBlock::const_iterator();
-}
-
-/// If the current bottom is not greater than the previous index, open it.
-void IntervalPressure::openBottom(SlotIndex PrevBottom) {
-  if (BottomIdx > PrevBottom)
-    return;
-  BottomIdx = SlotIndex();
-}
-
-/// If the current bottom is the previous instr (before advancing), open it.
-void RegionPressure::openBottom(MachineBasicBlock::const_iterator PrevBottom) {
-  if (BottomPos != PrevBottom)
-    return;
-  BottomPos = MachineBasicBlock::const_iterator();
-}
-
 const LiveRange *RegPressureTracker::getLiveRange(unsigned Reg) const {
   if (TargetRegisterInfo::isVirtualRegister(Reg))
     return &LIS->getInterval(Reg);
   return LIS->getCachedRegUnit(Reg);
 }
 
 void RegPressureTracker::reset() {
   MBB = nullptr;
   LIS = nullptr;
 
   CurrSetPressure.clear();
   LiveThruPressure.clear();
   MaxSetPressure.clear();
 
-  if (RequireIntervals)
-    static_cast<IntervalPressure&>(P).reset();
-  else
-    static_cast<RegionPressure&>(P).reset();
+  if (RequireIntervals) {
+    Boundary.Indizes.TopIdx = SlotIndex();
+    Boundary.Indizes.BottomIdx = SlotIndex();
+  } else {
+    Boundary.Iters.TopPos = MachineBasicBlock::const_iterator();
+    Boundary.Iters.BottomPos = MachineBasicBlock::const_iterator();
+  }
   MaxSetPressure.clear();
   LiveInRegs.clear();
   LiveOutRegs.clear();
 
   LiveRegs.PhysRegs.clear();
   LiveRegs.VirtRegs.clear();
   UntiedDefs.clear();
 }
void RegPressureTracker::init(const MachineFunction *mf,
   LiveRegs.PhysRegs.setUniverse(TRI->getNumRegs());
   LiveRegs.VirtRegs.setUniverse(MRI->getNumVirtRegs());
   if (TrackUntiedDefs)
     UntiedDefs.setUniverse(MRI->getNumVirtRegs());
 }
 
 /// Does this pressure result have a valid top position and live ins.
 bool RegPressureTracker::isTopClosed() const {
-  if (RequireIntervals)
-    return static_cast<IntervalPressure&>(P).TopIdx.isValid();
-  return (static_cast<RegionPressure&>(P).TopPos ==
-          MachineBasicBlock::const_iterator());
+  return RequireIntervals ? Boundary.Indizes.TopIdx.isValid()
+    : Boundary.Iters.TopPos == MachineBasicBlock::const_iterator();
 }
 
 /// Does this pressure result have a valid bottom position and live outs.
 bool RegPressureTracker::isBottomClosed() const {
-  if (RequireIntervals)
-    return static_cast<IntervalPressure&>(P).BottomIdx.isValid();
-  return (static_cast<RegionPressure&>(P).BottomPos ==
-          MachineBasicBlock::const_iterator());
+  return RequireIntervals ? Boundary.Indizes.BottomIdx.isValid()
+    : Boundary.Iters.BottomPos == MachineBasicBlock::const_iterator();
 }
 
 
 SlotIndex RegPressureTracker::getCurrSlot() const {
   MachineBasicBlock::const_iterator IdxPos = CurrPos;
   while (IdxPos != MBB->end() && IdxPos->isDebugValue())
     ++IdxPos;
   if (IdxPos == MBB->end())
     return LIS->getMBBEndIdx(MBB);
   return LIS->getInstructionIndex(IdxPos).getRegSlot();
 }
 
 /// Set the boundary for the top of the region and summarize live ins.
 void RegPressureTracker::closeTop() {
   if (RequireIntervals)
-    static_cast<IntervalPressure&>(P).TopIdx = getCurrSlot();
+    Boundary.Indizes.TopIdx = getCurrSlot();
   else
-    static_cast<RegionPressure&>(P).TopPos = CurrPos;
+    Boundary.Iters.TopPos = CurrPos;
 
   assert(LiveInRegs.empty() && "inconsistent max pressure result");
   LiveInRegs.reserve(LiveRegs.PhysRegs.size() + LiveRegs.VirtRegs.size());
   LiveInRegs.append(LiveRegs.PhysRegs.begin(), LiveRegs.PhysRegs.end());
   LiveInRegs.append(LiveRegs.VirtRegs.begin(), LiveRegs.VirtRegs.end());
 }
 
 /// Set the boundary for the bottom of the region and summarize live outs.
 void RegPressureTracker::closeBottom() {
   if (RequireIntervals)
-    static_cast<IntervalPressure&>(P).BottomIdx = getCurrSlot();
+    Boundary.Indizes.BottomIdx = getCurrSlot();
   else
-    static_cast<RegionPressure&>(P).BottomPos = CurrPos;
+    Boundary.Iters.BottomPos = CurrPos;
 
   assert(LiveOutRegs.empty() && "inconsistent max pressure result");
   LiveOutRegs.reserve(LiveRegs.PhysRegs.size() + LiveRegs.VirtRegs.size());
   LiveOutRegs.append(LiveRegs.PhysRegs.begin(), LiveRegs.PhysRegs.end());
   LiveOutRegs.append(LiveRegs.VirtRegs.begin(), LiveRegs.VirtRegs.end());
 }
 
 /// Finalize the region boundaries and record live ins and live outs.
bool RegPressureTracker::recede(SmallVectorImpl<unsigned> *LiveUses,
   if (CurrPos == MBB->begin()) {
     closeRegion();
     return false;
   }
   if (!isBottomClosed())
     closeBottom();
 
   // Open the top of the region using block iterators.
-  if (!RequireIntervals && isTopClosed())
-    static_cast<RegionPressure&>(P).openTop(CurrPos);
+  if (!RequireIntervals && isTopClosed()) {
+    // If the current top is the previous instruction (before receding),
+    // open it.
+    if (Boundary.Iters.TopPos == CurrPos)
+      Boundary.Iters.TopPos = MachineBasicBlock::const_iterator();
+  }
 
   // Find the previous instruction.
   do
     --CurrPos;
   while (CurrPos != MBB->begin() && CurrPos->isDebugValue());
 
   if (CurrPos->isDebugValue()) {
     closeRegion();
     return false;
   }
   SlotIndex SlotIdx;
   if (RequireIntervals)
     SlotIdx = LIS->getInstructionIndex(CurrPos).getRegSlot();
 
   // Open the top of the region using slot indexes.
   if (isTopClosed()) {
-    if (RequireIntervals)
-      static_cast<IntervalPressure&>(P).openTop(SlotIdx);
+    if (RequireIntervals) {
+      // If the current top is not less than or equal to the next index, open
+      // it. We happen to need the SlotIndex for the next top for pressure
+      // update.
+      if (Boundary.Indizes.TopIdx > SlotIdx)
+        Boundary.Indizes.TopIdx = SlotIndex();
+    }
     LiveInRegs.clear();
   }
 
   RegisterOperands RegOpers(TRI, MRI);
   collectOperands(CurrPos, RegOpers);
 
   if (PDiff)
     collectPDiff(*PDiff, RegOpers, MRI);
if (!isTopClosed())
     closeTop();
 
   SlotIndex SlotIdx;
   if (RequireIntervals)
     SlotIdx = getCurrSlot();
 
   // Open the bottom of the region using slot indexes.
   if (isBottomClosed()) {
-    if (RequireIntervals)
-      static_cast<IntervalPressure&>(P).openBottom(SlotIdx);
-    else
-      static_cast<RegionPressure&>(P).openBottom(CurrPos);
+    if (RequireIntervals) {
+      // If the current bottom is not greater than the previous index, open it.
+      if (Boundary.Indizes.BottomIdx <= SlotIdx)
+        Boundary.Indizes.BottomIdx = SlotIndex();
+    } else {
+      // If the current bottom is the previous instr (before advancing), open
+      // it.
+      if (Boundary.Iters.BottomPos == CurrPos)
+        Boundary.Iters.BottomPos = MachineBasicBlock::const_iterator();
+    }
     LiveInRegs.clear();
   }
 
   RegisterOperands RegOpers(TRI, MRI);
   collectOperands(CurrPos, RegOpers);
 
   for (unsigned i = 0, e = RegOpers.Uses.size(); i < e; ++i) {
     unsigned Reg = RegOpers.Uses[i];