LLVM  10.0.0svn
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_PROFILE_SUMMARY_INFO_H
15 #define LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
16 
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/SmallSet.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/Instructions.h"
22 #include "llvm/IR/PassManager.h"
23 #include "llvm/IR/ProfileSummary.h"
24 #include "llvm/IR/ValueHandle.h"
25 #include "llvm/Pass.h"
26 #include <memory>
27 
28 namespace llvm {
29 class BasicBlock;
30 class BlockFrequencyInfo;
31 class CallSite;
32 class ProfileSummary;
33 /// Analysis providing profile information.
34 ///
35 /// This is an immutable analysis pass that provides ability to query global
36 /// (program-level) profile information. The main APIs are isHotCount and
37 /// isColdCount that tells whether a given profile count is considered hot/cold
38 /// based on the profile summary. This also provides convenience methods to
39 /// check whether a function is hot or cold.
40 
41 // FIXME: Provide convenience methods to determine hotness/coldness of other IR
42 // units. This would require making this depend on BFI.
44 private:
45  Module &M;
46  std::unique_ptr<ProfileSummary> Summary;
47  bool computeSummary();
48  void computeThresholds();
49  // Count thresholds to answer isHotCount and isColdCount queries.
50  Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
51  // True if the working set size of the code is considered huge,
52  // because the number of profile counts required to reach the hot
53  // percentile is above a huge threshold.
54  Optional<bool> HasHugeWorkingSetSize;
55  // True if the working set size of the code is considered large,
56  // because the number of profile counts required to reach the hot
57  // percentile is above a large threshold.
58  Optional<bool> HasLargeWorkingSetSize;
59  // Compute the threshold for a given cutoff.
60  Optional<uint64_t> computeThreshold(int PercentileCutoff);
61  // The map that caches the threshold values. The keys are the percentile
62  // cutoff values and the values are the corresponding threshold values.
63  DenseMap<int, uint64_t> ThresholdCache;
64 
65 public:
66  ProfileSummaryInfo(Module &M) : M(M) {}
68  : M(Arg.M), Summary(std::move(Arg.Summary)) {}
69 
70  /// Returns true if profile summary is available.
71  bool hasProfileSummary() { return computeSummary(); }
72 
73  /// Returns true if module \c M has sample profile.
75  return hasProfileSummary() &&
76  Summary->getKind() == ProfileSummary::PSK_Sample;
77  }
78 
79  /// Returns true if module \c M has instrumentation profile.
81  return hasProfileSummary() &&
82  Summary->getKind() == ProfileSummary::PSK_Instr;
83  }
84 
85  /// Returns true if module \c M has context sensitive instrumentation profile.
87  return hasProfileSummary() &&
88  Summary->getKind() == ProfileSummary::PSK_CSInstr;
89  }
90 
91  /// Handle the invalidation of this information.
92  ///
93  /// When used as a result of \c ProfileSummaryAnalysis this method will be
94  /// called when the module this was computed for changes. Since profile
95  /// summary is immutable after it is annotated on the module, we return false
96  /// here.
99  return false;
100  }
101 
102  /// Returns the profile count for \p CallInst.
105  bool AllowSynthetic = false);
106  /// Returns true if the working set size of the code is considered huge.
107  bool hasHugeWorkingSetSize();
108  /// Returns true if the working set size of the code is considered large.
109  bool hasLargeWorkingSetSize();
110  /// Returns true if \p F has hot function entry.
111  bool isFunctionEntryHot(const Function *F);
112  /// Returns true if \p F contains hot code.
114  /// Returns true if \p F has cold function entry.
115  bool isFunctionEntryCold(const Function *F);
116  /// Returns true if \p F contains only cold code.
118  /// Returns true if \p F contains hot code with regard to a given hot
119  /// percentile cutoff value.
120  bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
121  const Function *F,
122  BlockFrequencyInfo &BFI);
123  /// Returns true if count \p C is considered hot.
124  bool isHotCount(uint64_t C);
125  /// Returns true if count \p C is considered cold.
126  bool isColdCount(uint64_t C);
127  /// Returns true if count \p C is considered hot with regard to a given
128  /// hot percentile cutoff value.
129  bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C);
130  /// Returns true if BasicBlock \p BB is considered hot.
131  bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI);
132  /// Returns true if BasicBlock \p BB is considered cold.
133  bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI);
134  /// Returns true if BasicBlock \p BB is considered hot with regard to a given
135  /// hot percentile cutoff value.
136  bool isHotBlockNthPercentile(int PercentileCutoff,
137  const BasicBlock *BB, BlockFrequencyInfo *BFI);
138  /// Returns true if CallSite \p CS is considered hot.
139  bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
140  /// Returns true if Callsite \p CS is considered cold.
141  bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
142  /// Returns HotCountThreshold if set. Recompute HotCountThreshold
143  /// if not set.
144  uint64_t getOrCompHotCountThreshold();
145  /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
146  /// if not set.
147  uint64_t getOrCompColdCountThreshold();
148  /// Returns HotCountThreshold if set.
149  uint64_t getHotCountThreshold() {
150  return HotCountThreshold ? HotCountThreshold.getValue() : 0;
151  }
152  /// Returns ColdCountThreshold if set.
154  return ColdCountThreshold ? ColdCountThreshold.getValue() : 0;
155  }
156 };
157 
158 /// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
160  std::unique_ptr<ProfileSummaryInfo> PSI;
161 
162 public:
163  static char ID;
165 
166  ProfileSummaryInfo &getPSI() { return *PSI; }
167  const ProfileSummaryInfo &getPSI() const { return *PSI; }
168 
169  bool doInitialization(Module &M) override;
170  bool doFinalization(Module &M) override;
171  void getAnalysisUsage(AnalysisUsage &AU) const override {
172  AU.setPreservesAll();
173  }
174 };
175 
176 /// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
178  : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
179 public:
181 
182  Result run(Module &M, ModuleAnalysisManager &);
183 
184 private:
186  static AnalysisKey Key;
187 };
188 
189 /// Printer pass that uses \c ProfileSummaryAnalysis.
191  : public PassInfoMixin<ProfileSummaryPrinterPass> {
192  raw_ostream &OS;
193 
194 public:
195  explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
197 };
198 
199 } // end namespace llvm
200 
201 #endif
uint64_t CallInst * C
bool hasInstrumentationProfile()
Returns true if module M has instrumentation profile.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:59
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:66
uint64_t getHotCountThreshold()
Returns HotCountThreshold if set.
bool isColdCount(uint64_t C)
Returns true if count C is considered cold.
Analysis providing profile information.
bool invalidate(Module &, const PreservedAnalyses &, ModuleAnalysisManager::Invalidator &)
Handle the invalidation of this information.
This class represents a function call, abstracting a target machine&#39;s calling convention.
bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI)
Returns true if F contains hot code with regard to a given hot percentile cutoff value.
F(f)
uint64_t getOrCompHotCountThreshold()
Returns HotCountThreshold if set.
bool isHotCount(uint64_t C)
Returns true if count C is considered hot.
bool isFunctionEntryCold(const Function *F)
Returns true if F has cold function entry.
bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI)
Returns true if CallSite CS is considered hot.
uint64_t getOrCompColdCountThreshold()
Returns ColdCountThreshold if set.
bool isFunctionHotInCallGraph(const Function *F, BlockFrequencyInfo &BFI)
Returns true if F contains hot code.
Definition: BitVector.h:937
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
const ProfileSummaryInfo & getPSI() const
Key
PAL metadata keys.
bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI)
Returns true if BasicBlock BB is considered cold.
bool hasLargeWorkingSetSize()
Returns true if the working set size of the code is considered large.
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:255
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:373
bool hasProfileSummary()
Returns true if profile summary is available.
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:154
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
bool hasSampleProfile()
Returns true if module M has sample profile.
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:390
Represent the analysis usage information of a pass.
bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C)
Returns true if count C is considered hot with regard to a given hot percentile cutoff value...
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
bool isHotBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB, BlockFrequencyInfo *BFI)
Returns true if BasicBlock BB is considered hot with regard to a given hot percentile cutoff value...
Optional< uint64_t > getProfileCount(const Instruction *CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false)
Returns the profile count for CallInst.
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:255
uint64_t getColdCountThreshold()
Returns ColdCountThreshold if set.
bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI)
Returns true if F contains only cold code.
void setPreservesAll()
Set by analyses that do not transform their input at all.
bool hasCSInstrumentationProfile()
Returns true if module M has context sensitive instrumentation profile.
ProfileSummaryInfo(ProfileSummaryInfo &&Arg)
Printer pass that uses ProfileSummaryAnalysis.
bool isFunctionEntryHot(const Function *F)
Returns true if F has hot function entry.
bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI)
Returns true if BasicBlock BB is considered hot.
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:649
bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI)
Returns true if Callsite CS is considered cold.
bool hasHugeWorkingSetSize()
Returns true if the working set size of the code is considered huge.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
A container for analyses that lazily runs them and caches their results.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
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:71