1/**
2 * Copyright (c) Glow Contributors. See CONTRIBUTORS file.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "InstrBuilder.h"
18
19#include <fstream>
20#include <iostream>
21
22int main(int argc, char **argv) {
23 if (argc != 7) {
24 std::cerr
25 << "Usage: " << argv[0]
26 << " header.h impl.cpp enums.def irbuilder.h irbuilder.cpp irgen.h\n";
27 return -1;
28 }
29
30 std::cout << "Writing instr descriptors to:\n\t" << argv[1] << "\n\t"
31 << argv[2] << "\n\t" << argv[3] << "\n\t" << argv[4] << "\n\t"
32 << argv[5] << "\n\t" << argv[6] << "\n";
33
34 std::ofstream headerStream(argv[1]);
35 std::ofstream cppStream(argv[2]);
36 std::ofstream defStream(argv[3]);
37 std::ofstream builderHeaderStream(argv[4]);
38 std::ofstream builderCppStream(argv[5]);
39 std::ofstream irGenStream(argv[6]);
40
41 Builder BB(headerStream, cppStream, defStream, builderHeaderStream,
42 builderCppStream, irGenStream);
43
44 //===--------------------------------------------------------------------===//
45 // Memory / Buffer Management
46 //===--------------------------------------------------------------------===//
47
48 BB.declareValue("WeightVar");
49
50 BB.newInstr("AllocActivation")
51 .addMember(MemberType::TypeRef, "Ty")
52 .setType("Ty")
53 .addExtraMethod(
54 "void setTy(TypeRef Ty);",
55 "void AllocActivationInst::setTy(TypeRef Ty) { Ty_ = Ty; }");
56
57 BB.newInstr("TensorView")
58 .addOperand("Src", OperandKind::In)
59 .addMember(MemberType::TypeRef, "Ty")
60 .addMember(MemberType::VectorDimT, "Offsets")
61 .setType("Ty");
62
63 BB.newInstr("DeallocActivation")
64 .addOperand("Src", OperandKind::Out)
65 .addExtraMethod("AllocActivationInst *getAlloc() const; ",
66 "AllocActivationInst *DeallocActivationInst::getAlloc() "
67 "const { return "
68 "llvm::cast<AllocActivationInst>(getSrc()); }")
69 .setType("Src->getType()");
70
71 BB.newInstr("Copy")
72 .addOperand("Dest", OperandKind::Out)
73 .addOperand("Src", OperandKind::In)
74 .setType("Src->getType()")
75 .inplaceOperand({"Dest", "Src"})
76 .dataParallel();
77
78 //===--------------------------------------------------------------------===//
79 // Convolution / Pool / FC
80 //===--------------------------------------------------------------------===//
81
82 BB.newInstr("Convolution")
83 .addOperand("Dest", OperandKind::Out)
84 .addOperand("Src", OperandKind::In)
85 .addOperand("Filter", OperandKind::In)
86 .addOperand("Bias", OperandKind::In)
87 .addMember(MemberType::VectorUnsigned, "Kernels")
88 .addMember(MemberType::VectorUnsigned, "Strides")
89 .addMember(MemberType::VectorUnsigned, "Pads")
90 .addMember(MemberType::Unsigned, "Group")
91 .addMember(MemberType::VectorUnsigned, "Dilation")
92 .addMember(MEMBER_TYPE_INFO(ConvolutionLayout), "Layout")
93 .addFusedActivation()
94 .autoIRGen()
95 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src", "Filter"})
96 .addGradientInstr({"Src", "Filter"}, {"Dest", "Src", "Filter", "Bias"});
97
98 BB.newInstr("ChannelwiseQuantizedConvolution")
99 .addOperand("Dest", OperandKind::Out)
100 .addOperand("Src", OperandKind::In)
101 .addOperand("Filter", OperandKind::In)
102 .addOperand("Bias", OperandKind::In)
103 .addOperand("FilterScales", OperandKind::In)
104 .addOperand("FilterOffsets", OperandKind::In)
105 .addOperand("BiasScales", OperandKind::In)
106 .addOperand("BiasOffsets", OperandKind::In)
107 .addMember(MemberType::VectorUnsigned, "Kernels")
108 .addMember(MemberType::VectorUnsigned, "Strides")
109 .addMember(MemberType::VectorUnsigned, "Pads")
110 .addMember(MemberType::Unsigned, "Group")
111 .addMember(MemberType::VectorUnsigned, "Dilation")
112 .addFusedActivation()
113 .autoIRGen()
114 .autoVerify(VerifyKind::SameElementType,
115 {"Dest", "Src", "Filter", "ElemKind::Int8QTy"});
116
117 BB.newInstr("ConvTranspose")
118 .addOperand("Dest", OperandKind::Out)
119 .addOperand("Src", OperandKind::In)
120 .addOperand("Filter", OperandKind::In)
121 .addOperand("Bias", OperandKind::In)
122 .addMember(MemberType::VectorUnsigned, "Kernels")
123 .addMember(MemberType::VectorUnsigned, "Strides")
124 .addMember(MemberType::VectorUnsigned, "Pads")
125 .addMember(MemberType::Unsigned, "Group")
126 .addMember(MemberType::VectorUnsigned, "Dilation")
127 .autoIRGen()
128 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src", "Filter"});
129
130 BB.newInstr("Convolution3D")
131 .addOperand("Dest", OperandKind::Out)
132 .addOperand("Src", OperandKind::In)
133 .addOperand("Filter", OperandKind::In)
134 .addOperand("Bias", OperandKind::In)
135 .addMember(MemberType::VectorUnsigned, "Kernels")
136 .addMember(MemberType::VectorUnsigned, "Strides")
137 .addMember(MemberType::VectorUnsigned, "Pads")
138 .addMember(MemberType::Unsigned, "Group")
139 .autoIRGen()
140 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src", "Filter"})
141 .addGradientInstr({"Src", "Filter"}, {"Dest", "Src", "Filter", "Bias"});
142
143 BB.newInstr("BatchNormalization")
144 .addOperand("Dest", OperandKind::Out)
145 .addOperand("Src", OperandKind::In)
146 .addOperand("Scale", OperandKind::In)
147 .addOperand("Bias", OperandKind::In)
148 .addOperand("Mean", OperandKind::In)
149 .addOperand("Var", OperandKind::In)
150 .addMember(MemberType::Unsigned, "ChannelIdx")
151 .addMember(MemberType::Float, "Epsilon")
152 .addMember(MemberType::Float, "Momentum")
153 .autoIRGen()
154 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
155 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
156 .setType("Dest->getType()");
157
158 // MaxPool version caching Argmax flattened coordinates. It is both used by
159 // itself, and also to restore XY coordinates to speedup gradient-based
160 // computations.
161 BB.newInstr("MaxPoolWithArgmax")
162 .addOperand("Dest", OperandKind::Out)
163 .addOperand("Src", OperandKind::In)
164 .addOperand("Argmax", OperandKind::Out)
165 .addMember(MemberType::VectorUnsigned, "Kernels")
166 .addMember(MemberType::VectorUnsigned, "Strides")
167 .addMember(MemberType::VectorUnsigned, "Pads")
168 .addMember(MemberType::Unsigned, "Layout")
169 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
170 .addGradientInstr({"Dest", "Src", "Argmax"}, {"Dest", "Src"});
171
172 BB.newInstr("MaxPool")
173 .addOperand("Dest", OperandKind::Out)
174 .addOperand("Src", OperandKind::In)
175 .addMember(MemberType::VectorUnsigned, "Kernels")
176 .addMember(MemberType::VectorUnsigned, "Strides")
177 .addMember(MemberType::VectorUnsigned, "Pads")
178 .addMember(MemberType::Unsigned, "Layout")
179 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"});
180
181 BB.newInstr("AvgPool")
182 .addOperand("Dest", OperandKind::Out)
183 .addOperand("Src", OperandKind::In)
184 .addMember(MemberType::VectorUnsigned, "Kernels")
185 .addMember(MemberType::VectorUnsigned, "Strides")
186 .addMember(MemberType::VectorUnsigned, "Pads")
187 .addMember(MemberType::Unsigned, "Layout")
188 .addMember(MemberType::Boolean, "CountIncludePads")
189 .autoIRGen()
190 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
191 .addGradientInstr({"Dest", "Src"}, {"Dest", "Src"});
192
193 BB.newInstr("ArgMax")
194 .addOperand("Dest", OperandKind::Out)
195 .addOperand("Src", OperandKind::In)
196 .addMember(MemberType::Unsigned, "Axis")
197 .addMember(MemberType::Boolean, "KeepDims")
198 .autoIRGen()
199 .autoVerify(VerifyKind::NoVerify);
200
201 BB.newInstr("ArgMin")
202 .addOperand("Dest", OperandKind::Out)
203 .addOperand("Src", OperandKind::In)
204 .addMember(MemberType::Unsigned, "Axis")
205 .addMember(MemberType::Boolean, "KeepDims")
206 .autoIRGen()
207 .autoVerify(VerifyKind::NoVerify);
208
209 BB.newInstr("AdaptiveAvgPool")
210 .addOperand("Dest", OperandKind::Out)
211 .addOperand("Src", OperandKind::In)
212 .autoIRGen()
213 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
214 .addGradientInstr({"Dest"}, {"Dest", "Src"});
215
216 BB.newInstr("FullyConnected")
217 .addOperand("Dest", OperandKind::Out)
218 .addOperand("Src", OperandKind::In)
219 .addOperand("Weights", OperandKind::In)
220 .addOperand("Bias", OperandKind::In)
221 .autoIRGen()
222 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"});
223
224 BB.newInstr("RowwiseQuantizedFullyConnected")
225 .addOperand("Dest", OperandKind::Out)
226 .addOperand("Src", OperandKind::In)
227 .addOperand("Weights", OperandKind::In)
228 .addOperand("Bias", OperandKind::In)
229 .addOperand("Scales", OperandKind::In)
230 .addOperand("Offsets", OperandKind::In)
231 .autoIRGen()
232 .autoVerify(VerifyKind::SameElementType,
233 {"Dest", "Src", "ElemKind::Int8QTy"});
234
235 BB.newInstr("DynamicQuantizedFullyConnected")
236 .addOperand("Dest", OperandKind::Out)
237 .addOperand("Src", OperandKind::In)
238 .addOperand("Weights", OperandKind::In)
239 .addOperand("Bias", OperandKind::In)
240 .addMember(MemberType::Boolean, "IsSymmetric")
241 .addMember(MemberType::Boolean, "IsPerBatchElement")
242 .autoIRGen()
243 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"});
244
245 BB.newInstr("DynamicRowwiseQuantizedFullyConnected")
246 .addOperand("Dest", OperandKind::Out)
247 .addOperand("Src", OperandKind::In)
248 .addOperand("Weights", OperandKind::In)
249 .addOperand("Bias", OperandKind::In)
250 .addOperand("Scales", OperandKind::In)
251 .addOperand("Offsets", OperandKind::In)
252 .addMember(MemberType::Boolean, "IsSymmetric")
253 .addMember(MemberType::Boolean, "IsPerBatchElement")
254 .autoIRGen()
255 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"});
256
257 //===--------------------------------------------------------------------===//
258 // Normalization
259 //===--------------------------------------------------------------------===//
260
261 BB.newInstr("LocalResponseNormalization")
262 .addOperand("Dest", OperandKind::Out)
263 .addOperand("Src", OperandKind::In)
264 .addOperand("Scale", OperandKind::Out)
265 .addMember(MemberType::Unsigned, "HalfWindowSize")
266 .addMember(MemberType::Float, "Alpha")
267 .addMember(MemberType::Float, "Beta")
268 .addMember(MemberType::Float, "K")
269 .setType("Src->getType()")
270 .autoVerify(VerifyKind::SameType, {"Dest", "Src", "Scale"})
271 .addGradientInstr({"Dest", "Src", "Scale"}, {"Dest", "Src"});
272
273 //===--------------------------------------------------------------------===//
274 // Bucketing
275 //===--------------------------------------------------------------------===//
276
277 BB.newInstr("Bucketize")
278 .addOperand("Dest", OperandKind::Out)
279 .addOperand("Src", OperandKind::In)
280 .addMember(MemberType::VectorFloat, "Boundaries")
281 .autoIRGen()
282 .autoVerify(VerifyKind::SameElementType, {"Src", "ElemKind::FloatTy"})
283 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::Int32ITy"});
284
285 BB.newInstr("LayerNormalization")
286 .addOperand("Dest", OperandKind::Out)
287 .addOperand("Src", OperandKind::In)
288 .addOperand("Scale", OperandKind::In)
289 .addOperand("Bias", OperandKind::In)
290 .addMember(MemberType::Float, "Epsilon")
291 .autoIRGen()
292 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
293 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
294 .setType("Dest->getType()");
295
296 //===--------------------------------------------------------------------===//
297 // Loss functions
298 //===--------------------------------------------------------------------===//
299
300 BB.newInstr("SoftMax")
301 .addOperand("Dest", OperandKind::Out)
302 .addOperand("Src", OperandKind::In)
303 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
304 .autoIRGen();
305
306 BB.newInstr("SoftMaxGrad")
307 .addOperand("OrigDest", OperandKind::In)
308 .addOperand("OrigSrc", OperandKind::In)
309 .addOperand("Selected", OperandKind::In)
310 .addOperand("SrcGrad", OperandKind::Out)
311 .autoVerify(VerifyKind::SameType, {"OrigDest", "OrigSrc", "SrcGrad"});
312
313 BB.newInstr("LogSoftMax")
314 .addOperand("Dest", OperandKind::Out)
315 .addOperand("Src", OperandKind::In)
316 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
317 .autoIRGen();
318
319 BB.newInstr("CrossEntropyLoss")
320 .addOperand("P", OperandKind::In)
321 .addOperand("Labels", OperandKind::In)
322 .addOperand("CE", OperandKind::Out)
323 .autoVerify(VerifyKind::NoVerify);
324
325 BB.newInstr("CrossEntropyLossGrad")
326 .addOperand("CEGrad", OperandKind::In)
327 .addOperand("P", OperandKind::In)
328 .addOperand("Labels", OperandKind::In)
329 .addOperand("Pgrad", OperandKind::Out)
330 .addOperand("Labelsgrad", OperandKind::Out)
331 .autoVerify(VerifyKind::NoVerify);
332
333 //===--------------------------------------------------------------------===//
334 // Arithmetic
335 //===--------------------------------------------------------------------===//
336
337 /// Perform matrix multiplication between the 3d tensors LHS and RHS.
338 /// If one of the sizes has a batch size of 1 the matrix is broadcasted.
339 BB.newInstr("MatMul")
340 .addOperand("Dest", OperandKind::Out)
341 .addOperand("LHS", OperandKind::In)
342 .addOperand("RHS", OperandKind::In)
343 .autoIRGen()
344 .autoVerify(VerifyKind::SameElementType, {"Dest", "LHS", "RHS"});
345
346 /// Performs batch matrix multiplication between the LHS and RHS. The operands
347 /// are a stack of two dimensional matrices. Example: (N, A, Z) x (N, Z, B) =>
348 /// (N, A, B).
349 BB.newInstr("BatchMatMul")
350 .addOperand("Dest", OperandKind::Out)
351 .addOperand("LHS", OperandKind::In)
352 .addOperand("RHS", OperandKind::In)
353 .autoIRGen()
354 .autoVerify(VerifyKind::SameElementType, {"Dest", "LHS", "RHS"});
355
356 /// Accumulates all of the layers in the batch along the Axis dimension and
357 /// produce a tensor that has the same dimensions as the input tensor without
358 /// the Axis dimension.
359 BB.newInstr("BatchedReduceAdd")
360 .addOperand("Dest", OperandKind::Out)
361 .addOperand("Batch", OperandKind::In)
362 .addMember(MemberType::Unsigned, "Axis")
363 .autoVerify(VerifyKind::SameElementType, {"Dest", "Batch"})
364 .autoIRGen();
365
366 /// Calculates minimum of all of the layers in the batch along the axes
367 /// dimensions and produce a tensor that has the same dimensions as the input
368 /// tensor without the Axes dimension.
369 BB.newInstr("BatchedReduceMin")
370 .addOperand("Dest", OperandKind::Out)
371 .addOperand("Batch", OperandKind::In)
372 .addMember(MemberType::VectorUnsigned, "Axes")
373 .autoVerify(VerifyKind::SameElementType, {"Dest", "Batch"})
374 .autoIRGen();
375
376 /// Calculates maximum of all of the layers in the batch along the axes
377 /// dimensions and produce a tensor that has the same dimensions as the input
378 /// tensor without the Axes dimension.
379 BB.newInstr("BatchedReduceMax")
380 .addOperand("Dest", OperandKind::Out)
381 .addOperand("Batch", OperandKind::In)
382 .addMember(MemberType::VectorUnsigned, "Axes")
383 .autoVerify(VerifyKind::SameElementType, {"Dest", "Batch"})
384 .autoIRGen();
385
386 /// Accumulates all of the layers in the batch along the Axis dimension and
387 /// produce a tensor that has the same dimensions as the input tensor without
388 /// the Axis dimension.
389 BB.newInstr("BatchedReduceProd")
390 .addOperand("Dest", OperandKind::Out)
391 .addOperand("Batch", OperandKind::In)
392 .addMember(MemberType::Unsigned, "Axis")
393 .autoVerify(VerifyKind::SameElementType, {"Dest", "Batch"})
394 .autoIRGen();
395
396 // Does a running accumulation of all values in input (inclusive).
397 // e.g [1, 2, 3, 4] -> [1, 3, 6, 10]
398 BB.newInstr("CumSum")
399 .addOperand("Dest", OperandKind::Out)
400 .addOperand("Input", OperandKind::In)
401 .addMember(MemberType::Int64, "Dim")
402 .addMember(MemberType::Unsigned, "Exclusive")
403 .addMember(MemberType::Unsigned, "Reverse")
404 .inplaceOperand({"Dest", "Input"})
405 .autoIRGen()
406 .autoVerify(VerifyKind::SameType, {"Dest", "Input"});
407
408 /// Sums together groups of consecutive slices of Data as per the group sizes
409 /// specified by Lengths.
410 BB.newInstr("LengthsSum")
411 .addOperand("Dest", OperandKind::Out)
412 .addOperand("Data", OperandKind::In)
413 .addOperand("Lengths", OperandKind::In)
414 .autoIRGen()
415 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data"})
416 .autoVerify(VerifyKind::SameElementType,
417 {"Lengths", "ElemKind::Int32ITy"});
418
419 BB.newInstr("SparseLengthsSum")
420 .addOperand("Dest", OperandKind::Out)
421 .addOperand("Data", OperandKind::In)
422 .addOperand("Indices", OperandKind::In)
423 .addOperand("Lengths", OperandKind::In)
424 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
425 .addMember(MemberType::Float, "AvgLength")
426 .autoIRGen()
427 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data"})
428 .autoVerify(VerifyKind::SameElementType,
429 {"Lengths", "ElemKind::Int32ITy"})
430 .addGradientInstr({"Data", "Indices", "Lengths"}, {"Dest", "Data"});
431
432 BB.newInstr("SparseLengthsWeightedSum")
433 .addOperand("Dest", OperandKind::Out)
434 .addOperand("Data", OperandKind::In)
435 .addOperand("Weights", OperandKind::In)
436 .addOperand("Indices", OperandKind::In)
437 .addOperand("Lengths", OperandKind::In)
438 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
439 .addMember(MemberType::Float, "AvgLength")
440 .autoIRGen()
441 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data", "Weights"})
442 .autoVerify(VerifyKind::SameElementType,
443 {"Lengths", "ElemKind::Int32ITy"})
444 .autoVerify(VerifyKind::SameShape, {"Weights", "Indices"})
445 .addGradientInstr({"Data", "Weights", "Indices", "Lengths"},
446 {"Dest", "Data", "Weights"});
447
448 BB.newInstr("Embedding")
449 .addOperand("Dest", OperandKind::Out)
450 .addOperand("Weights", OperandKind::In)
451 .addOperand("Indices", OperandKind::In)
452 .addMember(MemberType::Int64, "PadIdx")
453 .addMember(MemberType::Boolean, "Scale")
454 .addMember(MemberType::Boolean, "Sparse")
455 .autoIRGen()
456 .autoVerify(VerifyKind::SameElementType, {"Dest", "Weights"})
457 .autoVerify(VerifyKind::SameElementType,
458 {"Indices", "ElemKind::Int32ITy"});
459
460 BB.newInstr("EmbeddingBag")
461 .addOperand("Dest", OperandKind::Out)
462 .addOperand("Data", OperandKind::In)
463 .addOperand("Weights", OperandKind::In)
464 .addOperand("Indices", OperandKind::In)
465 .addOperand("Offsets", OperandKind::In)
466 .addMember(MemberType::Boolean, "HasEndOffset")
467 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
468 .addMember(MemberType::Float, "AvgLength")
469 .autoIRGen()
470 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data", "Weights"})
471 .autoVerify(VerifyKind::SameElementType,
472 {"Indices", "ElemKind::Int32ITy"})
473 .autoVerify(VerifyKind::SameElementType,
474 {"Offsets", "ElemKind::Int32ITy"})
475 .autoVerify(VerifyKind::SameShape, {"Weights", "Indices"});
476
477 BB.newInstr("RowwiseQuantizedSparseLengthsWeightedSum")
478 .addOperand("Dest", OperandKind::Out)
479 .addOperand("Data", OperandKind::In)
480 .addOperand("Scales", OperandKind::In)
481 .addOperand("Offsets", OperandKind::In)
482 .addOperand("Weights", OperandKind::In)
483 .addOperand("Indices", OperandKind::In)
484 .addOperand("Lengths", OperandKind::In)
485 .addMember(MemberType::Boolean, "UseFP16Accumulation")
486 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
487 .addMember(MemberType::Float, "AvgLength")
488 .autoIRGen()
489 .autoVerify(VerifyKind::SameElementType, {"Data", "ElemKind::UInt8QTy"})
490 .autoVerify(VerifyKind::SameElementType,
491 {"Lengths", "ElemKind::Int32ITy"})
492 .autoVerify(VerifyKind::SameShape, {"Weights", "Indices"});
493
494 BB.newInstr("FusedRowwiseQuantizedSparseLengthsWeightedSum")
495 .addOperand("Dest", OperandKind::Out)
496 .addOperand("Data", OperandKind::In)
497 .addOperand("Weights", OperandKind::In)
498 .addOperand("Indices", OperandKind::In)
499 .addOperand("Lengths", OperandKind::In)
500 .addMember(MemberType::Boolean, "UseFP16Accumulation")
501 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
502 .addMember(MemberType::Float, "AvgLength")
503 .autoIRGen()
504 .autoVerify(VerifyKind::SameElementType,
505 {"Lengths", "ElemKind::Int32ITy"})
506 .autoVerify(VerifyKind::SameShape, {"Weights", "Indices"});
507
508 BB.newInstr("FusedRowwiseQuantizedSparseLengthsSum")
509 .addOperand("Dest", OperandKind::Out)
510 .addOperand("Data", OperandKind::In)
511 .addOperand("Indices", OperandKind::In)
512 .addOperand("Lengths", OperandKind::In)
513 .addMember(MemberType::Boolean, "UseFP16Accumulation")
514 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
515 .addMember(MemberType::Float, "AvgLength")
516 .autoIRGen()
517 .autoVerify(VerifyKind::SameElementType,
518 {"Lengths", "ElemKind::Int32ITy"});
519
520 BB.newInstr("EmbeddingBagByteRowwiseOffsets")
521 .addOperand("Dest", OperandKind::Out)
522 .addOperand("Data", OperandKind::In)
523 .addOperand("Weights", OperandKind::In)
524 .addOperand("Indices", OperandKind::In)
525 .addOperand("Offsets", OperandKind::In)
526 .addMember(MemberType::Boolean, "UseFP16Accumulation")
527 .addMember(MemberType::Boolean, "HasEndOffset")
528 .addMember(MEMBER_TYPE_INFO(glow::LengthsMode), "LengthsMode")
529 .addMember(MemberType::Float, "AvgLength")
530 .autoIRGen()
531 .autoVerify(VerifyKind::SameElementType,
532 {"Indices", "ElemKind::Int32ITy"})
533 .autoVerify(VerifyKind::SameElementType,
534 {"Offsets", "ElemKind::Int32ITy"})
535 .autoVerify(VerifyKind::SameShape, {"Weights", "Indices"});
536
537 BB.newInstr("LengthsToRanges")
538 .addOperand("Dest", OperandKind::Out)
539 .addOperand("Lengths", OperandKind::In)
540 .autoIRGen()
541 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::Int32ITy"})
542 .autoVerify(VerifyKind::SameElementType,
543 {"Lengths", "ElemKind::Int32ITy"});
544
545 BB.newInstr("LengthsRangeFill")
546 .addOperand("Dest", OperandKind::Out)
547 .addOperand("Lengths", OperandKind::In)
548 .autoIRGen()
549 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::Int32ITy"})
550 .autoVerify(VerifyKind::SameElementType,
551 {"Lengths", "ElemKind::Int32ITy"});
552
553 BB.newInstr("BatchSparseToDense")
554 .addOperand("Dest", OperandKind::Out)
555 .addOperand("Lengths", OperandKind::In)
556 .addOperand("Indices", OperandKind::In)
557 .addOperand("Values", OperandKind::In)
558 .addMember(MemberType::Float, "DefaultValue")
559 .addMember(MemberType::Unsigned, "DenseLastDim")
560 .autoVerify(VerifyKind::SameElementType, {"Dest", "Values"})
561 .autoIRGen();
562
563 BB.newInstr("FillExamplesWithIndicator")
564 .addOperand("Dest", OperandKind::Out)
565 .addOperand("Data", OperandKind::In)
566 .addOperand("Indicator", OperandKind::In)
567 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data"})
568 .autoIRGen();
569
570 BB.newInstr("SparseToDenseMask")
571 .addOperand("Dest", OperandKind::Out)
572 .addOperand("Indices", OperandKind::In)
573 .addOperand("Values", OperandKind::In)
574 .addOperand("DefaultValue", OperandKind::In)
575 .addOperand("Lengths", OperandKind::In)
576 .addMember(MemberType::VectorDimT, "Mask")
577 .autoVerify(VerifyKind::SameElementType,
578 {"Dest", "Values", "DefaultValue"})
579 .autoVerify(VerifyKind::SameElementType,
580 {"Indices", "ElemKind::Int64ITy"})
581 .autoVerify(VerifyKind::SameElementType,
582 {"Lengths", "ElemKind::Int32ITy"})
583 .autoIRGen();
584
585 /// Adds the 'Slice' operand to each one of the slices in the batch.
586 BB.newInstr("BatchedAdd")
587 .addOperand("Dest", OperandKind::Out)
588 .addOperand("Batch", OperandKind::In)
589 .addOperand("Slice", OperandKind::In)
590 .inplaceOperand({"Dest", "Batch"})
591 .autoVerify(VerifyKind::SameShape, {"Batch", "Dest"})
592 .autoIRGen();
593
594 BB.newInstr("ElementAdd")
595 .addOperand("Dest", OperandKind::Out)
596 .addOperand("LHS", OperandKind::In)
597 .addOperand("RHS", OperandKind::In)
598 .inplaceOperand({"Dest", "LHS", "RHS"})
599 .dataParallel()
600 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
601 .autoIRGen("Add");
602
603 BB.newInstr("ElementSub")
604 .addOperand("Dest", OperandKind::Out)
605 .addOperand("LHS", OperandKind::In)
606 .addOperand("RHS", OperandKind::In)
607 .inplaceOperand({"Dest", "LHS", "RHS"})
608 .dataParallel()
609 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
610 .autoIRGen("Sub");
611
612 BB.newInstr("ElementMul")
613 .addOperand("Dest", OperandKind::Out)
614 .addOperand("LHS", OperandKind::In)
615 .addOperand("RHS", OperandKind::In)
616 .inplaceOperand({"Dest", "LHS", "RHS"})
617 .dataParallel()
618 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
619 .autoIRGen("Mul");
620
621 BB.newInstr("ElementDiv")
622 .addOperand("Dest", OperandKind::Out)
623 .addOperand("LHS", OperandKind::In)
624 .addOperand("RHS", OperandKind::In)
625 .inplaceOperand({"Dest", "LHS", "RHS"})
626 .dataParallel()
627 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
628 .autoIRGen("Div");
629
630 BB.newInstr("ElementFmod")
631 .addOperand("Dest", OperandKind::Out)
632 .addOperand("LHS", OperandKind::In)
633 .addOperand("RHS", OperandKind::In)
634 .inplaceOperand({"Dest", "LHS", "RHS"})
635 .dataParallel()
636 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
637 .autoIRGen("Fmod");
638
639 BB.newInstr("ElementMax")
640 .addOperand("Dest", OperandKind::Out)
641 .addOperand("LHS", OperandKind::In)
642 .addOperand("RHS", OperandKind::In)
643 .inplaceOperand({"Dest", "LHS", "RHS"})
644 .dataParallel()
645 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
646 .autoIRGen("Max");
647
648 BB.newInstr("ElementMin")
649 .addOperand("Dest", OperandKind::Out)
650 .addOperand("LHS", OperandKind::In)
651 .addOperand("RHS", OperandKind::In)
652 .inplaceOperand({"Dest", "LHS", "RHS"})
653 .dataParallel()
654 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
655 .autoIRGen("Min");
656
657 BB.newInstr("ElementCmpEQ")
658 .addOperand("Dest", OperandKind::Out)
659 .addOperand("LHS", OperandKind::In)
660 .addOperand("RHS", OperandKind::In)
661 .dataParallel()
662 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
663 .autoVerify(VerifyKind::SameElementType, {"LHS", "RHS"})
664 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
665 .autoIRGen("CmpEQ");
666
667 BB.newInstr("ElementCmpNEQ")
668 .addOperand("Dest", OperandKind::Out)
669 .addOperand("LHS", OperandKind::In)
670 .addOperand("RHS", OperandKind::In)
671 .dataParallel()
672 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
673 .autoVerify(VerifyKind::SameElementType, {"LHS", "RHS"})
674 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
675 .autoIRGen("CmpNEQ");
676
677 BB.newInstr("ElementCmpLT")
678 .addOperand("Dest", OperandKind::Out)
679 .addOperand("LHS", OperandKind::In)
680 .addOperand("RHS", OperandKind::In)
681 .dataParallel()
682 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
683 .autoVerify(VerifyKind::SameElementType, {"LHS", "RHS"})
684 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
685 .autoIRGen("CmpLT");
686
687 BB.newInstr("ElementCmpLTE")
688 .addOperand("Dest", OperandKind::Out)
689 .addOperand("LHS", OperandKind::In)
690 .addOperand("RHS", OperandKind::In)
691 .dataParallel()
692 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
693 .autoVerify(VerifyKind::SameElementType, {"LHS", "RHS"})
694 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
695 .autoIRGen("CmpLTE");
696
697 BB.newInstr("ElementIsNaN")
698 .addOperand("Dest", OperandKind::Out)
699 .addOperand("Src", OperandKind::In)
700 .dataParallel()
701 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
702 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
703 .autoIRGen("IsNaN");
704
705 BB.newInstr("ElementPow")
706 .addOperand("Dest", OperandKind::Out)
707 .addOperand("LHS", OperandKind::In)
708 .addOperand("RHS", OperandKind::In)
709 .inplaceOperand({"Dest", "LHS", "RHS"})
710 .dataParallel()
711 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
712 .autoIRGen("Pow");
713
714 BB.newInstr("ElementAnd")
715 .addOperand("Dest", OperandKind::Out)
716 .addOperand("LHS", OperandKind::In)
717 .addOperand("RHS", OperandKind::In)
718 .inplaceOperand({"Dest", "LHS", "RHS"})
719 .dataParallel()
720 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
721 .autoVerify(VerifyKind::SameElementType, {"LHS", "ElemKind::BoolTy"})
722 .autoVerify(VerifyKind::SameElementType, {"RHS", "ElemKind::BoolTy"})
723 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
724 .autoIRGen("And");
725
726 BB.newInstr("ElementBitwiseAnd")
727 .addOperand("Dest", OperandKind::Out)
728 .addOperand("LHS", OperandKind::In)
729 .addOperand("RHS", OperandKind::In)
730 .inplaceOperand({"Dest", "LHS", "RHS"})
731 .dataParallel()
732 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
733 .autoIRGen("BitwiseAnd");
734
735 BB.newInstr("ElementOr")
736 .addOperand("Dest", OperandKind::Out)
737 .addOperand("LHS", OperandKind::In)
738 .addOperand("RHS", OperandKind::In)
739 .inplaceOperand({"Dest", "LHS", "RHS"})
740 .dataParallel()
741 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
742 .autoVerify(VerifyKind::SameElementType, {"LHS", "ElemKind::BoolTy"})
743 .autoVerify(VerifyKind::SameElementType, {"RHS", "ElemKind::BoolTy"})
744 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
745 .autoIRGen("Or");
746
747 BB.newInstr("ElementBitwiseOr")
748 .addOperand("Dest", OperandKind::Out)
749 .addOperand("LHS", OperandKind::In)
750 .addOperand("RHS", OperandKind::In)
751 .inplaceOperand({"Dest", "LHS", "RHS"})
752 .dataParallel()
753 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
754 .autoIRGen("BitwiseOr");
755
756 BB.newInstr("ElementXor")
757 .addOperand("Dest", OperandKind::Out)
758 .addOperand("LHS", OperandKind::In)
759 .addOperand("RHS", OperandKind::In)
760 .inplaceOperand({"Dest", "LHS", "RHS"})
761 .dataParallel()
762 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
763 .autoVerify(VerifyKind::SameElementType, {"LHS", "ElemKind::BoolTy"})
764 .autoVerify(VerifyKind::SameElementType, {"RHS", "ElemKind::BoolTy"})
765 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
766 .autoIRGen("Xor");
767
768 BB.newInstr("ElementBitwiseXor")
769 .addOperand("Dest", OperandKind::Out)
770 .addOperand("LHS", OperandKind::In)
771 .addOperand("RHS", OperandKind::In)
772 .inplaceOperand({"Dest", "LHS", "RHS"})
773 .dataParallel()
774 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS"})
775 .autoIRGen("BitwiseXor");
776
777 BB.newInstr("ElementNot")
778 .addOperand("Dest", OperandKind::Out)
779 .addOperand("Src", OperandKind::In)
780 .inplaceOperand({"Dest", "Src"})
781 .dataParallel()
782 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
783 .autoVerify(VerifyKind::SameElementType, {"Src", "ElemKind::BoolTy"})
784 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::BoolTy"})
785 .autoIRGen("Not");
786
787 BB.newInstr("ElementBitwiseNot")
788 .addOperand("Dest", OperandKind::Out)
789 .addOperand("Src", OperandKind::In)
790 .inplaceOperand({"Dest", "Src"})
791 .dataParallel()
792 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
793 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
794 .autoIRGen("BitwiseNot");
795
796 BB.newInstr("ElementNeg")
797 .addOperand("Dest", OperandKind::Out)
798 .addOperand("Src", OperandKind::In)
799 .inplaceOperand({"Dest", "Src"})
800 .dataParallel()
801 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
802 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
803 .autoIRGen("Neg");
804
805 BB.newInstr("ElementAbs")
806 .addOperand("Dest", OperandKind::Out)
807 .addOperand("Src", OperandKind::In)
808 .inplaceOperand({"Dest", "Src"})
809 .dataParallel()
810 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
811 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
812 .autoIRGen("Abs");
813
814 BB.newInstr("ElementFloor")
815 .addOperand("Dest", OperandKind::Out)
816 .addOperand("Src", OperandKind::In)
817 .inplaceOperand({"Dest", "Src"})
818 .dataParallel()
819 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
820 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
821 .autoIRGen("Floor");
822
823 BB.newInstr("ElementSign")
824 .addOperand("Dest", OperandKind::Out)
825 .addOperand("Src", OperandKind::In)
826 .inplaceOperand({"Dest", "Src"})
827 .dataParallel()
828 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
829 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
830 .autoIRGen("Sign");
831
832 BB.newInstr("ElementCeil")
833 .addOperand("Dest", OperandKind::Out)
834 .addOperand("Src", OperandKind::In)
835 .inplaceOperand({"Dest", "Src"})
836 .dataParallel()
837 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
838 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
839 .autoIRGen("Ceil");
840
841 BB.newInstr("ElementTruncate")
842 .addOperand("Dest", OperandKind::Out)
843 .addOperand("Src", OperandKind::In)
844 .inplaceOperand({"Dest", "Src"})
845 .dataParallel()
846 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
847 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
848 .autoIRGen("Truncate");
849
850 BB.newInstr("ElementRound")
851 .addOperand("Dest", OperandKind::Out)
852 .addOperand("Src", OperandKind::In)
853 .inplaceOperand({"Dest", "Src"})
854 .dataParallel()
855 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
856 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
857 .autoIRGen("Round");
858
859 BB.newInstr("ElementSqrt")
860 .addOperand("Dest", OperandKind::Out)
861 .addOperand("Src", OperandKind::In)
862 .inplaceOperand({"Dest", "Src"})
863 .dataParallel()
864 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
865 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
866 .autoIRGen("Sqrt");
867
868 BB.newInstr("ElementRsqrt")
869 .addOperand("Dest", OperandKind::Out)
870 .addOperand("Src", OperandKind::In)
871 .inplaceOperand({"Dest", "Src"})
872 .dataParallel()
873 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
874 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
875 .autoIRGen("Rsqrt");
876
877 BB.newInstr("ElementReciprocal")
878 .addOperand("Dest", OperandKind::Out)
879 .addOperand("Src", OperandKind::In)
880 .inplaceOperand({"Dest", "Src"})
881 .dataParallel()
882 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
883 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
884 .autoIRGen("Reciprocal");
885
886 BB.newInstr("ElementSin")
887 .addOperand("Dest", OperandKind::Out)
888 .addOperand("Src", OperandKind::In)
889 .inplaceOperand({"Dest", "Src"})
890 .dataParallel()
891 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
892 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
893 .autoIRGen("Sin");
894
895 BB.newInstr("ElementCos")
896 .addOperand("Dest", OperandKind::Out)
897 .addOperand("Src", OperandKind::In)
898 .inplaceOperand({"Dest", "Src"})
899 .dataParallel()
900 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
901 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
902 .autoIRGen("Cos");
903
904 BB.newInstr("ElementLog")
905 .addOperand("Dest", OperandKind::Out)
906 .addOperand("Src", OperandKind::In)
907 .inplaceOperand({
908 "Dest",
909 "Src",
910 })
911 .dataParallel()
912 .autoVerify(VerifyKind::SameType, {"Dest", "Src"})
913 .autoIRGen("Log");
914
915 BB.newInstr("ElementExp")
916 .addOperand("Dest", OperandKind::Out)
917 .addOperand("Src", OperandKind::In)
918 .inplaceOperand({
919 "Dest",
920 "Src",
921 })
922 .dataParallel()
923 .autoVerify(VerifyKind::SameType, {"Dest", "Src"})
924 .autoIRGen("Exp");
925
926 BB.newInstr("ElementAcos")
927 .addOperand("Dest", OperandKind::Out)
928 .addOperand("Src", OperandKind::In)
929 .inplaceOperand({"Dest", "Src"})
930 .dataParallel()
931 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
932 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
933 .autoIRGen("Acos");
934
935 BB.newInstr("ElementAsin")
936 .addOperand("Dest", OperandKind::Out)
937 .addOperand("Src", OperandKind::In)
938 .inplaceOperand({"Dest", "Src"})
939 .dataParallel()
940 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
941 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
942 .autoIRGen("Asin");
943
944 BB.newInstr("ElementAtan")
945 .addOperand("Dest", OperandKind::Out)
946 .addOperand("Src", OperandKind::In)
947 .inplaceOperand({"Dest", "Src"})
948 .dataParallel()
949 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
950 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
951 .autoIRGen("Atan");
952
953 BB.newInstr("ElementErf")
954 .addOperand("Dest", OperandKind::Out)
955 .addOperand("Src", OperandKind::In)
956 .inplaceOperand({"Dest", "Src"})
957 .dataParallel()
958 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
959 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
960 .autoIRGen("Erf");
961
962 BB.newInstr("NonZero")
963 .addOperand("Dest", OperandKind::Out)
964 .addOperand("Cond", OperandKind::In)
965 .inplaceOperand({"Dest", "Cond"})
966 .dataParallel()
967 .autoVerify(VerifyKind::SameElementType, {"Cond", "ElemKind::BoolTy"})
968 .autoIRGen("NonZero");
969
970 BB.newInstr("ElementSelect")
971 .addOperand("Dest", OperandKind::Out)
972 .addOperand("Cond", OperandKind::In)
973 .addOperand("LHS", OperandKind::In)
974 .addOperand("RHS", OperandKind::In)
975 .inplaceOperand({"Dest", "LHS", "RHS", "Cond"})
976 .dataParallel()
977 .autoVerify(VerifyKind::SameShape, {"Dest", "LHS", "RHS", "Cond"})
978 .autoVerify(VerifyKind::SameElementType, {"Dest", "LHS", "RHS"})
979 .autoVerify(VerifyKind::SameElementType, {"Cond", "ElemKind::BoolTy"})
980 .autoIRGen("Select");
981
982 BB.newInstr("Modulo")
983 .addOperand("Dest", OperandKind::Out)
984 .addOperand("Src", OperandKind::In)
985 .addMember(MemberType::Int64, "Divisor")
986 .addMember(MemberType::Boolean, "SignFollowDivisor")
987 .inplaceOperand({
988 "Dest",
989 "Src",
990 })
991 .dataParallel()
992 .autoVerify(VerifyKind::SameType, {"Dest", "Src"})
993 .autoIRGen();
994
995 BB.newInstr("BatchedPairwiseDotProduct")
996 .addOperand("Dest", OperandKind::Out)
997 .addMember(MemberType::Unsigned, "NumInputs")
998 .addMember(MemberType::Unsigned, "VectorSize")
999 .autoVerify(VerifyKind::NoVerify);
1000
1001 BB.newInstr("BatchedPairwiseDotProductGrad")
1002 .addOperand("DestGrad", OperandKind::In)
1003 .addMember(MemberType::Unsigned, "NumInputs")
1004 .addMember(MemberType::Unsigned, "VectorSize")
1005 .autoVerify(VerifyKind::NoVerify);
1006
1007 BB.newInstr("BatchedUnaryEmbeddingsBags")
1008 .addOperand("Dest", OperandKind::Out)
1009 .addOperand("Weights", OperandKind::In)
1010 .addOperand("TableOffsets", OperandKind::In)
1011 .addOperand("Offsets", OperandKind::In)
1012 .addOperand("Indices", OperandKind::In)
1013 .autoIRGen()
1014 .autoVerify(VerifyKind::SameElementType,
1015 {"TableOffsets", "Indices", "Offsets"})
1016 .autoVerify(VerifyKind::SameElementType,
1017 {"Indices", "ElemKind::Int32ITy"})
1018 .autoVerify(VerifyKind::SameElementType,
1019 {"Offsets", "ElemKind::Int32ITy"});
1020
1021 BB.newInstr("IntNBitSplitEmbeddingBags")
1022 .addOperand("Dest", OperandKind::Out)
1023 .addOperand("DevWeights", OperandKind::In)
1024 .addOperand("UvmWeights", OperandKind::In)
1025 .addOperand("WeightsPlacements", OperandKind::In)
1026 .addOperand("WeightsOffsets", OperandKind::In)
1027 .addOperand("WeightsTys", OperandKind::In)
1028 .addOperand("DimOffsets", OperandKind::In)
1029 .addOperand("Indices", OperandKind::In)
1030 .addOperand("Offsets", OperandKind::In)
1031 .addMember(MemberType::Int64, "TotalDims")
1032 .addMember(MEMBER_TYPE_INFO(glow::SplitEmbeddingPoolingMode),
1033 "PoolingMode")
1034 .addMember(MEMBER_TYPE_INFO(glow::SplitEmbeddingSparseType),
1035 "OutputDType")
1036 .autoIRGen()
1037 .autoVerify(VerifyKind::SameElementType,
1038 {"Indices", "ElemKind::Int32ITy"})
1039 .autoVerify(VerifyKind::SameElementType,
1040 {"Offsets", "ElemKind::Int32ITy"});
1041
1042 BB.newInstr("IntNBitSplitEmbeddingWeightedBags")
1043 .addOperand("Dest", OperandKind::Out)
1044 .addOperand("DevWeights", OperandKind::In)
1045 .addOperand("UvmWeights", OperandKind::In)
1046 .addOperand("WeightsPlacements", OperandKind::In)
1047 .addOperand("WeightsOffsets", OperandKind::In)
1048 .addOperand("WeightsTys", OperandKind::In)
1049 .addOperand("DimOffsets", OperandKind::In)
1050 .addOperand("Indices", OperandKind::In)
1051 .addOperand("Offsets", OperandKind::In)
1052 .addOperand("IndiceWeight", OperandKind::In)
1053 .addMember(MemberType::Int64, "TotalDims")
1054 .addMember(MemberType::Int64, "PoolingMode")
1055 .addMember(MemberType::Int64, "OutputDType")
1056 .autoIRGen()
1057 .autoVerify(VerifyKind::SameElementType,
1058 {"Indices", "ElemKind::Int32ITy"})
1059 .autoVerify(VerifyKind::SameElementType,
1060 {"Offsets", "ElemKind::Int32ITy"});
1061
1062 //===--------------------------------------------------------------------===//
1063 // Fillers
1064 //===--------------------------------------------------------------------===//
1065
1066 BB.newInstr("GaussianFill")
1067 .addOperand("Dest", OperandKind::Out)
1068 .addOperand("Input", OperandKind::In)
1069 .addMember(MemberType::Float, "Mean")
1070 .addMember(MemberType::Float, "Scale")
1071 .addMember(MemberType::Float, "Seed")
1072 .autoIRGen()
1073 .autoVerify(VerifyKind::SameElementType, {"Dest", "ElemKind::Float16Ty"});
1074
1075 //===--------------------------------------------------------------------===//
1076 // Non-linearities
1077 //===--------------------------------------------------------------------===//
1078 BB.newInstr("Relu")
1079 .addOperand("Dest", OperandKind::Out)
1080 .addOperand("Src", OperandKind::In)
1081 .inplaceOperand({
1082 "Dest",
1083 "Src",
1084 })
1085 .dataParallel()
1086 .autoIRGen()
1087 .addGradientInstr({"Dest"}, {"Dest", "Src"});
1088
1089 BB.newInstr("Clip")
1090 .addOperand("Dest", OperandKind::Out)
1091 .addOperand("Src", OperandKind::In)
1092 .addMember(MemberType::Float, "Min")
1093 .addMember(MemberType::Float, "Max")
1094 .inplaceOperand({
1095 "Dest",
1096 "Src",
1097 })
1098 .dataParallel()
1099 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
1100 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1101 .autoIRGen();
1102
1103 BB.newInstr("Sigmoid")
1104 .addOperand("Dest", OperandKind::Out)
1105 .addOperand("Src", OperandKind::In)
1106 .inplaceOperand({
1107 "Dest",
1108 "Src",
1109 })
1110 .dataParallel()
1111 .autoVerify(VerifyKind::SameType, {"Dest", "Src"})
1112 .autoIRGen();
1113
1114 BB.newInstr("Tanh")
1115 .addOperand("Dest", OperandKind::Out)
1116 .addOperand("Src", OperandKind::In)
1117 .inplaceOperand({
1118 "Dest",
1119 "Src",
1120 })
1121 .dataParallel()
1122 .autoVerify(VerifyKind::SameType, {"Dest", "Src"})
1123 .autoIRGen();
1124
1125 BB.newInstr("LeakyRelu")
1126 .addOperand("Dest", OperandKind::Out)
1127 .addOperand("Src", OperandKind::In)
1128 .addMember(MemberType::Float, "Alpha")
1129 .inplaceOperand({
1130 "Dest",
1131 "Src",
1132 })
1133 .dataParallel()
1134 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
1135 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1136 .autoIRGen();
1137
1138 BB.newInstr("SoftPlus")
1139 .addOperand("Dest", OperandKind::Out)
1140 .addOperand("Src", OperandKind::In)
1141 .inplaceOperand({
1142 "Dest",
1143 "Src",
1144 })
1145 .dataParallel()
1146 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
1147 .autoIRGen();
1148
1149 //===--------------------------------------------------------------------===//
1150 // Shape transformations
1151 //===--------------------------------------------------------------------===//
1152
1153 BB.newInstr("Transpose")
1154 .addOperand("Dest", OperandKind::Out)
1155 .addOperand("Src", OperandKind::In)
1156 .addMember(MemberType::VectorUnsigned, "Shuffle")
1157 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1158 .autoIRGen();
1159
1160 /// Input(s) will be added in backend specific function
1161 /// (Backend::generateInst()) when the concat node is not lowered into a list
1162 // of inserttensor.
1163 BB.newInstr("Concat")
1164 .addOperand("Dest", OperandKind::Out)
1165 .addMember(MemberType::Unsigned, "Axis")
1166 .autoVerify(VerifyKind::NoVerify);
1167
1168 BB.newInstr("Splat")
1169 .addMember(MemberType::Float, "Value")
1170 .addOperand("Dest", OperandKind::Out)
1171 .dataParallel()
1172 .autoVerify(VerifyKind::NoVerify)
1173 .autoIRGen();
1174
1175 BB.newInstr("Touch")
1176 .addOperand("Dest", OperandKind::Out)
1177 .dataParallel()
1178 .autoVerify(VerifyKind::NoVerify)
1179 .autoIRGen();
1180
1181 BB.newInstr("InsertTensor")
1182 .addOperand("Dest", OperandKind::InOut)
1183 .addOperand("Src", OperandKind::In)
1184 .addMember(MemberType::VectorDimT, "Offsets")
1185 .addMember(MemberType::Unsigned, "Count")
1186 .addMember(MemberType::Unsigned, "Axis");
1187
1188 BB.newInstr("ExtractTensor")
1189 .addOperand("Dest", OperandKind::Out)
1190 .addOperand("Src", OperandKind::In)
1191 .addMember(MemberType::VectorDimT, "Offsets");
1192
1193 // TODO: Rename "BatchDims" member to "Axis". This was attempted in #5565 but
1194 // some internal FB tests failed. The member needs to be renamed because that
1195 // is the true meaning of the member and that is what the implementation does
1196 // according to both Caffe2, ONNX and TFLite operator definitions.
1197 // https://github.com/onnx/onnx/blob/master/docs/Operators.md#gather
1198 // https://www.tensorflow.org/mlir/tfl_ops#tflgather_tflgatherop
1199 BB.newInstr("Gather")
1200 .addOperand("Dest", OperandKind::Out)
1201 .addOperand("Data", OperandKind::In)
1202 .addOperand("Indices", OperandKind::In)
1203 .addMember(MemberType::Unsigned, "BatchDims")
1204 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data"})
1205 .autoIRGen();
1206
1207 BB.newInstr("GatherND")
1208 .addOperand("Dest", OperandKind::Out)
1209 .addOperand("Data", OperandKind::In)
1210 .addOperand("Indices", OperandKind::In)
1211 .addMember(MemberType::Unsigned, "BatchDims")
1212 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data"})
1213 .autoIRGen();
1214
1215 BB.newInstr("GatherElements")
1216 .addOperand("Dest", OperandKind::Out)
1217 .addOperand("Data", OperandKind::In)
1218 .addOperand("Indices", OperandKind::In)
1219 .addMember(MemberType::Unsigned, "Dim")
1220 .autoVerify(VerifyKind::SameElementType, {"Dest", "Data"})
1221 .autoIRGen();
1222
1223 BB.newInstr("GatherRanges")
1224 .addOperand("Output", OperandKind::Out)
1225 .addOperand("Lengths", OperandKind::Out)
1226 .addOperand("Data", OperandKind::In)
1227 .addOperand("Ranges", OperandKind::In)
1228 .autoVerify(VerifyKind::SameElementType, {"Data", "Output"})
1229 .autoVerify(VerifyKind::SameElementType, {"Ranges", "Lengths"})
1230 .autoIRGen();
1231
1232 BB.newInstr("ScatterData")
1233 .addOperand("Data", OperandKind::InOut)
1234 .addOperand("Indices", OperandKind::In)
1235 .addOperand("Slices", OperandKind::In)
1236 .addMember(MemberType::Boolean, "Cumulative")
1237 .autoVerify(VerifyKind::NoVerify);
1238
1239 BB.newInstr("BatchOneHot")
1240 .addOperand("Dest", OperandKind::Out)
1241 .addOperand("Data", OperandKind::In)
1242 .addOperand("Lengths", OperandKind::In)
1243 .addOperand("Values", OperandKind::In)
1244 .autoVerify(VerifyKind::SameElementType, {"Values", "Data", "Dest"})
1245 .autoVerify(VerifyKind::SameElementType,
1246 {"Lengths", "ElemKind::Int32ITy"})
1247 .autoIRGen();
1248
1249 BB.newInstr("SpaceToDepth")
1250 .addOperand("Dest", OperandKind::Out)
1251 .addOperand("Src", OperandKind::In)
1252 .addMember(MemberType::Unsigned, "BlockSize")
1253 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1254 .autoIRGen();
1255
1256 BB.newInstr("ResizeNearest")
1257 .addOperand("Dest", OperandKind::Out)
1258 .addOperand("Src", OperandKind::In)
1259 .addMember(MemberType::VectorFloat, "Scale")
1260 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1261 .autoIRGen();
1262
1263 BB.newInstr("ResizeBilinear")
1264 .addOperand("Dest", OperandKind::Out)
1265 .addOperand("Src", OperandKind::In)
1266 .addMember(MemberType::VectorFloat, "Scale")
1267 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1268 .autoIRGen();
1269
1270 BB.newInstr("SparseLabelSplit")
1271 .addOperand("LabelValues", OperandKind::Out)
1272 .addOperand("ExampleIds", OperandKind::Out)
1273 .addOperand("GradientOffsetMap", OperandKind::Out)
1274 .addOperand("Lengths", OperandKind::In)
1275 .addOperand("Indices", OperandKind::In)
1276 .addOperand("Values", OperandKind::In)
1277 .addMember(MemberType::Unsigned, "NumLabels")
1278 .autoVerify(VerifyKind::SameElementType, {"Values", "LabelValues"})
1279 .autoIRGen();
1280
1281 //===--------------------------------------------------------------------===//
1282 // Reorder transformations
1283 //===--------------------------------------------------------------------===//
1284
1285 BB.newInstr("Flip")
1286 .addOperand("Dest", OperandKind::Out)
1287 .addOperand("Src", OperandKind::In)
1288 .addMember(MemberType::Unsigned, "Axis")
1289 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1290 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
1291 .autoIRGen();
1292
1293 //===--------------------------------------------------------------------===//
1294 // Instructions used for debugging/profiling/printing
1295 //===--------------------------------------------------------------------===//
1296
1297 BB.newInstr("DebugPrint")
1298 .addOperand("Src", OperandKind::In)
1299 .addMember(MemberType::String, "Format")
1300 .addMember(MemberType::String, "FileName")
1301 .autoVerify(VerifyKind::NoVerify);
1302
1303 BB.newInstr("TraceEvent")
1304 .addOperand("Data", OperandKind::In)
1305 .addMember(MemberType::Unsigned, "Index")
1306 .autoVerify(VerifyKind::NoVerify);
1307
1308 /// Instruction used to instrument other instructions. InstrRef is a reference
1309 /// of the instruction being instrumented, ID is a unique identifier assigned
1310 /// to the instrumented instruction and InstrumentKind is the instrumentation
1311 /// kind/type. OperandsInfo is a temporary buffer used to store the addresses
1312 /// and the sizes of the operands for the instrumented instruction.
1313 BB.newInstr("Instrument")
1314 .addOperand("OperandsInfo", OperandKind::Out)
1315 .addMember(MEMBER_TYPE_INFO(glow::Instruction *), "InstrRef")
1316 .addMember(MemberType::Unsigned, "ID")
1317 .addMember(MEMBER_TYPE_INFO(glow::InstrumentKind), "InstrumentKind")
1318 .autoVerify(VerifyKind::NoVerify);
1319
1320 //===--------------------------------------------------------------------===//
1321 // Instructions used for quantization
1322 //===--------------------------------------------------------------------===//
1323
1324 BB.newInstr("QuantizationProfile")
1325 .addOperand("InputTensor", OperandKind::In)
1326 .addOperand("Histogram", OperandKind::InOut)
1327 .addOperand("ComputationInfo", OperandKind::InOut)
1328 .autoVerify(VerifyKind::SameElementType,
1329 {"InputTensor", "ElemKind::FloatTy"});
1330
1331 BB.newInstr("IntLookupTable")
1332 .addOperand("Dest", OperandKind::Out)
1333 .addOperand("Src", OperandKind::In)
1334 .addOperand("Mapping", OperandKind::In)
1335 .autoVerify(VerifyKind::TypeCheck, {"Src", "isQuantizedType()"})
1336 .autoVerify(VerifyKind::TypeCheck, {"Dest", "isQuantizedType()"})
1337 .dataParallel()
1338 .autoIRGen();
1339
1340 BB.newInstr("Quantize")
1341 .addOperand("Dest", OperandKind::Out)
1342 .addOperand("Src", OperandKind::In)
1343 .autoVerify(VerifyKind::TypeCheck, {"Src", "isFPType()"})
1344 .autoVerify(VerifyKind::TypeCheck, {"Dest", "isQuantizedType()"})
1345 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
1346 .dataParallel()
1347 .autoIRGen();
1348
1349 BB.newInstr("Dequantize")
1350 .addOperand("Dest", OperandKind::Out)
1351 .addOperand("Src", OperandKind::In)
1352 .autoVerify(VerifyKind::TypeCheck, {"Dest", "isFPType()"})
1353 .autoVerify(VerifyKind::TypeCheck, {"Src", "isQuantizedType()"})
1354 .dataParallel()
1355 .autoIRGen();
1356
1357 BB.newInstr("RescaleQuantized")
1358 .addOperand("Dest", OperandKind::Out)
1359 .addOperand("Src", OperandKind::In)
1360 .autoVerify(VerifyKind::SameElementType, {"Dest", "Src"})
1361 .autoVerify(VerifyKind::TypeCheck, {"Dest", "isQuantizedType()"})
1362 .autoVerify(VerifyKind::SameShape, {"Dest", "Src"})
1363 .dataParallel()
1364 .autoIRGen();
1365
1366 //===--------------------------------------------------------------------===//
1367 // Instructions used by RNN
1368 //===--------------------------------------------------------------------===//
1369
1370 BB.newInstr("TopK")
1371 .addOperand("Values", OperandKind::Out)
1372 .addOperand("Indices", OperandKind::Out)
1373 .addOperand("Input", OperandKind::In)
1374 .addOperand("Scratch", OperandKind::Scratch)
1375 .addMember(MemberType::Unsigned, "K")
1376 .autoVerify(VerifyKind::SameElementType, {"Values", "Input"})
1377 .autoVerify(VerifyKind::SameShape, {"Values", "Indices"});
1378
1379 //===--------------------------------------------------------------------===//
1380 // Conversions
1381 //===--------------------------------------------------------------------===//
1382
1383 BB.newInstr("ConvertTo")
1384 .addOperand("Result", OperandKind::Out)
1385 .addOperand("Input", OperandKind::In)
1386 .autoVerify(VerifyKind::NoVerify)
1387 .autoIRGen();
1388
1389 //===--------------------------------------------------------------------===//
1390 // Custom kernels invocations
1391 //===--------------------------------------------------------------------===//
1392 BB.newInstr("ExternalFunctionCall")
1393 .addOperand("Dest", OperandKind::Out)
1394 .addMember(MemberType::String, "FunctionName")
1395 .addMember(MemberType::String, "FunctionImpl")
1396 .addMember(MemberType::String, "FunctionKind")
1397 .autoVerify(VerifyKind::NoVerify);
1398
1399 //===--------------------------------------------------------------------===//
1400 // Pre Processing
1401 //===--------------------------------------------------------------------===//
1402
1403 BB.newInstr("AudioSpectrogram")
1404 .addOperand("Spectrogram", OperandKind::Out)
1405 .addOperand("Input", OperandKind::In)
1406 .addOperand("Window", OperandKind::In)
1407 .addOperand("TwiddleFactors", OperandKind::In)
1408 .addOperand("BitReverseIndices", OperandKind::In)
1409 .addOperand("ComplexToRealWeights", OperandKind::In)
1410 .addOperand("WinOutScratch", OperandKind::Scratch)
1411 .addOperand("FftOutScratch", OperandKind::Scratch)
1412 .addMember(MemberType::Int64, "WindowSize")
1413 .addMember(MemberType::Int64, "WindowStride")
1414 .addMember(MemberType::Boolean, "MagnitudeSquared")
1415 .autoVerify(VerifyKind::SameElementType,
1416 {"Spectrogram", "Input", "Window", "TwiddleFactors",
1417 "ComplexToRealWeights", "ElemKind::FloatTy"})
1418 .autoVerify(VerifyKind::SameElementType,
1419 {"BitReverseIndices", "ElemKind::Int32ITy"})
1420 .autoIRGen();
1421
1422 BB.newInstr("MFCC")
1423 .addOperand("Coefficients", OperandKind::Out)
1424 .addOperand("Spectrogram", OperandKind::In)
1425 .addOperand("MelWeights", OperandKind::In)
1426 .addOperand("MelRanges", OperandKind::In)
1427 .addOperand("DctMat", OperandKind::In)
1428 .addOperand("Scratch", OperandKind::Scratch)
1429 .addMember(MemberType::Float, "SampleRate")
1430 .addMember(MemberType::Float, "LowerFrequency")
1431 .addMember(MemberType::Float, "UpperFrequency")
1432 .addMember(MemberType::Int64, "FilterBankCount")
1433 .addMember(MemberType::Int64, "NumCoefficients")
1434 .autoVerify(VerifyKind::SameElementType,
1435 {"Coefficients", "Spectrogram", "MelWeights", "DctMat",
1436 "ElemKind::FloatTy"})
1437 .autoVerify(VerifyKind::SameElementType,
1438 {"MelRanges", "ElemKind::Int32ITy"})
1439 .autoIRGen();
1440
1441 //===--------------------------------------------------------------------===//
1442 // Post Processing
1443 //===--------------------------------------------------------------------===//
1444
1445 BB.newInstr("NonMaxSuppression")
1446 .addOperand("Indices", OperandKind::Out)
1447 .addOperand("NumberOfSelectedIndices", OperandKind::Out)
1448 .addOperand("Boxes", OperandKind::In)
1449 .addOperand("Scores", OperandKind::In)
1450 .addMember(MemberType::Int64, "CenterPointBox")
1451 .addMember(MemberType::Int64, "MaxOutputBoxesPerClass")
1452 .addMember(MemberType::Float, "IouThreshold")
1453 .addMember(MemberType::Float, "ScoreThreshold")
1454 .addMember(MemberType::Boolean, "IsTFVersion4")
1455 .autoVerify(VerifyKind::SameElementType, {"Boxes", "Scores"})
1456 .autoVerify(VerifyKind::SameElementType,
1457 {"Indices", "NumberOfSelectedIndices"})
1458 .autoIRGen();
1459
1460 BB.newInstr("TFLiteDetectionPostProcess")
1461 .addOperand("DetectionBoxes", OperandKind::Out)
1462 .addOperand("DetectionClasses", OperandKind::Out)
1463 .addOperand("DetectionScores", OperandKind::Out)
1464 .addOperand("NumDetections", OperandKind::Out)
1465 .addOperand("Boxes", OperandKind::In)
1466 .addOperand("Scores", OperandKind::In)
1467 .addOperand("Anchors", OperandKind::In)
1468 .addOperand("Scratch", OperandKind::Scratch)
1469 .addMember(MemberType::Unsigned, "NumClasses")
1470 .addMember(MemberType::Unsigned, "MaxDetections")
1471 .addMember(MemberType::Unsigned, "MaxClassesPerDetection")
1472 .addMember(MemberType::Unsigned, "MaxDetectionsPerClass")
1473 .addMember(MemberType::Float, "IouThreshold")
1474 .addMember(MemberType::Float, "ScoreThreshold")
1475 .addMember(MemberType::Float, "XScale")
1476 .addMember(MemberType::Float, "YScale")
1477 .addMember(MemberType::Float, "HScale")
1478 .addMember(MemberType::Float, "WScale")
1479 .addMember(MemberType::Boolean, "RegularNMS")
1480 .autoVerify(VerifyKind::NoVerify)
1481 .autoIRGen();
1482
1483 //===--------------------------------------------------------------------===//
1484 // Region of Interest (ROI)
1485 //===--------------------------------------------------------------------===//
1486 BB.newInstr("ROIAlign")
1487 .addOperand("Result", OperandKind::Out)
1488 .addOperand("FeatureMap", OperandKind::In)
1489 .addOperand("Boxes", OperandKind::In)
1490 .addOperand("BatchIndices", OperandKind::In)
1491 .addMember(MemberType::Enum, "Mode")
1492 .addMember(MemberType::Unsigned, "OutputHeight")
1493 .addMember(MemberType::Unsigned, "OutputWidth")
1494 .addMember(MemberType::Unsigned, "SamplingRatio")
1495 .addMember(MemberType::Float, "SpatialScale")
1496 .addMember(MemberType::Boolean, "Aligned")
1497 .addMember(MemberType::Boolean, "Rotated")
1498 .autoVerify(VerifyKind::SameElementType, {"FeatureMap", "Boxes"})
1499 .autoIRGen();
1500
1501 BB.newInstr("BBoxTransform")
1502 .addOperand("BoxOut", OperandKind::Out)
1503 .addOperand("RoiBatchSplits", OperandKind::Out)
1504 .addOperand("Rois", OperandKind::In)
1505 .addOperand("Deltas", OperandKind::In)
1506 .addOperand("ImInfo", OperandKind::In)
1507 .addMember(MemberType::VectorFloat, "Weights")
1508 .addMember(MemberType::Boolean, "ApplyScale")
1509 .addMember(MemberType::Boolean, "Rotated")
1510 .addMember(MemberType::Boolean, "AngleBoundOn")
1511 .addMember(MemberType::Int64, "AngleBoundLo")
1512 .addMember(MemberType::Int64, "AngleBoundHi")
1513 .addMember(MemberType::Float, "ClipAngleThresh")
1514 .addMember(MemberType::Boolean, "LegacyPlusOne")
1515 .autoVerify(VerifyKind::SameElementType, {"Rois", "Deltas"})
1516 .autoVerify(VerifyKind::SameElementType, {"Rois", "ImInfo"})
1517 .autoIRGen();
1518
1519 BB.newInstr("CollectRpnProposals")
1520 .addOperand("Result", OperandKind::Out)
1521 .addMember(MemberType::Int64, "RpnMaxLevel")
1522 .addMember(MemberType::Int64, "RpnMinLevel")
1523 .addMember(MemberType::Unsigned, "RpnPostNmsTopN")
1524 .autoVerify(VerifyKind::NoVerify);
1525
1526 //===--------------------------------------------------------------------===//
1527 // Lookup Table Operators
1528 //===--------------------------------------------------------------------===//
1529
1530 BB.newInstr("LookupTable")
1531 .addOperand("Dest", OperandKind::Out)
1532 .addOperand("Src", OperandKind::In)
1533 .addOperand("Table", OperandKind::In)
1534 .addOperand("TableIdx", OperandKind::In)
1535 .addMember(MEMBER_TYPE_INFO(glow::LUTOperator), "Operator")
1536 .addMember(MemberType::VectorFloat, "OperatorArgs")
1537 .dataParallel()
1538 .autoIRGen()
1539 .autoVerify(VerifyKind::NoVerify);
1540
1541 //===--------------------------------------------------------------------===//
1542 // Backend-Specific Instructions
1543 //===--------------------------------------------------------------------===//
1544
1545#include "glow/InstrGenIncludes.h"
1546
1547 return 0;
1548}
1549