1//===- TuneExtensionOps.cpp - Tune extension for the Transform dialect ----===//
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#include "mlir/Dialect/Transform/IR/TransformOps.h"
10#include "mlir/Dialect/Transform/Interfaces/TransformInterfaces.h"
11#include "mlir/IR/OpImplementation.h"
12#include "mlir/Interfaces/ControlFlowInterfaces.h"
13#include "llvm/Support/Debug.h"
14
15#include "mlir/Dialect/Transform/TuneExtension/TuneExtensionOps.h"
16
17using namespace mlir;
18
19static ParseResult parseAlternativesOpSelectedRegion(
20 OpAsmParser &parser, IntegerAttr &selectedRegionAttr,
21 std::optional<OpAsmParser::UnresolvedOperand> &selectedRegionParam);
22
23static void printAlternativesOpSelectedRegion(OpAsmPrinter &printer,
24 Operation *op,
25 IntegerAttr selectedRegionAttr,
26 Value selectedRegionParam);
27
28#define GET_OP_CLASSES
29#include "mlir/Dialect/Transform/TuneExtension/TuneExtensionOps.cpp.inc"
30
31#define DEBUG_TYPE "transform-tune"
32#define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "] ")
33
34//===----------------------------------------------------------------------===//
35// KnobOp
36//===----------------------------------------------------------------------===//
37
38void transform::tune::KnobOp::getEffects(
39 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
40 producesHandle(handles: getOperation()->getOpResults(), effects);
41 onlyReadsPayload(effects);
42}
43
44DiagnosedSilenceableFailure
45transform::tune::KnobOp::apply(transform::TransformRewriter &rewriter,
46 transform::TransformResults &results,
47 transform::TransformState &state) {
48 if (getSelected()) {
49 results.setParams(value: llvm::cast<OpResult>(Val: getResult()), params: *getSelected());
50 return DiagnosedSilenceableFailure::success();
51 }
52
53 return emitDefiniteFailure()
54 << "non-deterministic choice " << getName()
55 << " is only resolved through providing a `selected` attr";
56}
57
58LogicalResult transform::tune::KnobOp::verify() {
59 if (auto selected = getSelected()) {
60 if (auto optionsArray = dyn_cast<ArrayAttr>(Val: getOptions())) {
61 if (!llvm::is_contained(Range&: optionsArray, Element: selected))
62 return emitOpError(message: "provided `selected` attribute is not an element of "
63 "`options` array of attributes");
64 } else
65 LLVM_DEBUG(DBGS() << "cannot verify `selected` attribute " << selected
66 << " is an element of `options` attribute "
67 << getOptions());
68 }
69
70 return success();
71}
72
73//===----------------------------------------------------------------------===//
74// AlternativesOp
75//===----------------------------------------------------------------------===//
76
77static ParseResult parseAlternativesOpSelectedRegion(
78 OpAsmParser &parser, IntegerAttr &selectedRegionAttr,
79 std::optional<OpAsmParser::UnresolvedOperand> &selectedRegionParam) {
80 size_t selectedRegionIdx;
81 OptionalParseResult attrParseRes =
82 parser.parseOptionalInteger(result&: selectedRegionIdx);
83 if (attrParseRes.has_value()) {
84 if (failed(Result: *attrParseRes))
85 return failure();
86
87 selectedRegionAttr = parser.getBuilder().getIndexAttr(value: selectedRegionIdx);
88 return success();
89 }
90
91 OpAsmParser::UnresolvedOperand param;
92 auto paramParseRes = parser.parseOptionalOperand(result&: param);
93 if (paramParseRes.has_value()) {
94 if (failed(Result: *paramParseRes))
95 return failure();
96
97 selectedRegionParam = param;
98 return success();
99 }
100
101 return parser.emitError(loc: parser.getCurrentLocation())
102 << "expected either an integer attribute or a transform.param operand";
103}
104
105static void printAlternativesOpSelectedRegion(OpAsmPrinter &printer,
106 Operation *op,
107 IntegerAttr selectedRegionAttr,
108 Value selectedRegionParam) {
109 if (selectedRegionAttr)
110 printer << selectedRegionAttr.getValue();
111 if (selectedRegionParam)
112 printer << selectedRegionParam;
113}
114
115OperandRange transform::tune::AlternativesOp::getEntrySuccessorOperands(
116 RegionSuccessor successor) {
117 // No operands will be forwarded to the region(s).
118 return getOperands().slice(n: 0, m: 0);
119}
120
121void transform::tune::AlternativesOp::getSuccessorRegions(
122 RegionBranchPoint point, SmallVectorImpl<RegionSuccessor> &regions) {
123 if (point.isParent())
124 if (auto selectedRegionIdx = getSelectedRegionAttr())
125 regions.emplace_back(
126 Args: &getAlternatives()[selectedRegionIdx->getSExtValue()]);
127 else
128 for (Region &alternative : getAlternatives())
129 regions.emplace_back(Args: &alternative);
130 else
131 regions.push_back(Elt: RegionSuccessor(getOperation()));
132}
133
134ValueRange
135transform::tune::AlternativesOp::getSuccessorInputs(RegionSuccessor successor) {
136 return successor.isOperation() ? ValueRange(getOperation()->getResults())
137 : ValueRange();
138}
139
140void transform::tune::AlternativesOp::getRegionInvocationBounds(
141 ArrayRef<Attribute> operands, SmallVectorImpl<InvocationBounds> &bounds) {
142 (void)operands;
143 bounds.reserve(N: getNumRegions());
144
145 if (auto selectedRegionIdx = getSelectedRegionAttr()) {
146 bounds.resize(N: getNumRegions(), NV: InvocationBounds(0, 0));
147 bounds[selectedRegionIdx->getSExtValue()] = InvocationBounds(1, 1);
148 } else {
149 bounds.resize(N: getNumRegions(), NV: InvocationBounds(0, 1));
150 }
151}
152
153void transform::tune::AlternativesOp::getEffects(
154 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
155 onlyReadsHandle(handles: getSelectedRegionParamMutable(), effects);
156 producesHandle(handles: getOperation()->getOpResults(), effects);
157 // TODO: should effects from regions be forwarded?
158}
159
160DiagnosedSilenceableFailure
161transform::tune::AlternativesOp::apply(transform::TransformRewriter &rewriter,
162 transform::TransformResults &results,
163 transform::TransformState &state) {
164 std::optional<int64_t> selectedRegionIdx;
165
166 if (auto selectedRegionAttr = getSelectedRegionAttr())
167 selectedRegionIdx = selectedRegionAttr->getSExtValue();
168
169 if (Value selectedRegionParam = getSelectedRegionParam()) {
170 ArrayRef<Attribute> associatedAttrs = state.getParams(value: selectedRegionParam);
171 IntegerAttr selectedRegionAttr;
172 if (associatedAttrs.size() != 1 ||
173 !(selectedRegionAttr = dyn_cast<IntegerAttr>(Val: associatedAttrs[0])))
174 return emitDefiniteFailure()
175 << "param should hold exactly one integer attribute, got: "
176 << associatedAttrs[0];
177 selectedRegionIdx = selectedRegionAttr.getValue().getSExtValue();
178 }
179
180 if (!selectedRegionIdx)
181 return emitDefiniteFailure() << "non-deterministic choice " << getName()
182 << " is only resolved through providing a "
183 "`selected_region` attr/param";
184
185 if (*selectedRegionIdx < 0 || *selectedRegionIdx >= getNumRegions())
186 return emitDefiniteFailure()
187 << "'selected_region' attribute/param specifies region at index "
188 << *selectedRegionIdx << " while op has only " << getNumRegions()
189 << " regions";
190
191 Region &selectedRegion = getRegion(i: *selectedRegionIdx);
192 auto scope = state.make_region_scope(region&: selectedRegion);
193 Block &block = selectedRegion.front();
194 // Apply the region's ops one by one.
195 for (Operation &transform : block.without_terminator()) {
196 DiagnosedSilenceableFailure result =
197 state.applyTransform(transform: cast<transform::TransformOpInterface>(Val&: transform));
198 if (result.isDefiniteFailure())
199 return result;
200
201 if (result.isSilenceableFailure()) {
202 for (const auto &res : getResults())
203 results.set(value: res, ops: {});
204 return result;
205 }
206 }
207 // Forward the operation mapping for values yielded from the region to the
208 // values produced by the alternatives op.
209 transform::detail::forwardTerminatorOperands(block: &block, state, results);
210 return DiagnosedSilenceableFailure::success();
211}
212
213LogicalResult transform::tune::AlternativesOp::verify() {
214 for (auto *region : getRegions()) {
215 auto yieldTerminator =
216 llvm::dyn_cast_if_present<transform::YieldOp>(Val&: region->front().back());
217 if (!yieldTerminator)
218 return emitOpError() << "expected '"
219 << transform::YieldOp::getOperationName()
220 << "' as terminator";
221
222 if (yieldTerminator->getNumOperands() != getNumResults())
223 return yieldTerminator.emitOpError()
224 << "expected terminator to have as many operands as the parent op "
225 "has results";
226
227 for (auto [i, operandType, resultType] : llvm::zip_equal(
228 t: llvm::seq<unsigned>(Begin: 0, End: yieldTerminator->getNumOperands()),
229 u: yieldTerminator->getOperands().getType(), args: getResultTypes())) {
230 if (operandType == resultType)
231 continue;
232 return yieldTerminator.emitOpError()
233 << "the type of the terminator operand #" << i
234 << " must match the type of the corresponding parent op result ("
235 << operandType << " vs " << resultType << ")";
236 }
237 }
238
239 if (auto selectedRegionAttr = getSelectedRegionAttr()) {
240 int64_t regionIdx = selectedRegionAttr->getSExtValue();
241 if (regionIdx < 0 || regionIdx >= getNumRegions())
242 return emitOpError()
243 << "'selected_region' attribute specifies region at index "
244 << regionIdx << " while op has only " << getNumRegions()
245 << " regions";
246 }
247
248 return success();
249}
250