LLVM 19.0.0git
SampleProfileLoaderBaseUtil.cpp
Go to the documentation of this file.
1//===- SampleProfileLoaderBaseUtil.cpp - Profile loader Util func ---------===//
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 implements the SampleProfileLoader base utility functions.
10//
11//===----------------------------------------------------------------------===//
12
15#include "llvm/IR/Constants.h"
16#include "llvm/IR/Module.h"
18
19namespace llvm {
20
22 "sample-profile-max-propagate-iterations", cl::init(100),
23 cl::desc("Maximum number of iterations to go through when propagating "
24 "sample block/edge weights through the CFG."));
25
27 "sample-profile-check-record-coverage", cl::init(0), cl::value_desc("N"),
28 cl::desc("Emit a warning if less than N% of records in the input profile "
29 "are matched to the IR."));
30
32 "sample-profile-check-sample-coverage", cl::init(0), cl::value_desc("N"),
33 cl::desc("Emit a warning if less than N% of samples in the input profile "
34 "are matched to the IR."));
35
37 "no-warn-sample-unused", cl::init(false), cl::Hidden,
38 cl::desc("Use this option to turn off/on warnings about function with "
39 "samples but without debug information to use those samples. "));
40
42 "sample-profile-use-profi", cl::Hidden,
43 cl::desc("Use profi to infer block and edge counts."));
44
45namespace sampleprofutil {
46
47/// Return true if the given callsite is hot wrt to hot cutoff threshold.
48///
49/// Functions that were inlined in the original binary will be represented
50/// in the inline stack in the sample profile. If the profile shows that
51/// the original inline decision was "good" (i.e., the callsite is executed
52/// frequently), then we will recreate the inline decision and apply the
53/// profile from the inlined callsite.
54///
55/// To decide whether an inlined callsite is hot, we compare the callsite
56/// sample count with the hot cutoff computed by ProfileSummaryInfo, it is
57/// regarded as hot if the count is above the cutoff value.
58///
59/// When ProfileAccurateForSymsInList is enabled and profile symbol list
60/// is present, functions in the profile symbol list but without profile will
61/// be regarded as cold and much less inlining will happen in CGSCC inlining
62/// pass, so we tend to lower the hot criteria here to allow more early
63/// inlining to happen for warm callsites and it is helpful for performance.
65 bool ProfAccForSymsInList) {
66 if (!CallsiteFS)
67 return false; // The callsite was not inlined in the original binary.
68
69 assert(PSI && "PSI is expected to be non null");
70 uint64_t CallsiteTotalSamples = CallsiteFS->getTotalSamples();
71 if (ProfAccForSymsInList)
72 return !PSI->isColdCount(CallsiteTotalSamples);
73 else
74 return PSI->isHotCount(CallsiteTotalSamples);
75}
76
77/// Mark as used the sample record for the given function samples at
78/// (LineOffset, Discriminator).
79///
80/// \returns true if this is the first time we mark the given record.
82 uint32_t LineOffset,
83 uint32_t Discriminator,
84 uint64_t Samples) {
85 LineLocation Loc(LineOffset, Discriminator);
86 unsigned &Count = SampleCoverage[FS][Loc];
87 bool FirstTime = (++Count == 1);
88 if (FirstTime)
89 TotalUsedSamples += Samples;
90 return FirstTime;
91}
92
93/// Return the number of sample records that were applied from this profile.
94///
95/// This count does not include records from cold inlined callsites.
96unsigned
98 ProfileSummaryInfo *PSI) const {
99 auto I = SampleCoverage.find(FS);
100
101 // The size of the coverage map for FS represents the number of records
102 // that were marked used at least once.
103 unsigned Count = (I != SampleCoverage.end()) ? I->second.size() : 0;
104
105 // If there are inlined callsites in this function, count the samples found
106 // in the respective bodies. However, do not bother counting callees with 0
107 // total samples, these are callees that were never invoked at runtime.
108 for (const auto &I : FS->getCallsiteSamples())
109 for (const auto &J : I.second) {
110 const FunctionSamples *CalleeSamples = &J.second;
111 if (callsiteIsHot(CalleeSamples, PSI, ProfAccForSymsInList))
112 Count += countUsedRecords(CalleeSamples, PSI);
113 }
114
115 return Count;
116}
117
118/// Return the number of sample records in the body of this profile.
119///
120/// This count does not include records from cold inlined callsites.
121unsigned
123 ProfileSummaryInfo *PSI) const {
124 unsigned Count = FS->getBodySamples().size();
125
126 // Only count records in hot callsites.
127 for (const auto &I : FS->getCallsiteSamples())
128 for (const auto &J : I.second) {
129 const FunctionSamples *CalleeSamples = &J.second;
130 if (callsiteIsHot(CalleeSamples, PSI, ProfAccForSymsInList))
131 Count += countBodyRecords(CalleeSamples, PSI);
132 }
133
134 return Count;
135}
136
137/// Return the number of samples collected in the body of this profile.
138///
139/// This count does not include samples from cold inlined callsites.
142 ProfileSummaryInfo *PSI) const {
143 uint64_t Total = 0;
144 for (const auto &I : FS->getBodySamples())
145 Total += I.second.getSamples();
146
147 // Only count samples in hot callsites.
148 for (const auto &I : FS->getCallsiteSamples())
149 for (const auto &J : I.second) {
150 const FunctionSamples *CalleeSamples = &J.second;
151 if (callsiteIsHot(CalleeSamples, PSI, ProfAccForSymsInList))
152 Total += countBodySamples(CalleeSamples, PSI);
153 }
154
155 return Total;
156}
157
158/// Return the fraction of sample records used in this profile.
159///
160/// The returned value is an unsigned integer in the range 0-100 indicating
161/// the percentage of sample records that were used while applying this
162/// profile to the associated function.
164 unsigned Total) const {
165 assert(Used <= Total &&
166 "number of used records cannot exceed the total number of records");
167 return Total > 0 ? Used * 100 / Total : 100;
168}
169
170/// Create a global variable to flag FSDiscriminators are used.
172 const char *FSDiscriminatorVar = "__llvm_fs_discriminator__";
173 if (M->getGlobalVariable(FSDiscriminatorVar))
174 return;
175
176 auto &Context = M->getContext();
177 // Place this variable to llvm.used so it won't be GC'ed.
178 appendToUsed(*M, {new GlobalVariable(*M, Type::getInt1Ty(Context), true,
180 ConstantInt::getTrue(Context),
181 FSDiscriminatorVar)});
182}
183
184} // end of namespace sampleprofutil
185} // end of namespace llvm
This file contains the declarations for the subclasses of Constant, which represent the different fla...
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides the utility functions for the sampled PGO loader base implementation.
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:850
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:56
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Analysis providing profile information.
bool isColdCount(uint64_t C) const
Returns true if count C is considered cold.
bool isHotCount(uint64_t C) const
Returns true if count C is considered hot.
static IntegerType * getInt1Ty(LLVMContext &C)
Representation of the samples collected for a function.
Definition: SampleProf.h:744
uint64_t getTotalSamples() const
Return the total number of samples collected inside the function.
Definition: SampleProf.h:932
unsigned countBodyRecords(const FunctionSamples *FS, ProfileSummaryInfo *PSI) const
Return the number of sample records in the body of this profile.
unsigned countUsedRecords(const FunctionSamples *FS, ProfileSummaryInfo *PSI) const
Return the number of sample records that were applied from this profile.
unsigned computeCoverage(unsigned Used, unsigned Total) const
Return the fraction of sample records used in this profile.
uint64_t countBodySamples(const FunctionSamples *FS, ProfileSummaryInfo *PSI) const
Return the number of samples collected in the body of this profile.
bool markSamplesUsed(const FunctionSamples *FS, uint32_t LineOffset, uint32_t Discriminator, uint64_t Samples)
Mark as used the sample record for the given function samples at (LineOffset, Discriminator).
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
void createFSDiscriminatorVariable(Module *M)
Create a global variable to flag FSDiscriminators are used.
bool callsiteIsHot(const FunctionSamples *CallsiteFS, ProfileSummaryInfo *PSI, bool ProfAccForSymsInList)
Return true if the given callsite is hot wrt to hot cutoff threshold.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
cl::opt< unsigned > SampleProfileSampleCoverage
cl::opt< unsigned > SampleProfileRecordCoverage
cl::opt< unsigned > SampleProfileMaxPropagateIterations
cl::opt< bool > SampleProfileUseProfi
cl::opt< bool > NoWarnSampleUnused
void appendToUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.used list.
Represents the relative location of an instruction.
Definition: SampleProf.h:280