33 #define DEBUG_TYPE "block-freq" 36 "view-block-freq-propagation-dags",
cl::Hidden,
37 cl::desc(
"Pop up a window to show a dag displaying how block " 38 "frequencies propagation through the CFG."),
41 "display a graph using the " 42 "fractional block frequency representation."),
44 "display a graph using the raw " 45 "integer fractional block frequency representation."),
47 "profile count if available.")));
52 "the name of the function " 53 "whose CFG will be displayed."));
57 cl::desc(
"An integer in percent used to specify " 58 "the hot blocks/edges to be displayed " 59 "in red: a block or edge whose frequency " 60 "is no less than the max frequency of the " 61 "function multiplied by this percent."));
66 cl::desc(
"A boolean option to show CFG dag or text with " 67 "block profile counts and branch probabilities " 68 "right after PGO profile annotation step. The " 69 "profile counts are computed using branch " 70 "probabilities from the runtime profile data and " 71 "block frequency propagation algorithm. To view " 72 "the raw counts from the profile, use option " 73 "-pgo-view-raw-counts instead. To limit graph " 74 "display to only one function, use filtering option " 75 "-view-bfi-func-name."),
82 cl::desc(
"Print the block frequency info."));
86 cl::desc(
"The option to specify the name of the function " 87 "whose block frequency info is printed."));
164 BFI = std::move(RHS.BFI);
188 BFI->calculate(F, BPI, LI);
202 return BFI ?
BFI->getBlockFreq(BB) : 0;
207 bool AllowSynthetic)
const {
211 return BFI->getBlockProfileCount(*
getFunction(), BB, AllowSynthetic);
222 assert(
BFI &&
"Expected analysis to be available");
223 return BFI->isIrrLoopHeader(BB);
227 assert(
BFI &&
"Expected analysis to be available");
228 BFI->setBlockFreq(BB, Freq);
234 assert(
BFI &&
"Expected analysis to be available");
236 APInt NewFreq(128, Freq);
237 APInt OldFreq(128,
BFI->getBlockFreq(ReferenceBB).getFrequency());
238 APInt BBFreq(128, 0);
239 for (
auto *BB : BlocksToScale) {
240 BBFreq =
BFI->getBlockFreq(BB).getFrequency();
247 BBFreq = BBFreq.
udiv(OldFreq);
248 BFI->setBlockFreq(BB, BBFreq.getLimitedValue());
250 BFI->setBlockFreq(ReferenceBB, Freq);
256 ViewGraph(const_cast<BlockFrequencyInfo *>(
this), title);
260 return BFI ?
BFI->getFunction() :
nullptr;
264 return BFI ? &
BFI->getBPI() :
nullptr;
269 return BFI ?
BFI->printBlockFreq(OS, Freq) : OS;
275 return BFI ?
BFI->printBlockFreq(OS, BB) : OS;
279 return BFI ?
BFI->getEntryFreq() : 0;
290 "Block Frequency Analysis",
true,
true)
296 char BlockFrequencyInfoWrapperPass::
ID = 0;
298 BlockFrequencyInfoWrapperPass::BlockFrequencyInfoWrapperPass()
320 getAnalysis<BranchProbabilityInfoWrapperPass>().
getBPI();
321 LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
322 BFI.calculate(F, BPI, LI);
337 OS <<
"Printing analysis results of BFI for function " Optional< uint64_t > getBlockProfileCount(const BasicBlock *BB, bool AllowSynthetic=false) const
Returns the estimated profile count of BB.
static NodeRef getEntryNode(const BlockFrequencyInfo *G)
Result run(Function &F, FunctionAnalysisManager &AM)
Run the analysis pass over a function and produce BFI.
std::string getNodeLabel(const BasicBlock *Node, const BlockFrequencyInfo *Graph)
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
This class represents lattice values for constants.
BlockFrequencyInfo & operator=(const BlockFrequencyInfo &)=delete
A Module instance is used to store all the information related to an LLVM module. ...
DOTGraphTraits(bool isSimple=false)
cl::opt< unsigned > ViewHotFreqPercent("view-hot-freq-percent", cl::init(10), cl::Hidden, cl::desc("An integer in percent used to specify " "the hot blocks/edges to be displayed " "in red: a block or edge whose frequency " "is no less than the max frequency of the " "function multiplied by this percent."))
APInt udiv(const APInt &RHS) const
Unsigned division operation.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
cl::opt< PGOViewCountsType > PGOViewCounts("pgo-view-counts", cl::Hidden, cl::desc("A boolean option to show CFG dag or text with " "block profile counts and branch probabilities " "right after PGO profile annotation step. The " "profile counts are computed using branch " "probabilities from the runtime profile data and " "block frequency propagation algorithm. To view " "the raw counts from the profile, use option " "-pgo-view-raw-counts instead. To limit graph " "display to only one function, use filtering option " "-view-bfi-func-name."), cl::values(clEnumValN(PGOVCT_None, "none", "do not show."), clEnumValN(PGOVCT_Graph, "graph", "show a graph."), clEnumValN(PGOVCT_Text, "text", "show in text.")))
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
~BlockFrequencyInfoWrapperPass() override
block Block Frequency true
void view(StringRef="BlockFrequencyDAGs") const
Pop up a ghostview window with the current block frequency propagation rendered using dot...
SuccIterator< const Instruction, const BasicBlock > succ_const_iterator
static GVDAGType getGVDT()
raw_ostream & printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
*ViewGraph Emit a dot run run gv on the postscript *then cleanup For use from the debugger *void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
void initializeBlockFrequencyInfoWrapperPassPass(PassRegistry &)
Legacy analysis pass which computes BlockFrequencyInfo.
std::string getNodeLabel(NodeRef Node, const BlockFrequencyInfoT *Graph, GVDAGType GType, int layout_order=-1)
void setBlockFreqAndScale(const BasicBlock *ReferenceBB, uint64_t Freq, SmallPtrSetImpl< BasicBlock *> &BlocksToScale)
Set the frequency of ReferenceBB to Freq and scale the frequencies of the blocks in BlocksToScale suc...
Analysis pass that exposes the LoopInfo for a function.
This file implements a class to represent arbitrary precision integral constant values and operations...
std::string getNodeAttributes(const BasicBlock *Node, const BlockFrequencyInfo *Graph)
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
static bool isSimple(Instruction *I)
Analysis pass which computes BranchProbabilityInfo.
static nodes_iterator nodes_begin(const BlockFrequencyInfo *G)
INITIALIZE_PASS_BEGIN(BlockFrequencyInfoWrapperPass, "block-freq", "Block Frequency Analysis", true, true) INITIALIZE_PASS_END(BlockFrequencyInfoWrapperPass
static ChildIteratorType child_end(const NodeRef N)
Legacy analysis pass which computes BranchProbabilityInfo.
Interval::succ_iterator succ_end(Interval *I)
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
initializer< Ty > init(const Ty &Val)
A set of analyses that are preserved following a run of a transformation pass.
LLVM Basic Block Representation.
static cl::opt< bool > PrintBlockFreq("print-bfi", cl::init(false), cl::Hidden, cl::desc("Print the block frequency info."))
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
static ChildIteratorType child_begin(const NodeRef N)
void calculate(const Function &F, const BranchProbabilityInfo &BPI, const LoopInfo &LI)
calculate - compute block frequency info for the given function.
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
void print(raw_ostream &OS) const
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
std::string getEdgeAttributes(NodeRef Node, EdgeIter EI, const BlockFrequencyInfoT *BFI, const BranchProbabilityInfoT *BPI, unsigned HotPercentThreshold=0)
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &)
Handle invalidation explicitly.
bool isIrrLoopHeader(const BasicBlock *BB)
Returns true if BB is an irreducible loop header block.
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
uint64_t getEntryFreq() const
std::string getNodeAttributes(NodeRef Node, const BlockFrequencyInfoT *Graph, unsigned HotPercentThreshold=0)
std::string getEdgeAttributes(const BasicBlock *Node, EdgeIter EI, const BlockFrequencyInfo *BFI)
Analysis pass which computes BlockFrequencyInfo.
void setBlockFreq(const BasicBlock *BB, uint64_t Freq)
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."), clEnumValN(GVDT_Count, "count", "display a graph using the real " "profile count if available.")))
BlockFrequency getBlockFreq(const BasicBlock *BB) const
getblockFreq - Return block frequency.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Class for arbitrary precision integers.
void setPreservesAll()
Set by analyses that do not transform their input at all.
cl::opt< std::string > PrintBlockFreqFuncName("print-bfi-func-name", cl::Hidden, cl::desc("The option to specify the name of the function " "whose block frequency info is printed."))
const BranchProbabilityInfo * getBPI() const
Represents analyses that only rely on functions' control flow.
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
cl::opt< std::string > ViewBlockFreqFuncName("view-bfi-func-name", cl::Hidden, cl::desc("The option to specify " "the name of the function " "whose CFG will be displayed."))
Analysis providing branch probability information.
block Block Frequency Analysis
StringRef getName() const
Return a constant reference to the value's name.
typename GTraits::ChildIteratorType EdgeIter
API to communicate dependencies between analyses during invalidation.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This templated class represents "all analyses that operate over <a particular IR unit>" (e...
const BasicBlock & front() const
void print(raw_ostream &OS, const Module *M) const override
print - Print out the internal state of the pass.
const Function * getFunction() const
This class implements an extremely fast bulk output stream that can only output to a stream...
The legacy pass manager's analysis pass to compute loop information.
Shared implementation for block frequency analysis.
StringRef - Represent a constant reference to a string, i.e.
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Optional< uint64_t > getProfileCountFromFreq(uint64_t Freq) const
Returns the estimated profile count of Freq.
static nodes_iterator nodes_end(const BlockFrequencyInfo *G)