1 | #include "glow/IR/IRBuilder.h" |
2 | #include "glow/IR/IR.h" |
3 | #include "glow/IR/Instrs.h" |
4 | |
5 | using namespace glow; |
6 | |
7 | AllocActivationInst *IRBuilder::createAllocActivationInst(llvm::StringRef name, TypeRef Ty) { |
8 | auto *A = new AllocActivationInst(uniqueName(name), Ty); |
9 | F_->pushInstr(A); |
10 | return A; |
11 | } |
12 | |
13 | TensorViewInst *IRBuilder::createTensorViewInst(llvm::StringRef name, Value *Src, TypeRef Ty, std::vector<dim_t> Offsets) { |
14 | auto *A = new TensorViewInst(uniqueName(name), Src, Ty, Offsets); |
15 | F_->pushInstr(A); |
16 | return A; |
17 | } |
18 | |
19 | DeallocActivationInst *IRBuilder::createDeallocActivationInst(llvm::StringRef name, Value *Src) { |
20 | auto *A = new DeallocActivationInst(uniqueName(name), Src); |
21 | F_->pushInstr(A); |
22 | return A; |
23 | } |
24 | |
25 | CopyInst *IRBuilder::createCopyInst(llvm::StringRef name, Value *Dest, Value *Src) { |
26 | auto *A = new CopyInst(uniqueName(name), Dest, Src); |
27 | F_->pushInstr(A); |
28 | return A; |
29 | } |
30 | |
31 | ConvolutionGradInst *IRBuilder::createConvolutionGradInst(llvm::StringRef name, Value *Src, Value *Filter, Value *DestGrad, Value *SrcGrad, Value *FilterGrad, Value *BiasGrad, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group, std::vector<unsigned_t> Dilation, ConvolutionLayout Layout, glow::FusedActivation FusedActivation, std::vector<float> FusedActivationArgs) { |
32 | auto *A = new ConvolutionGradInst(uniqueName(name), Src, Filter, DestGrad, SrcGrad, FilterGrad, BiasGrad, Kernels, Strides, Pads, Group, Dilation, Layout, FusedActivation, FusedActivationArgs); |
33 | F_->pushInstr(A); |
34 | return A; |
35 | } |
36 | |
37 | ConvolutionInst *IRBuilder::createConvolutionInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Filter, Value *Bias, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group, std::vector<unsigned_t> Dilation, ConvolutionLayout Layout, glow::FusedActivation FusedActivation, std::vector<float> FusedActivationArgs) { |
38 | auto *A = new ConvolutionInst(uniqueName(name), Dest, Src, Filter, Bias, Kernels, Strides, Pads, Group, Dilation, Layout, FusedActivation, FusedActivationArgs); |
39 | F_->pushInstr(A); |
40 | return A; |
41 | } |
42 | |
43 | ChannelwiseQuantizedConvolutionInst *IRBuilder::createChannelwiseQuantizedConvolutionInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Filter, Value *Bias, Value *FilterScales, Value *FilterOffsets, Value *BiasScales, Value *BiasOffsets, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group, std::vector<unsigned_t> Dilation, glow::FusedActivation FusedActivation, std::vector<float> FusedActivationArgs) { |
44 | auto *A = new ChannelwiseQuantizedConvolutionInst(uniqueName(name), Dest, Src, Filter, Bias, FilterScales, FilterOffsets, BiasScales, BiasOffsets, Kernels, Strides, Pads, Group, Dilation, FusedActivation, FusedActivationArgs); |
45 | F_->pushInstr(A); |
46 | return A; |
47 | } |
48 | |
49 | ConvTransposeInst *IRBuilder::createConvTransposeInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Filter, Value *Bias, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group, std::vector<unsigned_t> Dilation) { |
50 | auto *A = new ConvTransposeInst(uniqueName(name), Dest, Src, Filter, Bias, Kernels, Strides, Pads, Group, Dilation); |
51 | F_->pushInstr(A); |
52 | return A; |
53 | } |
54 | |
55 | Convolution3DGradInst *IRBuilder::createConvolution3DGradInst(llvm::StringRef name, Value *Src, Value *Filter, Value *DestGrad, Value *SrcGrad, Value *FilterGrad, Value *BiasGrad, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group) { |
56 | auto *A = new Convolution3DGradInst(uniqueName(name), Src, Filter, DestGrad, SrcGrad, FilterGrad, BiasGrad, Kernels, Strides, Pads, Group); |
57 | F_->pushInstr(A); |
58 | return A; |
59 | } |
60 | |
61 | Convolution3DInst *IRBuilder::createConvolution3DInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Filter, Value *Bias, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group) { |
62 | auto *A = new Convolution3DInst(uniqueName(name), Dest, Src, Filter, Bias, Kernels, Strides, Pads, Group); |
63 | F_->pushInstr(A); |
64 | return A; |
65 | } |
66 | |
67 | BatchNormalizationInst *IRBuilder::createBatchNormalizationInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Scale, Value *Bias, Value *Mean, Value *Var, unsigned_t ChannelIdx, float Epsilon, float Momentum) { |
68 | auto *A = new BatchNormalizationInst(uniqueName(name), Dest, Src, Scale, Bias, Mean, Var, ChannelIdx, Epsilon, Momentum); |
69 | F_->pushInstr(A); |
70 | return A; |
71 | } |
72 | |
73 | MaxPoolWithArgmaxGradInst *IRBuilder::createMaxPoolWithArgmaxGradInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Argmax, Value *DestGrad, Value *SrcGrad, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Layout) { |
74 | auto *A = new MaxPoolWithArgmaxGradInst(uniqueName(name), Dest, Src, Argmax, DestGrad, SrcGrad, Kernels, Strides, Pads, Layout); |
75 | F_->pushInstr(A); |
76 | return A; |
77 | } |
78 | |
79 | MaxPoolWithArgmaxInst *IRBuilder::createMaxPoolWithArgmaxInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Argmax, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Layout) { |
80 | auto *A = new MaxPoolWithArgmaxInst(uniqueName(name), Dest, Src, Argmax, Kernels, Strides, Pads, Layout); |
81 | F_->pushInstr(A); |
82 | return A; |
83 | } |
84 | |
85 | MaxPoolInst *IRBuilder::createMaxPoolInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Layout) { |
86 | auto *A = new MaxPoolInst(uniqueName(name), Dest, Src, Kernels, Strides, Pads, Layout); |
87 | F_->pushInstr(A); |
88 | return A; |
89 | } |
90 | |
91 | AvgPoolGradInst *IRBuilder::createAvgPoolGradInst(llvm::StringRef name, Value *Dest, Value *Src, Value *DestGrad, Value *SrcGrad, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Layout, bool CountIncludePads) { |
92 | auto *A = new AvgPoolGradInst(uniqueName(name), Dest, Src, DestGrad, SrcGrad, Kernels, Strides, Pads, Layout, CountIncludePads); |
93 | F_->pushInstr(A); |
94 | return A; |
95 | } |
96 | |
97 | AvgPoolInst *IRBuilder::createAvgPoolInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Layout, bool CountIncludePads) { |
98 | auto *A = new AvgPoolInst(uniqueName(name), Dest, Src, Kernels, Strides, Pads, Layout, CountIncludePads); |
99 | F_->pushInstr(A); |
100 | return A; |
101 | } |
102 | |
103 | ArgMaxInst *IRBuilder::createArgMaxInst(llvm::StringRef name, Value *Dest, Value *Src, unsigned_t Axis, bool KeepDims) { |
104 | auto *A = new ArgMaxInst(uniqueName(name), Dest, Src, Axis, KeepDims); |
105 | F_->pushInstr(A); |
106 | return A; |
107 | } |
108 | |
109 | ArgMinInst *IRBuilder::createArgMinInst(llvm::StringRef name, Value *Dest, Value *Src, unsigned_t Axis, bool KeepDims) { |
110 | auto *A = new ArgMinInst(uniqueName(name), Dest, Src, Axis, KeepDims); |
111 | F_->pushInstr(A); |
112 | return A; |
113 | } |
114 | |
115 | AdaptiveAvgPoolGradInst *IRBuilder::createAdaptiveAvgPoolGradInst(llvm::StringRef name, Value *Dest, Value *DestGrad, Value *SrcGrad) { |
116 | auto *A = new AdaptiveAvgPoolGradInst(uniqueName(name), Dest, DestGrad, SrcGrad); |
117 | F_->pushInstr(A); |
118 | return A; |
119 | } |
120 | |
121 | AdaptiveAvgPoolInst *IRBuilder::createAdaptiveAvgPoolInst(llvm::StringRef name, Value *Dest, Value *Src) { |
122 | auto *A = new AdaptiveAvgPoolInst(uniqueName(name), Dest, Src); |
123 | F_->pushInstr(A); |
124 | return A; |
125 | } |
126 | |
127 | FullyConnectedInst *IRBuilder::createFullyConnectedInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Weights, Value *Bias) { |
128 | auto *A = new FullyConnectedInst(uniqueName(name), Dest, Src, Weights, Bias); |
129 | F_->pushInstr(A); |
130 | return A; |
131 | } |
132 | |
133 | RowwiseQuantizedFullyConnectedInst *IRBuilder::createRowwiseQuantizedFullyConnectedInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Weights, Value *Bias, Value *Scales, Value *Offsets) { |
134 | auto *A = new RowwiseQuantizedFullyConnectedInst(uniqueName(name), Dest, Src, Weights, Bias, Scales, Offsets); |
135 | F_->pushInstr(A); |
136 | return A; |
137 | } |
138 | |
139 | DynamicQuantizedFullyConnectedInst *IRBuilder::createDynamicQuantizedFullyConnectedInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Weights, Value *Bias, bool IsSymmetric, bool IsPerBatchElement) { |
140 | auto *A = new DynamicQuantizedFullyConnectedInst(uniqueName(name), Dest, Src, Weights, Bias, IsSymmetric, IsPerBatchElement); |
141 | F_->pushInstr(A); |
142 | return A; |
143 | } |
144 | |
145 | DynamicRowwiseQuantizedFullyConnectedInst *IRBuilder::createDynamicRowwiseQuantizedFullyConnectedInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Weights, Value *Bias, Value *Scales, Value *Offsets, bool IsSymmetric, bool IsPerBatchElement) { |
146 | auto *A = new DynamicRowwiseQuantizedFullyConnectedInst(uniqueName(name), Dest, Src, Weights, Bias, Scales, Offsets, IsSymmetric, IsPerBatchElement); |
147 | F_->pushInstr(A); |
148 | return A; |
149 | } |
150 | |
151 | LocalResponseNormalizationGradInst *IRBuilder::createLocalResponseNormalizationGradInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Scale, Value *DestGrad, Value *SrcGrad, unsigned_t HalfWindowSize, float Alpha, float Beta, float K) { |
152 | auto *A = new LocalResponseNormalizationGradInst(uniqueName(name), Dest, Src, Scale, DestGrad, SrcGrad, HalfWindowSize, Alpha, Beta, K); |
153 | F_->pushInstr(A); |
154 | return A; |
155 | } |
156 | |
157 | LocalResponseNormalizationInst *IRBuilder::createLocalResponseNormalizationInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Scale, unsigned_t HalfWindowSize, float Alpha, float Beta, float K) { |
158 | auto *A = new LocalResponseNormalizationInst(uniqueName(name), Dest, Src, Scale, HalfWindowSize, Alpha, Beta, K); |
159 | F_->pushInstr(A); |
160 | return A; |
161 | } |
162 | |
163 | BucketizeInst *IRBuilder::createBucketizeInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<float> Boundaries) { |
164 | auto *A = new BucketizeInst(uniqueName(name), Dest, Src, Boundaries); |
165 | F_->pushInstr(A); |
166 | return A; |
167 | } |
168 | |
169 | LayerNormalizationInst *IRBuilder::createLayerNormalizationInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Scale, Value *Bias, float Epsilon) { |
170 | auto *A = new LayerNormalizationInst(uniqueName(name), Dest, Src, Scale, Bias, Epsilon); |
171 | F_->pushInstr(A); |
172 | return A; |
173 | } |
174 | |
175 | SoftMaxInst *IRBuilder::createSoftMaxInst(llvm::StringRef name, Value *Dest, Value *Src) { |
176 | auto *A = new SoftMaxInst(uniqueName(name), Dest, Src); |
177 | F_->pushInstr(A); |
178 | return A; |
179 | } |
180 | |
181 | SoftMaxGradInst *IRBuilder::createSoftMaxGradInst(llvm::StringRef name, Value *OrigDest, Value *OrigSrc, Value *Selected, Value *SrcGrad) { |
182 | auto *A = new SoftMaxGradInst(uniqueName(name), OrigDest, OrigSrc, Selected, SrcGrad); |
183 | F_->pushInstr(A); |
184 | return A; |
185 | } |
186 | |
187 | LogSoftMaxInst *IRBuilder::createLogSoftMaxInst(llvm::StringRef name, Value *Dest, Value *Src) { |
188 | auto *A = new LogSoftMaxInst(uniqueName(name), Dest, Src); |
189 | F_->pushInstr(A); |
190 | return A; |
191 | } |
192 | |
193 | CrossEntropyLossInst *IRBuilder::createCrossEntropyLossInst(llvm::StringRef name, Value *P, Value *Labels, Value *CE) { |
194 | auto *A = new CrossEntropyLossInst(uniqueName(name), P, Labels, CE); |
195 | F_->pushInstr(A); |
196 | return A; |
197 | } |
198 | |
199 | CrossEntropyLossGradInst *IRBuilder::createCrossEntropyLossGradInst(llvm::StringRef name, Value *CEGrad, Value *P, Value *Labels, Value *Pgrad, Value *Labelsgrad) { |
200 | auto *A = new CrossEntropyLossGradInst(uniqueName(name), CEGrad, P, Labels, Pgrad, Labelsgrad); |
201 | F_->pushInstr(A); |
202 | return A; |
203 | } |
204 | |
205 | MatMulInst *IRBuilder::createMatMulInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
206 | auto *A = new MatMulInst(uniqueName(name), Dest, LHS, RHS); |
207 | F_->pushInstr(A); |
208 | return A; |
209 | } |
210 | |
211 | BatchMatMulInst *IRBuilder::createBatchMatMulInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
212 | auto *A = new BatchMatMulInst(uniqueName(name), Dest, LHS, RHS); |
213 | F_->pushInstr(A); |
214 | return A; |
215 | } |
216 | |
217 | BatchedReduceAddInst *IRBuilder::createBatchedReduceAddInst(llvm::StringRef name, Value *Dest, Value *Batch, unsigned_t Axis) { |
218 | auto *A = new BatchedReduceAddInst(uniqueName(name), Dest, Batch, Axis); |
219 | F_->pushInstr(A); |
220 | return A; |
221 | } |
222 | |
223 | BatchedReduceMinInst *IRBuilder::createBatchedReduceMinInst(llvm::StringRef name, Value *Dest, Value *Batch, std::vector<unsigned_t> Axes) { |
224 | auto *A = new BatchedReduceMinInst(uniqueName(name), Dest, Batch, Axes); |
225 | F_->pushInstr(A); |
226 | return A; |
227 | } |
228 | |
229 | BatchedReduceMaxInst *IRBuilder::createBatchedReduceMaxInst(llvm::StringRef name, Value *Dest, Value *Batch, std::vector<unsigned_t> Axes) { |
230 | auto *A = new BatchedReduceMaxInst(uniqueName(name), Dest, Batch, Axes); |
231 | F_->pushInstr(A); |
232 | return A; |
233 | } |
234 | |
235 | BatchedReduceProdInst *IRBuilder::createBatchedReduceProdInst(llvm::StringRef name, Value *Dest, Value *Batch, unsigned_t Axis) { |
236 | auto *A = new BatchedReduceProdInst(uniqueName(name), Dest, Batch, Axis); |
237 | F_->pushInstr(A); |
238 | return A; |
239 | } |
240 | |
241 | CumSumInst *IRBuilder::createCumSumInst(llvm::StringRef name, Value *Dest, Value *Input, int64_t Dim, unsigned_t Exclusive, unsigned_t Reverse) { |
242 | auto *A = new CumSumInst(uniqueName(name), Dest, Input, Dim, Exclusive, Reverse); |
243 | F_->pushInstr(A); |
244 | return A; |
245 | } |
246 | |
247 | LengthsSumInst *IRBuilder::createLengthsSumInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Lengths) { |
248 | auto *A = new LengthsSumInst(uniqueName(name), Dest, Data, Lengths); |
249 | F_->pushInstr(A); |
250 | return A; |
251 | } |
252 | |
253 | SparseLengthsSumGradInst *IRBuilder::createSparseLengthsSumGradInst(llvm::StringRef name, Value *Data, Value *Indices, Value *Lengths, Value *DestGrad, Value *DataGrad, glow::LengthsMode LengthsMode, float AvgLength) { |
254 | auto *A = new SparseLengthsSumGradInst(uniqueName(name), Data, Indices, Lengths, DestGrad, DataGrad, LengthsMode, AvgLength); |
255 | F_->pushInstr(A); |
256 | return A; |
257 | } |
258 | |
259 | SparseLengthsSumInst *IRBuilder::createSparseLengthsSumInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Indices, Value *Lengths, glow::LengthsMode LengthsMode, float AvgLength) { |
260 | auto *A = new SparseLengthsSumInst(uniqueName(name), Dest, Data, Indices, Lengths, LengthsMode, AvgLength); |
261 | F_->pushInstr(A); |
262 | return A; |
263 | } |
264 | |
265 | SparseLengthsWeightedSumGradInst *IRBuilder::createSparseLengthsWeightedSumGradInst(llvm::StringRef name, Value *Data, Value *Weights, Value *Indices, Value *Lengths, Value *DestGrad, Value *DataGrad, Value *WeightsGrad, glow::LengthsMode LengthsMode, float AvgLength) { |
266 | auto *A = new SparseLengthsWeightedSumGradInst(uniqueName(name), Data, Weights, Indices, Lengths, DestGrad, DataGrad, WeightsGrad, LengthsMode, AvgLength); |
267 | F_->pushInstr(A); |
268 | return A; |
269 | } |
270 | |
271 | SparseLengthsWeightedSumInst *IRBuilder::createSparseLengthsWeightedSumInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Weights, Value *Indices, Value *Lengths, glow::LengthsMode LengthsMode, float AvgLength) { |
272 | auto *A = new SparseLengthsWeightedSumInst(uniqueName(name), Dest, Data, Weights, Indices, Lengths, LengthsMode, AvgLength); |
273 | F_->pushInstr(A); |
274 | return A; |
275 | } |
276 | |
277 | EmbeddingInst *IRBuilder::createEmbeddingInst(llvm::StringRef name, Value *Dest, Value *Weights, Value *Indices, int64_t PadIdx, bool Scale, bool Sparse) { |
278 | auto *A = new EmbeddingInst(uniqueName(name), Dest, Weights, Indices, PadIdx, Scale, Sparse); |
279 | F_->pushInstr(A); |
280 | return A; |
281 | } |
282 | |
283 | EmbeddingBagInst *IRBuilder::createEmbeddingBagInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Weights, Value *Indices, Value *Offsets, bool HasEndOffset, glow::LengthsMode LengthsMode, float AvgLength) { |
284 | auto *A = new EmbeddingBagInst(uniqueName(name), Dest, Data, Weights, Indices, Offsets, HasEndOffset, LengthsMode, AvgLength); |
285 | F_->pushInstr(A); |
286 | return A; |
287 | } |
288 | |
289 | RowwiseQuantizedSparseLengthsWeightedSumInst *IRBuilder::createRowwiseQuantizedSparseLengthsWeightedSumInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Scales, Value *Offsets, Value *Weights, Value *Indices, Value *Lengths, bool UseFP16Accumulation, glow::LengthsMode LengthsMode, float AvgLength) { |
290 | auto *A = new RowwiseQuantizedSparseLengthsWeightedSumInst(uniqueName(name), Dest, Data, Scales, Offsets, Weights, Indices, Lengths, UseFP16Accumulation, LengthsMode, AvgLength); |
291 | F_->pushInstr(A); |
292 | return A; |
293 | } |
294 | |
295 | FusedRowwiseQuantizedSparseLengthsWeightedSumInst *IRBuilder::createFusedRowwiseQuantizedSparseLengthsWeightedSumInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Weights, Value *Indices, Value *Lengths, bool UseFP16Accumulation, glow::LengthsMode LengthsMode, float AvgLength) { |
296 | auto *A = new FusedRowwiseQuantizedSparseLengthsWeightedSumInst(uniqueName(name), Dest, Data, Weights, Indices, Lengths, UseFP16Accumulation, LengthsMode, AvgLength); |
297 | F_->pushInstr(A); |
298 | return A; |
299 | } |
300 | |
301 | FusedRowwiseQuantizedSparseLengthsSumInst *IRBuilder::createFusedRowwiseQuantizedSparseLengthsSumInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Indices, Value *Lengths, bool UseFP16Accumulation, glow::LengthsMode LengthsMode, float AvgLength) { |
302 | auto *A = new FusedRowwiseQuantizedSparseLengthsSumInst(uniqueName(name), Dest, Data, Indices, Lengths, UseFP16Accumulation, LengthsMode, AvgLength); |
303 | F_->pushInstr(A); |
304 | return A; |
305 | } |
306 | |
307 | EmbeddingBagByteRowwiseOffsetsInst *IRBuilder::createEmbeddingBagByteRowwiseOffsetsInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Weights, Value *Indices, Value *Offsets, bool UseFP16Accumulation, bool HasEndOffset, glow::LengthsMode LengthsMode, float AvgLength) { |
308 | auto *A = new EmbeddingBagByteRowwiseOffsetsInst(uniqueName(name), Dest, Data, Weights, Indices, Offsets, UseFP16Accumulation, HasEndOffset, LengthsMode, AvgLength); |
309 | F_->pushInstr(A); |
310 | return A; |
311 | } |
312 | |
313 | LengthsToRangesInst *IRBuilder::createLengthsToRangesInst(llvm::StringRef name, Value *Dest, Value *Lengths) { |
314 | auto *A = new LengthsToRangesInst(uniqueName(name), Dest, Lengths); |
315 | F_->pushInstr(A); |
316 | return A; |
317 | } |
318 | |
319 | LengthsRangeFillInst *IRBuilder::createLengthsRangeFillInst(llvm::StringRef name, Value *Dest, Value *Lengths) { |
320 | auto *A = new LengthsRangeFillInst(uniqueName(name), Dest, Lengths); |
321 | F_->pushInstr(A); |
322 | return A; |
323 | } |
324 | |
325 | BatchSparseToDenseInst *IRBuilder::createBatchSparseToDenseInst(llvm::StringRef name, Value *Dest, Value *Lengths, Value *Indices, Value *Values, float DefaultValue, unsigned_t DenseLastDim) { |
326 | auto *A = new BatchSparseToDenseInst(uniqueName(name), Dest, Lengths, Indices, Values, DefaultValue, DenseLastDim); |
327 | F_->pushInstr(A); |
328 | return A; |
329 | } |
330 | |
331 | FillExamplesWithIndicatorInst *IRBuilder::createFillExamplesWithIndicatorInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Indicator) { |
332 | auto *A = new FillExamplesWithIndicatorInst(uniqueName(name), Dest, Data, Indicator); |
333 | F_->pushInstr(A); |
334 | return A; |
335 | } |
336 | |
337 | SparseToDenseMaskInst *IRBuilder::createSparseToDenseMaskInst(llvm::StringRef name, Value *Dest, Value *Indices, Value *Values, Value *DefaultValue, Value *Lengths, std::vector<dim_t> Mask) { |
338 | auto *A = new SparseToDenseMaskInst(uniqueName(name), Dest, Indices, Values, DefaultValue, Lengths, Mask); |
339 | F_->pushInstr(A); |
340 | return A; |
341 | } |
342 | |
343 | BatchedAddInst *IRBuilder::createBatchedAddInst(llvm::StringRef name, Value *Dest, Value *Batch, Value *Slice) { |
344 | auto *A = new BatchedAddInst(uniqueName(name), Dest, Batch, Slice); |
345 | F_->pushInstr(A); |
346 | return A; |
347 | } |
348 | |
349 | ElementAddInst *IRBuilder::createElementAddInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
350 | auto *A = new ElementAddInst(uniqueName(name), Dest, LHS, RHS); |
351 | F_->pushInstr(A); |
352 | return A; |
353 | } |
354 | |
355 | ElementSubInst *IRBuilder::createElementSubInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
356 | auto *A = new ElementSubInst(uniqueName(name), Dest, LHS, RHS); |
357 | F_->pushInstr(A); |
358 | return A; |
359 | } |
360 | |
361 | ElementMulInst *IRBuilder::createElementMulInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
362 | auto *A = new ElementMulInst(uniqueName(name), Dest, LHS, RHS); |
363 | F_->pushInstr(A); |
364 | return A; |
365 | } |
366 | |
367 | ElementDivInst *IRBuilder::createElementDivInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
368 | auto *A = new ElementDivInst(uniqueName(name), Dest, LHS, RHS); |
369 | F_->pushInstr(A); |
370 | return A; |
371 | } |
372 | |
373 | ElementFmodInst *IRBuilder::createElementFmodInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
374 | auto *A = new ElementFmodInst(uniqueName(name), Dest, LHS, RHS); |
375 | F_->pushInstr(A); |
376 | return A; |
377 | } |
378 | |
379 | ElementMaxInst *IRBuilder::createElementMaxInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
380 | auto *A = new ElementMaxInst(uniqueName(name), Dest, LHS, RHS); |
381 | F_->pushInstr(A); |
382 | return A; |
383 | } |
384 | |
385 | ElementMinInst *IRBuilder::createElementMinInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
386 | auto *A = new ElementMinInst(uniqueName(name), Dest, LHS, RHS); |
387 | F_->pushInstr(A); |
388 | return A; |
389 | } |
390 | |
391 | ElementCmpEQInst *IRBuilder::createElementCmpEQInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
392 | auto *A = new ElementCmpEQInst(uniqueName(name), Dest, LHS, RHS); |
393 | F_->pushInstr(A); |
394 | return A; |
395 | } |
396 | |
397 | ElementCmpNEQInst *IRBuilder::createElementCmpNEQInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
398 | auto *A = new ElementCmpNEQInst(uniqueName(name), Dest, LHS, RHS); |
399 | F_->pushInstr(A); |
400 | return A; |
401 | } |
402 | |
403 | ElementCmpLTInst *IRBuilder::createElementCmpLTInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
404 | auto *A = new ElementCmpLTInst(uniqueName(name), Dest, LHS, RHS); |
405 | F_->pushInstr(A); |
406 | return A; |
407 | } |
408 | |
409 | ElementCmpLTEInst *IRBuilder::createElementCmpLTEInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
410 | auto *A = new ElementCmpLTEInst(uniqueName(name), Dest, LHS, RHS); |
411 | F_->pushInstr(A); |
412 | return A; |
413 | } |
414 | |
415 | ElementIsNaNInst *IRBuilder::createElementIsNaNInst(llvm::StringRef name, Value *Dest, Value *Src) { |
416 | auto *A = new ElementIsNaNInst(uniqueName(name), Dest, Src); |
417 | F_->pushInstr(A); |
418 | return A; |
419 | } |
420 | |
421 | ElementPowInst *IRBuilder::createElementPowInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
422 | auto *A = new ElementPowInst(uniqueName(name), Dest, LHS, RHS); |
423 | F_->pushInstr(A); |
424 | return A; |
425 | } |
426 | |
427 | ElementAndInst *IRBuilder::createElementAndInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
428 | auto *A = new ElementAndInst(uniqueName(name), Dest, LHS, RHS); |
429 | F_->pushInstr(A); |
430 | return A; |
431 | } |
432 | |
433 | ElementBitwiseAndInst *IRBuilder::createElementBitwiseAndInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
434 | auto *A = new ElementBitwiseAndInst(uniqueName(name), Dest, LHS, RHS); |
435 | F_->pushInstr(A); |
436 | return A; |
437 | } |
438 | |
439 | ElementOrInst *IRBuilder::createElementOrInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
440 | auto *A = new ElementOrInst(uniqueName(name), Dest, LHS, RHS); |
441 | F_->pushInstr(A); |
442 | return A; |
443 | } |
444 | |
445 | ElementBitwiseOrInst *IRBuilder::createElementBitwiseOrInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
446 | auto *A = new ElementBitwiseOrInst(uniqueName(name), Dest, LHS, RHS); |
447 | F_->pushInstr(A); |
448 | return A; |
449 | } |
450 | |
451 | ElementXorInst *IRBuilder::createElementXorInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
452 | auto *A = new ElementXorInst(uniqueName(name), Dest, LHS, RHS); |
453 | F_->pushInstr(A); |
454 | return A; |
455 | } |
456 | |
457 | ElementBitwiseXorInst *IRBuilder::createElementBitwiseXorInst(llvm::StringRef name, Value *Dest, Value *LHS, Value *RHS) { |
458 | auto *A = new ElementBitwiseXorInst(uniqueName(name), Dest, LHS, RHS); |
459 | F_->pushInstr(A); |
460 | return A; |
461 | } |
462 | |
463 | ElementNotInst *IRBuilder::createElementNotInst(llvm::StringRef name, Value *Dest, Value *Src) { |
464 | auto *A = new ElementNotInst(uniqueName(name), Dest, Src); |
465 | F_->pushInstr(A); |
466 | return A; |
467 | } |
468 | |
469 | ElementBitwiseNotInst *IRBuilder::createElementBitwiseNotInst(llvm::StringRef name, Value *Dest, Value *Src) { |
470 | auto *A = new ElementBitwiseNotInst(uniqueName(name), Dest, Src); |
471 | F_->pushInstr(A); |
472 | return A; |
473 | } |
474 | |
475 | ElementNegInst *IRBuilder::createElementNegInst(llvm::StringRef name, Value *Dest, Value *Src) { |
476 | auto *A = new ElementNegInst(uniqueName(name), Dest, Src); |
477 | F_->pushInstr(A); |
478 | return A; |
479 | } |
480 | |
481 | ElementAbsInst *IRBuilder::createElementAbsInst(llvm::StringRef name, Value *Dest, Value *Src) { |
482 | auto *A = new ElementAbsInst(uniqueName(name), Dest, Src); |
483 | F_->pushInstr(A); |
484 | return A; |
485 | } |
486 | |
487 | ElementFloorInst *IRBuilder::createElementFloorInst(llvm::StringRef name, Value *Dest, Value *Src) { |
488 | auto *A = new ElementFloorInst(uniqueName(name), Dest, Src); |
489 | F_->pushInstr(A); |
490 | return A; |
491 | } |
492 | |
493 | ElementSignInst *IRBuilder::createElementSignInst(llvm::StringRef name, Value *Dest, Value *Src) { |
494 | auto *A = new ElementSignInst(uniqueName(name), Dest, Src); |
495 | F_->pushInstr(A); |
496 | return A; |
497 | } |
498 | |
499 | ElementCeilInst *IRBuilder::createElementCeilInst(llvm::StringRef name, Value *Dest, Value *Src) { |
500 | auto *A = new ElementCeilInst(uniqueName(name), Dest, Src); |
501 | F_->pushInstr(A); |
502 | return A; |
503 | } |
504 | |
505 | ElementTruncateInst *IRBuilder::createElementTruncateInst(llvm::StringRef name, Value *Dest, Value *Src) { |
506 | auto *A = new ElementTruncateInst(uniqueName(name), Dest, Src); |
507 | F_->pushInstr(A); |
508 | return A; |
509 | } |
510 | |
511 | ElementRoundInst *IRBuilder::createElementRoundInst(llvm::StringRef name, Value *Dest, Value *Src) { |
512 | auto *A = new ElementRoundInst(uniqueName(name), Dest, Src); |
513 | F_->pushInstr(A); |
514 | return A; |
515 | } |
516 | |
517 | ElementSqrtInst *IRBuilder::createElementSqrtInst(llvm::StringRef name, Value *Dest, Value *Src) { |
518 | auto *A = new ElementSqrtInst(uniqueName(name), Dest, Src); |
519 | F_->pushInstr(A); |
520 | return A; |
521 | } |
522 | |
523 | ElementRsqrtInst *IRBuilder::createElementRsqrtInst(llvm::StringRef name, Value *Dest, Value *Src) { |
524 | auto *A = new ElementRsqrtInst(uniqueName(name), Dest, Src); |
525 | F_->pushInstr(A); |
526 | return A; |
527 | } |
528 | |
529 | ElementReciprocalInst *IRBuilder::createElementReciprocalInst(llvm::StringRef name, Value *Dest, Value *Src) { |
530 | auto *A = new ElementReciprocalInst(uniqueName(name), Dest, Src); |
531 | F_->pushInstr(A); |
532 | return A; |
533 | } |
534 | |
535 | ElementSinInst *IRBuilder::createElementSinInst(llvm::StringRef name, Value *Dest, Value *Src) { |
536 | auto *A = new ElementSinInst(uniqueName(name), Dest, Src); |
537 | F_->pushInstr(A); |
538 | return A; |
539 | } |
540 | |
541 | ElementCosInst *IRBuilder::createElementCosInst(llvm::StringRef name, Value *Dest, Value *Src) { |
542 | auto *A = new ElementCosInst(uniqueName(name), Dest, Src); |
543 | F_->pushInstr(A); |
544 | return A; |
545 | } |
546 | |
547 | ElementLogInst *IRBuilder::createElementLogInst(llvm::StringRef name, Value *Dest, Value *Src) { |
548 | auto *A = new ElementLogInst(uniqueName(name), Dest, Src); |
549 | F_->pushInstr(A); |
550 | return A; |
551 | } |
552 | |
553 | ElementExpInst *IRBuilder::createElementExpInst(llvm::StringRef name, Value *Dest, Value *Src) { |
554 | auto *A = new ElementExpInst(uniqueName(name), Dest, Src); |
555 | F_->pushInstr(A); |
556 | return A; |
557 | } |
558 | |
559 | ElementAcosInst *IRBuilder::createElementAcosInst(llvm::StringRef name, Value *Dest, Value *Src) { |
560 | auto *A = new ElementAcosInst(uniqueName(name), Dest, Src); |
561 | F_->pushInstr(A); |
562 | return A; |
563 | } |
564 | |
565 | ElementAsinInst *IRBuilder::createElementAsinInst(llvm::StringRef name, Value *Dest, Value *Src) { |
566 | auto *A = new ElementAsinInst(uniqueName(name), Dest, Src); |
567 | F_->pushInstr(A); |
568 | return A; |
569 | } |
570 | |
571 | ElementAtanInst *IRBuilder::createElementAtanInst(llvm::StringRef name, Value *Dest, Value *Src) { |
572 | auto *A = new ElementAtanInst(uniqueName(name), Dest, Src); |
573 | F_->pushInstr(A); |
574 | return A; |
575 | } |
576 | |
577 | ElementErfInst *IRBuilder::createElementErfInst(llvm::StringRef name, Value *Dest, Value *Src) { |
578 | auto *A = new ElementErfInst(uniqueName(name), Dest, Src); |
579 | F_->pushInstr(A); |
580 | return A; |
581 | } |
582 | |
583 | NonZeroInst *IRBuilder::createNonZeroInst(llvm::StringRef name, Value *Dest, Value *Cond) { |
584 | auto *A = new NonZeroInst(uniqueName(name), Dest, Cond); |
585 | F_->pushInstr(A); |
586 | return A; |
587 | } |
588 | |
589 | ElementSelectInst *IRBuilder::createElementSelectInst(llvm::StringRef name, Value *Dest, Value *Cond, Value *LHS, Value *RHS) { |
590 | auto *A = new ElementSelectInst(uniqueName(name), Dest, Cond, LHS, RHS); |
591 | F_->pushInstr(A); |
592 | return A; |
593 | } |
594 | |
595 | ModuloInst *IRBuilder::createModuloInst(llvm::StringRef name, Value *Dest, Value *Src, int64_t Divisor, bool SignFollowDivisor) { |
596 | auto *A = new ModuloInst(uniqueName(name), Dest, Src, Divisor, SignFollowDivisor); |
597 | F_->pushInstr(A); |
598 | return A; |
599 | } |
600 | |
601 | BatchedPairwiseDotProductInst *IRBuilder::createBatchedPairwiseDotProductInst(llvm::StringRef name, Value *Dest, unsigned_t NumInputs, unsigned_t VectorSize) { |
602 | auto *A = new BatchedPairwiseDotProductInst(uniqueName(name), Dest, NumInputs, VectorSize); |
603 | F_->pushInstr(A); |
604 | return A; |
605 | } |
606 | |
607 | BatchedPairwiseDotProductGradInst *IRBuilder::createBatchedPairwiseDotProductGradInst(llvm::StringRef name, Value *DestGrad, unsigned_t NumInputs, unsigned_t VectorSize) { |
608 | auto *A = new BatchedPairwiseDotProductGradInst(uniqueName(name), DestGrad, NumInputs, VectorSize); |
609 | F_->pushInstr(A); |
610 | return A; |
611 | } |
612 | |
613 | BatchedUnaryEmbeddingsBagsInst *IRBuilder::createBatchedUnaryEmbeddingsBagsInst(llvm::StringRef name, Value *Dest, Value *Weights, Value *TableOffsets, Value *Offsets, Value *Indices) { |
614 | auto *A = new BatchedUnaryEmbeddingsBagsInst(uniqueName(name), Dest, Weights, TableOffsets, Offsets, Indices); |
615 | F_->pushInstr(A); |
616 | return A; |
617 | } |
618 | |
619 | IntNBitSplitEmbeddingBagsInst *IRBuilder::createIntNBitSplitEmbeddingBagsInst(llvm::StringRef name, Value *Dest, Value *DevWeights, Value *UvmWeights, Value *WeightsPlacements, Value *WeightsOffsets, Value *WeightsTys, Value *DimOffsets, Value *Indices, Value *Offsets, int64_t TotalDims, glow::SplitEmbeddingPoolingMode PoolingMode, glow::SplitEmbeddingSparseType OutputDType) { |
620 | auto *A = new IntNBitSplitEmbeddingBagsInst(uniqueName(name), Dest, DevWeights, UvmWeights, WeightsPlacements, WeightsOffsets, WeightsTys, DimOffsets, Indices, Offsets, TotalDims, PoolingMode, OutputDType); |
621 | F_->pushInstr(A); |
622 | return A; |
623 | } |
624 | |
625 | IntNBitSplitEmbeddingWeightedBagsInst *IRBuilder::createIntNBitSplitEmbeddingWeightedBagsInst(llvm::StringRef name, Value *Dest, Value *DevWeights, Value *UvmWeights, Value *WeightsPlacements, Value *WeightsOffsets, Value *WeightsTys, Value *DimOffsets, Value *Indices, Value *Offsets, Value *IndiceWeight, int64_t TotalDims, int64_t PoolingMode, int64_t OutputDType) { |
626 | auto *A = new IntNBitSplitEmbeddingWeightedBagsInst(uniqueName(name), Dest, DevWeights, UvmWeights, WeightsPlacements, WeightsOffsets, WeightsTys, DimOffsets, Indices, Offsets, IndiceWeight, TotalDims, PoolingMode, OutputDType); |
627 | F_->pushInstr(A); |
628 | return A; |
629 | } |
630 | |
631 | GaussianFillInst *IRBuilder::createGaussianFillInst(llvm::StringRef name, Value *Dest, Value *Input, float Mean, float Scale, float Seed) { |
632 | auto *A = new GaussianFillInst(uniqueName(name), Dest, Input, Mean, Scale, Seed); |
633 | F_->pushInstr(A); |
634 | return A; |
635 | } |
636 | |
637 | ReluGradInst *IRBuilder::createReluGradInst(llvm::StringRef name, Value *Dest, Value *DestGrad, Value *SrcGrad) { |
638 | auto *A = new ReluGradInst(uniqueName(name), Dest, DestGrad, SrcGrad); |
639 | F_->pushInstr(A); |
640 | return A; |
641 | } |
642 | |
643 | ReluInst *IRBuilder::createReluInst(llvm::StringRef name, Value *Dest, Value *Src) { |
644 | auto *A = new ReluInst(uniqueName(name), Dest, Src); |
645 | F_->pushInstr(A); |
646 | return A; |
647 | } |
648 | |
649 | ClipInst *IRBuilder::createClipInst(llvm::StringRef name, Value *Dest, Value *Src, float Min, float Max) { |
650 | auto *A = new ClipInst(uniqueName(name), Dest, Src, Min, Max); |
651 | F_->pushInstr(A); |
652 | return A; |
653 | } |
654 | |
655 | SigmoidInst *IRBuilder::createSigmoidInst(llvm::StringRef name, Value *Dest, Value *Src) { |
656 | auto *A = new SigmoidInst(uniqueName(name), Dest, Src); |
657 | F_->pushInstr(A); |
658 | return A; |
659 | } |
660 | |
661 | TanhInst *IRBuilder::createTanhInst(llvm::StringRef name, Value *Dest, Value *Src) { |
662 | auto *A = new TanhInst(uniqueName(name), Dest, Src); |
663 | F_->pushInstr(A); |
664 | return A; |
665 | } |
666 | |
667 | LeakyReluInst *IRBuilder::createLeakyReluInst(llvm::StringRef name, Value *Dest, Value *Src, float Alpha) { |
668 | auto *A = new LeakyReluInst(uniqueName(name), Dest, Src, Alpha); |
669 | F_->pushInstr(A); |
670 | return A; |
671 | } |
672 | |
673 | SoftPlusInst *IRBuilder::createSoftPlusInst(llvm::StringRef name, Value *Dest, Value *Src) { |
674 | auto *A = new SoftPlusInst(uniqueName(name), Dest, Src); |
675 | F_->pushInstr(A); |
676 | return A; |
677 | } |
678 | |
679 | TransposeInst *IRBuilder::createTransposeInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<unsigned_t> Shuffle) { |
680 | auto *A = new TransposeInst(uniqueName(name), Dest, Src, Shuffle); |
681 | F_->pushInstr(A); |
682 | return A; |
683 | } |
684 | |
685 | ConcatInst *IRBuilder::createConcatInst(llvm::StringRef name, Value *Dest, unsigned_t Axis) { |
686 | auto *A = new ConcatInst(uniqueName(name), Dest, Axis); |
687 | F_->pushInstr(A); |
688 | return A; |
689 | } |
690 | |
691 | SplatInst *IRBuilder::createSplatInst(llvm::StringRef name, Value *Dest, float Value) { |
692 | auto *A = new SplatInst(uniqueName(name), Dest, Value); |
693 | F_->pushInstr(A); |
694 | return A; |
695 | } |
696 | |
697 | TouchInst *IRBuilder::createTouchInst(llvm::StringRef name, Value *Dest) { |
698 | auto *A = new TouchInst(uniqueName(name), Dest); |
699 | F_->pushInstr(A); |
700 | return A; |
701 | } |
702 | |
703 | InsertTensorInst *IRBuilder::createInsertTensorInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<dim_t> Offsets, unsigned_t Count, unsigned_t Axis) { |
704 | auto *A = new InsertTensorInst(uniqueName(name), Dest, Src, Offsets, Count, Axis); |
705 | F_->pushInstr(A); |
706 | return A; |
707 | } |
708 | |
709 | ExtractTensorInst *IRBuilder::(llvm::StringRef name, Value *Dest, Value *Src, std::vector<dim_t> Offsets) { |
710 | auto *A = new ExtractTensorInst(uniqueName(name), Dest, Src, Offsets); |
711 | F_->pushInstr(A); |
712 | return A; |
713 | } |
714 | |
715 | GatherInst *IRBuilder::createGatherInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Indices, unsigned_t BatchDims) { |
716 | auto *A = new GatherInst(uniqueName(name), Dest, Data, Indices, BatchDims); |
717 | F_->pushInstr(A); |
718 | return A; |
719 | } |
720 | |
721 | GatherNDInst *IRBuilder::createGatherNDInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Indices, unsigned_t BatchDims) { |
722 | auto *A = new GatherNDInst(uniqueName(name), Dest, Data, Indices, BatchDims); |
723 | F_->pushInstr(A); |
724 | return A; |
725 | } |
726 | |
727 | GatherElementsInst *IRBuilder::createGatherElementsInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Indices, unsigned_t Dim) { |
728 | auto *A = new GatherElementsInst(uniqueName(name), Dest, Data, Indices, Dim); |
729 | F_->pushInstr(A); |
730 | return A; |
731 | } |
732 | |
733 | GatherRangesInst *IRBuilder::createGatherRangesInst(llvm::StringRef name, Value *Output, Value *Lengths, Value *Data, Value *Ranges) { |
734 | auto *A = new GatherRangesInst(uniqueName(name), Output, Lengths, Data, Ranges); |
735 | F_->pushInstr(A); |
736 | return A; |
737 | } |
738 | |
739 | ScatterDataInst *IRBuilder::createScatterDataInst(llvm::StringRef name, Value *Data, Value *Indices, Value *Slices, bool Cumulative) { |
740 | auto *A = new ScatterDataInst(uniqueName(name), Data, Indices, Slices, Cumulative); |
741 | F_->pushInstr(A); |
742 | return A; |
743 | } |
744 | |
745 | BatchOneHotInst *IRBuilder::createBatchOneHotInst(llvm::StringRef name, Value *Dest, Value *Data, Value *Lengths, Value *Values) { |
746 | auto *A = new BatchOneHotInst(uniqueName(name), Dest, Data, Lengths, Values); |
747 | F_->pushInstr(A); |
748 | return A; |
749 | } |
750 | |
751 | SpaceToDepthInst *IRBuilder::createSpaceToDepthInst(llvm::StringRef name, Value *Dest, Value *Src, unsigned_t BlockSize) { |
752 | auto *A = new SpaceToDepthInst(uniqueName(name), Dest, Src, BlockSize); |
753 | F_->pushInstr(A); |
754 | return A; |
755 | } |
756 | |
757 | ResizeNearestInst *IRBuilder::createResizeNearestInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<float> Scale) { |
758 | auto *A = new ResizeNearestInst(uniqueName(name), Dest, Src, Scale); |
759 | F_->pushInstr(A); |
760 | return A; |
761 | } |
762 | |
763 | ResizeBilinearInst *IRBuilder::createResizeBilinearInst(llvm::StringRef name, Value *Dest, Value *Src, std::vector<float> Scale) { |
764 | auto *A = new ResizeBilinearInst(uniqueName(name), Dest, Src, Scale); |
765 | F_->pushInstr(A); |
766 | return A; |
767 | } |
768 | |
769 | SparseLabelSplitInst *IRBuilder::createSparseLabelSplitInst(llvm::StringRef name, Value *LabelValues, Value *ExampleIds, Value *GradientOffsetMap, Value *Lengths, Value *Indices, Value *Values, unsigned_t NumLabels) { |
770 | auto *A = new SparseLabelSplitInst(uniqueName(name), LabelValues, ExampleIds, GradientOffsetMap, Lengths, Indices, Values, NumLabels); |
771 | F_->pushInstr(A); |
772 | return A; |
773 | } |
774 | |
775 | FlipInst *IRBuilder::createFlipInst(llvm::StringRef name, Value *Dest, Value *Src, unsigned_t Axis) { |
776 | auto *A = new FlipInst(uniqueName(name), Dest, Src, Axis); |
777 | F_->pushInstr(A); |
778 | return A; |
779 | } |
780 | |
781 | DebugPrintInst *IRBuilder::createDebugPrintInst(llvm::StringRef name, Value *Src, std::string Format, std::string FileName) { |
782 | auto *A = new DebugPrintInst(uniqueName(name), Src, Format, FileName); |
783 | F_->pushInstr(A); |
784 | return A; |
785 | } |
786 | |
787 | TraceEventInst *IRBuilder::createTraceEventInst(llvm::StringRef name, Value *Data, unsigned_t Index) { |
788 | auto *A = new TraceEventInst(uniqueName(name), Data, Index); |
789 | F_->pushInstr(A); |
790 | return A; |
791 | } |
792 | |
793 | InstrumentInst *IRBuilder::createInstrumentInst(llvm::StringRef name, Value *OperandsInfo, glow::Instruction * InstrRef, unsigned_t ID, glow::InstrumentKind InstrumentKind) { |
794 | auto *A = new InstrumentInst(uniqueName(name), OperandsInfo, InstrRef, ID, InstrumentKind); |
795 | F_->pushInstr(A); |
796 | return A; |
797 | } |
798 | |
799 | QuantizationProfileInst *IRBuilder::createQuantizationProfileInst(llvm::StringRef name, Value *InputTensor, Value *Histogram, Value *ComputationInfo) { |
800 | auto *A = new QuantizationProfileInst(uniqueName(name), InputTensor, Histogram, ComputationInfo); |
801 | F_->pushInstr(A); |
802 | return A; |
803 | } |
804 | |
805 | IntLookupTableInst *IRBuilder::createIntLookupTableInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Mapping) { |
806 | auto *A = new IntLookupTableInst(uniqueName(name), Dest, Src, Mapping); |
807 | F_->pushInstr(A); |
808 | return A; |
809 | } |
810 | |
811 | QuantizeInst *IRBuilder::createQuantizeInst(llvm::StringRef name, Value *Dest, Value *Src) { |
812 | auto *A = new QuantizeInst(uniqueName(name), Dest, Src); |
813 | F_->pushInstr(A); |
814 | return A; |
815 | } |
816 | |
817 | DequantizeInst *IRBuilder::createDequantizeInst(llvm::StringRef name, Value *Dest, Value *Src) { |
818 | auto *A = new DequantizeInst(uniqueName(name), Dest, Src); |
819 | F_->pushInstr(A); |
820 | return A; |
821 | } |
822 | |
823 | RescaleQuantizedInst *IRBuilder::createRescaleQuantizedInst(llvm::StringRef name, Value *Dest, Value *Src) { |
824 | auto *A = new RescaleQuantizedInst(uniqueName(name), Dest, Src); |
825 | F_->pushInstr(A); |
826 | return A; |
827 | } |
828 | |
829 | TopKInst *IRBuilder::createTopKInst(llvm::StringRef name, Value *Values, Value *Indices, Value *Input, unsigned_t K) { |
830 | std::string ScratchName = name.str() + ".scratch" ; |
831 | auto *ScratchType = F_->getParent()->uniqueType(ElemKind::Int8QTy, {1}, 0.0, 0); |
832 | auto *Scratch = createAllocActivationInst(ScratchName, ScratchType); |
833 | auto *A = new TopKInst(uniqueName(name), Values, Indices, Input, Scratch, K); |
834 | dim_t ScratchSizeVar = static_cast<dim_t>(A->getScratchSize()); |
835 | ScratchSizeVar = ScratchSizeVar > 0 ? ScratchSizeVar : 1; |
836 | auto *ScratchTypeResized = F_->getParent()->uniqueType(ElemKind::Int8QTy, {ScratchSizeVar}, 0.0, 0); |
837 | Scratch->setType(ScratchTypeResized); |
838 | Scratch->setTy(ScratchTypeResized); |
839 | F_->pushInstr(A); |
840 | return A; |
841 | } |
842 | |
843 | ConvertToInst *IRBuilder::createConvertToInst(llvm::StringRef name, Value *Result, Value *Input) { |
844 | auto *A = new ConvertToInst(uniqueName(name), Result, Input); |
845 | F_->pushInstr(A); |
846 | return A; |
847 | } |
848 | |
849 | ExternalFunctionCallInst *IRBuilder::createExternalFunctionCallInst(llvm::StringRef name, Value *Dest, std::string FunctionName, std::string FunctionImpl, std::string FunctionKind) { |
850 | auto *A = new ExternalFunctionCallInst(uniqueName(name), Dest, FunctionName, FunctionImpl, FunctionKind); |
851 | F_->pushInstr(A); |
852 | return A; |
853 | } |
854 | |
855 | AudioSpectrogramInst *IRBuilder::createAudioSpectrogramInst(llvm::StringRef name, Value *Spectrogram, Value *Input, Value *Window, Value *TwiddleFactors, Value *BitReverseIndices, Value *ComplexToRealWeights, int64_t WindowSize, int64_t WindowStride, bool MagnitudeSquared) { |
856 | std::string WinOutScratchName = name.str() + ".winoutscratch" ; |
857 | auto *WinOutScratchType = F_->getParent()->uniqueType(ElemKind::Int8QTy, {1}, 0.0, 0); |
858 | auto *WinOutScratch = createAllocActivationInst(WinOutScratchName, WinOutScratchType); |
859 | std::string FftOutScratchName = name.str() + ".fftoutscratch" ; |
860 | auto *FftOutScratchType = F_->getParent()->uniqueType(ElemKind::Int8QTy, {1}, 0.0, 0); |
861 | auto *FftOutScratch = createAllocActivationInst(FftOutScratchName, FftOutScratchType); |
862 | auto *A = new AudioSpectrogramInst(uniqueName(name), Spectrogram, Input, Window, TwiddleFactors, BitReverseIndices, ComplexToRealWeights, WinOutScratch, FftOutScratch, WindowSize, WindowStride, MagnitudeSquared); |
863 | dim_t WinOutScratchSizeVar = static_cast<dim_t>(A->getWinOutScratchSize()); |
864 | WinOutScratchSizeVar = WinOutScratchSizeVar > 0 ? WinOutScratchSizeVar : 1; |
865 | auto *WinOutScratchTypeResized = F_->getParent()->uniqueType(ElemKind::Int8QTy, {WinOutScratchSizeVar}, 0.0, 0); |
866 | WinOutScratch->setType(WinOutScratchTypeResized); |
867 | WinOutScratch->setTy(WinOutScratchTypeResized); |
868 | dim_t FftOutScratchSizeVar = static_cast<dim_t>(A->getFftOutScratchSize()); |
869 | FftOutScratchSizeVar = FftOutScratchSizeVar > 0 ? FftOutScratchSizeVar : 1; |
870 | auto *FftOutScratchTypeResized = F_->getParent()->uniqueType(ElemKind::Int8QTy, {FftOutScratchSizeVar}, 0.0, 0); |
871 | FftOutScratch->setType(FftOutScratchTypeResized); |
872 | FftOutScratch->setTy(FftOutScratchTypeResized); |
873 | F_->pushInstr(A); |
874 | return A; |
875 | } |
876 | |
877 | MFCCInst *IRBuilder::createMFCCInst(llvm::StringRef name, Value *Coefficients, Value *Spectrogram, Value *MelWeights, Value *MelRanges, Value *DctMat, float SampleRate, float LowerFrequency, float UpperFrequency, int64_t FilterBankCount, int64_t NumCoefficients) { |
878 | std::string ScratchName = name.str() + ".scratch" ; |
879 | auto *ScratchType = F_->getParent()->uniqueType(ElemKind::Int8QTy, {1}, 0.0, 0); |
880 | auto *Scratch = createAllocActivationInst(ScratchName, ScratchType); |
881 | auto *A = new MFCCInst(uniqueName(name), Coefficients, Spectrogram, MelWeights, MelRanges, DctMat, Scratch, SampleRate, LowerFrequency, UpperFrequency, FilterBankCount, NumCoefficients); |
882 | dim_t ScratchSizeVar = static_cast<dim_t>(A->getScratchSize()); |
883 | ScratchSizeVar = ScratchSizeVar > 0 ? ScratchSizeVar : 1; |
884 | auto *ScratchTypeResized = F_->getParent()->uniqueType(ElemKind::Int8QTy, {ScratchSizeVar}, 0.0, 0); |
885 | Scratch->setType(ScratchTypeResized); |
886 | Scratch->setTy(ScratchTypeResized); |
887 | F_->pushInstr(A); |
888 | return A; |
889 | } |
890 | |
891 | NonMaxSuppressionInst *IRBuilder::createNonMaxSuppressionInst(llvm::StringRef name, Value *Indices, Value *NumberOfSelectedIndices, Value *Boxes, Value *Scores, int64_t CenterPointBox, int64_t MaxOutputBoxesPerClass, float IouThreshold, float ScoreThreshold, bool IsTFVersion4) { |
892 | auto *A = new NonMaxSuppressionInst(uniqueName(name), Indices, NumberOfSelectedIndices, Boxes, Scores, CenterPointBox, MaxOutputBoxesPerClass, IouThreshold, ScoreThreshold, IsTFVersion4); |
893 | F_->pushInstr(A); |
894 | return A; |
895 | } |
896 | |
897 | TFLiteDetectionPostProcessInst *IRBuilder::createTFLiteDetectionPostProcessInst(llvm::StringRef name, Value *DetectionBoxes, Value *DetectionClasses, Value *DetectionScores, Value *NumDetections, Value *Boxes, Value *Scores, Value *Anchors, unsigned_t NumClasses, unsigned_t MaxDetections, unsigned_t MaxClassesPerDetection, unsigned_t MaxDetectionsPerClass, float IouThreshold, float ScoreThreshold, float XScale, float YScale, float HScale, float WScale, bool RegularNMS) { |
898 | std::string ScratchName = name.str() + ".scratch" ; |
899 | auto *ScratchType = F_->getParent()->uniqueType(ElemKind::Int8QTy, {1}, 0.0, 0); |
900 | auto *Scratch = createAllocActivationInst(ScratchName, ScratchType); |
901 | auto *A = new TFLiteDetectionPostProcessInst(uniqueName(name), DetectionBoxes, DetectionClasses, DetectionScores, NumDetections, Boxes, Scores, Anchors, Scratch, NumClasses, MaxDetections, MaxClassesPerDetection, MaxDetectionsPerClass, IouThreshold, ScoreThreshold, XScale, YScale, HScale, WScale, RegularNMS); |
902 | dim_t ScratchSizeVar = static_cast<dim_t>(A->getScratchSize()); |
903 | ScratchSizeVar = ScratchSizeVar > 0 ? ScratchSizeVar : 1; |
904 | auto *ScratchTypeResized = F_->getParent()->uniqueType(ElemKind::Int8QTy, {ScratchSizeVar}, 0.0, 0); |
905 | Scratch->setType(ScratchTypeResized); |
906 | Scratch->setTy(ScratchTypeResized); |
907 | F_->pushInstr(A); |
908 | return A; |
909 | } |
910 | |
911 | ROIAlignInst *IRBuilder::createROIAlignInst(llvm::StringRef name, Value *Result, Value *FeatureMap, Value *Boxes, Value *BatchIndices, unsigned_t Mode, unsigned_t OutputHeight, unsigned_t OutputWidth, unsigned_t SamplingRatio, float SpatialScale, bool Aligned, bool Rotated) { |
912 | auto *A = new ROIAlignInst(uniqueName(name), Result, FeatureMap, Boxes, BatchIndices, Mode, OutputHeight, OutputWidth, SamplingRatio, SpatialScale, Aligned, Rotated); |
913 | F_->pushInstr(A); |
914 | return A; |
915 | } |
916 | |
917 | BBoxTransformInst *IRBuilder::createBBoxTransformInst(llvm::StringRef name, Value *BoxOut, Value *RoiBatchSplits, Value *Rois, Value *Deltas, Value *ImInfo, std::vector<float> Weights, bool ApplyScale, bool Rotated, bool AngleBoundOn, int64_t AngleBoundLo, int64_t AngleBoundHi, float ClipAngleThresh, bool LegacyPlusOne) { |
918 | auto *A = new BBoxTransformInst(uniqueName(name), BoxOut, RoiBatchSplits, Rois, Deltas, ImInfo, Weights, ApplyScale, Rotated, AngleBoundOn, AngleBoundLo, AngleBoundHi, ClipAngleThresh, LegacyPlusOne); |
919 | F_->pushInstr(A); |
920 | return A; |
921 | } |
922 | |
923 | CollectRpnProposalsInst *IRBuilder::createCollectRpnProposalsInst(llvm::StringRef name, Value *Result, int64_t RpnMaxLevel, int64_t RpnMinLevel, unsigned_t RpnPostNmsTopN) { |
924 | auto *A = new CollectRpnProposalsInst(uniqueName(name), Result, RpnMaxLevel, RpnMinLevel, RpnPostNmsTopN); |
925 | F_->pushInstr(A); |
926 | return A; |
927 | } |
928 | |
929 | LookupTableInst *IRBuilder::createLookupTableInst(llvm::StringRef name, Value *Dest, Value *Src, Value *Table, Value *TableIdx, glow::LUTOperator Operator, std::vector<float> OperatorArgs) { |
930 | auto *A = new LookupTableInst(uniqueName(name), Dest, Src, Table, TableIdx, Operator, OperatorArgs); |
931 | F_->pushInstr(A); |
932 | return A; |
933 | } |
934 | |
935 | CPUMaxSplatInst *IRBuilder::createCPUMaxSplatInst(llvm::StringRef name, Value *Dest, Value *Src, float SplatValue) { |
936 | auto *A = new CPUMaxSplatInst(uniqueName(name), Dest, Src, SplatValue); |
937 | F_->pushInstr(A); |
938 | return A; |
939 | } |
940 | |
941 | CPUConvDKKC8Inst *IRBuilder::createCPUConvDKKC8Inst(llvm::StringRef name, Value *Dest, Value *Src, Value *Filter, Value *Bias, std::vector<unsigned_t> Kernels, std::vector<unsigned_t> Strides, std::vector<unsigned_t> Pads, unsigned_t Group) { |
942 | auto *A = new CPUConvDKKC8Inst(uniqueName(name), Dest, Src, Filter, Bias, Kernels, Strides, Pads, Group); |
943 | F_->pushInstr(A); |
944 | return A; |
945 | } |
946 | |