LLVM  16.0.0git
ProfileSummaryInfo.h
Go to the documentation of this file.
1 //===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---*- 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 // This file contains a pass that provides access to profile summary
10 // information.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_ANALYSIS_PROFILESUMMARYINFO_H
15 #define LLVM_ANALYSIS_PROFILESUMMARYINFO_H
16 
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/IR/PassManager.h"
19 #include "llvm/IR/ProfileSummary.h"
20 #include "llvm/Pass.h"
21 #include <memory>
22 #include <optional>
23 
24 namespace llvm {
25 class BasicBlock;
26 class BlockFrequencyInfo;
27 class CallBase;
28 class Function;
29 
30 /// Analysis providing profile information.
31 ///
32 /// This is an immutable analysis pass that provides ability to query global
33 /// (program-level) profile information. The main APIs are isHotCount and
34 /// isColdCount that tells whether a given profile count is considered hot/cold
35 /// based on the profile summary. This also provides convenience methods to
36 /// check whether a function is hot or cold.
37 
38 // FIXME: Provide convenience methods to determine hotness/coldness of other IR
39 // units. This would require making this depend on BFI.
41 private:
42  const Module *M;
43  std::unique_ptr<ProfileSummary> Summary;
44  void computeThresholds();
45  // Count thresholds to answer isHotCount and isColdCount queries.
46  std::optional<uint64_t> HotCountThreshold, ColdCountThreshold;
47  // True if the working set size of the code is considered huge,
48  // because the number of profile counts required to reach the hot
49  // percentile is above a huge threshold.
50  std::optional<bool> HasHugeWorkingSetSize;
51  // True if the working set size of the code is considered large,
52  // because the number of profile counts required to reach the hot
53  // percentile is above a large threshold.
54  std::optional<bool> HasLargeWorkingSetSize;
55  // Compute the threshold for a given cutoff.
56  Optional<uint64_t> computeThreshold(int PercentileCutoff) const;
57  // The map that caches the threshold values. The keys are the percentile
58  // cutoff values and the values are the corresponding threshold values.
59  mutable DenseMap<int, uint64_t> ThresholdCache;
60 
61 public:
62  ProfileSummaryInfo(const Module &M) : M(&M) { refresh(); }
64 
65  /// If no summary is present, attempt to refresh.
66  void refresh();
67 
68  /// Returns true if profile summary is available.
69  bool hasProfileSummary() const { return Summary != nullptr; }
70 
71  /// Returns true if module \c M has sample profile.
72  bool hasSampleProfile() const {
73  return hasProfileSummary() &&
74  Summary->getKind() == ProfileSummary::PSK_Sample;
75  }
76 
77  /// Returns true if module \c M has instrumentation profile.
79  return hasProfileSummary() &&
80  Summary->getKind() == ProfileSummary::PSK_Instr;
81  }
82 
83  /// Returns true if module \c M has context sensitive instrumentation profile.
85  return hasProfileSummary() &&
86  Summary->getKind() == ProfileSummary::PSK_CSInstr;
87  }
88 
89  /// Handle the invalidation of this information.
90  ///
91  /// When used as a result of \c ProfileSummaryAnalysis this method will be
92  /// called when the module this was computed for changes. Since profile
93  /// summary is immutable after it is annotated on the module, we return false
94  /// here.
97  return false;
98  }
99 
100  /// Returns the profile count for \p CallInst.
103  bool AllowSynthetic = false) const;
104  /// Returns true if module \c M has partial-profile sample profile.
105  bool hasPartialSampleProfile() const;
106  /// Returns true if the working set size of the code is considered huge.
107  bool hasHugeWorkingSetSize() const;
108  /// Returns true if the working set size of the code is considered large.
109  bool hasLargeWorkingSetSize() const;
110  /// Returns true if \p F has hot function entry.
111  bool isFunctionEntryHot(const Function *F) const;
112  /// Returns true if \p F contains hot code.
113  bool isFunctionHotInCallGraph(const Function *F,
114  BlockFrequencyInfo &BFI) const;
115  /// Returns true if \p F has cold function entry.
116  bool isFunctionEntryCold(const Function *F) const;
117  /// Returns true if \p F contains only cold code.
119  BlockFrequencyInfo &BFI) const;
120  /// Returns true if the hotness of \p F is unknown.
121  bool isFunctionHotnessUnknown(const Function &F) const;
122  /// Returns true if \p F contains hot code with regard to a given hot
123  /// percentile cutoff value.
125  const Function *F,
126  BlockFrequencyInfo &BFI) const;
127  /// Returns true if \p F contains cold code with regard to a given cold
128  /// percentile cutoff value.
130  const Function *F,
131  BlockFrequencyInfo &BFI) const;
132  /// Returns true if count \p C is considered hot.
133  bool isHotCount(uint64_t C) const;
134  /// Returns true if count \p C is considered cold.
135  bool isColdCount(uint64_t C) const;
136  /// Returns true if count \p C is considered hot with regard to a given
137  /// hot percentile cutoff value.
138  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
139  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
141  /// Returns true if count \p C is considered cold with regard to a given
142  /// cold percentile cutoff value.
143  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
144  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
146  /// Returns true if BasicBlock \p BB is considered hot.
147  bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;
148  /// Returns true if BasicBlock \p BB is considered cold.
149  bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;
150  /// Returns true if BasicBlock \p BB is considered hot with regard to a given
151  /// hot percentile cutoff value.
152  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
153  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
155  BlockFrequencyInfo *BFI) const;
156  /// Returns true if BasicBlock \p BB is considered cold with regard to a given
157  /// cold percentile cutoff value.
158  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
159  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
161  BlockFrequencyInfo *BFI) const;
162  /// Returns true if the call site \p CB is considered hot.
163  bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
164  /// Returns true if call site \p CB is considered cold.
165  bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
166  /// Returns HotCountThreshold if set. Recompute HotCountThreshold
167  /// if not set.
169  /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
170  /// if not set.
172  /// Returns HotCountThreshold if set.
174  return HotCountThreshold.value_or(0);
175  }
176  /// Returns ColdCountThreshold if set.
178  return ColdCountThreshold.value_or(0);
179  }
180 
181  private:
182  template <bool isHot>
183  bool isFunctionHotOrColdInCallGraphNthPercentile(
184  int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) const;
185  template <bool isHot>
186  bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
187  template <bool isHot>
188  bool isHotOrColdBlockNthPercentile(int PercentileCutoff,
189  const BasicBlock *BB,
190  BlockFrequencyInfo *BFI) const;
191 };
192 
193 /// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
195  std::unique_ptr<ProfileSummaryInfo> PSI;
196 
197 public:
198  static char ID;
200 
201  ProfileSummaryInfo &getPSI() { return *PSI; }
202  const ProfileSummaryInfo &getPSI() const { return *PSI; }
203 
204  bool doInitialization(Module &M) override;
205  bool doFinalization(Module &M) override;
206  void getAnalysisUsage(AnalysisUsage &AU) const override {
207  AU.setPreservesAll();
208  }
209 };
210 
211 /// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
213  : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
214 public:
216 
218 
219 private:
221  static AnalysisKey Key;
222 };
223 
224 /// Printer pass that uses \c ProfileSummaryAnalysis.
226  : public PassInfoMixin<ProfileSummaryPrinterPass> {
227  raw_ostream &OS;
228 
229 public:
230  explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
232 };
233 
234 } // end namespace llvm
235 
236 #endif
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::ProfileSummaryInfo::isColdCallSite
bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const
Returns true if call site CB is considered cold.
Definition: ProfileSummaryInfo.cpp:365
llvm::ProfileSummaryInfo::isColdBlockNthPercentile
bool isColdBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB, BlockFrequencyInfo *BFI) const
Returns true if BasicBlock BB is considered cold with regard to a given cold percentile cutoff value.
Definition: ProfileSummaryInfo.cpp:354
llvm::ProfileSummaryInfo::hasPartialSampleProfile
bool hasPartialSampleProfile() const
Returns true if module M has partial-profile sample profile.
Definition: ProfileSummaryInfo.cpp:376
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:279
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
llvm::Function
Definition: Function.h:60
ProfileSummary.h
Pass.h
llvm::ProfileSummaryInfo::hasProfileSummary
bool hasProfileSummary() const
Returns true if profile summary is available.
Definition: ProfileSummaryInfo.h:69
llvm::ProfileSummaryInfo::isFunctionEntryHot
bool isFunctionEntryHot(const Function *F) const
Returns true if F has hot function entry.
Definition: ProfileSummaryInfo.cpp:100
llvm::ProfileSummaryInfo::getOrCompHotCountThreshold
uint64_t getOrCompHotCountThreshold() const
Returns HotCountThreshold if set.
Definition: ProfileSummaryInfo.cpp:319
llvm::ProfileSummaryInfo::isHotBlock
bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const
Returns true if BasicBlock BB is considered hot.
Definition: ProfileSummaryInfo.cpp:327
DenseMap.h
llvm::ProfileSummaryInfo::hasCSInstrumentationProfile
bool hasCSInstrumentationProfile() const
Returns true if module M has context sensitive instrumentation profile.
Definition: ProfileSummaryInfo.h:84
llvm::ProfileSummaryInfo::isFunctionEntryCold
bool isFunctionEntryCold(const Function *F) const
Returns true if F has cold function entry.
Definition: ProfileSummaryInfo.cpp:223
llvm::Optional< uint64_t >
llvm::ProfileSummaryInfo::getProfileCount
Optional< uint64_t > getProfileCount(const CallBase &CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false) const
Returns the profile count for CallInst.
Definition: ProfileSummaryInfo.cpp:78
llvm::ProfileSummaryInfo::isHotCallSite
bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const
Returns true if the call site CB is considered hot.
Definition: ProfileSummaryInfo.cpp:359
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:187
llvm::ProfileSummaryInfoWrapperPass::getPSI
ProfileSummaryInfo & getPSI()
Definition: ProfileSummaryInfo.h:201
llvm::ProfileSummaryInfo::isFunctionHotInCallGraph
bool isFunctionHotInCallGraph(const Function *F, BlockFrequencyInfo &BFI) const
Returns true if F contains hot code.
Definition: ProfileSummaryInfo.cpp:115
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
llvm::ProfileSummaryInfo::isColdCount
bool isColdCount(uint64_t C) const
Returns true if count C is considered cold.
Definition: ProfileSummaryInfo.cpp:295
llvm::ProfileSummaryInfo::isHotCountNthPercentile
bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C) const
Returns true if count C is considered hot with regard to a given hot percentile cutoff value.
Definition: ProfileSummaryInfo.cpp:309
llvm::ProfileSummaryInfoWrapperPass::doInitialization
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
Definition: ProfileSummaryInfo.cpp:390
llvm::ProfileSummaryInfo::isHotBlockNthPercentile
bool isHotBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB, BlockFrequencyInfo *BFI) const
Returns true if BasicBlock BB is considered hot with regard to a given hot percentile cutoff value.
Definition: ProfileSummaryInfo.cpp:349
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:661
llvm::ProfileSummary::PSK_Sample
@ PSK_Sample
Definition: ProfileSummary.h:47
llvm::ProfileSummaryInfo
Analysis providing profile information.
Definition: ProfileSummaryInfo.h:40
llvm::ProfileSummaryInfo::ProfileSummaryInfo
ProfileSummaryInfo(const Module &M)
Definition: ProfileSummaryInfo.h:62
llvm::ProfileSummaryInfo::isFunctionHotInCallGraphNthPercentile
bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) const
Returns true if F contains hot code with regard to a given hot percentile cutoff value.
Definition: ProfileSummaryInfo.cpp:208
llvm::ProfileSummaryPrinterPass
Printer pass that uses ProfileSummaryAnalysis.
Definition: ProfileSummaryInfo.h:225
llvm::ProfileSummaryInfo::isHotCount
bool isHotCount(uint64_t C) const
Returns true if count C is considered hot.
Definition: ProfileSummaryInfo.cpp:291
PercentileCutoff
static cl::opt< unsigned > PercentileCutoff("mfs-psi-cutoff", cl::desc("Percentile profile summary cutoff used to " "determine cold blocks. Unused if set to zero."), cl::init(999950), cl::Hidden)
uint64_t
llvm::ProfileSummaryInfoWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: ProfileSummaryInfo.h:206
llvm::ProfileSummaryAnalysis::Result
ProfileSummaryInfo Result
Definition: ProfileSummaryInfo.h:215
llvm::ProfileSummaryInfoWrapperPass::ProfileSummaryInfoWrapperPass
ProfileSummaryInfoWrapperPass()
llvm::DenseMap< int, uint64_t >
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
llvm::ProfileSummaryInfo::getColdCountThreshold
uint64_t getColdCountThreshold() const
Returns ColdCountThreshold if set.
Definition: ProfileSummaryInfo.h:177
llvm::ProfileSummaryInfoWrapperPass
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
Definition: ProfileSummaryInfo.h:194
llvm::ProfileSummaryPrinterPass::ProfileSummaryPrinterPass
ProfileSummaryPrinterPass(raw_ostream &OS)
Definition: ProfileSummaryInfo.h:230
llvm::ProfileSummaryInfo::hasSampleProfile
bool hasSampleProfile() const
Returns true if module M has sample profile.
Definition: ProfileSummaryInfo.h:72
llvm::ProfileSummaryInfoWrapperPass::doFinalization
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Definition: ProfileSummaryInfo.cpp:395
llvm::ProfileSummaryInfo::hasInstrumentationProfile
bool hasInstrumentationProfile() const
Returns true if module M has instrumentation profile.
Definition: ProfileSummaryInfo.h:78
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::ProfileSummaryPrinterPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: ProfileSummaryInfo.cpp:406
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::AnalysisInfoMixin
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:394
llvm::ProfileSummaryInfo::isFunctionColdInCallGraphNthPercentile
bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) const
Returns true if F contains cold code with regard to a given cold percentile cutoff value.
Definition: ProfileSummaryInfo.cpp:214
llvm::ProfileSummaryAnalysis
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
Definition: ProfileSummaryInfo.h:212
llvm::ProfileSummaryInfo::refresh
void refresh()
If no summary is present, attempt to refresh.
Definition: ProfileSummaryInfo.cpp:59
llvm::ProfileSummaryInfo::isFunctionHotnessUnknown
bool isFunctionHotnessUnknown(const Function &F) const
Returns true if the hotness of F is unknown.
Definition: ProfileSummaryInfo.cpp:168
llvm::ProfileSummary::PSK_CSInstr
@ PSK_CSInstr
Definition: ProfileSummary.h:47
llvm::AMDGPUISD::BFI
@ BFI
Definition: AMDGPUISelLowering.h:432
llvm::ProfileSummaryAnalysis::run
Result run(Module &M, ModuleAnalysisManager &)
Definition: ProfileSummaryInfo.cpp:401
llvm::ProfileSummaryInfo::hasLargeWorkingSetSize
bool hasLargeWorkingSetSize() const
Returns true if the working set size of the code is considered large.
Definition: ProfileSummaryInfo.cpp:287
llvm::ProfileSummaryInfoWrapperPass::getPSI
const ProfileSummaryInfo & getPSI() const
Definition: ProfileSummaryInfo.h:202
llvm::ProfileSummaryInfo::hasHugeWorkingSetSize
bool hasHugeWorkingSetSize() const
Returns true if the working set size of the code is considered huge.
Definition: ProfileSummaryInfo.cpp:283
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::ProfileSummaryInfo::isFunctionColdInCallGraph
bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI) const
Returns true if F contains only cold code.
Definition: ProfileSummaryInfo.cpp:144
llvm::ProfileSummaryInfo::getOrCompColdCountThreshold
uint64_t getOrCompColdCountThreshold() const
Returns ColdCountThreshold if set.
Definition: ProfileSummaryInfo.cpp:323
PassManager.h
llvm::ProfileSummaryInfo::isColdBlock
bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const
Returns true if BasicBlock BB is considered cold.
Definition: ProfileSummaryInfo.cpp:333
llvm::ProfileSummaryInfo::invalidate
bool invalidate(Module &, const PreservedAnalyses &, ModuleAnalysisManager::Invalidator &)
Handle the invalidation of this information.
Definition: ProfileSummaryInfo.h:95
llvm::ProfileSummary::PSK_Instr
@ PSK_Instr
Definition: ProfileSummary.h:47
llvm::ProfileSummaryInfo::getHotCountThreshold
uint64_t getHotCountThreshold() const
Returns HotCountThreshold if set.
Definition: ProfileSummaryInfo.h:173
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1474
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::ProfileSummaryInfoWrapperPass::ID
static char ID
Definition: ProfileSummaryInfo.h:198
llvm::ProfileSummaryInfo::isColdCountNthPercentile
bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C) const
Returns true if count C is considered cold with regard to a given cold percentile cutoff value.
Definition: ProfileSummaryInfo.cpp:314
llvm::codeview::PublicSymFlags::Function
@ Function