LLVM  4.0.0
BlockFrequencyInfo.h
Go to the documentation of this file.
1 //===- BlockFrequencyInfo.h - Block Frequency Analysis ----------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Loops should be simplified before this analysis.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
15 #define LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
16 
17 #include "llvm/ADT/Optional.h"
18 #include "llvm/IR/PassManager.h"
19 #include "llvm/Pass.h"
21 #include <climits>
22 
23 namespace llvm {
24 
25 class BranchProbabilityInfo;
26 class LoopInfo;
27 template <class BlockT> class BlockFrequencyInfoImpl;
28 
29 /// BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to
30 /// estimate IR basic block frequencies.
33  std::unique_ptr<ImplType> BFI;
34 
35  void operator=(const BlockFrequencyInfo &) = delete;
36  BlockFrequencyInfo(const BlockFrequencyInfo &) = delete;
37 
38 public:
41  const LoopInfo &LI);
43 
44  BlockFrequencyInfo &operator=(BlockFrequencyInfo &&RHS);
45 
47 
48  const Function *getFunction() const;
49  const BranchProbabilityInfo *getBPI() const;
50  void view() const;
51 
52  /// getblockFreq - Return block frequency. Return 0 if we don't have the
53  /// information. Please note that initial frequency is equal to ENTRY_FREQ. It
54  /// means that we should not rely on the value itself, but only on the
55  /// comparison to the other block frequencies. We do this to avoid using of
56  /// floating points.
57  BlockFrequency getBlockFreq(const BasicBlock *BB) const;
58 
59  /// \brief Returns the estimated profile count of \p BB.
60  /// This computes the relative block frequency of \p BB and multiplies it by
61  /// the enclosing function's count (if available) and returns the value.
63 
64  /// \brief Returns the estimated profile count of \p Freq.
65  /// This uses the frequency \p Freq and multiplies it by
66  /// the enclosing function's count (if available) and returns the value.
67  Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
68 
69  // Set the frequency of the given basic block.
70  void setBlockFreq(const BasicBlock *BB, uint64_t Freq);
71 
72  /// calculate - compute block frequency info for the given function.
73  void calculate(const Function &F, const BranchProbabilityInfo &BPI,
74  const LoopInfo &LI);
75 
76  // Print the block frequency Freq to OS using the current functions entry
77  // frequency to convert freq into a relative decimal form.
78  raw_ostream &printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const;
79 
80  // Convenience method that attempts to look up the frequency associated with
81  // BB and print it to OS.
82  raw_ostream &printBlockFreq(raw_ostream &OS, const BasicBlock *BB) const;
83 
84  uint64_t getEntryFreq() const;
85  void releaseMemory();
86  void print(raw_ostream &OS) const;
87 };
88 
89 /// \brief Analysis pass which computes \c BlockFrequencyInfo.
91  : public AnalysisInfoMixin<BlockFrequencyAnalysis> {
93  static AnalysisKey Key;
94 
95 public:
96  /// \brief Provide the result typedef for this analysis pass.
98 
99  /// \brief Run the analysis pass over a function and produce BFI.
101 };
102 
103 /// \brief Printer pass for the \c BlockFrequencyInfo results.
105  : public PassInfoMixin<BlockFrequencyPrinterPass> {
106  raw_ostream &OS;
107 
108 public:
109  explicit BlockFrequencyPrinterPass(raw_ostream &OS) : OS(OS) {}
111 };
112 
113 /// \brief Legacy analysis pass which computes \c BlockFrequencyInfo.
115  BlockFrequencyInfo BFI;
116 
117 public:
118  static char ID;
119 
122 
123  BlockFrequencyInfo &getBFI() { return BFI; }
124  const BlockFrequencyInfo &getBFI() const { return BFI; }
125 
126  void getAnalysisUsage(AnalysisUsage &AU) const override;
127 
128  bool runOnFunction(Function &F) override;
129  void releaseMemory() override;
130  void print(raw_ostream &OS, const Module *M) const override;
131 };
132 
133 }
134 
135 #endif
BlockFrequencyInfo Result
Provide the result typedef for this analysis pass.
Result run(Function &F, FunctionAnalysisManager &AM)
Run the analysis pass over a function and produce BFI.
raw_ostream & printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
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...
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
const BlockFrequencyInfo & getBFI() const
Legacy analysis pass which computes BlockFrequencyInfo.
#define F(x, y, z)
Definition: MD5.cpp:51
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:311
Optional< uint64_t > getProfileCountFromFreq(uint64_t Freq) const
Returns the estimated profile count of Freq.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
Printer pass for the BlockFrequencyInfo results.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:328
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.
Definition: Pass.h:298
Analysis pass which computes BlockFrequencyInfo.
void setBlockFreq(const BasicBlock *BB, uint64_t Freq)
void print(raw_ostream &OS) const
const BranchProbabilityInfo * getBPI() const
Analysis providing branch probability information.
const Function * getFunction() const
void view() const
Pop up a ghostview window with the current block frequency propagation rendered using dot...
void print(raw_ostream &OS, const Module *M) const override
print - Print out the internal state of the pass.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
Shared implementation for block frequency analysis.
A container for analyses that lazily runs them and caches their results.
Optional< uint64_t > getBlockProfileCount(const BasicBlock *BB) const
Returns the estimated profile count of BB.
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...
Definition: PassManager.h:64
BlockFrequency getBlockFreq(const BasicBlock *BB) const
getblockFreq - Return block frequency.