MLIR  21.0.0git
OpenACC.h
Go to the documentation of this file.
1 //===- OpenACC.h - MLIR OpenACC Dialect -------------------------*- C++ -*-===//
2 //
3 // Part of the MLIR 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 declares the OpenACC dialect in MLIR.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef MLIR_DIALECT_OPENACC_OPENACC_H_
14 #define MLIR_DIALECT_OPENACC_OPENACC_H_
15 
16 #include "mlir/IR/BuiltinTypes.h"
17 #include "mlir/IR/Dialect.h"
18 #include "mlir/IR/OpDefinition.h"
19 #include "mlir/IR/PatternMatch.h"
20 #include "mlir/IR/SymbolTable.h"
21 
23 #include "mlir/Dialect/OpenACC/OpenACCOpsDialect.h.inc"
24 #include "mlir/Dialect/OpenACC/OpenACCOpsEnums.h.inc"
25 #include "mlir/Dialect/OpenACC/OpenACCOpsInterfaces.h.inc"
26 #include "mlir/Dialect/OpenACC/OpenACCTypeInterfaces.h.inc"
28 #include "mlir/IR/Value.h"
32 
33 #define GET_TYPEDEF_CLASSES
34 #include "mlir/Dialect/OpenACC/OpenACCOpsTypes.h.inc"
35 
36 #define GET_ATTRDEF_CLASSES
37 #include "mlir/Dialect/OpenACC/OpenACCOpsAttributes.h.inc"
38 
40 
41 #define GET_OP_CLASSES
42 #include "mlir/Dialect/OpenACC/OpenACCOps.h.inc"
43 
44 #define ACC_DATA_ENTRY_OPS \
45  mlir::acc::CopyinOp, mlir::acc::CreateOp, mlir::acc::PresentOp, \
46  mlir::acc::NoCreateOp, mlir::acc::AttachOp, mlir::acc::DevicePtrOp, \
47  mlir::acc::GetDevicePtrOp, mlir::acc::PrivateOp, \
48  mlir::acc::FirstprivateOp, mlir::acc::UpdateDeviceOp, \
49  mlir::acc::UseDeviceOp, mlir::acc::ReductionOp, \
50  mlir::acc::DeclareDeviceResidentOp, mlir::acc::DeclareLinkOp, \
51  mlir::acc::CacheOp
52 #define ACC_DATA_EXIT_OPS \
53  mlir::acc::CopyoutOp, mlir::acc::DeleteOp, mlir::acc::DetachOp, \
54  mlir::acc::UpdateHostOp
55 #define ACC_DATA_CLAUSE_OPS ACC_DATA_ENTRY_OPS, ACC_DATA_EXIT_OPS
56 #define ACC_COMPUTE_CONSTRUCT_OPS \
57  mlir::acc::ParallelOp, mlir::acc::KernelsOp, mlir::acc::SerialOp
58 #define ACC_COMPUTE_CONSTRUCT_AND_LOOP_OPS \
59  ACC_COMPUTE_CONSTRUCT_OPS, mlir::acc::LoopOp
60 #define ACC_DATA_CONSTRUCT_STRUCTURED_OPS \
61  mlir::acc::DataOp, mlir::acc::DeclareOp, mlir::acc::HostDataOp
62 #define ACC_DATA_CONSTRUCT_UNSTRUCTURED_OPS \
63  mlir::acc::EnterDataOp, mlir::acc::ExitDataOp, mlir::acc::UpdateOp, \
64  mlir::acc::DeclareEnterOp, mlir::acc::DeclareExitOp
65 #define ACC_DATA_CONSTRUCT_OPS \
66  ACC_DATA_CONSTRUCT_STRUCTURED_OPS, ACC_DATA_CONSTRUCT_UNSTRUCTURED_OPS
67 #define ACC_COMPUTE_AND_DATA_CONSTRUCT_OPS \
68  ACC_COMPUTE_CONSTRUCT_OPS, ACC_DATA_CONSTRUCT_OPS
69 #define ACC_COMPUTE_LOOP_AND_DATA_CONSTRUCT_OPS \
70  ACC_COMPUTE_CONSTRUCT_AND_LOOP_OPS, ACC_DATA_CONSTRUCT_OPS
71 
72 namespace mlir {
73 namespace acc {
74 
75 /// Enumeration used to encode the execution mapping on a loop construct.
76 /// They refer directly to the OpenACC 3.3 standard:
77 /// 2.9.2. gang
78 /// 2.9.3. worker
79 /// 2.9.4. vector
80 ///
81 /// Value can be combined bitwise to reflect the mapping applied to the
82 /// construct. e.g. `acc.loop gang vector`, the `gang` and `vector` could be
83 /// combined and the final mapping value would be 5 (4 | 1).
84 enum OpenACCExecMapping { NONE = 0, VECTOR = 1, WORKER = 2, GANG = 4 };
85 
86 /// Used to obtain the `var` from a data clause operation.
87 /// Returns empty value if not a data clause operation or is a data exit
88 /// operation with no `var`.
89 mlir::Value getVar(mlir::Operation *accDataClauseOp);
90 
91 /// Used to obtain the `var` from a data clause operation if it implements
92 /// `PointerLikeType`.
94 getVarPtr(mlir::Operation *accDataClauseOp);
95 
96 /// Used to obtains the `varType` from a data clause operation which records
97 /// the type of variable. When `var` is `PointerLikeType`, this returns
98 /// the type of the pointer target.
99 mlir::Type getVarType(mlir::Operation *accDataClauseOp);
100 
101 /// Used to obtain the `accVar` from a data clause operation.
102 /// When a data entry operation, it obtains its result `accVar` value.
103 /// If a data exit operation, it obtains its operand `accVar` value.
104 /// Returns empty value if not a data clause operation.
105 mlir::Value getAccVar(mlir::Operation *accDataClauseOp);
106 
107 /// Used to obtain the `accVar` from a data clause operation if it implements
108 /// `PointerLikeType`.
110 getAccPtr(mlir::Operation *accDataClauseOp);
111 
112 /// Used to obtain the `varPtrPtr` from a data clause operation.
113 /// Returns empty value if not a data clause operation.
114 mlir::Value getVarPtrPtr(mlir::Operation *accDataClauseOp);
115 
116 /// Used to obtain `bounds` from an acc data clause operation.
117 /// Returns an empty vector if there are no bounds.
119 
120 /// Used to obtain `async` operands from an acc data clause operation.
121 /// Returns an empty vector if there are no such operands.
123 getAsyncOperands(mlir::Operation *accDataClauseOp);
124 
125 /// Returns an array of acc:DeviceTypeAttr attributes attached to
126 /// an acc data clause operation, that correspond to the device types
127 /// associated with the async clauses with an async-value.
128 mlir::ArrayAttr getAsyncOperandsDeviceType(mlir::Operation *accDataClauseOp);
129 
130 /// Returns an array of acc:DeviceTypeAttr attributes attached to
131 /// an acc data clause operation, that correspond to the device types
132 /// associated with the async clauses without an async-value.
133 mlir::ArrayAttr getAsyncOnly(mlir::Operation *accDataClauseOp);
134 
135 /// Used to obtain the `name` from an acc operation.
136 std::optional<llvm::StringRef> getVarName(mlir::Operation *accOp);
137 
138 /// Used to obtain the `dataClause` from a data entry operation.
139 /// Returns empty optional if not a data entry operation.
140 std::optional<mlir::acc::DataClause>
141 getDataClause(mlir::Operation *accDataEntryOp);
142 
143 /// Used to find out whether data operation is implicit.
144 /// Returns false if not a data operation or if it is a data operation without
145 /// implicit flag.
146 bool getImplicitFlag(mlir::Operation *accDataEntryOp);
147 
148 /// Used to get an immutable range iterating over the data operands.
150 
151 /// Used to get a mutable range iterating over the data operands.
153 
154 /// Used to obtain the enclosing compute construct operation that contains
155 /// the provided `region`. Returns nullptr if no compute construct operation
156 /// is found. The returns operation is one of types defined by
157 ///`ACC_COMPUTE_CONSTRUCT_OPS`.
159 
160 /// Used to check whether the provided `type` implements the `PointerLikeType`
161 /// interface.
162 inline bool isPointerLikeType(mlir::Type type) {
163  return mlir::isa<mlir::acc::PointerLikeType>(type);
164 }
165 
166 /// Used to check whether the provided `type` implements the `MappableType`
167 /// interface.
168 inline bool isMappableType(mlir::Type type) {
169  return mlir::isa<mlir::acc::MappableType>(type);
170 }
171 
172 /// Used to obtain the attribute name for declare.
173 static constexpr StringLiteral getDeclareAttrName() {
174  return StringLiteral("acc.declare");
175 }
176 
177 static constexpr StringLiteral getDeclareActionAttrName() {
178  return StringLiteral("acc.declare_action");
179 }
180 
181 static constexpr StringLiteral getRoutineInfoAttrName() {
182  return StringLiteral("acc.routine_info");
183 }
184 
185 static constexpr StringLiteral getCombinedConstructsAttrName() {
186  return CombinedConstructsTypeAttr::name;
187 }
188 
190  : public mlir::SideEffects::Resource::Base<RuntimeCounters> {
191  mlir::StringRef getName() final { return "AccRuntimeCounters"; }
192 };
193 
195  : public mlir::SideEffects::Resource::Base<ConstructResource> {
196  mlir::StringRef getName() final { return "AccConstructResource"; }
197 };
198 
200  : public mlir::SideEffects::Resource::Base<CurrentDeviceIdResource> {
201  mlir::StringRef getName() final { return "AccCurrentDeviceIdResource"; }
202 };
203 
204 } // namespace acc
205 } // namespace mlir
206 
207 #endif // MLIR_DIALECT_OPENACC_OPENACC_H_
This class provides a mutable adaptor for a range of operands.
Definition: ValueRange.h:118
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
This base class is used for derived effects that are non-parametric.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
This class provides an abstraction over the different types of ranges over Values.
Definition: ValueRange.h:387
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
mlir::Value getAccVar(mlir::Operation *accDataClauseOp)
Used to obtain the accVar from a data clause operation.
Definition: OpenACC.cpp:3761
mlir::Value getVar(mlir::Operation *accDataClauseOp)
Used to obtain the var from a data clause operation.
Definition: OpenACC.cpp:3730
mlir::TypedValue< mlir::acc::PointerLikeType > getAccPtr(mlir::Operation *accDataClauseOp)
Used to obtain the accVar from a data clause operation if it implements PointerLikeType.
Definition: OpenACC.cpp:3749
std::optional< mlir::acc::DataClause > getDataClause(mlir::Operation *accDataEntryOp)
Used to obtain the dataClause from a data entry operation.
Definition: OpenACC.cpp:3834
bool isPointerLikeType(mlir::Type type)
Used to check whether the provided type implements the PointerLikeType interface.
Definition: OpenACC.h:162
mlir::MutableOperandRange getMutableDataOperands(mlir::Operation *accOp)
Used to get a mutable range iterating over the data operands.
Definition: OpenACC.cpp:3862
mlir::SmallVector< mlir::Value > getBounds(mlir::Operation *accDataClauseOp)
Used to obtain bounds from an acc data clause operation.
Definition: OpenACC.cpp:3779
OpenACCExecMapping
Enumeration used to encode the execution mapping on a loop construct.
Definition: OpenACC.h:84
@ WORKER
Definition: OpenACC.h:84
@ NONE
Definition: OpenACC.h:84
@ GANG
Definition: OpenACC.h:84
@ VECTOR
Definition: OpenACC.h:84
mlir::ValueRange getDataOperands(mlir::Operation *accOp)
Used to get an immutable range iterating over the data operands.
Definition: OpenACC.cpp:3852
std::optional< llvm::StringRef > getVarName(mlir::Operation *accOp)
Used to obtain the name from an acc operation.
Definition: OpenACC.cpp:3823
static constexpr StringLiteral getRoutineInfoAttrName()
Definition: OpenACC.h:181
mlir::Operation * getEnclosingComputeOp(mlir::Region &region)
Used to obtain the enclosing compute construct operation that contains the provided region.
Definition: OpenACC.cpp:3871
bool getImplicitFlag(mlir::Operation *accDataEntryOp)
Used to find out whether data operation is implicit.
Definition: OpenACC.cpp:3844
mlir::SmallVector< mlir::Value > getAsyncOperands(mlir::Operation *accDataClauseOp)
Used to obtain async operands from an acc data clause operation.
Definition: OpenACC.cpp:3794
bool isMappableType(mlir::Type type)
Used to check whether the provided type implements the MappableType interface.
Definition: OpenACC.h:168
static constexpr StringLiteral getCombinedConstructsAttrName()
Definition: OpenACC.h:185
mlir::Value getVarPtrPtr(mlir::Operation *accDataClauseOp)
Used to obtain the varPtrPtr from a data clause operation.
Definition: OpenACC.cpp:3769
mlir::ArrayAttr getAsyncOnly(mlir::Operation *accDataClauseOp)
Returns an array of acc:DeviceTypeAttr attributes attached to an acc data clause operation,...
Definition: OpenACC.cpp:3816
static constexpr StringLiteral getDeclareAttrName()
Used to obtain the attribute name for declare.
Definition: OpenACC.h:173
static constexpr StringLiteral getDeclareActionAttrName()
Definition: OpenACC.h:177
mlir::Type getVarType(mlir::Operation *accDataClauseOp)
Used to obtains the varType from a data clause operation which records the type of variable.
Definition: OpenACC.cpp:3738
mlir::TypedValue< mlir::acc::PointerLikeType > getVarPtr(mlir::Operation *accDataClauseOp)
Used to obtain the var from a data clause operation if it implements PointerLikeType.
Definition: OpenACC.cpp:3716
mlir::ArrayAttr getAsyncOperandsDeviceType(mlir::Operation *accDataClauseOp)
Returns an array of acc:DeviceTypeAttr attributes attached to an acc data clause operation,...
Definition: OpenACC.cpp:3808
Include the generated interface declarations.
std::conditional_t< std::is_same_v< Ty, mlir::Type >, mlir::Value, detail::TypedValue< Ty > > TypedValue
If Ty is mlir::Type this will select Value instead of having a wrapper around it.
Definition: Value.h:488
mlir::StringRef getName() final
Return a string name of the resource.
Definition: OpenACC.h:196
mlir::StringRef getName() final
Return a string name of the resource.
Definition: OpenACC.h:201
mlir::StringRef getName() final
Return a string name of the resource.
Definition: OpenACC.h:191