replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

SIV/MIV classification for LDA. 

LoopDependenceAnalysis::getLoops is currently O(N*M) for a loop-nest of
depth N and a compound SCEV of M atomic SCEVs. As both N and M will
typically be very small, this should not be a problem. If it turns out
to be one, rewriting getLoops as SCEVVisitor will reduce complexity to
O(M).

llvm-svn: 78394
This commit is contained in:
Andreas Bolka 2009-08-07 18:23:41 +00:00
parent b93185d05a
commit 2f7562c83e
2 changed files with 43 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
llvm/include/llvm/Analysis/LoopDependenceAnalysis.h
View File

@ -20,6 +20,7 @@
#ifndef LLVM_ANALYSIS_LOOP_DEPENDENCE_ANALYSIS_H
#define LLVM_ANALYSIS_LOOP_DEPENDENCE_ANALYSIS_H
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Analysis/LoopPass.h"
@ -67,6 +68,10 @@ class LoopDependenceAnalysis : public LoopPass {
/// created. The third argument is set to the pair found or created.
bool findOrInsertDependencePair(Value*, Value*, DependencePair*&);
/// getLoops - Collect all loops of the loop-nest L a given SCEV is variant
/// in.
void getLoops(const SCEV*, DenseSet<const Loop*>*) const;
/// isLoopInvariant - True if a given SCEV is invariant in all loops of the
/// loop-nest starting at the innermost loop L.
bool isLoopInvariant(const SCEV*) const;
@ -78,7 +83,10 @@ class LoopDependenceAnalysis : public LoopPass {
/// TODO: doc
bool isZIVPair(const SCEV*, const SCEV*) const;
bool isSIVPair(const SCEV*, const SCEV*) const;
DependenceResult analyseZIV(const SCEV*, const SCEV*, Subscript*) const;
DependenceResult analyseSIV(const SCEV*, const SCEV*, Subscript*) const;
DependenceResult analyseMIV(const SCEV*, const SCEV*, Subscript*) const;
DependenceResult analyseSubscript(const SCEV*, const SCEV*, Subscript*) const;
DependenceResult analysePair(DependencePair*) const;

41
llvm/lib/Analysis/LoopDependenceAnalysis.cpp
View File

@ -20,6 +20,7 @@
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "lda"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/LoopDependenceAnalysis.h"
@ -124,11 +125,18 @@ bool LoopDependenceAnalysis::findOrInsertDependencePair(Value *A,
return false;
}
bool LoopDependenceAnalysis::isLoopInvariant(const SCEV *S) const {
void LoopDependenceAnalysis::getLoops(const SCEV *S,
DenseSet<const Loop*>* Loops) const {
// Refactor this into an SCEVVisitor, if efficiency becomes a concern.
for (const Loop *L = this->L; L != 0; L = L->getParentLoop())
if (!S->isLoopInvariant(L))
return false;
return true;
Loops->insert(L);
}
bool LoopDependenceAnalysis::isLoopInvariant(const SCEV *S) const {
DenseSet<const Loop*> loops;
getLoops(S, &loops);
return loops.empty();
}
bool LoopDependenceAnalysis::isAffine(const SCEV *S) const {
@ -140,6 +148,13 @@ bool LoopDependenceAnalysis::isZIVPair(const SCEV *A, const SCEV *B) const {
return isLoopInvariant(A) && isLoopInvariant(B);
}
bool LoopDependenceAnalysis::isSIVPair(const SCEV *A, const SCEV *B) const {
DenseSet<const Loop*> loops;
getLoops(A, &loops);
getLoops(B, &loops);
return loops.size() == 1;
}
LoopDependenceAnalysis::DependenceResult
LoopDependenceAnalysis::analyseZIV(const SCEV *A,
const SCEV *B,
@ -148,6 +163,20 @@ LoopDependenceAnalysis::analyseZIV(const SCEV *A,
return A == B ? Dependent : Independent;
}
LoopDependenceAnalysis::DependenceResult
LoopDependenceAnalysis::analyseSIV(const SCEV *A,
const SCEV *B,
Subscript *S) const {
return Unknown; // TODO: Implement.
}
LoopDependenceAnalysis::DependenceResult
LoopDependenceAnalysis::analyseMIV(const SCEV *A,
const SCEV *B,
Subscript *S) const {
return Unknown; // TODO: Implement.
}
LoopDependenceAnalysis::DependenceResult
LoopDependenceAnalysis::analyseSubscript(const SCEV *A,
const SCEV *B,
@ -167,10 +196,10 @@ LoopDependenceAnalysis::analyseSubscript(const SCEV *A,
if (isZIVPair(A, B))
return analyseZIV(A, B, S);
// TODO: Implement SIV/MIV testers.
if (isSIVPair(A, B))
return analyseSIV(A, B, S);
DEBUG(errs() << " -> [?] cannot analyse subscript\n");
return Unknown;
return analyseMIV(A, B, S);
}
LoopDependenceAnalysis::DependenceResult