LLVM  13.0.0git
SampleProfileProbe.h
Go to the documentation of this file.
1 //===- Transforms/IPO/SampleProfileProbe.h ----------*- 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 /// \file
10 /// This file provides the interface for the pseudo probe implementation for
11 /// AutoFDO.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
16 #define LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
17 
18 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/Analysis/LoopInfo.h"
23 #include "llvm/IR/PassManager.h"
24 #include "llvm/IR/PseudoProbe.h"
27 #include <unordered_map>
28 
29 namespace llvm {
30 
31 class Module;
32 
33 using namespace sampleprof;
34 using BlockIdMap = std::unordered_map<BasicBlock *, uint32_t>;
35 using InstructionIdMap = std::unordered_map<Instruction *, uint32_t>;
36 // Map from tuples of Probe id and inline stack hash code to distribution
37 // factors.
38 using ProbeFactorMap = std::unordered_map<std::pair<uint64_t, uint64_t>, float,
41 
42 enum class PseudoProbeReservedId { Invalid = 0, Last = Invalid };
43 
45  uint64_t FunctionGUID;
46  uint64_t FunctionHash;
47 
48 public:
49  PseudoProbeDescriptor(uint64_t GUID, uint64_t Hash)
50  : FunctionGUID(GUID), FunctionHash(Hash) {}
51  uint64_t getFunctionGUID() const { return FunctionGUID; }
52  uint64_t getFunctionHash() const { return FunctionHash; }
53 };
54 
55 // A pseudo probe verifier that can be run after each IR passes to detect the
56 // violation of updating probe factors. In principle, the sum of distribution
57 // factor for a probe should be identical before and after a pass. For a
58 // function pass, the factor sum for a probe would be typically 100%.
60 public:
62 
63  // Implementation of pass instrumentation callbacks for new pass manager.
64  void runAfterPass(StringRef PassID, Any IR);
65 
66 private:
67  // Allow a little bias due the rounding to integral factors.
68  constexpr static float DistributionFactorVariance = 0.02f;
69  // Distribution factors from last pass.
70  FuncProbeFactorMap FunctionProbeFactors;
71 
72  void collectProbeFactors(const BasicBlock *BB, ProbeFactorMap &ProbeFactors);
73  void runAfterPass(const Module *M);
74  void runAfterPass(const LazyCallGraph::SCC *C);
75  void runAfterPass(const Function *F);
76  void runAfterPass(const Loop *L);
77  bool shouldVerifyFunction(const Function *F);
78  void verifyProbeFactors(const Function *F,
79  const ProbeFactorMap &ProbeFactors);
80 };
81 
82 // This class serves sample counts correlation for SampleProfileLoader by
83 // analyzing pseudo probes and their function descriptors injected by
84 // SampleProfileProber.
87 
88  const PseudoProbeDescriptor *getDesc(const Function &F) const;
89 
90 public:
91  PseudoProbeManager(const Module &M);
92  bool moduleIsProbed(const Module &M) const;
93  bool profileIsValid(const Function &F, const FunctionSamples &Samples) const;
94 };
95 
96 /// Sample profile pseudo prober.
97 ///
98 /// Insert pseudo probes for block sampling and value sampling.
100 public:
101  // Give an empty module id when the prober is not used for instrumentation.
102  SampleProfileProber(Function &F, const std::string &CurModuleUniqueId);
104 
105 private:
106  Function *getFunction() const { return F; }
107  uint64_t getFunctionHash() const { return FunctionHash; }
108  uint32_t getBlockId(const BasicBlock *BB) const;
109  uint32_t getCallsiteId(const Instruction *Call) const;
110  void computeCFGHash();
111  void computeProbeIdForBlocks();
112  void computeProbeIdForCallsites();
113 
114  Function *F;
115 
116  /// The current module ID that is used to name a static object as a comdat
117  /// group.
118  std::string CurModuleUniqueId;
119 
120  /// A CFG hash code used to identify a function code changes.
121  uint64_t FunctionHash;
122 
123  /// Map basic blocks to the their pseudo probe ids.
124  BlockIdMap BlockProbeIds;
125 
126  /// Map indirect calls to the their pseudo probe ids.
127  InstructionIdMap CallProbeIds;
128 
129  /// The ID of the last probe, Can be used to number a new probe.
130  uint32_t LastProbeId;
131 };
132 
133 class SampleProfileProbePass : public PassInfoMixin<SampleProfileProbePass> {
134  TargetMachine *TM;
135 
136 public:
139 };
140 
141 // Pseudo probe distribution factor updater.
142 // Sample profile annotation can happen in both LTO prelink and postlink. The
143 // postlink-time re-annotation can degrade profile quality because of prelink
144 // code duplication transformation, such as loop unrolling, jump threading,
145 // indirect call promotion etc. As such, samples corresponding to a source
146 // location may be aggregated multiple times in postlink. With a concept of
147 // distribution factor for pseudo probes, samples can be distributed among
148 // duplicated probes reasonable based on the assumption that optimizations
149 // duplicating code well-maintain the branch frequency information (BFI). This
150 // pass updates distribution factors for each pseudo probe at the end of the
151 // prelink pipeline, to reflect an estimated portion of the real execution
152 // count.
153 class PseudoProbeUpdatePass : public PassInfoMixin<PseudoProbeUpdatePass> {
155 
156 public:
159 };
160 
161 } // end namespace llvm
162 #endif // LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
llvm
Definition: AllocatorList.h:23
llvm::HexagonMCInstrInfo::getDesc
const MCInstrDesc & getDesc(MCInstrInfo const &MCII, MCInst const &MCI)
Definition: HexagonMCInstrInfo.cpp:248
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::SampleProfileProbePass
Definition: SampleProfileProbe.h:133
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:374
llvm::Function
Definition: Function.h:61
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:253
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:530
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::PseudoProbeUpdatePass
Definition: SampleProfileProbe.h:153
DenseMap.h
PIC
PassInstrumentationCallbacks PIC
Definition: PassBuilderBindings.cpp:55
llvm::SampleProfileProber
Sample profile pseudo prober.
Definition: SampleProfileProbe.h:99
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::InstructionIdMap
std::unordered_map< Instruction *, uint32_t > InstructionIdMap
Definition: SampleProfileProbe.h:35
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
TargetMachine.h
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:421
llvm::PseudoProbeVerifier
Definition: SampleProfileProbe.h:59
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::SampleProfileProbePass::SampleProfileProbePass
SampleProfileProbePass(TargetMachine *TM)
Definition: SampleProfileProbe.h:137
PassInstrumentation.h
SampleProf.h
llvm::Instruction
Definition: Instruction.h:45
IR
Statically lint checks LLVM IR
Definition: Lint.cpp:744
LazyCallGraph.h
llvm::StringMap< ProbeFactorMap >
LoopInfo.h
llvm::PseudoProbeUpdatePass::PseudoProbeUpdatePass
PseudoProbeUpdatePass()
Definition: SampleProfileProbe.h:157
instrumentOneFunc
static void instrumentOneFunc(Function &F, Module *M, TargetLibraryInfo &TLI, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI, std::unordered_multimap< Comdat *, GlobalValue * > &ComdatMembers, bool IsCS)
Definition: PGOInstrumentation.cpp:894
llvm::sampleprof::FunctionSamples
Representation of the samples collected for a function.
Definition: SampleProf.h:533
llvm::PseudoProbeManager
Definition: SampleProfileProbe.h:85
llvm::DenseMap
Definition: DenseMap.h:714
llvm::pair_hash
Definition: STLExtras.h:1777
llvm::BlockIdMap
std::unordered_map< BasicBlock *, uint32_t > BlockIdMap
Definition: SampleProfileProbe.h:34
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
llvm::PseudoProbeDescriptor
Definition: SampleProfileProbe.h:44
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::PseudoProbeDescriptor::getFunctionHash
uint64_t getFunctionHash() const
Definition: SampleProfileProbe.h:52
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
uint32_t
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
CallGraphSCCPass.h
registerCallbacks
SI registerCallbacks(PIC, &FAM)
runOnFunction
static bool runOnFunction(Function &F, bool PostInlining)
Definition: EntryExitInstrumenter.cpp:69
llvm::Any
Definition: Any.h:26
llvm::ProbeFactorMap
std::unordered_map< std::pair< uint64_t, uint64_t >, float, pair_hash< uint64_t, uint64_t > > ProbeFactorMap
Definition: SampleProfileProbe.h:39
PassManager.h
PseudoProbe.h
llvm::PseudoProbeDescriptor::PseudoProbeDescriptor
PseudoProbeDescriptor(uint64_t GUID, uint64_t Hash)
Definition: SampleProfileProbe.h:49
llvm::PassInstrumentationCallbacks
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
Definition: PassInstrumentation.h:66
llvm::PseudoProbeDescriptor::getFunctionGUID
uint64_t getFunctionGUID() const
Definition: SampleProfileProbe.h:51
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
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::PseudoProbeReservedId
PseudoProbeReservedId
Definition: SampleProfileProbe.h:42