LLVM 20.0.0git
GenericUniformityInfo.h
Go to the documentation of this file.
1//===- GenericUniformityInfo.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#ifndef LLVM_ADT_GENERICUNIFORMITYINFO_H
10#define LLVM_ADT_GENERICUNIFORMITYINFO_H
11
14
15namespace llvm {
16
17class TargetTransformInfo;
18
19template <typename ContextT> class GenericUniformityAnalysisImpl;
20template <typename ImplT> struct GenericUniformityAnalysisImplDeleter {
21 // Ugly hack around the fact that recent (> 15.0) clang will run into an
22 // is_invocable() check in some GNU libc++'s unique_ptr implementation
23 // and reject this deleter if you just make it callable with an ImplT *,
24 // whether or not the type of ImplT is spelled out.
25 using pointer = ImplT *;
26 void operator()(ImplT *Impl);
27};
28
29template <typename ContextT> class GenericUniformityInfo {
30public:
31 using BlockT = typename ContextT::BlockT;
32 using FunctionT = typename ContextT::FunctionT;
33 using ValueRefT = typename ContextT::ValueRefT;
34 using ConstValueRefT = typename ContextT::ConstValueRefT;
35 using UseT = typename ContextT::UseT;
36 using InstructionT = typename ContextT::InstructionT;
37 using DominatorTreeT = typename ContextT::DominatorTreeT;
39
41 using CycleT = typename CycleInfoT::CycleT;
42
44 const TargetTransformInfo *TTI = nullptr);
48
49 void compute() {
50 DA->initialize();
51 DA->compute();
52 }
53
54 /// Whether any divergence was detected.
55 bool hasDivergence() const;
56
57 /// The GPU kernel this analysis result is for
58 const FunctionT &getFunction() const;
59
60 /// Whether \p V is divergent at its definition.
61 bool isDivergent(ConstValueRefT V) const;
62
63 /// Whether \p V is uniform/non-divergent.
64 bool isUniform(ConstValueRefT V) const { return !isDivergent(V); }
65
66 // Similar queries for InstructionT. These accept a pointer argument so that
67 // in LLVM IR, they overload the equivalent queries for Value*. For example,
68 // if querying whether a BranchInst is divergent, it should not be treated as
69 // a Value in LLVM IR.
70 bool isUniform(const InstructionT *I) const { return !isDivergent(I); };
71 bool isDivergent(const InstructionT *I) const;
72
73 /// \brief Whether \p U is divergent. Uses of a uniform value can be
74 /// divergent.
75 bool isDivergentUse(const UseT &U) const;
76
77 bool hasDivergentTerminator(const BlockT &B);
78
79 void print(raw_ostream &Out) const;
80
81private:
83
84 std::unique_ptr<ImplT, GenericUniformityAnalysisImplDeleter<ImplT>> DA;
85
88};
89
90} // namespace llvm
91
92#endif // LLVM_ADT_GENERICUNIFORMITYINFO_H
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Find all cycles in a control-flow graph, including irreducible loops.
#define I(x, y, z)
Definition: MD5.cpp:58
Cycle information for a function.
Analysis that identifies uniform values in a data-parallel execution.
bool hasDivergentTerminator(const BlockT &B)
bool isDivergentUse(const UseT &U) const
Whether U is divergent.
typename ContextT::ValueRefT ValueRefT
typename ContextT::FunctionT FunctionT
bool isDivergent(ConstValueRefT V) const
Whether V is divergent at its definition.
void print(raw_ostream &Out) const
T helper function for printing.
bool isUniform(ConstValueRefT V) const
Whether V is uniform/non-divergent.
typename CycleInfoT::CycleT CycleT
bool isUniform(const InstructionT *I) const
typename ContextT::ConstValueRefT ConstValueRefT
typename ContextT::BlockT BlockT
typename ContextT::InstructionT InstructionT
typename ContextT::UseT UseT
bool hasDivergence() const
Whether any divergence was detected.
GenericUniformityInfo & operator=(GenericUniformityInfo &&)=default
const FunctionT & getFunction() const
The GPU kernel this analysis result is for.
GenericCycleInfo< ContextT > CycleInfoT
typename ContextT::DominatorTreeT DominatorTreeT
GenericUniformityInfo(GenericUniformityInfo &&)=default
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18