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
23namespace llvm {
24class BasicBlock;
25class BlockFrequencyInfo;
26class CallBase;
27class Function;
28
29/// Analysis providing profile information.
30///
31/// This is an immutable analysis pass that provides ability to query global
32/// (program-level) profile information. The main APIs are isHotCount and
33/// isColdCount that tells whether a given profile count is considered hot/cold
34/// based on the profile summary. This also provides convenience methods to
35/// check whether a function is hot or cold.
36
37// FIXME: Provide convenience methods to determine hotness/coldness of other IR
38// units. This would require making this depend on BFI.
39class ProfileSummaryInfo {
40private:
41 const Module *M;
42 std::unique_ptr<ProfileSummary> Summary;
43 void computeThresholds();
44 // Count thresholds to answer isHotCount and isColdCount queries.
45 Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
46 // True if the working set size of the code is considered huge,
47 // because the number of profile counts required to reach the hot
48 // percentile is above a huge threshold.
49 Optional<bool> HasHugeWorkingSetSize;
50 // True if the working set size of the code is considered large,
51 // because the number of profile counts required to reach the hot
52 // percentile is above a large threshold.
53 Optional<bool> HasLargeWorkingSetSize;
54 // Compute the threshold for a given cutoff.
55 Optional<uint64_t> computeThreshold(int PercentileCutoff) const;
56 // The map that caches the threshold values. The keys are the percentile
57 // cutoff values and the values are the corresponding threshold values.
58 mutable DenseMap<int, uint64_t> ThresholdCache;
59
60public:
61 ProfileSummaryInfo(const Module &M) : M(&M) { refresh(); }
62 ProfileSummaryInfo(ProfileSummaryInfo &&Arg) = default;
63
64 /// If no summary is present, attempt to refresh.
65 void refresh();
66
67 /// Returns true if profile summary is available.
68 bool hasProfileSummary() const { return Summary != nullptr; }
69
70 /// Returns true if module \c M has sample profile.
71 bool hasSampleProfile() const {
72 return hasProfileSummary() &&
73 Summary->getKind() == ProfileSummary::PSK_Sample;
74 }
75
76 /// Returns true if module \c M has instrumentation profile.
77 bool hasInstrumentationProfile() const {
78 return hasProfileSummary() &&
79 Summary->getKind() == ProfileSummary::PSK_Instr;
80 }
81
82 /// Returns true if module \c M has context sensitive instrumentation profile.
83 bool hasCSInstrumentationProfile() const {
84 return hasProfileSummary() &&
85 Summary->getKind() == ProfileSummary::PSK_CSInstr;
86 }
87
88 /// Handle the invalidation of this information.
89 ///
90 /// When used as a result of \c ProfileSummaryAnalysis this method will be
91 /// called when the module this was computed for changes. Since profile
92 /// summary is immutable after it is annotated on the module, we return false
93 /// here.
94 bool invalidate(Module &, const PreservedAnalyses &,
95 ModuleAnalysisManager::Invalidator &) {
96 return false;
97 }
98
99 /// Returns the profile count for \p CallInst.
100 Optional<uint64_t> getProfileCount(const CallBase &CallInst,
101 BlockFrequencyInfo *BFI,
102 bool AllowSynthetic = false) const;
103 /// Returns true if module \c M has partial-profile sample profile.
104 bool hasPartialSampleProfile() const;
105 /// Returns true if the working set size of the code is considered huge.
106 bool hasHugeWorkingSetSize() const;
107 /// Returns true if the working set size of the code is considered large.
108 bool hasLargeWorkingSetSize() const;
109 /// Returns true if \p F has hot function entry.
110 bool isFunctionEntryHot(const Function *F) const;
111 /// Returns true if \p F contains hot code.
112 bool isFunctionHotInCallGraph(const Function *F,
113 BlockFrequencyInfo &BFI) const;
114 /// Returns true if \p F has cold function entry.
115 bool isFunctionEntryCold(const Function *F) const;
116 /// Returns true if \p F contains only cold code.
117 bool isFunctionColdInCallGraph(const Function *F,
118 BlockFrequencyInfo &BFI) const;
119 /// Returns true if the hotness of \p F is unknown.
120 bool isFunctionHotnessUnknown(const Function &F) const;
121 /// Returns true if \p F contains hot code with regard to a given hot
122 /// percentile cutoff value.
123 bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
124 const Function *F,
125 BlockFrequencyInfo &BFI) const;
126 /// Returns true if \p F contains cold code with regard to a given cold
127 /// percentile cutoff value.
128 bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,
129 const Function *F,
130 BlockFrequencyInfo &BFI) const;
131 /// Returns true if count \p C is considered hot.
132 bool isHotCount(uint64_t C) const;
133 /// Returns true if count \p C is considered cold.
134 bool isColdCount(uint64_t C) const;
135 /// Returns true if count \p C is considered hot with regard to a given
136 /// hot percentile cutoff value.
137 bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C) const;
138 /// Returns true if count \p C is considered cold with regard to a given
139 /// cold percentile cutoff value.
140 bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
141 /// Returns true if BasicBlock \p BB is considered hot.
142 bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;
143 /// Returns true if BasicBlock \p BB is considered cold.
144 bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;
145 /// Returns true if BasicBlock \p BB is considered hot with regard to a given
146 /// hot percentile cutoff value.
147 bool isHotBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,
148 BlockFrequencyInfo *BFI) const;
149 /// Returns true if BasicBlock \p BB is considered cold with regard to a given
150 /// cold percentile cutoff value.
151 bool isColdBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,
152 BlockFrequencyInfo *BFI) const;
153 /// Returns true if the call site \p CB is considered hot.
154 bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
155 /// Returns true if call site \p CB is considered cold.
156 bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
157 /// Returns HotCountThreshold if set. Recompute HotCountThreshold
158 /// if not set.
159 uint64_t getOrCompHotCountThreshold() const;
160 /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
161 /// if not set.
162 uint64_t getOrCompColdCountThreshold() const;
163 /// Returns HotCountThreshold if set.
164 uint64_t getHotCountThreshold() const {
165 return HotCountThreshold ? HotCountThreshold.getValue() : 0;
166 }
167 /// Returns ColdCountThreshold if set.
168 uint64_t getColdCountThreshold() const {
169 return ColdCountThreshold ? ColdCountThreshold.getValue() : 0;
170 }
171
172 private:
173 template <bool isHot>
174 bool isFunctionHotOrColdInCallGraphNthPercentile(
175 int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) const;
176 template <bool isHot>
177 bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
178 template <bool isHot>
179 bool isHotOrColdBlockNthPercentile(int PercentileCutoff,
180 const BasicBlock *BB,
181 BlockFrequencyInfo *BFI) const;
182};
183
184/// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
185class ProfileSummaryInfoWrapperPass : public ImmutablePass {
186 std::unique_ptr<ProfileSummaryInfo> PSI;
187
188public:
189 static char ID;
190 ProfileSummaryInfoWrapperPass();
191
192 ProfileSummaryInfo &getPSI() { return *PSI; }
193 const ProfileSummaryInfo &getPSI() const { return *PSI; }
194
195 bool doInitialization(Module &M) override;
196 bool doFinalization(Module &M) override;
197 void getAnalysisUsage(AnalysisUsage &AU) const override {
198 AU.setPreservesAll();
199 }
200};
201
202/// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
203class ProfileSummaryAnalysis
204 : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
205public:
206 typedef ProfileSummaryInfo Result;
207
208 Result run(Module &M, ModuleAnalysisManager &);
209
210private:
211 friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
212 static AnalysisKey Key;
213};
214
215/// Printer pass that uses \c ProfileSummaryAnalysis.
216class ProfileSummaryPrinterPass
217 : public PassInfoMixin<ProfileSummaryPrinterPass> {
218 raw_ostream &OS;
219
220public:
221 explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
222 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
223};
224
225} // end namespace llvm
226
227#endif
228