[llvm] 5c06f71 - [CodeGen] Remove splitCanCauseEvictionChain and its helpers (NFC)
Kazu Hirata via llvm-commits
llvm-commits at lists.llvm.org
Sun Jun 5 20:22:52 PDT 2022
Author: Kazu Hirata
Date: 2022-06-05T20:22:47-07:00
New Revision: 5c06f7168fd1bd589b831cacd5f1cb8a928446fb
URL: https://github.com/llvm/llvm-project/commit/5c06f7168fd1bd589b831cacd5f1cb8a928446fb
DIFF: https://github.com/llvm/llvm-project/commit/5c06f7168fd1bd589b831cacd5f1cb8a928446fb.diff
LOG: [CodeGen] Remove splitCanCauseEvictionChain and its helpers (NFC)
The last use was removed on Mar 7, 2022 in commit
294eca35a00f89dff474044ebd478a7f83ccc310.
Added:
Modified:
llvm/lib/CodeGen/RegAllocGreedy.cpp
llvm/lib/CodeGen/RegAllocGreedy.h
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/RegAllocGreedy.cpp b/llvm/lib/CodeGen/RegAllocGreedy.cpp
index d2e26197e94a..5f0525ad48e0 100644
--- a/llvm/lib/CodeGen/RegAllocGreedy.cpp
+++ b/llvm/lib/CodeGen/RegAllocGreedy.cpp
@@ -447,87 +447,6 @@ Register RegAllocEvictionAdvisor::canReassign(const LiveInterval &VirtReg,
return PhysReg;
}
-/// Return true if all interferences between VirtReg and PhysReg between
-/// Start and End can be evicted.
-///
-/// \param VirtReg Live range that is about to be assigned.
-/// \param PhysReg Desired register for assignment.
-/// \param Start Start of range to look for interferences.
-/// \param End End of range to look for interferences.
-/// \param MaxCost Only look for cheaper candidates and update with new cost
-/// when returning true.
-/// \return True when interference can be evicted cheaper than MaxCost.
-bool RAGreedy::canEvictInterferenceInRange(const LiveInterval &VirtReg,
- MCRegister PhysReg, SlotIndex Start,
- SlotIndex End,
- EvictionCost &MaxCost) const {
- EvictionCost Cost;
-
- for (MCRegUnitIterator Units(PhysReg, TRI); Units.isValid(); ++Units) {
- LiveIntervalUnion::Query &Q = Matrix->query(VirtReg, *Units);
-
- // Check if any interfering live range is heavier than MaxWeight.
- for (const LiveInterval *Intf : reverse(Q.interferingVRegs())) {
- // Check if interference overlast the segment in interest.
- if (!Intf->overlaps(Start, End))
- continue;
-
- // Never evict spill products. They cannot split or spill.
- if (ExtraInfo->getStage(*Intf) == RS_Done)
- return false;
-
- // Would this break a satisfied hint?
- bool BreaksHint = VRM->hasPreferredPhys(Intf->reg());
- // Update eviction cost.
- Cost.BrokenHints += BreaksHint;
- Cost.MaxWeight = std::max(Cost.MaxWeight, Intf->weight());
- // Abort if this would be too expensive.
- if (!(Cost < MaxCost))
- return false;
- }
- }
-
- if (Cost.MaxWeight == 0)
- return false;
-
- MaxCost = Cost;
- return true;
-}
-
-/// Return the physical register that will be best
-/// candidate for eviction by a local split interval that will be created
-/// between Start and End.
-///
-/// \param Order The allocation order
-/// \param VirtReg Live range that is about to be assigned.
-/// \param Start Start of range to look for interferences
-/// \param End End of range to look for interferences
-/// \param BestEvictweight The eviction cost of that eviction
-/// \return The PhysReg which is the best candidate for eviction and the
-/// eviction cost in BestEvictweight
-MCRegister RAGreedy::getCheapestEvicteeWeight(const AllocationOrder &Order,
- const LiveInterval &VirtReg,
- SlotIndex Start, SlotIndex End,
- float *BestEvictweight) const {
- EvictionCost BestEvictCost;
- BestEvictCost.setMax();
- BestEvictCost.MaxWeight = VirtReg.weight();
- MCRegister BestEvicteePhys;
-
- // Go over all physical registers and find the best candidate for eviction
- for (MCRegister PhysReg : Order.getOrder()) {
-
- if (!canEvictInterferenceInRange(VirtReg, PhysReg, Start, End,
- BestEvictCost))
- continue;
-
- // Best so far.
- BestEvicteePhys = PhysReg;
- }
- *BestEvictweight = BestEvictCost.MaxWeight;
- return BestEvicteePhys;
-}
-
/// evictInterference - Evict any interferring registers that prevent VirtReg
/// from being assigned to Physreg. This assumes that canEvictInterference
/// returned true.
@@ -898,106 +817,6 @@ BlockFrequency RAGreedy::calcSpillCost() {
return Cost;
}
-/// Check if splitting Evictee will create a local split interval in
-/// basic block number BBNumber that may cause a bad eviction chain. This is
-/// intended to prevent bad eviction sequences like:
-/// movl %ebp, 8(%esp) # 4-byte Spill
-/// movl %ecx, %ebp
-/// movl %ebx, %ecx
-/// movl %edi, %ebx
-/// movl %edx, %edi
-/// cltd
-/// idivl %esi
-/// movl %edi, %edx
-/// movl %ebx, %edi
-/// movl %ecx, %ebx
-/// movl %ebp, %ecx
-/// movl 16(%esp), %ebp # 4 - byte Reload
-///
-/// Such sequences are created in 2 scenarios:
-///
-/// Scenario #1:
-/// %0 is evicted from physreg0 by %1.
-/// Evictee %0 is intended for region splitting with split candidate
-/// physreg0 (the reg %0 was evicted from).
-/// Region splitting creates a local interval because of interference with the
-/// evictor %1 (normally region splitting creates 2 interval, the "by reg"
-/// and "by stack" intervals and local interval created when interference
-/// occurs).
-/// One of the split intervals ends up evicting %2 from physreg1.
-/// Evictee %2 is intended for region splitting with split candidate
-/// physreg1.
-/// One of the split intervals ends up evicting %3 from physreg2, etc.
-///
-/// Scenario #2
-/// %0 is evicted from physreg0 by %1.
-/// %2 is evicted from physreg2 by %3 etc.
-/// Evictee %0 is intended for region splitting with split candidate
-/// physreg1.
-/// Region splitting creates a local interval because of interference with the
-/// evictor %1.
-/// One of the split intervals ends up evicting back original evictor %1
-/// from physreg0 (the reg %0 was evicted from).
-/// Another evictee %2 is intended for region splitting with split candidate
-/// physreg1.
-/// One of the split intervals ends up evicting %3 from physreg2, etc.
-///
-/// \param Evictee The register considered to be split.
-/// \param Cand The split candidate that determines the physical register
-/// we are splitting for and the interferences.
-/// \param BBNumber The number of a BB for which the region split process will
-/// create a local split interval.
-/// \param Order The physical registers that may get evicted by a split
-/// artifact of Evictee.
-/// \return True if splitting Evictee may cause a bad eviction chain, false
-/// otherwise.
-bool RAGreedy::splitCanCauseEvictionChain(Register Evictee,
- GlobalSplitCandidate &Cand,
- unsigned BBNumber,
- const AllocationOrder &Order) {
- EvictionTrack::EvictorInfo VregEvictorInfo = LastEvicted.getEvictor(Evictee);
- unsigned Evictor = VregEvictorInfo.first;
- MCRegister PhysReg = VregEvictorInfo.second;
-
- // No actual evictor.
- if (!Evictor || !PhysReg)
- return false;
-
- float MaxWeight = 0;
- MCRegister FutureEvictedPhysReg =
- getCheapestEvicteeWeight(Order, LIS->getInterval(Evictee),
- Cand.Intf.first(), Cand.Intf.last(), &MaxWeight);
-
- // The bad eviction chain occurs when either the split candidate is the
- // evicting reg or one of the split artifact will evict the evicting reg.
- if ((PhysReg != Cand.PhysReg) && (PhysReg != FutureEvictedPhysReg))
- return false;
-
- Cand.Intf.moveToBlock(BBNumber);
-
- // Check to see if the Evictor contains interference (with Evictee) in the
- // given BB. If so, this interference caused the eviction of Evictee from
- // PhysReg. This suggest that we will create a local interval during the
- // region split to avoid this interference This local interval may cause a bad
- // eviction chain.
- if (!LIS->hasInterval(Evictor))
- return false;
- LiveInterval &EvictorLI = LIS->getInterval(Evictor);
- if (EvictorLI.FindSegmentContaining(Cand.Intf.first()) == EvictorLI.end())
- return false;
-
- // 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.
- float splitArtifactWeight =
- VRAI->futureWeight(LIS->getInterval(Evictee),
- Cand.Intf.first().getPrevIndex(), Cand.Intf.last());
- if (splitArtifactWeight >= 0 && splitArtifactWeight < MaxWeight)
- return false;
-
- return true;
-}
-
/// calcGlobalSplitCost - Return the global split cost of following the split
/// pattern in LiveBundles. This cost should be added to the local cost of the
/// interference pattern in SplitConstraints.
diff --git a/llvm/lib/CodeGen/RegAllocGreedy.h b/llvm/lib/CodeGen/RegAllocGreedy.h
index 1e30e2e2308d..8bbb091c58af 100644
--- a/llvm/lib/CodeGen/RegAllocGreedy.h
+++ b/llvm/lib/CodeGen/RegAllocGreedy.h
@@ -370,21 +370,11 @@ class LLVM_LIBRARY_VISIBILITY RAGreedy : public MachineFunctionPass,
bool addSplitConstraints(InterferenceCache::Cursor, BlockFrequency &);
bool addThroughConstraints(InterferenceCache::Cursor, ArrayRef<unsigned>);
bool growRegion(GlobalSplitCandidate &Cand);
- bool splitCanCauseEvictionChain(Register Evictee, GlobalSplitCandidate &Cand,
- unsigned BBNumber,
- const AllocationOrder &Order);
BlockFrequency calcGlobalSplitCost(GlobalSplitCandidate &,
const AllocationOrder &Order);
bool calcCompactRegion(GlobalSplitCandidate &);
void splitAroundRegion(LiveRangeEdit &, ArrayRef<unsigned>);
void calcGapWeights(MCRegister, SmallVectorImpl<float> &);
- bool canEvictInterferenceInRange(const LiveInterval &VirtReg,
- MCRegister PhysReg, SlotIndex Start,
- SlotIndex End, EvictionCost &MaxCost) const;
- MCRegister getCheapestEvicteeWeight(const AllocationOrder &Order,
- const LiveInterval &VirtReg,
- SlotIndex Start, SlotIndex End,
- float *BestEvictWeight) const;
void evictInterference(const LiveInterval &, MCRegister,
SmallVectorImpl<Register> &);
bool mayRecolorAllInterferences(MCRegister PhysReg,
More information about the llvm-commits
mailing list