================
@@ -4173,6 +4177,139 @@ bool SIRegisterInfo::getRegAllocationHints(Register VirtReg,
}
}
+bool SIRegisterInfo::shouldApplyAntiHints(
+ const MachineFunction &MF, unsigned NumAllocatedVGPRs,
+ unsigned &MaxVGPRsForCurrentOccupancy) const {
+
+ const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
+ unsigned DynamicVGPRBlockSize = MFI->getDynamicVGPRBlockSize();
+ unsigned TargetOccupancy = MFI->getOccupancy();
+ unsigned CurrentOccupancy =
+ ST.getOccupancyWithNumVGPRs(NumAllocatedVGPRs, DynamicVGPRBlockSize);
+ MaxVGPRsForCurrentOccupancy =
+ ST.getMaxNumVGPRs(CurrentOccupancy, DynamicVGPRBlockSize);
+
+ LLVM_DEBUG(dbgs() << "anti-hints: " << NumAllocatedVGPRs
+ << " VGPRs allocated, target occupancy " << TargetOccupancy
+ << ", current occupancy " << CurrentOccupancy << '\n');
+
+ // If we are already at lowest occupancy, then there is no need to protect
+ // against occupancy regression.
+ if (CurrentOccupancy == 1)
+ return true;
+
+ // Do not apply anti-hints if we are reaching close to the VGPR budget. For
+ // target occupancy, the 80% cutoff is a conservative: anti-hints are disabled
+ // early enough that later registers still have headroom to stay at target
+ // occupancy. For current occupancy, the 95% cutoff margin is used to not
+ // apply anti-hints close to the limit of the current occupancy budget.
+ unsigned MaxVGPRsCutOffForTargetOccupancy =
+ (ST.getMaxNumVGPRs(TargetOccupancy, DynamicVGPRBlockSize) * 80) / 100;
+ unsigned MaxVGPRsCutOffForCurrentOccupancy =
+ (MaxVGPRsForCurrentOccupancy * 95) / 100;
+
+ if (NumAllocatedVGPRs >= MaxVGPRsCutOffForTargetOccupancy) {
+ LLVM_DEBUG(dbgs() << "anti-hints: not applied, at or above the "
+ << MaxVGPRsCutOffForTargetOccupancy
+ << " VGPR cutoff for target occupancy\n");
+ return false;
+ }
+
+ if (NumAllocatedVGPRs >= MaxVGPRsCutOffForCurrentOccupancy) {
+ LLVM_DEBUG(dbgs() << "anti-hints: not applied, at or above the "
+ << MaxVGPRsCutOffForCurrentOccupancy
+ << " VGPR cutoff for current occupancy\n");
+ return false;
+ }
+
+ return true;
+}
+
+// Returns true if Reg fits within the current occupancy VGPR budget.
+bool SIRegisterInfo::isRegWithinOccupancyBudget(
+ MCPhysReg Reg, unsigned NumVGPRs, unsigned NumAGPRs,
+ unsigned MaxVGPRsForCurrentOccupancy) const {
+ const TargetRegisterClass *RC = getPhysRegBaseClass(Reg);
+
+ // No VGPR or AGPR usage.
+ if (!RC || (!isVGPRClass(RC) && !isAGPRClass(RC)))
+ return true;
+
+ unsigned RegEndIndex =
+ getHWRegIndex(Reg) + divideCeil(getRegSizeInBits(*RC), 32);
+
+ unsigned MaxVGPR = NumVGPRs;
+ unsigned MaxAGPR = NumAGPRs;
+
+ if (isAGPRClass(RC))
+ MaxAGPR = std::max(MaxAGPR, RegEndIndex);
+ else
+ MaxVGPR = std::max(MaxVGPR, RegEndIndex);
+
+ return static_cast<unsigned>(
+ AMDGPU::getTotalNumVGPRs(ST.hasGFX90AInsts(), MaxAGPR, MaxVGPR)) <=
+ MaxVGPRsForCurrentOccupancy;
+}
+
+void SIRegisterInfo::filterAndSortForAntiHintedRegs(
+ Register VirtReg, MutableArrayRef<MCPhysReg> CustomOrder,
+ const BitVector &AntiHintedRegUnits, const MachineFunction &MF,
+ const LiveRegMatrix *Matrix, const RegisterClassInfo *RegClassInfo) const {
+
+ if (none_of(CustomOrder, [&](MCPhysReg Reg) {
+ return isAntiHintedReg(Reg, AntiHintedRegUnits);
+ }))
+ return;
+
+ const MachineRegisterInfo &MRI = MF.getRegInfo();
+ unsigned NumVGPRs = getNumUsedPhysRegs(MRI, AMDGPU::VGPR_32RegClass,
----------------
arsenm wrote:
getNumUsedPhysRegs is expensive, is there a better way (or can we speed it up)?
You also have a second path under if Matrix, shouldn't need both
https://github.com/llvm/llvm-project/pull/218074