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 | |
22 | int 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 (argv[1]); |
35 | std::ofstream cppStream(argv[2]); |
36 | std::ofstream defStream(argv[3]); |
37 | std::ofstream (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 | |