maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[SCEV] Fix exponential time complexity by caching 

llvm-svn: 301149
This commit is contained in:
Sanjoy Das 2017-04-24 00:09:46 +00:00
parent db8d09b6c2
commit bdbc4938f9
3 changed files with 161 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
llvm/include/llvm/Analysis/ScalarEvolution.h
View File

@ -877,6 +877,47 @@ private:
bool ControlsExit,
bool AllowPredicates = false);
// Helper functions for computeExitLimitFromCond to avoid exponential time
// complexity.
class ExitLimitCache {
// It may look like we need key on the whole (L, TBB, FBB, ControlsExit,
// AllowPredicates) tuple, but recursive calls to
// computeExitLimitFromCondCached from computeExitLimitFromCondImpl only
// vary the in \c ExitCond and \c ControlsExit parameters. We remember the
// initial values of the other values to assert our assumption.
SmallDenseMap<PointerIntPair<Value *, 1>, ExitLimit> TripCountMap;
const Loop *L;
BasicBlock *TBB;
BasicBlock *FBB;
bool AllowPredicates;
public:
ExitLimitCache(const Loop *L, BasicBlock *TBB, BasicBlock *FBB,
bool AllowPredicates)
: L(L), TBB(TBB), FBB(FBB), AllowPredicates(AllowPredicates) {}
Optional<ExitLimit> find(const Loop *L, Value *ExitCond, BasicBlock *TBB,
BasicBlock *FBB, bool ControlsExit,
bool AllowPredicates);
void insert(const Loop *L, Value *ExitCond, BasicBlock *TBB,
BasicBlock *FBB, bool ControlsExit, bool AllowPredicates,
const ExitLimit &EL);
};
typedef ExitLimitCache ExitLimitCacheTy;
ExitLimit computeExitLimitFromCondCached(ExitLimitCacheTy &Cache,
const Loop *L, Value *ExitCond,
BasicBlock *TBB, BasicBlock *FBB,
bool ControlsExit,
bool AllowPredicates);
ExitLimit computeExitLimitFromCondImpl(ExitLimitCacheTy &Cache, const Loop *L,
Value *ExitCond, BasicBlock *TBB,
BasicBlock *FBB, bool ControlsExit,
bool AllowPredicates);
/// Compute the number of times the backedge of the specified loop will
/// execute if its exit condition were a conditional branch of the ICmpInst
/// ExitCond, TBB, and FBB. If AllowPredicates is set, this call will try

82
llvm/lib/Analysis/ScalarEvolution.cpp
View File

@ -6079,24 +6079,68 @@ ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
return getCouldNotCompute();
}
ScalarEvolution::ExitLimit
ScalarEvolution::computeExitLimitFromCond(const Loop *L,
Value *ExitCond,
BasicBlock *TBB,
BasicBlock *FBB,
bool ControlsExit,
bool AllowPredicates) {
ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCond(
const Loop *L, Value *ExitCond, BasicBlock *TBB, BasicBlock *FBB,
bool ControlsExit, bool AllowPredicates) {
ScalarEvolution::ExitLimitCacheTy Cache(L, TBB, FBB, AllowPredicates);
return computeExitLimitFromCondCached(Cache, L, ExitCond, TBB, FBB,
ControlsExit, AllowPredicates);
}
Optional<ScalarEvolution::ExitLimit>
ScalarEvolution::ExitLimitCache::find(const Loop *L, Value *ExitCond,
BasicBlock *TBB, BasicBlock *FBB,
bool ControlsExit, bool AllowPredicates) {
assert(this->L == L && this->TBB == TBB && this->FBB == FBB &&
this->AllowPredicates == AllowPredicates &&
"Variance in assumed invariant key components!");
auto Itr = TripCountMap.find({ExitCond, ControlsExit});
if (Itr == TripCountMap.end())
return None;
return Itr->second;
}
void ScalarEvolution::ExitLimitCache::insert(const Loop *L, Value *ExitCond,
BasicBlock *TBB, BasicBlock *FBB,
bool ControlsExit,
bool AllowPredicates,
const ExitLimit &EL) {
assert(this->L == L && this->TBB == TBB && this->FBB == FBB &&
this->AllowPredicates == AllowPredicates &&
"Variance in assumed invariant key components!");
auto InsertResult = TripCountMap.insert({{ExitCond, ControlsExit}, EL});
assert(InsertResult.second && "Expected successful insertion!");
}
ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCondCached(
ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, BasicBlock *TBB,
BasicBlock *FBB, bool ControlsExit, bool AllowPredicates) {
if (auto MaybeEL =
Cache.find(L, ExitCond, TBB, FBB, ControlsExit, AllowPredicates))
return *MaybeEL;
ExitLimit EL = computeExitLimitFromCondImpl(Cache, L, ExitCond, TBB, FBB,
ControlsExit, AllowPredicates);
Cache.insert(L, ExitCond, TBB, FBB, ControlsExit, AllowPredicates, EL);
return EL;
}
ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCondImpl(
ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, BasicBlock *TBB,
BasicBlock *FBB, bool ControlsExit, bool AllowPredicates) {
// Check if the controlling expression for this loop is an And or Or.
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(ExitCond)) {
if (BO->getOpcode() == Instruction::And) {
// Recurse on the operands of the and.
bool EitherMayExit = L->contains(TBB);
ExitLimit EL0 = computeExitLimitFromCond(L, BO->getOperand(0), TBB, FBB,
ControlsExit && !EitherMayExit,
AllowPredicates);
ExitLimit EL1 = computeExitLimitFromCond(L, BO->getOperand(1), TBB, FBB,
ControlsExit && !EitherMayExit,
AllowPredicates);
ExitLimit EL0 = computeExitLimitFromCondCached(
Cache, L, BO->getOperand(0), TBB, FBB, ControlsExit && !EitherMayExit,
AllowPredicates);
ExitLimit EL1 = computeExitLimitFromCondCached(
Cache, L, BO->getOperand(1), TBB, FBB, ControlsExit && !EitherMayExit,
AllowPredicates);
const SCEV *BECount = getCouldNotCompute();
const SCEV *MaxBECount = getCouldNotCompute();
if (EitherMayExit) {
@ -6140,12 +6184,12 @@ ScalarEvolution::computeExitLimitFromCond(const Loop *L,
if (BO->getOpcode() == Instruction::Or) {
// Recurse on the operands of the or.
bool EitherMayExit = L->contains(FBB);
ExitLimit EL0 = computeExitLimitFromCond(L, BO->getOperand(0), TBB, FBB,
ControlsExit && !EitherMayExit,
AllowPredicates);
ExitLimit EL1 = computeExitLimitFromCond(L, BO->getOperand(1), TBB, FBB,
ControlsExit && !EitherMayExit,
AllowPredicates);
ExitLimit EL0 = computeExitLimitFromCondCached(
Cache, L, BO->getOperand(0), TBB, FBB, ControlsExit && !EitherMayExit,
AllowPredicates);
ExitLimit EL1 = computeExitLimitFromCondCached(
Cache, L, BO->getOperand(1), TBB, FBB, ControlsExit && !EitherMayExit,
AllowPredicates);
const SCEV *BECount = getCouldNotCompute();
const SCEV *MaxBECount = getCouldNotCompute();
if (EitherMayExit) {

57
llvm/test/Analysis/ScalarEvolution/exponential-behavior.ll Normal file
View File

@ -0,0 +1,57 @@
; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f':
; CHECK: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %loop: max backedge-taken count is 0
; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
define void @f(i32 %n, i32* %ptr) {
entry:
br label %loop
loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %be ]
%iv.inc = add i32 %iv, 1
%unswitch_cond_root = icmp ne i32 %iv.inc, 42
%us.0 = and i1 %unswitch_cond_root, %unswitch_cond_root
%us.1 = and i1 %us.0, %us.0
%us.2 = and i1 %us.1, %us.1
%us.3 = and i1 %us.2, %us.2
%us.4 = and i1 %us.3, %us.3
%us.5 = and i1 %us.4, %us.4
%us.6 = and i1 %us.5, %us.5
%us.7 = and i1 %us.6, %us.6
%us.8 = and i1 %us.7, %us.7
%us.9 = and i1 %us.8, %us.8
%us.10 = and i1 %us.9, %us.9
%us.11 = and i1 %us.10, %us.10
%us.12 = and i1 %us.11, %us.11
%us.13 = and i1 %us.12, %us.12
%us.14 = and i1 %us.13, %us.13
%us.15 = and i1 %us.14, %us.14
%us.16 = and i1 %us.15, %us.15
%us.17 = and i1 %us.16, %us.16
%us.18 = and i1 %us.17, %us.17
%us.19 = and i1 %us.18, %us.18
%us.20 = and i1 %us.19, %us.19
%us.21 = and i1 %us.20, %us.20
%us.22 = and i1 %us.21, %us.21
%us.23 = and i1 %us.22, %us.22
%us.24 = and i1 %us.23, %us.23
%us.25 = and i1 %us.24, %us.24
%us.26 = and i1 %us.25, %us.25
%us.27 = and i1 %us.26, %us.26
%us.28 = and i1 %us.27, %us.27
%us.29 = and i1 %us.28, %us.28
br i1 %us.29, label %leave, label %be
be:
store volatile i32 0, i32* %ptr
%becond = icmp ult i32 %iv.inc, %n
br i1 %becond, label %leave, label %loop
leave:
ret void
}