include/llvm/Analysis/BlockFrequencyInfo.h

   1 //===- BlockFrequencyInfo.h - Block Frequency Analysis ----------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Loops should be simplified before this analysis.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
  14 #define LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
  15
  16 #include "llvm/ADT/Optional.h"
  17 #include "llvm/IR/PassManager.h"
  18 #include "llvm/Pass.h"
  19 #include "llvm/Support/BlockFrequency.h"
  20 #include <cstdint>
  21 #include <memory>
  22
  23 namespace llvm {
  24
  25 class BasicBlock;
  26 class BranchProbabilityInfo;
  27 class Function;
  28 class LoopInfo;
  29 class Module;
  30 class raw_ostream;
  31 template <class BlockT> class BlockFrequencyInfoImpl;
  32
  33 enum PGOViewCountsType { PGOVCT_None, PGOVCT_Graph, PGOVCT_Text };
  34
  35 /// BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to
  36 /// estimate IR basic block frequencies.
  37 class BlockFrequencyInfo {
  38   using ImplType = BlockFrequencyInfoImpl<BasicBlock>;
  39
  40   std::unique_ptr<ImplType> BFI;
  41
  42 public:
  43   BlockFrequencyInfo();
  44   BlockFrequencyInfo(const Function &F, const BranchProbabilityInfo &BPI,
  45                      const LoopInfo &LI);
  46   BlockFrequencyInfo(const BlockFrequencyInfo &) = delete;
  47   BlockFrequencyInfo &operator=(const BlockFrequencyInfo &) = delete;
  48   BlockFrequencyInfo(BlockFrequencyInfo &&Arg);
  49   BlockFrequencyInfo &operator=(BlockFrequencyInfo &&RHS);
  50   ~BlockFrequencyInfo();
  51
  52   /// Handle invalidation explicitly.
  53   bool invalidate(Function &F, const PreservedAnalyses &PA,
  54                   FunctionAnalysisManager::Invalidator &);
  55
  56   const Function *getFunction() const;
  57   const BranchProbabilityInfo *getBPI() const;
  58   void view(StringRef = "BlockFrequencyDAGs") const;
  59
  60   /// getblockFreq - Return block frequency. Return 0 if we don't have the
  61   /// information. Please note that initial frequency is equal to ENTRY_FREQ. It
  62   /// means that we should not rely on the value itself, but only on the
  63   /// comparison to the other block frequencies. We do this to avoid using of
  64   /// floating points.
  65   BlockFrequency getBlockFreq(const BasicBlock *BB) const;
  66
  67   /// Returns the estimated profile count of \p BB.
  68   /// This computes the relative block frequency of \p BB and multiplies it by
  69   /// the enclosing function's count (if available) and returns the value.
  70   Optional<uint64_t> getBlockProfileCount(const BasicBlock *BB) const;
  71
  72   /// Returns the estimated profile count of \p Freq.
  73   /// This uses the frequency \p Freq and multiplies it by
  74   /// the enclosing function's count (if available) and returns the value.
  75   Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
  76
  77   /// Returns true if \p BB is an irreducible loop header
  78   /// block. Otherwise false.
  79   bool isIrrLoopHeader(const BasicBlock *BB);
  80
  81   // Set the frequency of the given basic block.
  82   void setBlockFreq(const BasicBlock *BB, uint64_t Freq);
  83
  84   /// Set the frequency of \p ReferenceBB to \p Freq and scale the frequencies
  85   /// of the blocks in \p BlocksToScale such that their frequencies relative
  86   /// to \p ReferenceBB remain unchanged.
  87   void setBlockFreqAndScale(const BasicBlock *ReferenceBB, uint64_t Freq,
  88                             SmallPtrSetImpl<BasicBlock *> &BlocksToScale);
  89
  90   /// calculate - compute block frequency info for the given function.
  91   void calculate(const Function &F, const BranchProbabilityInfo &BPI,
  92                  const LoopInfo &LI);
  93
  94   // Print the block frequency Freq to OS using the current functions entry
  95   // frequency to convert freq into a relative decimal form.
  96   raw_ostream &printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const;
  97
  98   // Convenience method that attempts to look up the frequency associated with
  99   // BB and print it to OS.
 100   raw_ostream &printBlockFreq(raw_ostream &OS, const BasicBlock *BB) const;
 101
 102   uint64_t getEntryFreq() const;
 103   void releaseMemory();
 104   void print(raw_ostream &OS) const;
 105 };
 106
 107 /// Analysis pass which computes \c BlockFrequencyInfo.
 108 class BlockFrequencyAnalysis
 109     : public AnalysisInfoMixin<BlockFrequencyAnalysis> {
 110   friend AnalysisInfoMixin<BlockFrequencyAnalysis>;
 111
 112   static AnalysisKey Key;
 113
 114 public:
 115   /// Provide the result type for this analysis pass.
 116   using Result = BlockFrequencyInfo;
 117
 118   /// Run the analysis pass over a function and produce BFI.
 119   Result run(Function &F, FunctionAnalysisManager &AM);
 120 };
 121
 122 /// Printer pass for the \c BlockFrequencyInfo results.
 123 class BlockFrequencyPrinterPass
 124     : public PassInfoMixin<BlockFrequencyPrinterPass> {
 125   raw_ostream &OS;
 126
 127 public:
 128   explicit BlockFrequencyPrinterPass(raw_ostream &OS) : OS(OS) {}
 129
 130   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 131 };
 132
 133 /// Legacy analysis pass which computes \c BlockFrequencyInfo.
 134 class BlockFrequencyInfoWrapperPass : public FunctionPass {
 135   BlockFrequencyInfo BFI;
 136
 137 public:
 138   static char ID;
 139
 140   BlockFrequencyInfoWrapperPass();
 141   ~BlockFrequencyInfoWrapperPass() override;
 142
 143   BlockFrequencyInfo &getBFI() { return BFI; }
 144   const BlockFrequencyInfo &getBFI() const { return BFI; }
 145
 146   void getAnalysisUsage(AnalysisUsage &AU) const override;
 147
 148   bool runOnFunction(Function &F) override;
 149   void releaseMemory() override;
 150   void print(raw_ostream &OS, const Module *M) const override;
 151 };
 152
 153 } // end namespace llvm
 154
 155 #endif // LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H