From d6de40f8865e2c016731f9b63d8a0a218ce1b74f Mon Sep 17 00:00:00 2001 From: Mircea Trofin Date: Tue, 29 Sep 2020 09:09:25 -0700 Subject: [PATCH] [NFC][regalloc] Make VirtRegAuxInfo part of allocator state All the state of VRAI is allocator-wide, so we can avoid creating it every time we need it. In addition, the normalization function is allocator-specific. In a next change, we can simplify that design in favor of just having it as a virtual member. Differential Revision: https://reviews.llvm.org/D88499 --- llvm/include/llvm/CodeGen/CalcSpillWeights.h | 14 ++++---------- llvm/lib/CodeGen/CalcSpillWeights.cpp | 14 ++++---------- llvm/lib/CodeGen/RegAllocBasic.cpp | 7 +++---- llvm/lib/CodeGen/RegAllocGreedy.cpp | 15 ++++++++------- llvm/lib/CodeGen/RegAllocPBQP.cpp | 5 +++-- 5 files changed, 22 insertions(+), 33 deletions(-) diff --git a/llvm/include/llvm/CodeGen/CalcSpillWeights.h b/llvm/include/llvm/CodeGen/CalcSpillWeights.h index 9b8b732..d2e7917 100644 --- a/llvm/include/llvm/CodeGen/CalcSpillWeights.h +++ b/llvm/include/llvm/CodeGen/CalcSpillWeights.h @@ -91,17 +91,11 @@ class VirtRegMap; /// \return The spill weight. Returns negative weight for unspillable li. float weightCalcHelper(LiveInterval &li, SlotIndex *start = nullptr, SlotIndex *end = nullptr); - }; - - /// Compute spill weights and allocation hints for all virtual register - /// live intervals. - void calculateSpillWeightsAndHints(LiveIntervals &LIS, MachineFunction &MF, - VirtRegMap *VRM, - const MachineLoopInfo &MLI, - const MachineBlockFrequencyInfo &MBFI, - VirtRegAuxInfo::NormalizingFn norm = - normalizeSpillWeight); + /// Compute spill weights and allocation hints for all virtual register + /// live intervals. + void calculateSpillWeightsAndHints(); + }; } // end namespace llvm #endif // LLVM_CODEGEN_CALCSPILLWEIGHTS_H diff --git a/llvm/lib/CodeGen/CalcSpillWeights.cpp b/llvm/lib/CodeGen/CalcSpillWeights.cpp index 75cf6a6..4f59e08 100644 --- a/llvm/lib/CodeGen/CalcSpillWeights.cpp +++ b/llvm/lib/CodeGen/CalcSpillWeights.cpp @@ -28,22 +28,16 @@ using namespace llvm; #define DEBUG_TYPE "calcspillweights" -void llvm::calculateSpillWeightsAndHints(LiveIntervals &LIS, - MachineFunction &MF, - VirtRegMap *VRM, - const MachineLoopInfo &MLI, - const MachineBlockFrequencyInfo &MBFI, - VirtRegAuxInfo::NormalizingFn norm) { +void VirtRegAuxInfo::calculateSpillWeightsAndHints() { LLVM_DEBUG(dbgs() << "********** Compute Spill Weights **********\n" << "********** Function: " << MF.getName() << '\n'); MachineRegisterInfo &MRI = MF.getRegInfo(); - VirtRegAuxInfo VRAI(MF, LIS, VRM, MLI, MBFI, norm); - for (unsigned i = 0, e = MRI.getNumVirtRegs(); i != e; ++i) { - unsigned Reg = Register::index2VirtReg(i); + for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) { + unsigned Reg = Register::index2VirtReg(I); if (MRI.reg_nodbg_empty(Reg)) continue; - VRAI.calculateSpillWeightAndHint(LIS.getInterval(Reg)); + calculateSpillWeightAndHint(LIS.getInterval(Reg)); } } diff --git a/llvm/lib/CodeGen/RegAllocBasic.cpp b/llvm/lib/CodeGen/RegAllocBasic.cpp index 0fa50d9..8bbbbeb 100644 --- a/llvm/lib/CodeGen/RegAllocBasic.cpp +++ b/llvm/lib/CodeGen/RegAllocBasic.cpp @@ -311,10 +311,9 @@ bool RABasic::runOnMachineFunction(MachineFunction &mf) { RegAllocBase::init(getAnalysis(), getAnalysis(), getAnalysis()); - - calculateSpillWeightsAndHints(*LIS, *MF, VRM, - getAnalysis(), - getAnalysis()); + VirtRegAuxInfo VRAI(*MF, *LIS, VRM, getAnalysis(), + getAnalysis()); + VRAI.calculateSpillWeightsAndHints(); SpillerInstance.reset(createInlineSpiller(*this, *MF, *VRM)); diff --git a/llvm/lib/CodeGen/RegAllocGreedy.cpp b/llvm/lib/CodeGen/RegAllocGreedy.cpp index eb0a096..c159539 100644 --- a/llvm/lib/CodeGen/RegAllocGreedy.cpp +++ b/llvm/lib/CodeGen/RegAllocGreedy.cpp @@ -172,6 +172,7 @@ class RAGreedy : public MachineFunctionPass, std::unique_ptr SpillerInstance; PQueue Queue; unsigned NextCascade; + std::unique_ptr VRAI; // Live ranges pass through a number of stages as we try to allocate them. // Some of the stages may also create new live ranges: @@ -1507,10 +1508,9 @@ bool RAGreedy::splitCanCauseEvictionChain(unsigned Evictee, // Now, check to see if the local interval we will create is going to be // expensive enough to evict somebody If so, this may cause a bad eviction // chain. - VirtRegAuxInfo VRAI(*MF, *LIS, VRM, getAnalysis(), *MBFI); float splitArtifactWeight = - VRAI.futureWeight(LIS->getInterval(Evictee), - Cand.Intf.first().getPrevIndex(), Cand.Intf.last()); + VRAI->futureWeight(LIS->getInterval(Evictee), + Cand.Intf.first().getPrevIndex(), Cand.Intf.last()); if (splitArtifactWeight >= 0 && splitArtifactWeight < MaxWeight) return false; @@ -1550,10 +1550,9 @@ bool RAGreedy::splitCanCauseLocalSpill(unsigned VirtRegToSplit, // Have we found an interval that can be evicted? if (FutureEvictedPhysReg) { - VirtRegAuxInfo VRAI(*MF, *LIS, VRM, getAnalysis(), *MBFI); float splitArtifactWeight = - VRAI.futureWeight(LIS->getInterval(VirtRegToSplit), - Cand.Intf.first().getPrevIndex(), Cand.Intf.last()); + VRAI->futureWeight(LIS->getInterval(VirtRegToSplit), + Cand.Intf.first().getPrevIndex(), Cand.Intf.last()); // Will the weight of the local interval be higher than the cheapest evictee // weight? If so it will evict it and will not cause a spill. if (splitArtifactWeight >= 0 && splitArtifactWeight > CheapestEvictWeight) @@ -3228,7 +3227,9 @@ bool RAGreedy::runOnMachineFunction(MachineFunction &mf) { initializeCSRCost(); - calculateSpillWeightsAndHints(*LIS, mf, VRM, *Loops, *MBFI); + VRAI = std::make_unique(*MF, *LIS, VRM, *Loops, *MBFI); + + VRAI->calculateSpillWeightsAndHints(); LLVM_DEBUG(LIS->dump()); diff --git a/llvm/lib/CodeGen/RegAllocPBQP.cpp b/llvm/lib/CodeGen/RegAllocPBQP.cpp index 0f848f6..eb5dec5 100644 --- a/llvm/lib/CodeGen/RegAllocPBQP.cpp +++ b/llvm/lib/CodeGen/RegAllocPBQP.cpp @@ -792,8 +792,9 @@ bool RegAllocPBQP::runOnMachineFunction(MachineFunction &MF) { VirtRegMap &VRM = getAnalysis(); - calculateSpillWeightsAndHints(LIS, MF, &VRM, getAnalysis(), - MBFI, normalizePBQPSpillWeight); + VirtRegAuxInfo VRAI(MF, LIS, &VRM, getAnalysis(), MBFI, + normalizePBQPSpillWeight); + VRAI.calculateSpillWeightsAndHints(); std::unique_ptr VRegSpiller(createInlineSpiller(*this, MF, VRM)); -- 2.7.4