[llvm] 39f2740 - [AMDGPU] IGroupLP: Avoid repeating reachability checks in greedy algorithm (#182463)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Mar 3 01:40:35 PST 2026
Author: Frederik Harwath
Date: 2026-03-03T09:40:30Z
New Revision: 39f2740faceafb5bb9fc2ad799eb17135faa1a38
URL: https://github.com/llvm/llvm-project/commit/39f2740faceafb5bb9fc2ad799eb17135faa1a38
DIFF: https://github.com/llvm/llvm-project/commit/39f2740faceafb5bb9fc2ad799eb17135faa1a38.diff
LOG: [AMDGPU] IGroupLP: Avoid repeating reachability checks in greedy algorithm (#182463)
In the greedy pipeline solver, the group cost is found using the
addEdges function and the edges must be removed from the DAG after
processing each group. The best group edges are then reinserted using
the same function. This repeats the costly reachability checks inside
the function which become problematic for pipelines with many
SchedGroups.
The algorithm is changed to remember the best group edges instead of
recomputing them. Additionally, SchedGroup::tryAddEdge is refactored to
avoid a redundant cycle check which is already performed by DAG->addEdge.
Added:
Modified:
llvm/lib/Target/AMDGPU/AMDGPUIGroupLP.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUIGroupLP.cpp b/llvm/lib/Target/AMDGPU/AMDGPUIGroupLP.cpp
index fd222a206c4e1..e13147e9461eb 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUIGroupLP.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUIGroupLP.cpp
@@ -141,9 +141,6 @@ class SchedGroup {
// Count of the number of created SchedGroups, used to initialize SGID.
static unsigned NumSchedGroups;
- // Try to add and edge from SU A to SU B.
- bool tryAddEdge(SUnit *A, SUnit *B);
-
// Use SGMask to determine whether we can classify MI as a member of this
// SchedGroup object.
bool canAddMI(const MachineInstr &MI) const;
@@ -155,6 +152,9 @@ class SchedGroup {
ScheduleDAGInstrs *DAG;
const SIInstrInfo *TII;
+ // Try to add and edge from SU A to SU B.
+ bool tryAddEdge(SUnit *A, SUnit *B);
+
// Returns true if SU can be added to this SchedGroup.
bool canAddSU(SUnit &SU) const;
@@ -166,7 +166,7 @@ class SchedGroup {
// Add DAG dependencies and track which edges are added, and the count of
// missed edges
int link(SUnit &SU, bool MakePred,
- std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges);
+ std::list<std::pair<SUnit *, SUnit *>> &AddedEdges);
// Add DAG dependencies from all SUnits in this SchedGroup and this SU.
// Use the predicate to determine whether SU should be a predecessor (P =
@@ -303,8 +303,7 @@ class PipelineSolver {
// current information. One step in the greedy algorithm. Templated against
// the SchedGroup iterator (either reverse or forward).
template <typename T>
- void greedyFind(std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges, T I,
- T E);
+ void greedyFind(std::list<std::pair<SUnit *, SUnit *>> &AddedEdges, T I, T E);
// Whether or not the current solution is optimal
bool checkOptimal();
// Populate the ready list, prioiritizing fewest missed edges first
@@ -320,15 +319,15 @@ class PipelineSolver {
// Add the edges from the SU to the other SchedGroups in pipeline, and
// return the number of edges missed.
int addEdges(SmallVectorImpl<SchedGroup> &SyncPipeline, SUnit *SU, int SGID,
- std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges);
+ std::list<std::pair<SUnit *, SUnit *>> &AddedEdges);
/// Link the pipeline as if \p SU was in the SchedGroup with ID \p SGID. It
/// returns the cost (in terms of missed pipeline edges), and tracks the edges
/// added in \p AddedEdges
template <typename T>
int linkSUnit(SUnit *SU, int SGID,
- std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges, T I, T E);
+ std::list<std::pair<SUnit *, SUnit *>> &AddedEdges, T I, T E);
/// Remove the edges passed via \p AddedEdges
- void removeEdges(const std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges);
+ void removeEdges(const std::list<std::pair<SUnit *, SUnit *>> &AddedEdges);
// Convert the passed in maps to arrays for bidirectional iterators
void convertSyncMapsToArrays();
@@ -452,7 +451,7 @@ void PipelineSolver::makePipeline() {
template <typename T>
int PipelineSolver::linkSUnit(
- SUnit *SU, int SGID, std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges,
+ SUnit *SU, int SGID, std::list<std::pair<SUnit *, SUnit *>> &AddedEdges,
T I, T E) {
bool MakePred = false;
int AddedCost = 0;
@@ -470,7 +469,7 @@ int PipelineSolver::linkSUnit(
int PipelineSolver::addEdges(
SmallVectorImpl<SchedGroup> &SyncPipeline, SUnit *SU, int SGID,
- std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges) {
+ std::list<std::pair<SUnit *, SUnit *>> &AddedEdges) {
// For IsBottomUp, the first SchedGroup in SyncPipeline contains the
// instructions that are the ultimate successors in the resultant mutation.
@@ -487,7 +486,7 @@ int PipelineSolver::addEdges(
}
void PipelineSolver::removeEdges(
- const std::vector<std::pair<SUnit *, SUnit *>> &EdgesToRemove) {
+ const std::list<std::pair<SUnit *, SUnit *>> &EdgesToRemove) {
// Only remove the edges that we have added when testing
// the fit.
for (auto &PredSuccPair : EdgesToRemove) {
@@ -566,7 +565,7 @@ void PipelineSolver::populateReadyList(
assert(CurrSU.second.size() >= 1);
for (; I != E; ++I) {
- std::vector<std::pair<SUnit *, SUnit *>> AddedEdges;
+ std::list<std::pair<SUnit *, SUnit *>> AddedEdges;
int CandSGID = *I;
SchedGroup *Match = llvm::find_if(SyncPipeline, [CandSGID](SchedGroup &SG) {
return SG.getSGID() == CandSGID;
@@ -625,7 +624,7 @@ bool PipelineSolver::solveExact() {
int CandSGID = I->first;
int AddedCost = 0;
- std::vector<std::pair<SUnit *, SUnit *>> AddedEdges;
+ std::list<std::pair<SUnit *, SUnit *>> AddedEdges;
auto &SyncPipeline = CurrPipeline[CurrSyncGroupIdx];
SchedGroup *Match;
for (auto &SG : SyncPipeline) {
@@ -692,12 +691,13 @@ bool PipelineSolver::solveExact() {
template <typename T>
void PipelineSolver::greedyFind(
- std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges, T I, T E) {
+ std::list<std::pair<SUnit *, SUnit *>> &AddedEdges, T I, T E) {
SUToCandSGsPair CurrSU = PipelineInstrs[CurrSyncGroupIdx][CurrConflInstNo];
int BestNodeCost = -1;
int TempCost;
SchedGroup *BestGroup = nullptr;
int BestGroupID = -1;
+ std::list<std::pair<SUnit *, SUnit *>> BestEdges;
auto &SyncPipeline = CurrPipeline[CurrSyncGroupIdx];
LLVM_DEBUG(dbgs() << "Fitting SU(" << CurrSU.first->NodeNum
<< ") in Pipeline # " << CurrSyncGroupIdx << "\n");
@@ -707,7 +707,6 @@ void PipelineSolver::greedyFind(
// first. If we fail to do this for the greedy algorithm, the solution will
// likely not be good in more complex cases.
for (; I != E; ++I) {
- std::vector<std::pair<SUnit *, SUnit *>> AddedEdges;
int CandSGID = *I;
SchedGroup *Match = llvm::find_if(SyncPipeline, [CandSGID](SchedGroup &SG) {
return SG.getSGID() == CandSGID;
@@ -725,21 +724,36 @@ void PipelineSolver::greedyFind(
LLVM_DEBUG(dbgs() << "SGID # " << CandSGID << " has conflicting rule\n");
continue;
}
- TempCost = addEdges(SyncPipeline, CurrSU.first, CandSGID, AddedEdges);
+
+ std::list<std::pair<SUnit *, SUnit *>> TempEdges;
+ TempCost = addEdges(SyncPipeline, CurrSU.first, CandSGID, TempEdges);
LLVM_DEBUG(dbgs() << "Cost of Group " << TempCost << "\n");
+
if (TempCost < BestNodeCost || BestNodeCost == -1) {
+ BestEdges = TempEdges;
BestGroup = Match;
BestNodeCost = TempCost;
BestGroupID = CandSGID;
+
+ if (BestNodeCost == 0)
+ break;
}
- removeEdges(AddedEdges);
- if (BestNodeCost == 0)
- break;
+
+ removeEdges(TempEdges);
}
if (BestGroupID != -1) {
BestGroup->add(*CurrSU.first);
- addEdges(SyncPipeline, CurrSU.first, BestGroupID, AddedEdges);
+ if (AddedEdges.empty())
+ AddedEdges = BestEdges;
+ else
+ AddedEdges.splice(std::prev(AddedEdges.cend()), BestEdges);
+
+ for (const std::pair<SUnit *, SUnit *> &E : BestEdges) {
+ if (!BestGroup->tryAddEdge(E.first, E.second))
+ llvm_unreachable("Edges known to be insertable.");
+ }
+
LLVM_DEBUG(dbgs() << "Best Group has ID: " << BestGroupID << " and Mask"
<< (int)BestGroup->getMask() << "\n");
BestCost += TempCost;
@@ -751,7 +765,7 @@ void PipelineSolver::greedyFind(
bool PipelineSolver::solveGreedy() {
BestCost = 0;
- std::vector<std::pair<SUnit *, SUnit *>> AddedEdges;
+ std::list<std::pair<SUnit *, SUnit *>> AddedEdges;
while (static_cast<size_t>(CurrSyncGroupIdx) < PipelineInstrs.size()) {
SUToCandSGsPair CurrSU = PipelineInstrs[CurrSyncGroupIdx][CurrConflInstNo];
@@ -2377,11 +2391,7 @@ class IGroupLPDAGMutation : public ScheduleDAGMutation {
unsigned SchedGroup::NumSchedGroups = 0;
bool SchedGroup::tryAddEdge(SUnit *A, SUnit *B) {
- if (A != B && DAG->canAddEdge(B, A)) {
- DAG->addEdge(B, SDep(A, SDep::Artificial));
- return true;
- }
- return false;
+ return A != B && DAG->addEdge(B, SDep(A, SDep::Artificial));
}
bool SchedGroup::canAddMI(const MachineInstr &MI) const {
@@ -2501,7 +2511,7 @@ bool SchedGroup::canAddMI(const MachineInstr &MI) const {
}
int SchedGroup::link(SUnit &SU, bool MakePred,
- std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges) {
+ std::list<std::pair<SUnit *, SUnit *>> &AddedEdges) {
int MissedEdges = 0;
for (auto *A : Collection) {
SUnit *B = &SU;
More information about the llvm-commits
mailing list