RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-28 22:20:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Calculate backedge probability correctly.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@133776 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jakub Staszak 2011-06-23 23:52:11 +00:00
parent 0edb05b9e4
commit 66dddd1da3
3 changed files with 13 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/llvm/Analysis/BlockFrequencyImpl.h
View File

@ -133,6 +133,15 @@ class BlockFrequencyImpl {
} }
/// Return a probability of getting to the DST block through SRC->DST edge.
///
BranchProbability getBackEdgeProbability(BlockT *Src, BlockT *Dst) const {
uint32_t N = getEdgeFreq(Src, Dst);
uint32_t D = getBlockFreq(Dst);
return BranchProbability(N, D);
}
/// isReachable - Returns if BB block is reachable from the entry. /// isReachable - Returns if BB block is reachable from the entry.
/// ///
bool isReachable(BlockT *BB) { bool isReachable(BlockT *BB) {
@ -213,7 +222,9 @@ class BlockFrequencyImpl {
return; return;
assert(START_FREQ >= CycleProb[BB]); assert(START_FREQ >= CycleProb[BB]);
divBlockFreq(BB, BranchProbability(START_FREQ - CycleProb[BB], START_FREQ)); uint32_t CProb = CycleProb[BB];
uint32_t Numerator = START_FREQ - CProb ? START_FREQ - CProb : 1;
divBlockFreq(BB, BranchProbability(Numerator, START_FREQ));
} }
/// doLoop - Propagate block frequency down throught the loop. /// doLoop - Propagate block frequency down throught the loop.
@ -238,19 +249,17 @@ class BlockFrequencyImpl {
BlockT *Pred = *PI; BlockT *Pred = *PI;
assert(Pred); assert(Pred);
if (isReachable(Pred) && isBackedge(Pred, Head)) { if (isReachable(Pred) && isBackedge(Pred, Head)) {
BranchProbability Prob = BPI->getBackEdgeProbability(Pred, Head); BranchProbability Prob = getBackEdgeProbability(Pred, Head);
uint64_t N = Prob.getNumerator(); uint64_t N = Prob.getNumerator();
uint64_t D = Prob.getDenominator(); uint64_t D = Prob.getDenominator();
uint64_t Res = (N * START_FREQ) / D; uint64_t Res = (N * START_FREQ) / D;
// CycleProb[Head] += getEdgeFreq(Pred, Head);
assert(Res <= UINT32_MAX); assert(Res <= UINT32_MAX);
CycleProb[Head] += (uint32_t) Res; CycleProb[Head] += (uint32_t) Res;
} }
} }
} }
friend class BlockFrequency; friend class BlockFrequency;
void doFunction(FunctionT *fn, BlockProbInfoT *bpi) { void doFunction(FunctionT *fn, BlockProbInfoT *bpi) {

10
include/llvm/Analysis/BranchProbabilityInfo.h
View File

@ -39,9 +39,6 @@ class BranchProbabilityInfo : public FunctionPass {
// Get sum of the block successors' weights. // Get sum of the block successors' weights.
uint32_t getSumForBlock(BasicBlock *BB) const; uint32_t getSumForBlock(BasicBlock *BB) const;
// Get sum of the edge weights going to the BB block.
uint32_t getBackSumForBlock(BasicBlock *BB) const;
public: public:
static char ID; static char ID;
@ -74,13 +71,6 @@ public:
// only iff SRC block has only one successor. // only iff SRC block has only one successor.
BranchProbability getEdgeProbability(BasicBlock *Src, BasicBlock *Dst) const; BranchProbability getEdgeProbability(BasicBlock *Src, BasicBlock *Dst) const;
// Return a probability of getting to the DST block through SRC->DST edge.
// Returned value is a fraction between 0 (0% probability) and
// 1 (100% probability), however the value is never equal to 0, and can be 1
// only iff DST block has only one predecesor.
BranchProbability getBackEdgeProbability(BasicBlock *Src,
BasicBlock *Dst) const;
// Print value between 0 (0% probability) and 1 (100% probability), // Print value between 0 (0% probability) and 1 (100% probability),
// however the value is never equal to 0, and can be 1 only iff SRC block // however the value is never equal to 0, and can be 1 only iff SRC block
// has only one successor. // has only one successor.

24
lib/Analysis/BranchProbabilityInfo.cpp
View File

@ -279,21 +279,6 @@ uint32_t BranchProbabilityInfo::getSumForBlock(BasicBlock *BB) const {
return Sum; return Sum;
} }
uint32_t BranchProbabilityInfo::getBackSumForBlock(BasicBlock *BB) const {
uint32_t Sum = 0;
for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
BasicBlock *Pred = *I;
uint32_t Weight = getEdgeWeight(Pred, BB);
uint32_t PrevSum = Sum;
Sum += Weight;
assert(Sum > PrevSum); (void) PrevSum;
}
return Sum;
}
bool BranchProbabilityInfo::isEdgeHot(BasicBlock *Src, BasicBlock *Dst) const { bool BranchProbabilityInfo::isEdgeHot(BasicBlock *Src, BasicBlock *Dst) const {
// Hot probability is at least 4/5 = 80% // Hot probability is at least 4/5 = 80%
uint32_t Weight = getEdgeWeight(Src, Dst); uint32_t Weight = getEdgeWeight(Src, Dst);
@ -360,15 +345,6 @@ getEdgeProbability(BasicBlock *Src, BasicBlock *Dst) const {
return BranchProbability(N, D); return BranchProbability(N, D);
} }
BranchProbability BranchProbabilityInfo::
getBackEdgeProbability(BasicBlock *Src, BasicBlock *Dst) const {
uint32_t N = getEdgeWeight(Src, Dst);
uint32_t D = getBackSumForBlock(Dst);
return BranchProbability(N, D);
}
raw_ostream & raw_ostream &
BranchProbabilityInfo::printEdgeProbability(raw_ostream &OS, BasicBlock *Src, BranchProbabilityInfo::printEdgeProbability(raw_ostream &OS, BasicBlock *Src,
BasicBlock *Dst) const { BasicBlock *Dst) const {