LLVM 20.0.0git
UniformityAnalysis.cpp
Go to the documentation of this file.
1//===- UniformityAnalysis.cpp ---------------------------------------------===//
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
13#include "llvm/IR/Dominators.h"
17
18using namespace llvm;
19
20template <>
22 const Instruction &I) const {
23 return isDivergent((const Value *)&I);
24}
25
26template <>
28 const Instruction &Instr) {
29 return markDivergent(cast<Value>(&Instr));
30}
31
33 for (auto &I : instructions(F)) {
35 markDivergent(I);
36 else if (TTI->isAlwaysUniform(&I))
37 addUniformOverride(I);
38 }
39 for (auto &Arg : F.args()) {
40 if (TTI->isSourceOfDivergence(&Arg)) {
41 markDivergent(&Arg);
42 }
43 }
44}
45
46template <>
48 const Value *V) {
49 for (const auto *User : V->users()) {
50 if (const auto *UserInstr = dyn_cast<const Instruction>(User)) {
51 markDivergent(*UserInstr);
52 }
53 }
54}
55
56template <>
58 const Instruction &Instr) {
59 assert(!isAlwaysUniform(Instr));
60 if (Instr.isTerminator())
61 return;
62 pushUsers(cast<Value>(&Instr));
63}
64
65template <>
67 const Instruction &I, const Cycle &DefCycle) const {
68 assert(!isAlwaysUniform(I));
69 for (const Use &U : I.operands()) {
70 if (auto *I = dyn_cast<Instruction>(&U)) {
71 if (DefCycle.contains(I->getParent()))
72 return true;
73 }
74 }
75 return false;
76}
77
78template <>
80 SSAContext>::propagateTemporalDivergence(const Instruction &I,
81 const Cycle &DefCycle) {
82 if (isDivergent(I))
83 return;
84 for (auto *User : I.users()) {
85 auto *UserInstr = cast<Instruction>(User);
86 if (DefCycle.contains(UserInstr->getParent()))
87 continue;
88 markDivergent(*UserInstr);
89 }
90}
91
92template <>
94 const Use &U) const {
95 const auto *V = U.get();
96 if (isDivergent(V))
97 return true;
98 if (const auto *DefInstr = dyn_cast<Instruction>(V)) {
99 const auto *UseInstr = cast<Instruction>(U.getUser());
100 return isTemporalDivergent(*UseInstr->getParent(), *DefInstr);
101 }
102 return false;
103}
104
105// This ensures explicit instantiation of
106// GenericUniformityAnalysisImpl::ImplDeleter::operator()
110
111//===----------------------------------------------------------------------===//
112// UniformityInfoAnalysis and related pass implementations
113//===----------------------------------------------------------------------===//
114
119 auto &CI = FAM.getResult<CycleAnalysis>(F);
120 UniformityInfo UI{DT, CI, &TTI};
121 // Skip computation if we can assume everything is uniform.
123 UI.compute();
124
125 return UI;
126}
127
128AnalysisKey UniformityInfoAnalysis::Key;
129
131 : OS(OS) {}
132
135 OS << "UniformityInfo for function '" << F.getName() << "':\n";
137
138 return PreservedAnalyses::all();
139}
140
141//===----------------------------------------------------------------------===//
142// UniformityInfoWrapperPass Implementation
143//===----------------------------------------------------------------------===//
144
146
149}
150
152 "Uniformity Analysis", true, true)
157 "Uniformity Analysis", true, true)
158
159void UniformityInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
160 AU.setPreservesAll();
161 AU.addRequired<DominatorTreeWrapperPass>();
162 AU.addRequiredTransitive<CycleInfoWrapperPass>();
163 AU.addRequired<TargetTransformInfoWrapperPass>();
164}
165
167 auto &cycleInfo = getAnalysis<CycleInfoWrapperPass>().getResult();
168 auto &domTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
169 auto &targetTransformInfo =
170 getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
171
172 m_function = &F;
173 m_uniformityInfo = UniformityInfo{domTree, cycleInfo, &targetTransformInfo};
174
175 // Skip computation if we can assume everything is uniform.
176 if (targetTransformInfo.hasBranchDivergence(m_function))
177 m_uniformityInfo.compute();
178
179 return false;
180}
181
183 OS << "UniformityInfo for function '" << m_function->getName() << "':\n";
184}
185
187 m_uniformityInfo = UniformityInfo{};
188 m_function = nullptr;
189}
Expand Atomic instructions
basic Basic Alias true
block Block Frequency Analysis
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
Implementation of uniformity analysis.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
FunctionAnalysisManager FAM
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:57
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This pass exposes codegen information to IR-level passes.
LLVM IR instance of the generic uniformity analysis.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:410
Represent the analysis usage information of a pass.
Analysis pass which computes a CycleInfo.
Definition: CycleAnalysis.h:46
Legacy analysis pass which computes a CycleInfo.
Definition: CycleAnalysis.h:25
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:279
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:317
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:310
A possibly irreducible generalization of a Loop.
bool contains(const BlockT *Block) const
Return whether Block is contained in the cycle.
Analysis that identifies uniform values in a data-parallel execution.
bool isDivergentUse(const UseT &U) const
bool hasDivergentDefs(const InstructionT &I) const
bool markDefsDivergent(const InstructionT &Instr)
Mark outputs of Instr as divergent.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:111
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:117
Analysis pass providing the TargetTransformInfo.
Wrapper pass for TargetTransformInfo.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
bool isAlwaysUniform(const Value *V) const
bool hasBranchDivergence(const Function *F=nullptr) const
Return true if branch divergence exists.
bool isSourceOfDivergence(const Value *V) const
Returns whether V is a source of divergence.
Analysis pass which computes UniformityInfo.
UniformityInfo run(Function &F, FunctionAnalysisManager &)
Run the analysis pass over a function and produce a dominator tree.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Legacy analysis pass which computes a CycleInfo.
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
NodeAddr< InstrNode * > Instr
Definition: RDFGraph.h:389
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr)
void initializeUniformityInfoWrapperPassPass(PassRegistry &)
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:28