RegisterPressure: Move MaxSetPressure from RegisterPressure to PressureTracker

[MatzeB]

Summary

This is part of a patchseries to remove the RegisterPressure class.

[atrick]

LGTM except for one thing...

lib/CodeGen/RegisterPressure.cpp

163

You don't need to clear it twice.

include/llvm/CodeGen/MachineScheduler.h

public:
   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.
-  const IntervalPressure &getRegPressure() const { return RegPressure; }
+  ArrayRef<unsigned> getMaxSetPressure() const {
+    return RPTracker.getMaxSetPressure();
+  }
 
   const std::vector<PressureChange> &getRegionCriticalPSets() const {
     return RegionCriticalPSets;
   }
 
   PressureDiff &getPressureDiff(const SUnit *SU) {
     return SUPressureDiffs[SU->NodeNum];
   }
protected:
 
   // Lesser helpers...
 
   void initRegPressure();
 
   void updatePressureDiffs(ArrayRef<unsigned> LiveUses);
 
   void updateScheduledPressure(const SUnit *SU,
-                               const std::vector<unsigned> &NewMaxPressure);
+                               ArrayRef<unsigned> NewMaxPressure);
 };
 
 //===----------------------------------------------------------------------===//
 ///
 /// Helpers for implementing custom MachineSchedStrategy classes. These take
 /// care of the book-keeping associated with list scheduling heuristics.
 ///
 //===----------------------------------------------------------------------===//

include/llvm/CodeGen/RegisterPressure.h

 
 class LiveIntervals;
 class LiveRange;
 class RegisterClassInfo;
 class MachineInstr;
 
 /// Base class for register pressure results.
 struct RegisterPressure {
-  /// Map of max reg pressure indexed by pressure set ID, not class ID.
-  std::vector<unsigned> MaxSetPressure;
-
-  void dump(const TargetRegisterInfo *TRI) const;
 };
 
 /// 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,
class RegPressureTracker {
 
   /// 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.
   MachineBasicBlock::const_iterator CurrPos;
 
   /// Pressure map indexed by pressure set ID, not class ID.
   std::vector<unsigned> CurrSetPressure;
+  /// Maximum region pressure map indexed by pressure set ID, not class ID.
+  std::vector<unsigned> MaxSetPressure;
 
   /// Set of live registers.
   LiveRegSet LiveRegs;
 
   /// Set of vreg defs that start a live range.
   SparseSet<unsigned, VirtReg2IndexFunctor> UntiedDefs;
   /// List of live in virtual registers or physical register units.
   SmallVector<unsigned,8> LiveInRegs;
public:
   /// RPTracker.
   void initLiveThru(const RegPressureTracker &RPTracker);
 
   /// Copy an existing live thru pressure result.
   void initLiveThru(ArrayRef<unsigned> PressureSet) {
     LiveThruPressure.assign(PressureSet.begin(), PressureSet.end());
   }
 
+  /// @name region pressure results
+  /// These properties are complete if either advance() or recede() has returned
+  /// true or if closeRegion() was explicitely invoked.
+  /// @{
   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

lib/CodeGen/MachineScheduler.cpp

if (LiveRegionEnd != RegionEnd) {
     updatePressureDiffs(LiveUses);
   }
 
   assert(BotRPTracker.getPos() == RegionEnd && "Can't find the region bottom");
 
   // Cache the list of excess pressure sets in this region. This will also track
   // the max pressure in the scheduled code for these sets.
   RegionCriticalPSets.clear();
-  const std::vector<unsigned> &RegionPressure =
-    RPTracker.getPressure().MaxSetPressure;
+  ArrayRef<unsigned> RegionPressure = RPTracker.getMaxSetPressure();
   for (unsigned i = 0, e = RegionPressure.size(); i < e; ++i) {
     unsigned Limit = RegClassInfo->getRegPressureSetLimit(i);
     if (RegionPressure[i] > Limit) {
       DEBUG(dbgs() << TRI->getRegPressureSetName(i)
             << " Limit " << Limit
             << " Actual " << RegionPressure[i] << "\n");
       RegionCriticalPSets.push_back(PressureChange(i));
     }
   }
   DEBUG(dbgs() << "Excess PSets: ";
         for (unsigned i = 0, e = RegionCriticalPSets.size(); i != e; ++i)
           dbgs() << TRI->getRegPressureSetName(
             RegionCriticalPSets[i].getPSet()) << " ";
         dbgs() << "\n");
 }
 
 void ScheduleDAGMILive::
-updateScheduledPressure(const SUnit *SU,
-                        const std::vector<unsigned> &NewMaxPressure) {
+updateScheduledPressure(const SUnit *SU, ArrayRef<unsigned> NewMaxPressure) {
   const PressureDiff &PDiff = getPressureDiff(SU);
   unsigned CritIdx = 0, CritEnd = RegionCriticalPSets.size();
   for (PressureDiff::const_iterator I = PDiff.begin(), E = PDiff.end();
        I != E; ++I) {
     if (!I->isValid())
       break;
     unsigned ID = I->getPSet();
     while (CritIdx != CritEnd && RegionCriticalPSets[CritIdx].getPSet() < ID)
else {
       moveInstruction(MI, CurrentTop);
       TopRPTracker.setPos(MI);
     }
 
     if (ShouldTrackPressure) {
       // Update top scheduled pressure.
       TopRPTracker.advance();
       assert(TopRPTracker.getPos() == CurrentTop && "out of sync");
-      updateScheduledPressure(SU, TopRPTracker.getPressure().MaxSetPressure);
+      updateScheduledPressure(SU, TopRPTracker.getMaxSetPressure());
     }
   }
   else {
     assert(SU->isBottomReady() && "node still has unscheduled dependencies");
     MachineBasicBlock::iterator priorII =
       priorNonDebug(CurrentBottom, CurrentTop);
     if (&*priorII == MI)
       CurrentBottom = priorII;
     else {
       if (&*CurrentTop == MI) {
         CurrentTop = nextIfDebug(++CurrentTop, priorII);
         TopRPTracker.setPos(CurrentTop);
       }
       moveInstruction(MI, CurrentBottom);
       CurrentBottom = MI;
     }
     if (ShouldTrackPressure) {
       // Update bottom scheduled pressure.
       SmallVector<unsigned, 8> LiveUses;
       BotRPTracker.recede(&LiveUses);
       assert(BotRPTracker.getPos() == CurrentBottom && "out of sync");
-      updateScheduledPressure(SU, BotRPTracker.getPressure().MaxSetPressure);
+      updateScheduledPressure(SU, BotRPTracker.getMaxSetPressure());
       updatePressureDiffs(LiveUses);
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // LoadClusterMutation - DAG post-processing to cluster loads.
 //===----------------------------------------------------------------------===//
void GenericScheduler::tryCandidate(SchedCandidate &Cand,
 
   if (DAG->isTrackingPressure()) {
     // Always initialize TryCand's RPDelta.
     if (Zone.isTop()) {
       TempTracker.getMaxDownwardPressureDelta(
         TryCand.SU->getInstr(),
         TryCand.RPDelta,
         DAG->getRegionCriticalPSets(),
-        DAG->getRegPressure().MaxSetPressure);
+        DAG->getMaxSetPressure());
     }
     else {
       if (VerifyScheduling) {
         TempTracker.getMaxUpwardPressureDelta(
           TryCand.SU->getInstr(),
           &DAG->getPressureDiff(TryCand.SU),
           TryCand.RPDelta,
           DAG->getRegionCriticalPSets(),
-          DAG->getRegPressure().MaxSetPressure);
+          DAG->getMaxSetPressure());
       }
       else {
         RPTracker.getUpwardPressureDelta(
           TryCand.SU->getInstr(),
           DAG->getPressureDiff(TryCand.SU),
           TryCand.RPDelta,
           DAG->getRegionCriticalPSets(),
-          DAG->getRegPressure().MaxSetPressure);
+          DAG->getMaxSetPressure());
       }
     }
   }
   DEBUG(if (TryCand.RPDelta.Excess.isValid())
           dbgs() << "  SU(" << TryCand.SU->NodeNum << ") "
                  << TRI->getRegPressureSetName(TryCand.RPDelta.Excess.getPSet())
                  << ":" << TryCand.RPDelta.Excess.getUnitInc() << "\n");
 

lib/CodeGen/RegisterPressure.cpp

if (SetPressure[i] != 0) {
       Empty = false;
     }
   }
   if (Empty)
     dbgs() << "\n";
 }
 
 LLVM_DUMP_METHOD
-void RegisterPressure::dump(const TargetRegisterInfo *TRI) const {
-  dbgs() << "Max Pressure: ";
-  dumpRegSetPressure(MaxSetPressure, TRI);
-}
-
-LLVM_DUMP_METHOD
 void RegPressureTracker::dump() const {
   if (!isTopClosed() || !isBottomClosed()) {
     dbgs() << "Curr Pressure: ";
     dumpRegSetPressure(CurrSetPressure, TRI);
   }
-  P.dump(TRI);
+  dbgs() << "Max Pressure: ";
+  dumpRegSetPressure(MaxSetPressure, TRI);
   dbgs() << "Live In: ";
   for (unsigned i = 0, e = LiveInRegs.size(); i < e; ++i)
     dbgs() << PrintVRegOrUnit(LiveInRegs[i], TRI) << " ";
   dbgs() << '\n';
   dbgs() << "Live Out: ";
   for (unsigned i = 0, e = LiveOutRegs.size(); i < e; ++i)
     dbgs() << PrintVRegOrUnit(LiveOutRegs[i], TRI) << " ";
   dbgs() << '\n';

 /// Increase the current pressure as impacted by these registers and bump
 /// the high water mark if needed.
 void RegPressureTracker::increaseRegPressure(ArrayRef<unsigned> RegUnits) {
   for (unsigned i = 0, e = RegUnits.size(); i != e; ++i) {
     PSetIterator PSetI = MRI->getPressureSets(RegUnits[i]);
     unsigned Weight = PSetI.getWeight();
     for (; PSetI.isValid(); ++PSetI) {
       CurrSetPressure[*PSetI] += Weight;
-      if (CurrSetPressure[*PSetI] > P.MaxSetPressure[*PSetI]) {
-        P.MaxSetPressure[*PSetI] = CurrSetPressure[*PSetI];
+      if (CurrSetPressure[*PSetI] > MaxSetPressure[*PSetI]) {
+        MaxSetPressure[*PSetI] = CurrSetPressure[*PSetI];
       }
     }
   }
 }
 
 /// 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();
-  MaxSetPressure.clear();
 }
 
 /// Clear the result so it can be used for another round of pressure tracking.
 void RegionPressure::reset() {
   TopPos = BottomPos = MachineBasicBlock::const_iterator();
-  MaxSetPressure.clear();
 }
 
 /// 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();

 }
 
 void RegPressureTracker::reset() {
   MBB = nullptr;
   LIS = nullptr;
 
   CurrSetPressure.clear();
   LiveThruPressure.clear();
-  P.MaxSetPressure.clear();
+  MaxSetPressure.clear();
 
   if (RequireIntervals)
     static_cast<IntervalPressure&>(P).reset();
   else
     static_cast<RegionPressure&>(P).reset();
+  MaxSetPressure.clear();
   LiveInRegs.clear();
   LiveOutRegs.clear();
 
   LiveRegs.PhysRegs.clear();
   LiveRegs.VirtRegs.clear();
   UntiedDefs.clear();
 }
 
void RegPressureTracker::init(const MachineFunction *mf,
   if (RequireIntervals) {
     assert(lis && "IntervalPressure requires LiveIntervals");
     LIS = lis;
   }
 
   CurrPos = pos;
   CurrSetPressure.assign(TRI->getNumRegPressureSets(), 0);
 
-  P.MaxSetPressure = CurrSetPressure;
+  MaxSetPressure = CurrSetPressure;
 
   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.

 /// Add Reg to the live in set and increase max pressure.
 void RegPressureTracker::discoverLiveIn(unsigned Reg) {
   assert(!LiveRegs.contains(Reg) && "avoid bumping max pressure twice");
   if (containsReg(LiveInRegs, Reg))
     return;
 
   // At live in discovery, unconditionally increase the high water mark.
   LiveInRegs.push_back(Reg);
-  increaseSetPressure(P.MaxSetPressure, MRI->getPressureSets(Reg));
+  increaseSetPressure(MaxSetPressure, MRI->getPressureSets(Reg));
 }
 
 /// Add Reg to the live out set and increase max pressure.
 void RegPressureTracker::discoverLiveOut(unsigned Reg) {
   assert(!LiveRegs.contains(Reg) && "avoid bumping max pressure twice");
   if (containsReg(LiveOutRegs, Reg))
     return;
 
   // At live out discovery, unconditionally increase the high water mark.
   LiveOutRegs.push_back(Reg);
-  increaseSetPressure(P.MaxSetPressure, MRI->getPressureSets(Reg));
+  increaseSetPressure(MaxSetPressure, MRI->getPressureSets(Reg));
 }
 
 /// Recede across the previous instruction. If LiveUses is provided, record any
 /// RegUnits that are made live by the current instruction's uses. This includes
 /// registers that are both defined and used by the instruction.  If a pressure
 /// difference pointer is provided record the changes is pressure caused by this
 /// instruction independent of liveness.
 bool RegPressureTracker::recede(SmallVectorImpl<unsigned> *LiveUses,

 getMaxUpwardPressureDelta(const MachineInstr *MI, PressureDiff *PDiff,
                           RegPressureDelta &Delta,
                           ArrayRef<PressureChange> CriticalPSets,
                           ArrayRef<unsigned> MaxPressureLimit) {
   // Snapshot Pressure.
   // FIXME: The snapshot heap space should persist. But I'm planning to
   // summarize the pressure effect so we don't need to snapshot at all.
   std::vector<unsigned> SavedPressure = CurrSetPressure;
-  std::vector<unsigned> SavedMaxPressure = P.MaxSetPressure;
+  std::vector<unsigned> SavedMaxPressure = MaxSetPressure;
 
   bumpUpwardPressure(MI);
 
   computeExcessPressureDelta(SavedPressure, CurrSetPressure, Delta, RCI,
                              LiveThruPressure);
-  computeMaxPressureDelta(SavedMaxPressure, P.MaxSetPressure, CriticalPSets,
+  computeMaxPressureDelta(SavedMaxPressure, MaxSetPressure, CriticalPSets,
                           MaxPressureLimit, Delta);
   assert(Delta.CriticalMax.getUnitInc() >= 0 &&
          Delta.CurrentMax.getUnitInc() >= 0 && "cannot decrease max pressure");
 
   // Restore the tracker's state.
-  P.MaxSetPressure.swap(SavedMaxPressure);
+  MaxSetPressure.swap(SavedMaxPressure);
   CurrSetPressure.swap(SavedPressure);
 
 #ifndef NDEBUG
   if (!PDiff)
     return;
 
   // Check if the alternate algorithm yields the same result.
   RegPressureDelta Delta2;
for (PressureDiff::const_iterator
        PDiffI != PDiffE && PDiffI->isValid(); ++PDiffI) {
 
     unsigned PSetID = PDiffI->getPSet();
     unsigned Limit = RCI->getRegPressureSetLimit(PSetID);
     if (!LiveThruPressure.empty())
       Limit += LiveThruPressure[PSetID];
 
     unsigned POld = CurrSetPressure[PSetID];
-    unsigned MOld = P.MaxSetPressure[PSetID];
+    unsigned MOld = MaxSetPressure[PSetID];
     unsigned MNew = MOld;
     // Ignore DeadDefs here because they aren't captured by PressureChange.
     unsigned PNew = POld + PDiffI->getUnitInc();
     assert((PDiffI->getUnitInc() >= 0) == (PNew >= POld) && "PSet overflow");
     if (PNew > MOld)
       MNew = PNew;
     // Check if current pressure has exceeded the limit.
     if (!Delta.Excess.isValid()) {

 /// liveness. We don't yet have a fast version of downward pressure tracking
 /// analogous to getUpwardPressureDelta.
 void RegPressureTracker::
 getMaxDownwardPressureDelta(const MachineInstr *MI, RegPressureDelta &Delta,
                             ArrayRef<PressureChange> CriticalPSets,
                             ArrayRef<unsigned> MaxPressureLimit) {
   // Snapshot Pressure.
   std::vector<unsigned> SavedPressure = CurrSetPressure;
-  std::vector<unsigned> SavedMaxPressure = P.MaxSetPressure;
+  std::vector<unsigned> SavedMaxPressure = MaxSetPressure;
 
   bumpDownwardPressure(MI);
 
   computeExcessPressureDelta(SavedPressure, CurrSetPressure, Delta, RCI,
                              LiveThruPressure);
-  computeMaxPressureDelta(SavedMaxPressure, P.MaxSetPressure, CriticalPSets,
+  computeMaxPressureDelta(SavedMaxPressure, MaxSetPressure, CriticalPSets,
                           MaxPressureLimit, Delta);
   assert(Delta.CriticalMax.getUnitInc() >= 0 &&
          Delta.CurrentMax.getUnitInc() >= 0 && "cannot decrease max pressure");
 
   // Restore the tracker's state.
-  P.MaxSetPressure.swap(SavedMaxPressure);
+  MaxSetPressure.swap(SavedMaxPressure);
   CurrSetPressure.swap(SavedPressure);
 }
 
 /// Get the pressure of each PSet after traversing this instruction bottom-up.
 void RegPressureTracker::
 getUpwardPressure(const MachineInstr *MI,
                   std::vector<unsigned> &PressureResult,
                   std::vector<unsigned> &MaxPressureResult) {
   // Snapshot pressure.
   PressureResult = CurrSetPressure;
-  MaxPressureResult = P.MaxSetPressure;
+  MaxPressureResult = MaxSetPressure;
 
   bumpUpwardPressure(MI);
 
   // Current pressure becomes the result. Restore current pressure.
-  P.MaxSetPressure.swap(MaxPressureResult);
+  MaxSetPressure.swap(MaxPressureResult);
   CurrSetPressure.swap(PressureResult);
 }
 
 /// Get the pressure of each PSet after traversing this instruction top-down.
 void RegPressureTracker::
 getDownwardPressure(const MachineInstr *MI,
                     std::vector<unsigned> &PressureResult,
                     std::vector<unsigned> &MaxPressureResult) {
   // Snapshot pressure.
   PressureResult = CurrSetPressure;
-  MaxPressureResult = P.MaxSetPressure;
+  MaxPressureResult = MaxSetPressure;
 
   bumpDownwardPressure(MI);
 
   // Current pressure becomes the result. Restore current pressure.
-  P.MaxSetPressure.swap(MaxPressureResult);
+  MaxSetPressure.swap(MaxPressureResult);
   CurrSetPressure.swap(PressureResult);
 }

lib/Target/Hexagon/HexagonMachineScheduler.cpp

pickNodeFromQueue(ReadyQueue &Q, const RegPressureTracker &RPTracker,
   RegPressureTracker &TempTracker = const_cast<RegPressureTracker&>(RPTracker);
 
   // BestSU remains NULL if no top candidates beat the best existing candidate.
   CandResult FoundCandidate = NoCand;
   for (ReadyQueue::iterator I = Q.begin(), E = Q.end(); I != E; ++I) {
     RegPressureDelta RPDelta;
     TempTracker.getMaxPressureDelta((*I)->getInstr(), RPDelta,
                                     DAG->getRegionCriticalPSets(),
-                                    DAG->getRegPressure().MaxSetPressure);
+                                    DAG->getMaxSetPressure());
 
     int CurrentCost = SchedulingCost(Q, *I, Candidate, RPDelta, false);
 
     // Initialize the candidate if needed.
     if (!Candidate.SU) {
       Candidate.SU = *I;
       Candidate.RPDelta = RPDelta;
       Candidate.SCost = CurrentCost;