[LoopFusion] Detecting legal dependencies for fusion using DA info #146383
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
llvm:analysis
|
@llvm/pr-subscribers-llvm-analysis @llvm/pr-subscribers-llvm-transforms Author: Alireza Torabian (1997alireza) ChangesDepends on PR #128782. The first two commits are part of the base PR and the last commit belongs to this PR. Loop fusion pass will uses the information provided by DA to detect loop-carried dependencies and fuse the loops if it is legal. Patch is 75.31 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/146383.diff 6 Files Affected:
diff --git a/llvm/include/llvm/Analysis/DependenceAnalysis.h b/llvm/include/llvm/Analysis/DependenceAnalysis.h
index f98bd684149f9..aff326879263d 100644
--- a/llvm/include/llvm/Analysis/DependenceAnalysis.h
+++ b/llvm/include/llvm/Analysis/DependenceAnalysis.h
@@ -82,6 +82,17 @@ namespace llvm {
/// Dependence::DVEntry - Each level in the distance/direction vector
/// has a direction (or perhaps a union of several directions), and
/// perhaps a distance.
+ /// The dependency information could be across a single loop level or across
+ /// two separate levels that are similar. Two levels are considered similar
+ /// if they can be interpreted as a single fused loop, i.e., have the same
+ /// trip count and the same nesting depth.
+ /// For example, loops b and c are similar and considered as separate loops:
+ /// for (a = ...) {
+ /// for (b = 0; b < 10; b++) {
+ /// }
+ /// for (c = 0; c < 10; c++) {
+ /// }
+ /// }
struct DVEntry {
enum : unsigned char {
NONE = 0,
@@ -153,13 +164,26 @@ namespace llvm {
/// source and destination of the dependence.
virtual unsigned getLevels() const { return 0; }
+ /// getSeparateLevels - Returns the number of separate loops surrounding
+ /// the source and destination of the dependence.
+ virtual unsigned getSeparateLevels() const { return 0; }
+
+ /// getDVEntry - Returns the DV entry associated with a regular or a
+ /// separate level
+ DVEntry getDVEntry(unsigned Level, bool Separate) const;
+
/// getDirection - Returns the direction associated with a particular
- /// level.
- virtual unsigned getDirection(unsigned Level) const { return DVEntry::ALL; }
+ /// common or separate level.
+ virtual unsigned getDirection(unsigned Level, bool Separate = false) const {
+ return DVEntry::ALL;
+ }
/// getDistance - Returns the distance (or NULL) associated with a
- /// particular level.
- virtual const SCEV *getDistance(unsigned Level) const { return nullptr; }
+ /// particular common or separate level.
+ virtual const SCEV *getDistance(unsigned Level,
+ bool Separate = false) const {
+ return nullptr;
+ }
/// Check if the direction vector is negative. A negative direction
/// vector means Src and Dst are reversed in the actual program.
@@ -172,21 +196,31 @@ namespace llvm {
virtual bool normalize(ScalarEvolution *SE) { return false; }
/// isPeelFirst - Returns true if peeling the first iteration from
- /// this loop will break this dependence.
- virtual bool isPeelFirst(unsigned Level) const { return false; }
+ /// this regular or separate loop level will break this dependence.
+ virtual bool isPeelFirst(unsigned Level, bool Separate = false) const {
+ return false;
+ }
/// isPeelLast - Returns true if peeling the last iteration from
- /// this loop will break this dependence.
- virtual bool isPeelLast(unsigned Level) const { return false; }
+ /// this regular or separate loop level will break this dependence.
+ virtual bool isPeelLast(unsigned Level, bool Separate = false) const {
+ return false;
+ }
- /// isSplitable - Returns true if splitting this loop will break
+ /// isSplitable - Returns true if splitting the loop will break
/// the dependence.
- virtual bool isSplitable(unsigned Level) const { return false; }
+ virtual bool isSplitable(unsigned Level, bool Separate = false) const {
+ return false;
+ }
+
+ /// inSeparateLoops - Returns true if this level is a separate level, i.e.,
+ /// performed across two separate loop nests.
+ virtual bool inSeparateLoops(unsigned Level) const { return false; }
- /// isScalar - Returns true if a particular level is scalar; that is,
- /// if no subscript in the source or destination mention the induction
- /// variable associated with the loop at this level.
- virtual bool isScalar(unsigned Level) const;
+ /// isScalar - Returns true if a particular regular or separate level is
+ /// scalar; that is, if no subscript in the source or destination mention
+ /// the induction variable associated with the loop at this level.
+ virtual bool isScalar(unsigned Level, bool Separate = false) const;
/// getNextPredecessor - Returns the value of the NextPredecessor
/// field.
@@ -212,6 +246,10 @@ namespace llvm {
///
void dump(raw_ostream &OS) const;
+ /// dumpImp - For debugging purposes. Dumps a dependence to OS with or
+ /// without considering the separate levels.
+ void dumpImp(raw_ostream &OS, bool Separate = false) const;
+
protected:
Instruction *Src, *Dst;
@@ -252,13 +290,31 @@ namespace llvm {
/// source and destination of the dependence.
unsigned getLevels() const override { return Levels; }
+ /// getSeparateLevels - Returns the number of separate loops surrounding
+ /// the source and destination of the dependence.
+ unsigned getSeparateLevels() const override { return SeparateLevels; }
+
+ /// getDVEntry - Returns the DV entry associated with a regular or a
+ /// separate level
+ DVEntry getDVEntry(unsigned Level, bool Separate) const {
+ if (!Separate) {
+ assert(0 < Level && Level <= Levels && "Level out of range");
+ return DV[Level - 1];
+ } else {
+ assert(Levels < Level && Level <= Levels + SeparateLevels &&
+ "Separate level out of range");
+ return DVSeparate[Level - Levels - 1];
+ }
+ }
+
/// getDirection - Returns the direction associated with a particular
- /// level.
- unsigned getDirection(unsigned Level) const override;
+ /// common or separate level.
+ unsigned getDirection(unsigned Level, bool Separate = false) const override;
/// getDistance - Returns the distance (or NULL) associated with a
- /// particular level.
- const SCEV *getDistance(unsigned Level) const override;
+ /// particular common or separate level.
+ const SCEV *getDistance(unsigned Level,
+ bool Separate = false) const override;
/// Check if the direction vector is negative. A negative direction
/// vector means Src and Dst are reversed in the actual program.
@@ -271,27 +327,33 @@ namespace llvm {
bool normalize(ScalarEvolution *SE) override;
/// isPeelFirst - Returns true if peeling the first iteration from
- /// this loop will break this dependence.
- bool isPeelFirst(unsigned Level) const override;
+ /// this regular or separate loop level will break this dependence.
+ bool isPeelFirst(unsigned Level, bool Separate = false) const override;
/// isPeelLast - Returns true if peeling the last iteration from
- /// this loop will break this dependence.
- bool isPeelLast(unsigned Level) const override;
+ /// this regular or separate loop level will break this dependence.
+ bool isPeelLast(unsigned Level, bool Separate = false) const override;
/// isSplitable - Returns true if splitting the loop will break
/// the dependence.
- bool isSplitable(unsigned Level) const override;
+ bool isSplitable(unsigned Level, bool Separate = false) const override;
- /// isScalar - Returns true if a particular level is scalar; that is,
- /// if no subscript in the source or destination mention the induction
- /// variable associated with the loop at this level.
- bool isScalar(unsigned Level) const override;
+ /// inSeparateLoops - Returns true if this level is a separate level, i.e.,
+ /// performed across two separate loop nests.
+ bool inSeparateLoops(unsigned Level) const override;
+
+ /// isScalar - Returns true if a particular regular or separate level is
+ /// scalar; that is, if no subscript in the source or destination mention
+ /// the induction variable associated with the loop at this level.
+ bool isScalar(unsigned Level, bool Separate = false) const override;
private:
unsigned short Levels;
+ unsigned short SeparateLevels;
bool LoopIndependent;
bool Consistent; // Init to true, then refine.
std::unique_ptr<DVEntry[]> DV;
+ std::unique_ptr<DVEntry[]> DVSeparate;
friend class DependenceInfo;
};
@@ -423,7 +485,8 @@ namespace llvm {
const SCEV *A;
const SCEV *B;
const SCEV *C;
- const Loop *AssociatedLoop;
+ const Loop *AssociatedSrcLoop;
+ const Loop *AssociatedDstLoop;
public:
/// isEmpty - Return true if the constraint is of kind Empty.
@@ -467,19 +530,27 @@ namespace llvm {
/// Otherwise assert.
LLVM_ABI const SCEV *getD() const;
- /// getAssociatedLoop - Returns the loop associated with this constraint.
- LLVM_ABI const Loop *getAssociatedLoop() const;
+ /// getAssociatedSrcLoop - Returns the source loop associated with this
+ /// constraint.
+ LLVM_ABI const Loop *getAssociatedSrcLoop() const;
+
+ /// getAssociatedDstLoop - Returns the destination loop associated with
+ /// this constraint.
+ LLVM_ABI const Loop *getAssociatedDstLoop() const;
/// setPoint - Change a constraint to Point.
LLVM_ABI void setPoint(const SCEV *X, const SCEV *Y,
- const Loop *CurrentLoop);
+ const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop);
/// setLine - Change a constraint to Line.
LLVM_ABI void setLine(const SCEV *A, const SCEV *B, const SCEV *C,
- const Loop *CurrentLoop);
+ const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop);
/// setDistance - Change a constraint to Distance.
- LLVM_ABI void setDistance(const SCEV *D, const Loop *CurrentLoop);
+ LLVM_ABI void setDistance(const SCEV *D, const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop);
/// setEmpty - Change a constraint to Empty.
LLVM_ABI void setEmpty();
@@ -492,6 +563,10 @@ namespace llvm {
LLVM_ABI void dump(raw_ostream &OS) const;
};
+ /// Returns true if two loops are the same or they have the same tripcount
+ /// and depth
+ bool areLoopsSimilar(const Loop *SrcLoop, const Loop *DstLoop) const;
+
/// establishNestingLevels - Examines the loop nesting of the Src and Dst
/// instructions and establishes their shared loops. Sets the variables
/// CommonLevels, SrcLevels, and MaxLevels.
@@ -503,8 +578,8 @@ namespace llvm {
/// This lets us allocate vectors MaxLevels in length, with room for every
/// distinct loop referenced in both the source and destination subscripts.
/// The variable SrcLevels is the nesting depth of the source instruction.
- /// It's used to help calculate distinct loops referenced by the destination.
- /// Here's the map from loops to levels:
+ /// It's used to help calculate distinct loops referenced by the
+ /// destination. Here's the map from loops to levels:
/// 0 - unused
/// 1 - outermost common loop
/// ... - other common loops
@@ -542,10 +617,15 @@ namespace llvm {
/// e - 5
/// f - 6
/// g - 7 = MaxLevels
- void establishNestingLevels(const Instruction *Src,
- const Instruction *Dst);
+ /// SeparateLevels counts the number of loop levels after the common levels
+ /// that are not identical but are considered similar. Two levels are
+ /// considered similar if they have the same trip count and the same
+ /// nesting depth.
+ /// For example, if loops `c` and `e` are similar, then they contribute to
+ /// the SeparateLevels count and SeparateLevels is set to 1.
+ void establishNestingLevels(const Instruction *Src, const Instruction *Dst);
- unsigned CommonLevels, SrcLevels, MaxLevels;
+ unsigned CommonLevels, SrcLevels, MaxLevels, SeparateLevels;
/// mapSrcLoop - Given one of the loops containing the source, return
/// its level index in our numbering scheme.
@@ -684,13 +764,10 @@ namespace llvm {
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction and distance.
- bool strongSIVtest(const SCEV *Coeff,
- const SCEV *SrcConst,
- const SCEV *DstConst,
- const Loop *CurrentLoop,
- unsigned Level,
- FullDependence &Result,
- Constraint &NewConstraint) const;
+ bool strongSIVtest(const SCEV *Coeff, const SCEV *SrcConst,
+ const SCEV *DstConst, const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop, unsigned Level,
+ FullDependence &Result, Constraint &NewConstraint) const;
/// weakCrossingSIVtest - Tests the weak-crossing SIV subscript pair
/// (Src and Dst) for dependence.
@@ -702,13 +779,10 @@ namespace llvm {
/// Sets appropriate direction entry.
/// Set consistent to false.
/// Marks the dependence as splitable.
- bool weakCrossingSIVtest(const SCEV *SrcCoeff,
- const SCEV *SrcConst,
- const SCEV *DstConst,
- const Loop *CurrentLoop,
- unsigned Level,
- FullDependence &Result,
- Constraint &NewConstraint,
+ bool weakCrossingSIVtest(const SCEV *SrcCoeff, const SCEV *SrcConst,
+ const SCEV *DstConst, const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop, unsigned Level,
+ FullDependence &Result, Constraint &NewConstraint,
const SCEV *&SplitIter) const;
/// ExactSIVtest - Tests the SIV subscript pair
@@ -720,13 +794,10 @@ namespace llvm {
/// If there might be a dependence, returns false.
/// Sets appropriate direction entry.
/// Set consistent to false.
- bool exactSIVtest(const SCEV *SrcCoeff,
- const SCEV *DstCoeff,
- const SCEV *SrcConst,
- const SCEV *DstConst,
- const Loop *CurrentLoop,
- unsigned Level,
- FullDependence &Result,
+ bool exactSIVtest(const SCEV *SrcCoeff, const SCEV *DstCoeff,
+ const SCEV *SrcConst, const SCEV *DstConst,
+ const Loop *CurrentSrcLoop, const Loop *CurrentDstLoop,
+ unsigned Level, FullDependence &Result,
Constraint &NewConstraint) const;
/// weakZeroSrcSIVtest - Tests the weak-zero SIV subscript pair
@@ -739,11 +810,9 @@ namespace llvm {
/// Sets appropriate direction entry.
/// Set consistent to false.
/// If loop peeling will break the dependence, mark appropriately.
- bool weakZeroSrcSIVtest(const SCEV *DstCoeff,
- const SCEV *SrcConst,
- const SCEV *DstConst,
- const Loop *CurrentLoop,
- unsigned Level,
+ bool weakZeroSrcSIVtest(const SCEV *DstCoeff, const SCEV *SrcConst,
+ const SCEV *DstConst, const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop, unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const;
@@ -757,11 +826,9 @@ namespace llvm {
/// Sets appropriate direction entry.
/// Set consistent to false.
/// If loop peeling will break the dependence, mark appropriately.
- bool weakZeroDstSIVtest(const SCEV *SrcCoeff,
- const SCEV *SrcConst,
- const SCEV *DstConst,
- const Loop *CurrentLoop,
- unsigned Level,
+ bool weakZeroDstSIVtest(const SCEV *SrcCoeff, const SCEV *SrcConst,
+ const SCEV *DstConst, const Loop *CurrentSrcLoop,
+ const Loop *CurrentDstLoop, unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const;
diff --git a/llvm/lib/Analysis/DependenceAnalysis.cpp b/llvm/lib/Analysis/DependenceAnalysis.cpp
index c1b1d002c9979..9faf1d5f00edb 100644
--- a/llvm/lib/Analysis/DependenceAnalysis.cpp
+++ b/llvm/lib/Analysis/DependenceAnalysis.cpp
@@ -104,6 +104,7 @@ STATISTIC(GCDindependence, "GCD independence");
STATISTIC(BanerjeeApplications, "Banerjee applications");
STATISTIC(BanerjeeIndependence, "Banerjee independence");
STATISTIC(BanerjeeSuccesses, "Banerjee successes");
+STATISTIC(SeparateLoopsConsidered, "Separate loops considered");
static cl::opt<bool>
Delinearize("da-delinearize", cl::init(true), cl::Hidden,
@@ -258,10 +259,7 @@ bool Dependence::isAnti() const {
// if no subscript in the source or destination mention the induction
// variable associated with the loop at this level.
// Leave this out of line, so it will serve as a virtual method anchor
-bool Dependence::isScalar(unsigned level) const {
- return false;
-}
-
+bool Dependence::isScalar(unsigned level, bool Separate) const { return false; }
//===----------------------------------------------------------------------===//
// FullDependence methods
@@ -273,6 +271,7 @@ FullDependence::FullDependence(Instruction *Source, Instruction *Destination,
: Dependence(Source, Destination, Assumes), Levels(CommonLevels),
LoopIndependent(PossiblyLoopIndependent) {
Consistent = true;
+ SeparateLevels = 0;
if (CommonLevels)
DV = std::make_unique<DVEntry[]>(CommonLevels);
}
@@ -335,51 +334,48 @@ bool FullDependence::normalize(ScalarEvolution *SE) {
// The rest are simple getters that hide the implementation.
-// getDirection - Returns the direction associated with a particular level.
-unsigned FullDependence::getDirection(unsigned Level) const {
- assert(0 < Level && Level <= Levels && "Level out of range");
- return DV[Level - 1].Direction;
+// getDirection - Returns the direction associated with a particular common or
+// separate level.
+unsigned FullDependence::getDirection(unsigned Level, bool Separate) const {
+ return getDVEntry(Level, Separate).Direction;
}
-
-// Returns the distance (or NULL) associated with a particular level.
-const SCEV *FullDependence::getDistance(unsigned Level) const {
- assert(0 < Level && Level <= Levels && "Level out of range");
- return DV[Level - 1].Distance;
+// Returns the distance (or NULL) associated with a particular common or
+// separate level.
+const SCEV *FullDependence::getDistance(unsigned Level, bool Separate) const {
+ return getDVEntry(Level, Separate).Distance;
}
-
-// Returns true if a particular level is scalar; that is,
-// if no subscript in the source or destination mention the induction
-// variable associated with the loop at this level.
-bool FullDependence::isScalar(unsigned Level) const {
- assert(0 < Level && Level <= Levels && "Level out of range");
- return DV[Level - 1].Scalar;
+// Returns true if a particular regular or separate level is scalar; that is,
+// if no subscript in the source or destination mention the induction variable
+// associated with the loop at this level.
+bool FullDependence::isScalar(unsigned Level, bool Separate) const {
+ return getDVEntry(Level, Separate).Scalar;
}
-
-// Returns true if peeling the first iteration from this loop
-// will break this dependence.
-bool FullDependence::isPeelFirst(unsigned Level) const {
- assert(0 < Level && Level <= Levels && "Level out of range");
- return DV[Level - 1].PeelFirst;
+// Returns true if peeling the first iteration from this regular or separate
+// loop level will break this dependence.
+bool FullDependence::isPeelFirst(unsigned Level, bool Separate) const {
+ return getDVEntry(Level, Separate).PeelFirst;
}
-
-// Returns true if peeling the last iteration from this loop
-// will break this dependence.
-bool FullDependence::isPeelLast(un...
[truncated]
|
|
Stacked PRs are applied to the branch of the predecessor PR (https://github.com/1997alireza/llvm-project/tree/da-siv-separate-loops). However, problems occur when branches are PRs are from different repositories (here: https://github.com/llvm/llvm-project and https://github.com/1997alireza/llvm-project). Anyway, one can see the changes introduced only by this PR here: |
Meinersbur
reviewed
Jul 2, 2025
1997alireza
force-pushed
the
loopfuse-da-info
branch
from
91ce52e to
a8f2d5b
Compare
This was referenced Jul 29, 2025
Meinersbur
added a commit
that referenced
this pull request
Aug 7, 2025
To avoid noise in PRs such as in #146383.
1997alireza
force-pushed
the
loopfuse-da-info
branch
from
a8f2d5b to
9fbd0fc
Compare
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
1997alireza
force-pushed
the
loopfuse-da-info
branch
from
9fbd0fc to
f816d80
Compare
amehsan
reviewed
Sep 20, 2025
amehsan
reviewed
Sep 20, 2025
amehsan
reviewed
Sep 20, 2025
1997alireza
force-pushed
the
loopfuse-da-info
branch
2 times, most recently
from
cfa9e25 to
f463d8e
Compare
CongzheUalberta
requested changes
Sep 24, 2025
| unsigned CurLoopLevel = FC0.L->getLoopDepth(); | ||
|
|
||
| bool OuterEqDir = true; | ||
| for (unsigned II = 1; II <= std::min(CurLoopLevel - 1, Levels); ++II) { |
There was a problem hiding this comment.
It would be better to use more meaningful variable names instead of II.
There was a problem hiding this comment.
Changed to Level.
| bool OuterEqDir = true; | ||
| for (unsigned II = 1; II <= std::min(CurLoopLevel - 1, Levels); ++II) { | ||
| unsigned Direction = DepResult->getDirection(II, II > Levels); | ||
| if (!(Direction & Dependence::DVEntry::EQ)) { |
There was a problem hiding this comment.
Would it be more readable if it is changed to the following?
if (Direction != Dependence::DVEntry::EQ)
There was a problem hiding this comment.
We want to consider directions that include equality not only the equality itself. For example if the direction is >=, it needs to return false as well.
|
|
||
| assert(CurLoopLevel > Levels && "Fusion candidates are not separated"); | ||
| unsigned CurDir = DepResult->getDirection(CurLoopLevel, true); | ||
| if (!(CurDir & Dependence::DVEntry::GT)) { |
There was a problem hiding this comment.
Would it be more readable if it is changed to the following?
if (CurDir != Dependence::DVEntry::GT)
There was a problem hiding this comment.
Similar to above.
| @@ -100,6 +100,8 @@ STATISTIC(OnlySecondCandidateIsGuarded, | |||
| "The second candidate is guarded while the first one is not"); | |||
| STATISTIC(NumHoistedInsts, "Number of hoisted preheader instructions."); | |||
| STATISTIC(NumSunkInsts, "Number of hoisted preheader instructions."); | |||
| STATISTIC(NumDepSafeFused, "Number of fused loops with dependencies " | |||
There was a problem hiding this comment.
I suggest to change the description to something more descriptive, something like "dependence checks passed".
There was a problem hiding this comment.
Changed to (NumDA, "DA checks passed")
| unsigned SameSDLevels = DepResult->getSameSDLevels(); | ||
| unsigned CurLoopLevel = FC0.L->getLoopDepth(); | ||
|
|
||
| bool OuterEqDir = true; |
There was a problem hiding this comment.
I suggest to rename OuterEqDir to something like sameOuterIndex or sameOuterIterSpace that is more descriptive.
There was a problem hiding this comment.
Turned out I didn't need it. Removed.
| ;; } | ||
| ;; } | ||
|
|
||
| define void @backward_dep0(i64 %n, ptr %A) nounwind uwtable ssp { |
There was a problem hiding this comment.
I suggest to rename this function. This function is testing the case where accesses to A in the outer dimensions are different, hence in terms of the innermost dimension k, there is no dependency on the k-level.
There was a problem hiding this comment.
Changed to nonequal_outer_access.
| br i1 %cmp10, label %for.cond1.preheader.preheader, label %for.end26 | ||
|
|
||
| ; CHECK-LABEL: backward_dep | ||
| ; CHECK-COUNT-1: for.body{{[0-9]+}}: |
There was a problem hiding this comment.
I suggest to not rely on BB names in CHECK. You can check stats, like how many functions are fused, how many dependence checks are passed, etc.
| br i1 %cmp10, label %for.cond1.preheader.preheader, label %for.end26 | ||
|
|
||
| ; CHECK-LABEL: backward_dep | ||
| ; CHECK-COUNT-1: for.body{{[0-9]+}}: |
There was a problem hiding this comment.
Same as the comment above.
| ; arg[j] = val * 3; | ||
| ; } | ||
| ; } | ||
| ; |
There was a problem hiding this comment.
This function was not fused previously, and now with your patch it is fused. Can you add some comment here to describe it like why it can be fused now?
Loop fusion pass will use the information provided by the recent DA patch to fuse additional legal loops, including those with forward loop-carried dependencies.
1997alireza
force-pushed
the
loopfuse-da-info
branch
from
f463d8e to
6da3076
Compare
1997alireza
changed the title
CongzheUalberta
approved these changes
Sep 25, 2025
mahesh-attarde
pushed a commit
to mahesh-attarde/llvm-project
that referenced
this pull request
Oct 3, 2025
…lvm#146383) Loop fusion pass will use the information provided by the recent DA patch to fuse additional legal loops, including those with forward loop-carried dependencies.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
5 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Using the information provided by the recent DA patch to detect additional legal fusions.