mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-20 19:42:54 +02:00
78f8766db3
Rewrite the shared implementation of BlockFrequencyInfo and MachineBlockFrequencyInfo entirely. The old implementation had a fundamental flaw: precision losses from nested loops (or very wide branches) compounded past loop exits (and convergence points). The @nested_loops testcase at the end of test/Analysis/BlockFrequencyAnalysis/basic.ll is motivating. This function has three nested loops, with branch weights in the loop headers of 1:4000 (exit:continue). The old analysis gives non-sensical results: Printing analysis 'Block Frequency Analysis' for function 'nested_loops': ---- Block Freqs ---- entry = 1.0 for.cond1.preheader = 1.00103 for.cond4.preheader = 5.5222 for.body6 = 18095.19995 for.inc8 = 4.52264 for.inc11 = 0.00109 for.end13 = 0.0 The new analysis gives correct results: Printing analysis 'Block Frequency Analysis' for function 'nested_loops': block-frequency-info: nested_loops - entry: float = 1.0, int = 8 - for.cond1.preheader: float = 4001.0, int = 32007 - for.cond4.preheader: float = 16008001.0, int = 128064007 - for.body6: float = 64048012001.0, int = 512384096007 - for.inc8: float = 16008001.0, int = 128064007 - for.inc11: float = 4001.0, int = 32007 - for.end13: float = 1.0, int = 8 Most importantly, the frequency leaving each loop matches the frequency entering it. The new algorithm leverages BlockMass and PositiveFloat to maintain precision, separates "probability mass distribution" from "loop scaling", and uses dithering to eliminate probability mass loss. I have unit tests for these types out of tree, but it was decided in the review to make the classes private to BlockFrequencyInfoImpl, and try to shrink them (or remove them entirely) in follow-up commits. The new algorithm should generally have a complexity advantage over the old. The previous algorithm was quadratic in the worst case. The new algorithm is still worst-case quadratic in the presence of irreducible control flow, but it's linear without it. The key difference between the old algorithm and the new is that control flow within a loop is evaluated separately from control flow outside, limiting propagation of precision problems and allowing loop scale to be calculated independently of mass distribution. Loops are visited bottom-up, their loop scales are calculated, and they are replaced by pseudo-nodes. Mass is then distributed through the function, which is now a DAG. Finally, loops are revisited top-down to multiply through the loop scales and the masses distributed to pseudo nodes. There are some remaining flaws. - Irreducible control flow isn't modelled correctly. LoopInfo and MachineLoopInfo ignore irreducible edges, so this algorithm will fail to scale accordingly. There's a note in the class documentation about how to get closer. See also the comments in test/Analysis/BlockFrequencyInfo/irreducible.ll. - Loop scale is limited to 4096 per loop (2^12) to avoid exhausting the 64-bit integer precision used downstream. - The "bias" calculation proposed on llvmdev is *not* incorporated here. This will be added in a follow-up commit, once comments from this review have been handled. llvm-svn: 206548
182 lines
5.5 KiB
C++
182 lines
5.5 KiB
C++
//===- BlockFrequencyInfo.cpp - Block Frequency Analysis ------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Loops should be simplified before this analysis.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define DEBUG_TYPE "block-freq"
|
|
#include "llvm/Analysis/BlockFrequencyInfo.h"
|
|
#include "llvm/Analysis/BlockFrequencyInfoImpl.h"
|
|
#include "llvm/Analysis/BranchProbabilityInfo.h"
|
|
#include "llvm/Analysis/LoopInfo.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/IR/CFG.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/GraphWriter.h"
|
|
|
|
using namespace llvm;
|
|
|
|
#ifndef NDEBUG
|
|
enum GVDAGType {
|
|
GVDT_None,
|
|
GVDT_Fraction,
|
|
GVDT_Integer
|
|
};
|
|
|
|
static cl::opt<GVDAGType>
|
|
ViewBlockFreqPropagationDAG("view-block-freq-propagation-dags", cl::Hidden,
|
|
cl::desc("Pop up a window to show a dag displaying how block "
|
|
"frequencies propagation through the CFG."),
|
|
cl::values(
|
|
clEnumValN(GVDT_None, "none",
|
|
"do not display graphs."),
|
|
clEnumValN(GVDT_Fraction, "fraction", "display a graph using the "
|
|
"fractional block frequency representation."),
|
|
clEnumValN(GVDT_Integer, "integer", "display a graph using the raw "
|
|
"integer fractional block frequency representation."),
|
|
clEnumValEnd));
|
|
|
|
namespace llvm {
|
|
|
|
template <>
|
|
struct GraphTraits<BlockFrequencyInfo *> {
|
|
typedef const BasicBlock NodeType;
|
|
typedef succ_const_iterator ChildIteratorType;
|
|
typedef Function::const_iterator nodes_iterator;
|
|
|
|
static inline const NodeType *getEntryNode(const BlockFrequencyInfo *G) {
|
|
return G->getFunction()->begin();
|
|
}
|
|
static ChildIteratorType child_begin(const NodeType *N) {
|
|
return succ_begin(N);
|
|
}
|
|
static ChildIteratorType child_end(const NodeType *N) {
|
|
return succ_end(N);
|
|
}
|
|
static nodes_iterator nodes_begin(const BlockFrequencyInfo *G) {
|
|
return G->getFunction()->begin();
|
|
}
|
|
static nodes_iterator nodes_end(const BlockFrequencyInfo *G) {
|
|
return G->getFunction()->end();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct DOTGraphTraits<BlockFrequencyInfo*> : public DefaultDOTGraphTraits {
|
|
explicit DOTGraphTraits(bool isSimple=false) :
|
|
DefaultDOTGraphTraits(isSimple) {}
|
|
|
|
static std::string getGraphName(const BlockFrequencyInfo *G) {
|
|
return G->getFunction()->getName();
|
|
}
|
|
|
|
std::string getNodeLabel(const BasicBlock *Node,
|
|
const BlockFrequencyInfo *Graph) {
|
|
std::string Result;
|
|
raw_string_ostream OS(Result);
|
|
|
|
OS << Node->getName().str() << ":";
|
|
switch (ViewBlockFreqPropagationDAG) {
|
|
case GVDT_Fraction:
|
|
Graph->printBlockFreq(OS, Node);
|
|
break;
|
|
case GVDT_Integer:
|
|
OS << Graph->getBlockFreq(Node).getFrequency();
|
|
break;
|
|
case GVDT_None:
|
|
llvm_unreachable("If we are not supposed to render a graph we should "
|
|
"never reach this point.");
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
};
|
|
|
|
} // end namespace llvm
|
|
#endif
|
|
|
|
INITIALIZE_PASS_BEGIN(BlockFrequencyInfo, "block-freq",
|
|
"Block Frequency Analysis", true, true)
|
|
INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfo)
|
|
INITIALIZE_PASS_DEPENDENCY(LoopInfo)
|
|
INITIALIZE_PASS_END(BlockFrequencyInfo, "block-freq",
|
|
"Block Frequency Analysis", true, true)
|
|
|
|
char BlockFrequencyInfo::ID = 0;
|
|
|
|
|
|
BlockFrequencyInfo::BlockFrequencyInfo() : FunctionPass(ID) {
|
|
initializeBlockFrequencyInfoPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
BlockFrequencyInfo::~BlockFrequencyInfo() {}
|
|
|
|
void BlockFrequencyInfo::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addRequired<BranchProbabilityInfo>();
|
|
AU.addRequired<LoopInfo>();
|
|
AU.setPreservesAll();
|
|
}
|
|
|
|
bool BlockFrequencyInfo::runOnFunction(Function &F) {
|
|
BranchProbabilityInfo &BPI = getAnalysis<BranchProbabilityInfo>();
|
|
LoopInfo &LI = getAnalysis<LoopInfo>();
|
|
if (!BFI)
|
|
BFI.reset(new ImplType);
|
|
BFI->doFunction(&F, &BPI, &LI);
|
|
#ifndef NDEBUG
|
|
if (ViewBlockFreqPropagationDAG != GVDT_None)
|
|
view();
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
void BlockFrequencyInfo::releaseMemory() { BFI.reset(); }
|
|
|
|
void BlockFrequencyInfo::print(raw_ostream &O, const Module *) const {
|
|
if (BFI) BFI->print(O);
|
|
}
|
|
|
|
BlockFrequency BlockFrequencyInfo::getBlockFreq(const BasicBlock *BB) const {
|
|
return BFI ? BFI->getBlockFreq(BB) : 0;
|
|
}
|
|
|
|
/// Pop up a ghostview window with the current block frequency propagation
|
|
/// rendered using dot.
|
|
void BlockFrequencyInfo::view() const {
|
|
// This code is only for debugging.
|
|
#ifndef NDEBUG
|
|
ViewGraph(const_cast<BlockFrequencyInfo *>(this), "BlockFrequencyDAGs");
|
|
#else
|
|
errs() << "BlockFrequencyInfo::view is only available in debug builds on "
|
|
"systems with Graphviz or gv!\n";
|
|
#endif // NDEBUG
|
|
}
|
|
|
|
const Function *BlockFrequencyInfo::getFunction() const {
|
|
return BFI ? BFI->getFunction() : nullptr;
|
|
}
|
|
|
|
raw_ostream &BlockFrequencyInfo::
|
|
printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const {
|
|
return BFI ? BFI->printBlockFreq(OS, Freq) : OS;
|
|
}
|
|
|
|
raw_ostream &
|
|
BlockFrequencyInfo::printBlockFreq(raw_ostream &OS,
|
|
const BasicBlock *BB) const {
|
|
return BFI ? BFI->printBlockFreq(OS, BB) : OS;
|
|
}
|
|
|
|
uint64_t BlockFrequencyInfo::getEntryFreq() const {
|
|
return BFI ? BFI->getEntryFreq() : 0;
|
|
}
|