1 | case glow::Kinded::Kind::ConvolutionNodeKind: { |
2 | auto *CN__ = cast<ConvolutionNode>(N); |
3 | auto *Src = valueForNode(CN__->getInput()); |
4 | auto *Filter = valueForNode(CN__->getFilter()); |
5 | auto *Bias = valueForNode(CN__->getBias()); |
6 | std::string allocName = std::string(N->getName()) + ".res" ; |
7 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
8 | auto *V = builder_.createConvolutionInst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup(), CN__->getDilation(), CN__->getLayout(), CN__->getFusedActivation(), CN__->getFusedActivationArgs()); |
9 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
10 | registerIR(CN__->getResult(), V->getDest()); |
11 | nodeToInstr_[N] = V; |
12 | break; |
13 | } |
14 | case glow::Kinded::Kind::ChannelwiseQuantizedConvolutionNodeKind: { |
15 | auto *CN__ = cast<ChannelwiseQuantizedConvolutionNode>(N); |
16 | auto *Src = valueForNode(CN__->getInput()); |
17 | auto *Filter = valueForNode(CN__->getFilter()); |
18 | auto *Bias = valueForNode(CN__->getBias()); |
19 | auto *FilterScales = valueForNode(CN__->getFilterScales()); |
20 | auto *FilterOffsets = valueForNode(CN__->getFilterOffsets()); |
21 | auto *BiasScales = valueForNode(CN__->getBiasScales()); |
22 | auto *BiasOffsets = valueForNode(CN__->getBiasOffsets()); |
23 | std::string allocName = std::string(N->getName()) + ".res" ; |
24 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
25 | auto *V = builder_.createChannelwiseQuantizedConvolutionInst(N->getName(), Dest__, Src, Filter, Bias, FilterScales, FilterOffsets, BiasScales, BiasOffsets, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup(), CN__->getDilation(), CN__->getFusedActivation(), CN__->getFusedActivationArgs()); |
26 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
27 | registerIR(CN__->getResult(), V->getDest()); |
28 | nodeToInstr_[N] = V; |
29 | break; |
30 | } |
31 | case glow::Kinded::Kind::ConvTransposeNodeKind: { |
32 | auto *CN__ = cast<ConvTransposeNode>(N); |
33 | auto *Src = valueForNode(CN__->getInput()); |
34 | auto *Filter = valueForNode(CN__->getFilter()); |
35 | auto *Bias = valueForNode(CN__->getBias()); |
36 | std::string allocName = std::string(N->getName()) + ".res" ; |
37 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
38 | auto *V = builder_.createConvTransposeInst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup(), CN__->getDilation()); |
39 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
40 | registerIR(CN__->getResult(), V->getDest()); |
41 | nodeToInstr_[N] = V; |
42 | break; |
43 | } |
44 | case glow::Kinded::Kind::Convolution3DNodeKind: { |
45 | auto *CN__ = cast<Convolution3DNode>(N); |
46 | auto *Src = valueForNode(CN__->getInput()); |
47 | auto *Filter = valueForNode(CN__->getFilter()); |
48 | auto *Bias = valueForNode(CN__->getBias()); |
49 | std::string allocName = std::string(N->getName()) + ".res" ; |
50 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
51 | auto *V = builder_.createConvolution3DInst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup()); |
52 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
53 | registerIR(CN__->getResult(), V->getDest()); |
54 | nodeToInstr_[N] = V; |
55 | break; |
56 | } |
57 | case glow::Kinded::Kind::BatchNormalizationNodeKind: { |
58 | auto *CN__ = cast<BatchNormalizationNode>(N); |
59 | auto *Src = valueForNode(CN__->getInput()); |
60 | auto *Scale = valueForNode(CN__->getScale()); |
61 | auto *Bias = valueForNode(CN__->getBias()); |
62 | auto *Mean = valueForNode(CN__->getMean()); |
63 | auto *Var = valueForNode(CN__->getVar()); |
64 | std::string allocName = std::string(N->getName()) + ".res" ; |
65 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
66 | auto *V = builder_.createBatchNormalizationInst(N->getName(), Dest__, Src, Scale, Bias, Mean, Var, CN__->getChannelIdx(), CN__->getEpsilon(), CN__->getMomentum()); |
67 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
68 | registerIR(CN__->getResult(), V->getDest()); |
69 | nodeToInstr_[N] = V; |
70 | break; |
71 | } |
72 | case glow::Kinded::Kind::AvgPoolNodeKind: { |
73 | auto *CN__ = cast<AvgPoolNode>(N); |
74 | auto *Src = valueForNode(CN__->getInput()); |
75 | std::string allocName = std::string(N->getName()) + ".res" ; |
76 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
77 | auto *V = builder_.createAvgPoolInst(N->getName(), Dest__, Src, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getLayout(), CN__->getCountIncludePads()); |
78 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
79 | registerIR(CN__->getResult(), V->getDest()); |
80 | nodeToInstr_[N] = V; |
81 | break; |
82 | } |
83 | case glow::Kinded::Kind::ArgMaxNodeKind: { |
84 | auto *CN__ = cast<ArgMaxNode>(N); |
85 | auto *Src = valueForNode(CN__->getInput()); |
86 | std::string allocName = std::string(N->getName()) + ".res" ; |
87 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
88 | auto *V = builder_.createArgMaxInst(N->getName(), Dest__, Src, CN__->getAxis(), CN__->getKeepDims()); |
89 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
90 | registerIR(CN__->getResult(), V->getDest()); |
91 | nodeToInstr_[N] = V; |
92 | break; |
93 | } |
94 | case glow::Kinded::Kind::ArgMinNodeKind: { |
95 | auto *CN__ = cast<ArgMinNode>(N); |
96 | auto *Src = valueForNode(CN__->getInput()); |
97 | std::string allocName = std::string(N->getName()) + ".res" ; |
98 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
99 | auto *V = builder_.createArgMinInst(N->getName(), Dest__, Src, CN__->getAxis(), CN__->getKeepDims()); |
100 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
101 | registerIR(CN__->getResult(), V->getDest()); |
102 | nodeToInstr_[N] = V; |
103 | break; |
104 | } |
105 | case glow::Kinded::Kind::AdaptiveAvgPoolNodeKind: { |
106 | auto *CN__ = cast<AdaptiveAvgPoolNode>(N); |
107 | auto *Src = valueForNode(CN__->getInput()); |
108 | std::string allocName = std::string(N->getName()) + ".res" ; |
109 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
110 | auto *V = builder_.createAdaptiveAvgPoolInst(N->getName(), Dest__, Src); |
111 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
112 | registerIR(CN__->getResult(), V->getDest()); |
113 | nodeToInstr_[N] = V; |
114 | break; |
115 | } |
116 | case glow::Kinded::Kind::FullyConnectedNodeKind: { |
117 | auto *CN__ = cast<FullyConnectedNode>(N); |
118 | auto *Src = valueForNode(CN__->getInput()); |
119 | auto *Weights = valueForNode(CN__->getWeights()); |
120 | auto *Bias = valueForNode(CN__->getBias()); |
121 | std::string allocName = std::string(N->getName()) + ".res" ; |
122 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
123 | auto *V = builder_.createFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias); |
124 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
125 | registerIR(CN__->getResult(), V->getDest()); |
126 | nodeToInstr_[N] = V; |
127 | break; |
128 | } |
129 | case glow::Kinded::Kind::RowwiseQuantizedFullyConnectedNodeKind: { |
130 | auto *CN__ = cast<RowwiseQuantizedFullyConnectedNode>(N); |
131 | auto *Src = valueForNode(CN__->getInput()); |
132 | auto *Weights = valueForNode(CN__->getWeights()); |
133 | auto *Bias = valueForNode(CN__->getBias()); |
134 | auto *Scales = valueForNode(CN__->getScales()); |
135 | auto *Offsets = valueForNode(CN__->getOffsets()); |
136 | std::string allocName = std::string(N->getName()) + ".res" ; |
137 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
138 | auto *V = builder_.createRowwiseQuantizedFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias, Scales, Offsets); |
139 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
140 | registerIR(CN__->getResult(), V->getDest()); |
141 | nodeToInstr_[N] = V; |
142 | break; |
143 | } |
144 | case glow::Kinded::Kind::DynamicQuantizedFullyConnectedNodeKind: { |
145 | auto *CN__ = cast<DynamicQuantizedFullyConnectedNode>(N); |
146 | auto *Src = valueForNode(CN__->getInput()); |
147 | auto *Weights = valueForNode(CN__->getWeights()); |
148 | auto *Bias = valueForNode(CN__->getBias()); |
149 | std::string allocName = std::string(N->getName()) + ".res" ; |
150 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
151 | auto *V = builder_.createDynamicQuantizedFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias, CN__->getIsSymmetric(), CN__->getIsPerBatchElement()); |
152 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
153 | registerIR(CN__->getResult(), V->getDest()); |
154 | nodeToInstr_[N] = V; |
155 | break; |
156 | } |
157 | case glow::Kinded::Kind::DynamicRowwiseQuantizedFullyConnectedNodeKind: { |
158 | auto *CN__ = cast<DynamicRowwiseQuantizedFullyConnectedNode>(N); |
159 | auto *Src = valueForNode(CN__->getInput()); |
160 | auto *Weights = valueForNode(CN__->getWeights()); |
161 | auto *Bias = valueForNode(CN__->getBias()); |
162 | auto *Scales = valueForNode(CN__->getScales()); |
163 | auto *Offsets = valueForNode(CN__->getOffsets()); |
164 | std::string allocName = std::string(N->getName()) + ".res" ; |
165 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
166 | auto *V = builder_.createDynamicRowwiseQuantizedFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias, Scales, Offsets, CN__->getIsSymmetric(), CN__->getIsPerBatchElement()); |
167 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
168 | registerIR(CN__->getResult(), V->getDest()); |
169 | nodeToInstr_[N] = V; |
170 | break; |
171 | } |
172 | case glow::Kinded::Kind::BucketizeNodeKind: { |
173 | auto *CN__ = cast<BucketizeNode>(N); |
174 | auto *Src = valueForNode(CN__->getInput()); |
175 | std::string allocName = std::string(N->getName()) + ".res" ; |
176 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
177 | auto *V = builder_.createBucketizeInst(N->getName(), Dest__, Src, CN__->getBoundaries()); |
178 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
179 | registerIR(CN__->getResult(), V->getDest()); |
180 | nodeToInstr_[N] = V; |
181 | break; |
182 | } |
183 | case glow::Kinded::Kind::LayerNormalizationNodeKind: { |
184 | auto *CN__ = cast<LayerNormalizationNode>(N); |
185 | auto *Src = valueForNode(CN__->getInput()); |
186 | auto *Scale = valueForNode(CN__->getScale()); |
187 | auto *Bias = valueForNode(CN__->getBias()); |
188 | std::string allocName = std::string(N->getName()) + ".res" ; |
189 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
190 | auto *V = builder_.createLayerNormalizationInst(N->getName(), Dest__, Src, Scale, Bias, CN__->getEpsilon()); |
191 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
192 | registerIR(CN__->getResult(), V->getDest()); |
193 | nodeToInstr_[N] = V; |
194 | break; |
195 | } |
196 | case glow::Kinded::Kind::SoftMaxNodeKind: { |
197 | auto *CN__ = cast<SoftMaxNode>(N); |
198 | auto *Src = valueForNode(CN__->getInput()); |
199 | std::string allocName = std::string(N->getName()) + ".res" ; |
200 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
201 | auto *V = builder_.createSoftMaxInst(N->getName(), Dest__, Src); |
202 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
203 | registerIR(CN__->getResult(), V->getDest()); |
204 | nodeToInstr_[N] = V; |
205 | break; |
206 | } |
207 | case glow::Kinded::Kind::LogSoftMaxNodeKind: { |
208 | auto *CN__ = cast<LogSoftMaxNode>(N); |
209 | auto *Src = valueForNode(CN__->getInput()); |
210 | std::string allocName = std::string(N->getName()) + ".res" ; |
211 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
212 | auto *V = builder_.createLogSoftMaxInst(N->getName(), Dest__, Src); |
213 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
214 | registerIR(CN__->getResult(), V->getDest()); |
215 | nodeToInstr_[N] = V; |
216 | break; |
217 | } |
218 | case glow::Kinded::Kind::MatMulNodeKind: { |
219 | auto *CN__ = cast<MatMulNode>(N); |
220 | auto *LHS = valueForNode(CN__->getLHS()); |
221 | auto *RHS = valueForNode(CN__->getRHS()); |
222 | std::string allocName = std::string(N->getName()) + ".res" ; |
223 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
224 | auto *V = builder_.createMatMulInst(N->getName(), Dest__, LHS, RHS); |
225 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
226 | registerIR(CN__->getResult(), V->getDest()); |
227 | nodeToInstr_[N] = V; |
228 | break; |
229 | } |
230 | case glow::Kinded::Kind::BatchMatMulNodeKind: { |
231 | auto *CN__ = cast<BatchMatMulNode>(N); |
232 | auto *LHS = valueForNode(CN__->getLHS()); |
233 | auto *RHS = valueForNode(CN__->getRHS()); |
234 | std::string allocName = std::string(N->getName()) + ".res" ; |
235 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
236 | auto *V = builder_.createBatchMatMulInst(N->getName(), Dest__, LHS, RHS); |
237 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
238 | registerIR(CN__->getResult(), V->getDest()); |
239 | nodeToInstr_[N] = V; |
240 | break; |
241 | } |
242 | case glow::Kinded::Kind::BatchedReduceAddNodeKind: { |
243 | auto *CN__ = cast<BatchedReduceAddNode>(N); |
244 | auto *Batch = valueForNode(CN__->getBatch()); |
245 | std::string allocName = std::string(N->getName()) + ".res" ; |
246 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
247 | auto *V = builder_.createBatchedReduceAddInst(N->getName(), Dest__, Batch, CN__->getAxis()); |
248 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
249 | registerIR(CN__->getResult(), V->getDest()); |
250 | nodeToInstr_[N] = V; |
251 | break; |
252 | } |
253 | case glow::Kinded::Kind::BatchedReduceMinNodeKind: { |
254 | auto *CN__ = cast<BatchedReduceMinNode>(N); |
255 | auto *Batch = valueForNode(CN__->getBatch()); |
256 | std::string allocName = std::string(N->getName()) + ".res" ; |
257 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
258 | auto *V = builder_.createBatchedReduceMinInst(N->getName(), Dest__, Batch, CN__->getAxes()); |
259 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
260 | registerIR(CN__->getResult(), V->getDest()); |
261 | nodeToInstr_[N] = V; |
262 | break; |
263 | } |
264 | case glow::Kinded::Kind::BatchedReduceMaxNodeKind: { |
265 | auto *CN__ = cast<BatchedReduceMaxNode>(N); |
266 | auto *Batch = valueForNode(CN__->getBatch()); |
267 | std::string allocName = std::string(N->getName()) + ".res" ; |
268 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
269 | auto *V = builder_.createBatchedReduceMaxInst(N->getName(), Dest__, Batch, CN__->getAxes()); |
270 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
271 | registerIR(CN__->getResult(), V->getDest()); |
272 | nodeToInstr_[N] = V; |
273 | break; |
274 | } |
275 | case glow::Kinded::Kind::BatchedReduceProdNodeKind: { |
276 | auto *CN__ = cast<BatchedReduceProdNode>(N); |
277 | auto *Batch = valueForNode(CN__->getBatch()); |
278 | std::string allocName = std::string(N->getName()) + ".res" ; |
279 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
280 | auto *V = builder_.createBatchedReduceProdInst(N->getName(), Dest__, Batch, CN__->getAxis()); |
281 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
282 | registerIR(CN__->getResult(), V->getDest()); |
283 | nodeToInstr_[N] = V; |
284 | break; |
285 | } |
286 | case glow::Kinded::Kind::CumSumNodeKind: { |
287 | auto *CN__ = cast<CumSumNode>(N); |
288 | auto *Input = valueForNode(CN__->getInput()); |
289 | std::string allocName = std::string(N->getName()) + ".res" ; |
290 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
291 | auto *V = builder_.createCumSumInst(N->getName(), Dest__, Input, CN__->getDim(), CN__->getExclusive(), CN__->getReverse()); |
292 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
293 | registerIR(CN__->getResult(), V->getDest()); |
294 | nodeToInstr_[N] = V; |
295 | break; |
296 | } |
297 | case glow::Kinded::Kind::LengthsSumNodeKind: { |
298 | auto *CN__ = cast<LengthsSumNode>(N); |
299 | auto *Data = valueForNode(CN__->getData()); |
300 | auto *Lengths = valueForNode(CN__->getLengths()); |
301 | std::string allocName = std::string(N->getName()) + ".res" ; |
302 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
303 | auto *V = builder_.createLengthsSumInst(N->getName(), Dest__, Data, Lengths); |
304 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
305 | registerIR(CN__->getResult(), V->getDest()); |
306 | nodeToInstr_[N] = V; |
307 | break; |
308 | } |
309 | case glow::Kinded::Kind::SparseLengthsSumNodeKind: { |
310 | auto *CN__ = cast<SparseLengthsSumNode>(N); |
311 | auto *Data = valueForNode(CN__->getData()); |
312 | auto *Indices = valueForNode(CN__->getIndices()); |
313 | auto *Lengths = valueForNode(CN__->getLengths()); |
314 | std::string allocName = std::string(N->getName()) + ".res" ; |
315 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
316 | auto *V = builder_.createSparseLengthsSumInst(N->getName(), Dest__, Data, Indices, Lengths, CN__->getLengthsMode(), CN__->getAvgLength()); |
317 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
318 | registerIR(CN__->getResult(), V->getDest()); |
319 | nodeToInstr_[N] = V; |
320 | break; |
321 | } |
322 | case glow::Kinded::Kind::SparseLengthsWeightedSumNodeKind: { |
323 | auto *CN__ = cast<SparseLengthsWeightedSumNode>(N); |
324 | auto *Data = valueForNode(CN__->getData()); |
325 | auto *Weights = valueForNode(CN__->getWeights()); |
326 | auto *Indices = valueForNode(CN__->getIndices()); |
327 | auto *Lengths = valueForNode(CN__->getLengths()); |
328 | std::string allocName = std::string(N->getName()) + ".res" ; |
329 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
330 | auto *V = builder_.createSparseLengthsWeightedSumInst(N->getName(), Dest__, Data, Weights, Indices, Lengths, CN__->getLengthsMode(), CN__->getAvgLength()); |
331 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
332 | registerIR(CN__->getResult(), V->getDest()); |
333 | nodeToInstr_[N] = V; |
334 | break; |
335 | } |
336 | case glow::Kinded::Kind::EmbeddingNodeKind: { |
337 | auto *CN__ = cast<EmbeddingNode>(N); |
338 | auto *Weights = valueForNode(CN__->getWeights()); |
339 | auto *Indices = valueForNode(CN__->getIndices()); |
340 | std::string allocName = std::string(N->getName()) + ".res" ; |
341 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
342 | auto *V = builder_.createEmbeddingInst(N->getName(), Dest__, Weights, Indices, CN__->getPadIdx(), CN__->getScale(), CN__->getSparse()); |
343 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
344 | registerIR(CN__->getResult(), V->getDest()); |
345 | nodeToInstr_[N] = V; |
346 | break; |
347 | } |
348 | case glow::Kinded::Kind::EmbeddingBagNodeKind: { |
349 | auto *CN__ = cast<EmbeddingBagNode>(N); |
350 | auto *Data = valueForNode(CN__->getData()); |
351 | auto *Weights = valueForNode(CN__->getWeights()); |
352 | auto *Indices = valueForNode(CN__->getIndices()); |
353 | auto *Offsets = valueForNode(CN__->getOffsets()); |
354 | std::string allocName = std::string(N->getName()) + ".res" ; |
355 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
356 | auto *V = builder_.createEmbeddingBagInst(N->getName(), Dest__, Data, Weights, Indices, Offsets, CN__->getHasEndOffset(), CN__->getLengthsMode(), CN__->getAvgLength()); |
357 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
358 | registerIR(CN__->getResult(), V->getDest()); |
359 | nodeToInstr_[N] = V; |
360 | break; |
361 | } |
362 | case glow::Kinded::Kind::RowwiseQuantizedSparseLengthsWeightedSumNodeKind: { |
363 | auto *CN__ = cast<RowwiseQuantizedSparseLengthsWeightedSumNode>(N); |
364 | auto *Data = valueForNode(CN__->getData()); |
365 | auto *Scales = valueForNode(CN__->getScales()); |
366 | auto *Offsets = valueForNode(CN__->getOffsets()); |
367 | auto *Weights = valueForNode(CN__->getWeights()); |
368 | auto *Indices = valueForNode(CN__->getIndices()); |
369 | auto *Lengths = valueForNode(CN__->getLengths()); |
370 | std::string allocName = std::string(N->getName()) + ".res" ; |
371 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
372 | auto *V = builder_.createRowwiseQuantizedSparseLengthsWeightedSumInst(N->getName(), Dest__, Data, Scales, Offsets, Weights, Indices, Lengths, CN__->getUseFP16Accumulation(), CN__->getLengthsMode(), CN__->getAvgLength()); |
373 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
374 | registerIR(CN__->getResult(), V->getDest()); |
375 | nodeToInstr_[N] = V; |
376 | break; |
377 | } |
378 | case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsWeightedSumNodeKind: { |
379 | auto *CN__ = cast<FusedRowwiseQuantizedSparseLengthsWeightedSumNode>(N); |
380 | auto *Data = valueForNode(CN__->getData()); |
381 | auto *Weights = valueForNode(CN__->getWeights()); |
382 | auto *Indices = valueForNode(CN__->getIndices()); |
383 | auto *Lengths = valueForNode(CN__->getLengths()); |
384 | std::string allocName = std::string(N->getName()) + ".res" ; |
385 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
386 | auto *V = builder_.createFusedRowwiseQuantizedSparseLengthsWeightedSumInst(N->getName(), Dest__, Data, Weights, Indices, Lengths, CN__->getUseFP16Accumulation(), CN__->getLengthsMode(), CN__->getAvgLength()); |
387 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
388 | registerIR(CN__->getResult(), V->getDest()); |
389 | nodeToInstr_[N] = V; |
390 | break; |
391 | } |
392 | case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsSumNodeKind: { |
393 | auto *CN__ = cast<FusedRowwiseQuantizedSparseLengthsSumNode>(N); |
394 | auto *Data = valueForNode(CN__->getData()); |
395 | auto *Indices = valueForNode(CN__->getIndices()); |
396 | auto *Lengths = valueForNode(CN__->getLengths()); |
397 | std::string allocName = std::string(N->getName()) + ".res" ; |
398 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
399 | auto *V = builder_.createFusedRowwiseQuantizedSparseLengthsSumInst(N->getName(), Dest__, Data, Indices, Lengths, CN__->getUseFP16Accumulation(), CN__->getLengthsMode(), CN__->getAvgLength()); |
400 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
401 | registerIR(CN__->getResult(), V->getDest()); |
402 | nodeToInstr_[N] = V; |
403 | break; |
404 | } |
405 | case glow::Kinded::Kind::EmbeddingBagByteRowwiseOffsetsNodeKind: { |
406 | auto *CN__ = cast<EmbeddingBagByteRowwiseOffsetsNode>(N); |
407 | auto *Data = valueForNode(CN__->getData()); |
408 | auto *Weights = valueForNode(CN__->getWeights()); |
409 | auto *Indices = valueForNode(CN__->getIndices()); |
410 | auto *Offsets = valueForNode(CN__->getOffsets()); |
411 | std::string allocName = std::string(N->getName()) + ".res" ; |
412 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
413 | auto *V = builder_.createEmbeddingBagByteRowwiseOffsetsInst(N->getName(), Dest__, Data, Weights, Indices, Offsets, CN__->getUseFP16Accumulation(), CN__->getHasEndOffset(), CN__->getLengthsMode(), CN__->getAvgLength()); |
414 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
415 | registerIR(CN__->getResult(), V->getDest()); |
416 | nodeToInstr_[N] = V; |
417 | break; |
418 | } |
419 | case glow::Kinded::Kind::LengthsToRangesNodeKind: { |
420 | auto *CN__ = cast<LengthsToRangesNode>(N); |
421 | auto *Lengths = valueForNode(CN__->getLengths()); |
422 | std::string allocName = std::string(N->getName()) + ".res" ; |
423 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
424 | auto *V = builder_.createLengthsToRangesInst(N->getName(), Dest__, Lengths); |
425 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
426 | registerIR(CN__->getResult(), V->getDest()); |
427 | nodeToInstr_[N] = V; |
428 | break; |
429 | } |
430 | case glow::Kinded::Kind::LengthsRangeFillNodeKind: { |
431 | auto *CN__ = cast<LengthsRangeFillNode>(N); |
432 | auto *Lengths = valueForNode(CN__->getLengths()); |
433 | std::string allocName = std::string(N->getName()) + ".res" ; |
434 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
435 | auto *V = builder_.createLengthsRangeFillInst(N->getName(), Dest__, Lengths); |
436 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
437 | registerIR(CN__->getResult(), V->getDest()); |
438 | nodeToInstr_[N] = V; |
439 | break; |
440 | } |
441 | case glow::Kinded::Kind::BatchSparseToDenseNodeKind: { |
442 | auto *CN__ = cast<BatchSparseToDenseNode>(N); |
443 | auto *Lengths = valueForNode(CN__->getLengths()); |
444 | auto *Indices = valueForNode(CN__->getIndices()); |
445 | auto *Values = valueForNode(CN__->getValues()); |
446 | std::string allocName = std::string(N->getName()) + ".res" ; |
447 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
448 | auto *V = builder_.createBatchSparseToDenseInst(N->getName(), Dest__, Lengths, Indices, Values, CN__->getDefaultValue(), CN__->getDenseLastDim()); |
449 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
450 | registerIR(CN__->getResult(), V->getDest()); |
451 | nodeToInstr_[N] = V; |
452 | break; |
453 | } |
454 | case glow::Kinded::Kind::FillExamplesWithIndicatorNodeKind: { |
455 | auto *CN__ = cast<FillExamplesWithIndicatorNode>(N); |
456 | auto *Data = valueForNode(CN__->getData()); |
457 | auto *Indicator = valueForNode(CN__->getIndicator()); |
458 | std::string allocName = std::string(N->getName()) + ".res" ; |
459 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
460 | auto *V = builder_.createFillExamplesWithIndicatorInst(N->getName(), Dest__, Data, Indicator); |
461 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
462 | registerIR(CN__->getResult(), V->getDest()); |
463 | nodeToInstr_[N] = V; |
464 | break; |
465 | } |
466 | case glow::Kinded::Kind::SparseToDenseMaskNodeKind: { |
467 | auto *CN__ = cast<SparseToDenseMaskNode>(N); |
468 | auto *Indices = valueForNode(CN__->getIndices()); |
469 | auto *Values = valueForNode(CN__->getValues()); |
470 | auto *DefaultValue = valueForNode(CN__->getDefaultValue()); |
471 | auto *Lengths = valueForNode(CN__->getLengths()); |
472 | std::string allocName = std::string(N->getName()) + ".res" ; |
473 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
474 | auto *V = builder_.createSparseToDenseMaskInst(N->getName(), Dest__, Indices, Values, DefaultValue, Lengths, CN__->getMask()); |
475 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
476 | registerIR(CN__->getResult(), V->getDest()); |
477 | nodeToInstr_[N] = V; |
478 | break; |
479 | } |
480 | case glow::Kinded::Kind::BatchedAddNodeKind: { |
481 | auto *CN__ = cast<BatchedAddNode>(N); |
482 | auto *Batch = valueForNode(CN__->getBatch()); |
483 | auto *Slice = valueForNode(CN__->getSlice()); |
484 | std::string allocName = std::string(N->getName()) + ".res" ; |
485 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
486 | auto *V = builder_.createBatchedAddInst(N->getName(), Dest__, Batch, Slice); |
487 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
488 | registerIR(CN__->getResult(), V->getDest()); |
489 | nodeToInstr_[N] = V; |
490 | break; |
491 | } |
492 | case glow::Kinded::Kind::AddNodeKind: { |
493 | auto *CN__ = cast<AddNode>(N); |
494 | auto *LHS = valueForNode(CN__->getLHS()); |
495 | auto *RHS = valueForNode(CN__->getRHS()); |
496 | std::string allocName = std::string(N->getName()) + ".res" ; |
497 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
498 | auto *V = builder_.createElementAddInst(N->getName(), Dest__, LHS, RHS); |
499 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
500 | registerIR(CN__->getResult(), V->getDest()); |
501 | nodeToInstr_[N] = V; |
502 | break; |
503 | } |
504 | case glow::Kinded::Kind::SubNodeKind: { |
505 | auto *CN__ = cast<SubNode>(N); |
506 | auto *LHS = valueForNode(CN__->getLHS()); |
507 | auto *RHS = valueForNode(CN__->getRHS()); |
508 | std::string allocName = std::string(N->getName()) + ".res" ; |
509 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
510 | auto *V = builder_.createElementSubInst(N->getName(), Dest__, LHS, RHS); |
511 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
512 | registerIR(CN__->getResult(), V->getDest()); |
513 | nodeToInstr_[N] = V; |
514 | break; |
515 | } |
516 | case glow::Kinded::Kind::MulNodeKind: { |
517 | auto *CN__ = cast<MulNode>(N); |
518 | auto *LHS = valueForNode(CN__->getLHS()); |
519 | auto *RHS = valueForNode(CN__->getRHS()); |
520 | std::string allocName = std::string(N->getName()) + ".res" ; |
521 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
522 | auto *V = builder_.createElementMulInst(N->getName(), Dest__, LHS, RHS); |
523 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
524 | registerIR(CN__->getResult(), V->getDest()); |
525 | nodeToInstr_[N] = V; |
526 | break; |
527 | } |
528 | case glow::Kinded::Kind::DivNodeKind: { |
529 | auto *CN__ = cast<DivNode>(N); |
530 | auto *LHS = valueForNode(CN__->getLHS()); |
531 | auto *RHS = valueForNode(CN__->getRHS()); |
532 | std::string allocName = std::string(N->getName()) + ".res" ; |
533 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
534 | auto *V = builder_.createElementDivInst(N->getName(), Dest__, LHS, RHS); |
535 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
536 | registerIR(CN__->getResult(), V->getDest()); |
537 | nodeToInstr_[N] = V; |
538 | break; |
539 | } |
540 | case glow::Kinded::Kind::FmodNodeKind: { |
541 | auto *CN__ = cast<FmodNode>(N); |
542 | auto *LHS = valueForNode(CN__->getLHS()); |
543 | auto *RHS = valueForNode(CN__->getRHS()); |
544 | std::string allocName = std::string(N->getName()) + ".res" ; |
545 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
546 | auto *V = builder_.createElementFmodInst(N->getName(), Dest__, LHS, RHS); |
547 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
548 | registerIR(CN__->getResult(), V->getDest()); |
549 | nodeToInstr_[N] = V; |
550 | break; |
551 | } |
552 | case glow::Kinded::Kind::MaxNodeKind: { |
553 | auto *CN__ = cast<MaxNode>(N); |
554 | auto *LHS = valueForNode(CN__->getLHS()); |
555 | auto *RHS = valueForNode(CN__->getRHS()); |
556 | std::string allocName = std::string(N->getName()) + ".res" ; |
557 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
558 | auto *V = builder_.createElementMaxInst(N->getName(), Dest__, LHS, RHS); |
559 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
560 | registerIR(CN__->getResult(), V->getDest()); |
561 | nodeToInstr_[N] = V; |
562 | break; |
563 | } |
564 | case glow::Kinded::Kind::MinNodeKind: { |
565 | auto *CN__ = cast<MinNode>(N); |
566 | auto *LHS = valueForNode(CN__->getLHS()); |
567 | auto *RHS = valueForNode(CN__->getRHS()); |
568 | std::string allocName = std::string(N->getName()) + ".res" ; |
569 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
570 | auto *V = builder_.createElementMinInst(N->getName(), Dest__, LHS, RHS); |
571 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
572 | registerIR(CN__->getResult(), V->getDest()); |
573 | nodeToInstr_[N] = V; |
574 | break; |
575 | } |
576 | case glow::Kinded::Kind::CmpEQNodeKind: { |
577 | auto *CN__ = cast<CmpEQNode>(N); |
578 | auto *LHS = valueForNode(CN__->getLHS()); |
579 | auto *RHS = valueForNode(CN__->getRHS()); |
580 | std::string allocName = std::string(N->getName()) + ".res" ; |
581 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
582 | auto *V = builder_.createElementCmpEQInst(N->getName(), Dest__, LHS, RHS); |
583 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
584 | registerIR(CN__->getResult(), V->getDest()); |
585 | nodeToInstr_[N] = V; |
586 | break; |
587 | } |
588 | case glow::Kinded::Kind::CmpNEQNodeKind: { |
589 | auto *CN__ = cast<CmpNEQNode>(N); |
590 | auto *LHS = valueForNode(CN__->getLHS()); |
591 | auto *RHS = valueForNode(CN__->getRHS()); |
592 | std::string allocName = std::string(N->getName()) + ".res" ; |
593 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
594 | auto *V = builder_.createElementCmpNEQInst(N->getName(), Dest__, LHS, RHS); |
595 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
596 | registerIR(CN__->getResult(), V->getDest()); |
597 | nodeToInstr_[N] = V; |
598 | break; |
599 | } |
600 | case glow::Kinded::Kind::CmpLTNodeKind: { |
601 | auto *CN__ = cast<CmpLTNode>(N); |
602 | auto *LHS = valueForNode(CN__->getLHS()); |
603 | auto *RHS = valueForNode(CN__->getRHS()); |
604 | std::string allocName = std::string(N->getName()) + ".res" ; |
605 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
606 | auto *V = builder_.createElementCmpLTInst(N->getName(), Dest__, LHS, RHS); |
607 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
608 | registerIR(CN__->getResult(), V->getDest()); |
609 | nodeToInstr_[N] = V; |
610 | break; |
611 | } |
612 | case glow::Kinded::Kind::CmpLTENodeKind: { |
613 | auto *CN__ = cast<CmpLTENode>(N); |
614 | auto *LHS = valueForNode(CN__->getLHS()); |
615 | auto *RHS = valueForNode(CN__->getRHS()); |
616 | std::string allocName = std::string(N->getName()) + ".res" ; |
617 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
618 | auto *V = builder_.createElementCmpLTEInst(N->getName(), Dest__, LHS, RHS); |
619 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
620 | registerIR(CN__->getResult(), V->getDest()); |
621 | nodeToInstr_[N] = V; |
622 | break; |
623 | } |
624 | case glow::Kinded::Kind::IsNaNNodeKind: { |
625 | auto *CN__ = cast<IsNaNNode>(N); |
626 | auto *Src = valueForNode(CN__->getInput()); |
627 | std::string allocName = std::string(N->getName()) + ".res" ; |
628 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
629 | auto *V = builder_.createElementIsNaNInst(N->getName(), Dest__, Src); |
630 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
631 | registerIR(CN__->getResult(), V->getDest()); |
632 | nodeToInstr_[N] = V; |
633 | break; |
634 | } |
635 | case glow::Kinded::Kind::PowNodeKind: { |
636 | auto *CN__ = cast<PowNode>(N); |
637 | auto *LHS = valueForNode(CN__->getLHS()); |
638 | auto *RHS = valueForNode(CN__->getRHS()); |
639 | std::string allocName = std::string(N->getName()) + ".res" ; |
640 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
641 | auto *V = builder_.createElementPowInst(N->getName(), Dest__, LHS, RHS); |
642 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
643 | registerIR(CN__->getResult(), V->getDest()); |
644 | nodeToInstr_[N] = V; |
645 | break; |
646 | } |
647 | case glow::Kinded::Kind::AndNodeKind: { |
648 | auto *CN__ = cast<AndNode>(N); |
649 | auto *LHS = valueForNode(CN__->getLHS()); |
650 | auto *RHS = valueForNode(CN__->getRHS()); |
651 | std::string allocName = std::string(N->getName()) + ".res" ; |
652 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
653 | auto *V = builder_.createElementAndInst(N->getName(), Dest__, LHS, RHS); |
654 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
655 | registerIR(CN__->getResult(), V->getDest()); |
656 | nodeToInstr_[N] = V; |
657 | break; |
658 | } |
659 | case glow::Kinded::Kind::BitwiseAndNodeKind: { |
660 | auto *CN__ = cast<BitwiseAndNode>(N); |
661 | auto *LHS = valueForNode(CN__->getLHS()); |
662 | auto *RHS = valueForNode(CN__->getRHS()); |
663 | std::string allocName = std::string(N->getName()) + ".res" ; |
664 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
665 | auto *V = builder_.createElementBitwiseAndInst(N->getName(), Dest__, LHS, RHS); |
666 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
667 | registerIR(CN__->getResult(), V->getDest()); |
668 | nodeToInstr_[N] = V; |
669 | break; |
670 | } |
671 | case glow::Kinded::Kind::OrNodeKind: { |
672 | auto *CN__ = cast<OrNode>(N); |
673 | auto *LHS = valueForNode(CN__->getLHS()); |
674 | auto *RHS = valueForNode(CN__->getRHS()); |
675 | std::string allocName = std::string(N->getName()) + ".res" ; |
676 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
677 | auto *V = builder_.createElementOrInst(N->getName(), Dest__, LHS, RHS); |
678 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
679 | registerIR(CN__->getResult(), V->getDest()); |
680 | nodeToInstr_[N] = V; |
681 | break; |
682 | } |
683 | case glow::Kinded::Kind::BitwiseOrNodeKind: { |
684 | auto *CN__ = cast<BitwiseOrNode>(N); |
685 | auto *LHS = valueForNode(CN__->getLHS()); |
686 | auto *RHS = valueForNode(CN__->getRHS()); |
687 | std::string allocName = std::string(N->getName()) + ".res" ; |
688 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
689 | auto *V = builder_.createElementBitwiseOrInst(N->getName(), Dest__, LHS, RHS); |
690 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
691 | registerIR(CN__->getResult(), V->getDest()); |
692 | nodeToInstr_[N] = V; |
693 | break; |
694 | } |
695 | case glow::Kinded::Kind::XorNodeKind: { |
696 | auto *CN__ = cast<XorNode>(N); |
697 | auto *LHS = valueForNode(CN__->getLHS()); |
698 | auto *RHS = valueForNode(CN__->getRHS()); |
699 | std::string allocName = std::string(N->getName()) + ".res" ; |
700 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
701 | auto *V = builder_.createElementXorInst(N->getName(), Dest__, LHS, RHS); |
702 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
703 | registerIR(CN__->getResult(), V->getDest()); |
704 | nodeToInstr_[N] = V; |
705 | break; |
706 | } |
707 | case glow::Kinded::Kind::BitwiseXorNodeKind: { |
708 | auto *CN__ = cast<BitwiseXorNode>(N); |
709 | auto *LHS = valueForNode(CN__->getLHS()); |
710 | auto *RHS = valueForNode(CN__->getRHS()); |
711 | std::string allocName = std::string(N->getName()) + ".res" ; |
712 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
713 | auto *V = builder_.createElementBitwiseXorInst(N->getName(), Dest__, LHS, RHS); |
714 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
715 | registerIR(CN__->getResult(), V->getDest()); |
716 | nodeToInstr_[N] = V; |
717 | break; |
718 | } |
719 | case glow::Kinded::Kind::NotNodeKind: { |
720 | auto *CN__ = cast<NotNode>(N); |
721 | auto *Src = valueForNode(CN__->getInput()); |
722 | std::string allocName = std::string(N->getName()) + ".res" ; |
723 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
724 | auto *V = builder_.createElementNotInst(N->getName(), Dest__, Src); |
725 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
726 | registerIR(CN__->getResult(), V->getDest()); |
727 | nodeToInstr_[N] = V; |
728 | break; |
729 | } |
730 | case glow::Kinded::Kind::BitwiseNotNodeKind: { |
731 | auto *CN__ = cast<BitwiseNotNode>(N); |
732 | auto *Src = valueForNode(CN__->getInput()); |
733 | std::string allocName = std::string(N->getName()) + ".res" ; |
734 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
735 | auto *V = builder_.createElementBitwiseNotInst(N->getName(), Dest__, Src); |
736 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
737 | registerIR(CN__->getResult(), V->getDest()); |
738 | nodeToInstr_[N] = V; |
739 | break; |
740 | } |
741 | case glow::Kinded::Kind::NegNodeKind: { |
742 | auto *CN__ = cast<NegNode>(N); |
743 | auto *Src = valueForNode(CN__->getInput()); |
744 | std::string allocName = std::string(N->getName()) + ".res" ; |
745 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
746 | auto *V = builder_.createElementNegInst(N->getName(), Dest__, Src); |
747 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
748 | registerIR(CN__->getResult(), V->getDest()); |
749 | nodeToInstr_[N] = V; |
750 | break; |
751 | } |
752 | case glow::Kinded::Kind::AbsNodeKind: { |
753 | auto *CN__ = cast<AbsNode>(N); |
754 | auto *Src = valueForNode(CN__->getInput()); |
755 | std::string allocName = std::string(N->getName()) + ".res" ; |
756 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
757 | auto *V = builder_.createElementAbsInst(N->getName(), Dest__, Src); |
758 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
759 | registerIR(CN__->getResult(), V->getDest()); |
760 | nodeToInstr_[N] = V; |
761 | break; |
762 | } |
763 | case glow::Kinded::Kind::FloorNodeKind: { |
764 | auto *CN__ = cast<FloorNode>(N); |
765 | auto *Src = valueForNode(CN__->getInput()); |
766 | std::string allocName = std::string(N->getName()) + ".res" ; |
767 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
768 | auto *V = builder_.createElementFloorInst(N->getName(), Dest__, Src); |
769 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
770 | registerIR(CN__->getResult(), V->getDest()); |
771 | nodeToInstr_[N] = V; |
772 | break; |
773 | } |
774 | case glow::Kinded::Kind::SignNodeKind: { |
775 | auto *CN__ = cast<SignNode>(N); |
776 | auto *Src = valueForNode(CN__->getInput()); |
777 | std::string allocName = std::string(N->getName()) + ".res" ; |
778 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
779 | auto *V = builder_.createElementSignInst(N->getName(), Dest__, Src); |
780 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
781 | registerIR(CN__->getResult(), V->getDest()); |
782 | nodeToInstr_[N] = V; |
783 | break; |
784 | } |
785 | case glow::Kinded::Kind::CeilNodeKind: { |
786 | auto *CN__ = cast<CeilNode>(N); |
787 | auto *Src = valueForNode(CN__->getInput()); |
788 | std::string allocName = std::string(N->getName()) + ".res" ; |
789 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
790 | auto *V = builder_.createElementCeilInst(N->getName(), Dest__, Src); |
791 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
792 | registerIR(CN__->getResult(), V->getDest()); |
793 | nodeToInstr_[N] = V; |
794 | break; |
795 | } |
796 | case glow::Kinded::Kind::TruncateNodeKind: { |
797 | auto *CN__ = cast<TruncateNode>(N); |
798 | auto *Src = valueForNode(CN__->getInput()); |
799 | std::string allocName = std::string(N->getName()) + ".res" ; |
800 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
801 | auto *V = builder_.createElementTruncateInst(N->getName(), Dest__, Src); |
802 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
803 | registerIR(CN__->getResult(), V->getDest()); |
804 | nodeToInstr_[N] = V; |
805 | break; |
806 | } |
807 | case glow::Kinded::Kind::RoundNodeKind: { |
808 | auto *CN__ = cast<RoundNode>(N); |
809 | auto *Src = valueForNode(CN__->getInput()); |
810 | std::string allocName = std::string(N->getName()) + ".res" ; |
811 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
812 | auto *V = builder_.createElementRoundInst(N->getName(), Dest__, Src); |
813 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
814 | registerIR(CN__->getResult(), V->getDest()); |
815 | nodeToInstr_[N] = V; |
816 | break; |
817 | } |
818 | case glow::Kinded::Kind::SqrtNodeKind: { |
819 | auto *CN__ = cast<SqrtNode>(N); |
820 | auto *Src = valueForNode(CN__->getInput()); |
821 | std::string allocName = std::string(N->getName()) + ".res" ; |
822 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
823 | auto *V = builder_.createElementSqrtInst(N->getName(), Dest__, Src); |
824 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
825 | registerIR(CN__->getResult(), V->getDest()); |
826 | nodeToInstr_[N] = V; |
827 | break; |
828 | } |
829 | case glow::Kinded::Kind::RsqrtNodeKind: { |
830 | auto *CN__ = cast<RsqrtNode>(N); |
831 | auto *Src = valueForNode(CN__->getInput()); |
832 | std::string allocName = std::string(N->getName()) + ".res" ; |
833 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
834 | auto *V = builder_.createElementRsqrtInst(N->getName(), Dest__, Src); |
835 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
836 | registerIR(CN__->getResult(), V->getDest()); |
837 | nodeToInstr_[N] = V; |
838 | break; |
839 | } |
840 | case glow::Kinded::Kind::ReciprocalNodeKind: { |
841 | auto *CN__ = cast<ReciprocalNode>(N); |
842 | auto *Src = valueForNode(CN__->getInput()); |
843 | std::string allocName = std::string(N->getName()) + ".res" ; |
844 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
845 | auto *V = builder_.createElementReciprocalInst(N->getName(), Dest__, Src); |
846 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
847 | registerIR(CN__->getResult(), V->getDest()); |
848 | nodeToInstr_[N] = V; |
849 | break; |
850 | } |
851 | case glow::Kinded::Kind::SinNodeKind: { |
852 | auto *CN__ = cast<SinNode>(N); |
853 | auto *Src = valueForNode(CN__->getInput()); |
854 | std::string allocName = std::string(N->getName()) + ".res" ; |
855 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
856 | auto *V = builder_.createElementSinInst(N->getName(), Dest__, Src); |
857 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
858 | registerIR(CN__->getResult(), V->getDest()); |
859 | nodeToInstr_[N] = V; |
860 | break; |
861 | } |
862 | case glow::Kinded::Kind::CosNodeKind: { |
863 | auto *CN__ = cast<CosNode>(N); |
864 | auto *Src = valueForNode(CN__->getInput()); |
865 | std::string allocName = std::string(N->getName()) + ".res" ; |
866 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
867 | auto *V = builder_.createElementCosInst(N->getName(), Dest__, Src); |
868 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
869 | registerIR(CN__->getResult(), V->getDest()); |
870 | nodeToInstr_[N] = V; |
871 | break; |
872 | } |
873 | case glow::Kinded::Kind::LogNodeKind: { |
874 | auto *CN__ = cast<LogNode>(N); |
875 | auto *Src = valueForNode(CN__->getInput()); |
876 | std::string allocName = std::string(N->getName()) + ".res" ; |
877 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
878 | auto *V = builder_.createElementLogInst(N->getName(), Dest__, Src); |
879 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
880 | registerIR(CN__->getResult(), V->getDest()); |
881 | nodeToInstr_[N] = V; |
882 | break; |
883 | } |
884 | case glow::Kinded::Kind::ExpNodeKind: { |
885 | auto *CN__ = cast<ExpNode>(N); |
886 | auto *Src = valueForNode(CN__->getInput()); |
887 | std::string allocName = std::string(N->getName()) + ".res" ; |
888 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
889 | auto *V = builder_.createElementExpInst(N->getName(), Dest__, Src); |
890 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
891 | registerIR(CN__->getResult(), V->getDest()); |
892 | nodeToInstr_[N] = V; |
893 | break; |
894 | } |
895 | case glow::Kinded::Kind::AcosNodeKind: { |
896 | auto *CN__ = cast<AcosNode>(N); |
897 | auto *Src = valueForNode(CN__->getInput()); |
898 | std::string allocName = std::string(N->getName()) + ".res" ; |
899 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
900 | auto *V = builder_.createElementAcosInst(N->getName(), Dest__, Src); |
901 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
902 | registerIR(CN__->getResult(), V->getDest()); |
903 | nodeToInstr_[N] = V; |
904 | break; |
905 | } |
906 | case glow::Kinded::Kind::AsinNodeKind: { |
907 | auto *CN__ = cast<AsinNode>(N); |
908 | auto *Src = valueForNode(CN__->getInput()); |
909 | std::string allocName = std::string(N->getName()) + ".res" ; |
910 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
911 | auto *V = builder_.createElementAsinInst(N->getName(), Dest__, Src); |
912 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
913 | registerIR(CN__->getResult(), V->getDest()); |
914 | nodeToInstr_[N] = V; |
915 | break; |
916 | } |
917 | case glow::Kinded::Kind::AtanNodeKind: { |
918 | auto *CN__ = cast<AtanNode>(N); |
919 | auto *Src = valueForNode(CN__->getInput()); |
920 | std::string allocName = std::string(N->getName()) + ".res" ; |
921 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
922 | auto *V = builder_.createElementAtanInst(N->getName(), Dest__, Src); |
923 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
924 | registerIR(CN__->getResult(), V->getDest()); |
925 | nodeToInstr_[N] = V; |
926 | break; |
927 | } |
928 | case glow::Kinded::Kind::ErfNodeKind: { |
929 | auto *CN__ = cast<ErfNode>(N); |
930 | auto *Src = valueForNode(CN__->getInput()); |
931 | std::string allocName = std::string(N->getName()) + ".res" ; |
932 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
933 | auto *V = builder_.createElementErfInst(N->getName(), Dest__, Src); |
934 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
935 | registerIR(CN__->getResult(), V->getDest()); |
936 | nodeToInstr_[N] = V; |
937 | break; |
938 | } |
939 | case glow::Kinded::Kind::NonZeroNodeKind: { |
940 | auto *CN__ = cast<NonZeroNode>(N); |
941 | auto *Cond = valueForNode(CN__->getCond()); |
942 | std::string allocName = std::string(N->getName()) + ".res" ; |
943 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
944 | auto *V = builder_.createNonZeroInst(N->getName(), Dest__, Cond); |
945 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
946 | registerIR(CN__->getResult(), V->getDest()); |
947 | nodeToInstr_[N] = V; |
948 | break; |
949 | } |
950 | case glow::Kinded::Kind::SelectNodeKind: { |
951 | auto *CN__ = cast<SelectNode>(N); |
952 | auto *Cond = valueForNode(CN__->getCond()); |
953 | auto *LHS = valueForNode(CN__->getLHS()); |
954 | auto *RHS = valueForNode(CN__->getRHS()); |
955 | std::string allocName = std::string(N->getName()) + ".res" ; |
956 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
957 | auto *V = builder_.createElementSelectInst(N->getName(), Dest__, Cond, LHS, RHS); |
958 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
959 | registerIR(CN__->getResult(), V->getDest()); |
960 | nodeToInstr_[N] = V; |
961 | break; |
962 | } |
963 | case glow::Kinded::Kind::ModuloNodeKind: { |
964 | auto *CN__ = cast<ModuloNode>(N); |
965 | auto *Src = valueForNode(CN__->getInput()); |
966 | std::string allocName = std::string(N->getName()) + ".res" ; |
967 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
968 | auto *V = builder_.createModuloInst(N->getName(), Dest__, Src, CN__->getDivisor(), CN__->getSignFollowDivisor()); |
969 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
970 | registerIR(CN__->getResult(), V->getDest()); |
971 | nodeToInstr_[N] = V; |
972 | break; |
973 | } |
974 | case glow::Kinded::Kind::BatchedUnaryEmbeddingsBagsNodeKind: { |
975 | auto *CN__ = cast<BatchedUnaryEmbeddingsBagsNode>(N); |
976 | auto *Weights = valueForNode(CN__->getWeights()); |
977 | auto *TableOffsets = valueForNode(CN__->getTableOffsets()); |
978 | auto *Offsets = valueForNode(CN__->getOffsets()); |
979 | auto *Indices = valueForNode(CN__->getIndices()); |
980 | std::string allocName = std::string(N->getName()) + ".res" ; |
981 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
982 | auto *V = builder_.createBatchedUnaryEmbeddingsBagsInst(N->getName(), Dest__, Weights, TableOffsets, Offsets, Indices); |
983 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
984 | registerIR(CN__->getResult(), V->getDest()); |
985 | nodeToInstr_[N] = V; |
986 | break; |
987 | } |
988 | case glow::Kinded::Kind::IntNBitSplitEmbeddingBagsNodeKind: { |
989 | auto *CN__ = cast<IntNBitSplitEmbeddingBagsNode>(N); |
990 | auto *DevWeights = valueForNode(CN__->getDevWeights()); |
991 | auto *UvmWeights = valueForNode(CN__->getUvmWeights()); |
992 | auto *WeightsPlacements = valueForNode(CN__->getWeightsPlacements()); |
993 | auto *WeightsOffsets = valueForNode(CN__->getWeightsOffsets()); |
994 | auto *WeightsTys = valueForNode(CN__->getWeightsTys()); |
995 | auto *DimOffsets = valueForNode(CN__->getDimOffsets()); |
996 | auto *Indices = valueForNode(CN__->getIndices()); |
997 | auto *Offsets = valueForNode(CN__->getOffsets()); |
998 | std::string allocName = std::string(N->getName()) + ".res" ; |
999 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1000 | auto *V = builder_.createIntNBitSplitEmbeddingBagsInst(N->getName(), Dest__, DevWeights, UvmWeights, WeightsPlacements, WeightsOffsets, WeightsTys, DimOffsets, Indices, Offsets, CN__->getTotalDims(), CN__->getPoolingMode(), CN__->getOutputDType()); |
1001 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1002 | registerIR(CN__->getResult(), V->getDest()); |
1003 | nodeToInstr_[N] = V; |
1004 | break; |
1005 | } |
1006 | case glow::Kinded::Kind::IntNBitSplitEmbeddingWeightedBagsNodeKind: { |
1007 | auto *CN__ = cast<IntNBitSplitEmbeddingWeightedBagsNode>(N); |
1008 | auto *DevWeights = valueForNode(CN__->getDevWeights()); |
1009 | auto *UvmWeights = valueForNode(CN__->getUvmWeights()); |
1010 | auto *WeightsPlacements = valueForNode(CN__->getWeightsPlacements()); |
1011 | auto *WeightsOffsets = valueForNode(CN__->getWeightsOffsets()); |
1012 | auto *WeightsTys = valueForNode(CN__->getWeightsTys()); |
1013 | auto *DimOffsets = valueForNode(CN__->getDimOffsets()); |
1014 | auto *Indices = valueForNode(CN__->getIndices()); |
1015 | auto *Offsets = valueForNode(CN__->getOffsets()); |
1016 | auto *IndiceWeight = valueForNode(CN__->getIndiceWeight()); |
1017 | std::string allocName = std::string(N->getName()) + ".res" ; |
1018 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1019 | auto *V = builder_.createIntNBitSplitEmbeddingWeightedBagsInst(N->getName(), Dest__, DevWeights, UvmWeights, WeightsPlacements, WeightsOffsets, WeightsTys, DimOffsets, Indices, Offsets, IndiceWeight, CN__->getTotalDims(), CN__->getPoolingMode(), CN__->getOutputDType()); |
1020 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1021 | registerIR(CN__->getResult(), V->getDest()); |
1022 | nodeToInstr_[N] = V; |
1023 | break; |
1024 | } |
1025 | case glow::Kinded::Kind::GaussianFillNodeKind: { |
1026 | auto *CN__ = cast<GaussianFillNode>(N); |
1027 | auto *Input = valueForNode(CN__->getInput()); |
1028 | std::string allocName = std::string(N->getName()) + ".res" ; |
1029 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1030 | auto *V = builder_.createGaussianFillInst(N->getName(), Dest__, Input, CN__->getMean(), CN__->getScale(), CN__->getSeed()); |
1031 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1032 | registerIR(CN__->getResult(), V->getDest()); |
1033 | nodeToInstr_[N] = V; |
1034 | break; |
1035 | } |
1036 | case glow::Kinded::Kind::ReluNodeKind: { |
1037 | auto *CN__ = cast<ReluNode>(N); |
1038 | auto *Src = valueForNode(CN__->getInput()); |
1039 | std::string allocName = std::string(N->getName()) + ".res" ; |
1040 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1041 | auto *V = builder_.createReluInst(N->getName(), Dest__, Src); |
1042 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1043 | registerIR(CN__->getResult(), V->getDest()); |
1044 | nodeToInstr_[N] = V; |
1045 | break; |
1046 | } |
1047 | case glow::Kinded::Kind::ClipNodeKind: { |
1048 | auto *CN__ = cast<ClipNode>(N); |
1049 | auto *Src = valueForNode(CN__->getInput()); |
1050 | std::string allocName = std::string(N->getName()) + ".res" ; |
1051 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1052 | auto *V = builder_.createClipInst(N->getName(), Dest__, Src, CN__->getMin(), CN__->getMax()); |
1053 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1054 | registerIR(CN__->getResult(), V->getDest()); |
1055 | nodeToInstr_[N] = V; |
1056 | break; |
1057 | } |
1058 | case glow::Kinded::Kind::SigmoidNodeKind: { |
1059 | auto *CN__ = cast<SigmoidNode>(N); |
1060 | auto *Src = valueForNode(CN__->getInput()); |
1061 | std::string allocName = std::string(N->getName()) + ".res" ; |
1062 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1063 | auto *V = builder_.createSigmoidInst(N->getName(), Dest__, Src); |
1064 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1065 | registerIR(CN__->getResult(), V->getDest()); |
1066 | nodeToInstr_[N] = V; |
1067 | break; |
1068 | } |
1069 | case glow::Kinded::Kind::TanhNodeKind: { |
1070 | auto *CN__ = cast<TanhNode>(N); |
1071 | auto *Src = valueForNode(CN__->getInput()); |
1072 | std::string allocName = std::string(N->getName()) + ".res" ; |
1073 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1074 | auto *V = builder_.createTanhInst(N->getName(), Dest__, Src); |
1075 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1076 | registerIR(CN__->getResult(), V->getDest()); |
1077 | nodeToInstr_[N] = V; |
1078 | break; |
1079 | } |
1080 | case glow::Kinded::Kind::LeakyReluNodeKind: { |
1081 | auto *CN__ = cast<LeakyReluNode>(N); |
1082 | auto *Src = valueForNode(CN__->getInput()); |
1083 | std::string allocName = std::string(N->getName()) + ".res" ; |
1084 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1085 | auto *V = builder_.createLeakyReluInst(N->getName(), Dest__, Src, CN__->getAlpha()); |
1086 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1087 | registerIR(CN__->getResult(), V->getDest()); |
1088 | nodeToInstr_[N] = V; |
1089 | break; |
1090 | } |
1091 | case glow::Kinded::Kind::SoftPlusNodeKind: { |
1092 | auto *CN__ = cast<SoftPlusNode>(N); |
1093 | auto *Src = valueForNode(CN__->getInput()); |
1094 | std::string allocName = std::string(N->getName()) + ".res" ; |
1095 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1096 | auto *V = builder_.createSoftPlusInst(N->getName(), Dest__, Src); |
1097 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1098 | registerIR(CN__->getResult(), V->getDest()); |
1099 | nodeToInstr_[N] = V; |
1100 | break; |
1101 | } |
1102 | case glow::Kinded::Kind::TransposeNodeKind: { |
1103 | auto *CN__ = cast<TransposeNode>(N); |
1104 | auto *Src = valueForNode(CN__->getInput()); |
1105 | std::string allocName = std::string(N->getName()) + ".res" ; |
1106 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1107 | auto *V = builder_.createTransposeInst(N->getName(), Dest__, Src, CN__->getShuffle()); |
1108 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1109 | registerIR(CN__->getResult(), V->getDest()); |
1110 | nodeToInstr_[N] = V; |
1111 | break; |
1112 | } |
1113 | case glow::Kinded::Kind::SplatNodeKind: { |
1114 | auto *CN__ = cast<SplatNode>(N); |
1115 | std::string allocName = std::string(N->getName()) + ".res" ; |
1116 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1117 | auto *V = builder_.createSplatInst(N->getName(), Dest__, CN__->getValue()); |
1118 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1119 | registerIR(CN__->getResult(), V->getDest()); |
1120 | nodeToInstr_[N] = V; |
1121 | break; |
1122 | } |
1123 | case glow::Kinded::Kind::TouchNodeKind: { |
1124 | auto *CN__ = cast<TouchNode>(N); |
1125 | std::string allocName = std::string(N->getName()) + ".res" ; |
1126 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1127 | auto *V = builder_.createTouchInst(N->getName(), Dest__); |
1128 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1129 | registerIR(CN__->getResult(), V->getDest()); |
1130 | nodeToInstr_[N] = V; |
1131 | break; |
1132 | } |
1133 | case glow::Kinded::Kind::GatherNodeKind: { |
1134 | auto *CN__ = cast<GatherNode>(N); |
1135 | auto *Data = valueForNode(CN__->getData()); |
1136 | auto *Indices = valueForNode(CN__->getIndices()); |
1137 | std::string allocName = std::string(N->getName()) + ".res" ; |
1138 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1139 | auto *V = builder_.createGatherInst(N->getName(), Dest__, Data, Indices, CN__->getBatchDims()); |
1140 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1141 | registerIR(CN__->getResult(), V->getDest()); |
1142 | nodeToInstr_[N] = V; |
1143 | break; |
1144 | } |
1145 | case glow::Kinded::Kind::GatherNDNodeKind: { |
1146 | auto *CN__ = cast<GatherNDNode>(N); |
1147 | auto *Data = valueForNode(CN__->getData()); |
1148 | auto *Indices = valueForNode(CN__->getIndices()); |
1149 | std::string allocName = std::string(N->getName()) + ".res" ; |
1150 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1151 | auto *V = builder_.createGatherNDInst(N->getName(), Dest__, Data, Indices, CN__->getBatchDims()); |
1152 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1153 | registerIR(CN__->getResult(), V->getDest()); |
1154 | nodeToInstr_[N] = V; |
1155 | break; |
1156 | } |
1157 | case glow::Kinded::Kind::GatherElementsNodeKind: { |
1158 | auto *CN__ = cast<GatherElementsNode>(N); |
1159 | auto *Data = valueForNode(CN__->getData()); |
1160 | auto *Indices = valueForNode(CN__->getIndices()); |
1161 | std::string allocName = std::string(N->getName()) + ".res" ; |
1162 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1163 | auto *V = builder_.createGatherElementsInst(N->getName(), Dest__, Data, Indices, CN__->getDim()); |
1164 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1165 | registerIR(CN__->getResult(), V->getDest()); |
1166 | nodeToInstr_[N] = V; |
1167 | break; |
1168 | } |
1169 | case glow::Kinded::Kind::GatherRangesNodeKind: { |
1170 | auto *CN__ = cast<GatherRangesNode>(N); |
1171 | auto *Data = valueForNode(CN__->getData()); |
1172 | auto *Ranges = valueForNode(CN__->getRanges()); |
1173 | std::string allocName = std::string(N->getName()) + ".res" ; |
1174 | auto *Output__ = builder_.createAllocActivationInst(allocName,CN__->getOutput().getType()); |
1175 | auto *Lengths__ = builder_.createAllocActivationInst(allocName,CN__->getLengths().getType()); |
1176 | auto *V = builder_.createGatherRangesInst(N->getName(), Output__, Lengths__, Data, Ranges); |
1177 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1178 | registerIR(CN__->getOutput(), V->getOutput()); |
1179 | registerIR(CN__->getLengths(), V->getLengths()); |
1180 | nodeToInstr_[N] = V; |
1181 | break; |
1182 | } |
1183 | case glow::Kinded::Kind::BatchOneHotNodeKind: { |
1184 | auto *CN__ = cast<BatchOneHotNode>(N); |
1185 | auto *Data = valueForNode(CN__->getData()); |
1186 | auto *Lengths = valueForNode(CN__->getLengths()); |
1187 | auto *Values = valueForNode(CN__->getValues()); |
1188 | std::string allocName = std::string(N->getName()) + ".res" ; |
1189 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1190 | auto *V = builder_.createBatchOneHotInst(N->getName(), Dest__, Data, Lengths, Values); |
1191 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1192 | registerIR(CN__->getResult(), V->getDest()); |
1193 | nodeToInstr_[N] = V; |
1194 | break; |
1195 | } |
1196 | case glow::Kinded::Kind::SpaceToDepthNodeKind: { |
1197 | auto *CN__ = cast<SpaceToDepthNode>(N); |
1198 | auto *Src = valueForNode(CN__->getInput()); |
1199 | std::string allocName = std::string(N->getName()) + ".res" ; |
1200 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1201 | auto *V = builder_.createSpaceToDepthInst(N->getName(), Dest__, Src, CN__->getBlockSize()); |
1202 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1203 | registerIR(CN__->getResult(), V->getDest()); |
1204 | nodeToInstr_[N] = V; |
1205 | break; |
1206 | } |
1207 | case glow::Kinded::Kind::ResizeNearestNodeKind: { |
1208 | auto *CN__ = cast<ResizeNearestNode>(N); |
1209 | auto *Src = valueForNode(CN__->getInput()); |
1210 | std::string allocName = std::string(N->getName()) + ".res" ; |
1211 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1212 | auto *V = builder_.createResizeNearestInst(N->getName(), Dest__, Src, CN__->getScale()); |
1213 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1214 | registerIR(CN__->getResult(), V->getDest()); |
1215 | nodeToInstr_[N] = V; |
1216 | break; |
1217 | } |
1218 | case glow::Kinded::Kind::ResizeBilinearNodeKind: { |
1219 | auto *CN__ = cast<ResizeBilinearNode>(N); |
1220 | auto *Src = valueForNode(CN__->getInput()); |
1221 | std::string allocName = std::string(N->getName()) + ".res" ; |
1222 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1223 | auto *V = builder_.createResizeBilinearInst(N->getName(), Dest__, Src, CN__->getScale()); |
1224 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1225 | registerIR(CN__->getResult(), V->getDest()); |
1226 | nodeToInstr_[N] = V; |
1227 | break; |
1228 | } |
1229 | case glow::Kinded::Kind::SparseLabelSplitNodeKind: { |
1230 | auto *CN__ = cast<SparseLabelSplitNode>(N); |
1231 | auto *Lengths = valueForNode(CN__->getLengths()); |
1232 | auto *Indices = valueForNode(CN__->getIndices()); |
1233 | auto *Values = valueForNode(CN__->getValues()); |
1234 | std::string allocName = std::string(N->getName()) + ".res" ; |
1235 | auto *LabelValues__ = builder_.createAllocActivationInst(allocName,CN__->getLabelValues().getType()); |
1236 | auto *ExampleIds__ = builder_.createAllocActivationInst(allocName,CN__->getExampleIds().getType()); |
1237 | auto *GradientOffsetMap__ = builder_.createAllocActivationInst(allocName,CN__->getGradientOffsetMap().getType()); |
1238 | auto *V = builder_.createSparseLabelSplitInst(N->getName(), LabelValues__, ExampleIds__, GradientOffsetMap__, Lengths, Indices, Values, CN__->getNumLabels()); |
1239 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1240 | registerIR(CN__->getLabelValues(), V->getLabelValues()); |
1241 | registerIR(CN__->getExampleIds(), V->getExampleIds()); |
1242 | registerIR(CN__->getGradientOffsetMap(), V->getGradientOffsetMap()); |
1243 | nodeToInstr_[N] = V; |
1244 | break; |
1245 | } |
1246 | case glow::Kinded::Kind::FlipNodeKind: { |
1247 | auto *CN__ = cast<FlipNode>(N); |
1248 | auto *Src = valueForNode(CN__->getInput()); |
1249 | std::string allocName = std::string(N->getName()) + ".res" ; |
1250 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1251 | auto *V = builder_.createFlipInst(N->getName(), Dest__, Src, CN__->getAxis()); |
1252 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1253 | registerIR(CN__->getResult(), V->getDest()); |
1254 | nodeToInstr_[N] = V; |
1255 | break; |
1256 | } |
1257 | case glow::Kinded::Kind::IntLookupTableNodeKind: { |
1258 | auto *CN__ = cast<IntLookupTableNode>(N); |
1259 | auto *Src = valueForNode(CN__->getInput()); |
1260 | auto *Mapping = valueForNode(CN__->getMapping()); |
1261 | std::string allocName = std::string(N->getName()) + ".res" ; |
1262 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1263 | auto *V = builder_.createIntLookupTableInst(N->getName(), Dest__, Src, Mapping); |
1264 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1265 | registerIR(CN__->getResult(), V->getDest()); |
1266 | nodeToInstr_[N] = V; |
1267 | break; |
1268 | } |
1269 | case glow::Kinded::Kind::QuantizeNodeKind: { |
1270 | auto *CN__ = cast<QuantizeNode>(N); |
1271 | auto *Src = valueForNode(CN__->getInput()); |
1272 | std::string allocName = std::string(N->getName()) + ".res" ; |
1273 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1274 | auto *V = builder_.createQuantizeInst(N->getName(), Dest__, Src); |
1275 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1276 | registerIR(CN__->getResult(), V->getDest()); |
1277 | nodeToInstr_[N] = V; |
1278 | break; |
1279 | } |
1280 | case glow::Kinded::Kind::DequantizeNodeKind: { |
1281 | auto *CN__ = cast<DequantizeNode>(N); |
1282 | auto *Src = valueForNode(CN__->getInput()); |
1283 | std::string allocName = std::string(N->getName()) + ".res" ; |
1284 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1285 | auto *V = builder_.createDequantizeInst(N->getName(), Dest__, Src); |
1286 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1287 | registerIR(CN__->getResult(), V->getDest()); |
1288 | nodeToInstr_[N] = V; |
1289 | break; |
1290 | } |
1291 | case glow::Kinded::Kind::RescaleQuantizedNodeKind: { |
1292 | auto *CN__ = cast<RescaleQuantizedNode>(N); |
1293 | auto *Src = valueForNode(CN__->getInput()); |
1294 | std::string allocName = std::string(N->getName()) + ".res" ; |
1295 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1296 | auto *V = builder_.createRescaleQuantizedInst(N->getName(), Dest__, Src); |
1297 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1298 | registerIR(CN__->getResult(), V->getDest()); |
1299 | nodeToInstr_[N] = V; |
1300 | break; |
1301 | } |
1302 | case glow::Kinded::Kind::ConvertToNodeKind: { |
1303 | auto *CN__ = cast<ConvertToNode>(N); |
1304 | auto *Input = valueForNode(CN__->getInput()); |
1305 | std::string allocName = std::string(N->getName()) + ".res" ; |
1306 | auto *Result__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1307 | auto *V = builder_.createConvertToInst(N->getName(), Result__, Input); |
1308 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1309 | registerIR(CN__->getResult(), V->getResult()); |
1310 | nodeToInstr_[N] = V; |
1311 | break; |
1312 | } |
1313 | case glow::Kinded::Kind::AudioSpectrogramNodeKind: { |
1314 | auto *CN__ = cast<AudioSpectrogramNode>(N); |
1315 | auto *Input = valueForNode(CN__->getInput()); |
1316 | auto *Window = valueForNode(CN__->getWindow()); |
1317 | auto *TwiddleFactors = valueForNode(CN__->getTwiddleFactors()); |
1318 | auto *BitReverseIndices = valueForNode(CN__->getBitReverseIndices()); |
1319 | auto *ComplexToRealWeights = valueForNode(CN__->getComplexToRealWeights()); |
1320 | std::string allocName = std::string(N->getName()) + ".res" ; |
1321 | auto *Spectrogram__ = builder_.createAllocActivationInst(allocName,CN__->getSpectrogram().getType()); |
1322 | auto *V = builder_.createAudioSpectrogramInst(N->getName(), Spectrogram__, Input, Window, TwiddleFactors, BitReverseIndices, ComplexToRealWeights, CN__->getWindowSize(), CN__->getWindowStride(), CN__->getMagnitudeSquared()); |
1323 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1324 | registerIR(CN__->getSpectrogram(), V->getSpectrogram()); |
1325 | nodeToInstr_[N] = V; |
1326 | break; |
1327 | } |
1328 | case glow::Kinded::Kind::MFCCNodeKind: { |
1329 | auto *CN__ = cast<MFCCNode>(N); |
1330 | auto *Spectrogram = valueForNode(CN__->getSpectrogram()); |
1331 | auto *MelWeights = valueForNode(CN__->getMelWeights()); |
1332 | auto *MelRanges = valueForNode(CN__->getMelRanges()); |
1333 | auto *DctMat = valueForNode(CN__->getDctMat()); |
1334 | std::string allocName = std::string(N->getName()) + ".res" ; |
1335 | auto *Coefficients__ = builder_.createAllocActivationInst(allocName,CN__->getCoefficients().getType()); |
1336 | auto *V = builder_.createMFCCInst(N->getName(), Coefficients__, Spectrogram, MelWeights, MelRanges, DctMat, CN__->getSampleRate(), CN__->getLowerFrequency(), CN__->getUpperFrequency(), CN__->getFilterBankCount(), CN__->getNumCoefficients()); |
1337 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1338 | registerIR(CN__->getCoefficients(), V->getCoefficients()); |
1339 | nodeToInstr_[N] = V; |
1340 | break; |
1341 | } |
1342 | case glow::Kinded::Kind::NonMaxSuppressionNodeKind: { |
1343 | auto *CN__ = cast<NonMaxSuppressionNode>(N); |
1344 | auto *Boxes = valueForNode(CN__->getBoxes()); |
1345 | auto *Scores = valueForNode(CN__->getScores()); |
1346 | std::string allocName = std::string(N->getName()) + ".res" ; |
1347 | auto *Indices__ = builder_.createAllocActivationInst(allocName,CN__->getIndices().getType()); |
1348 | auto *NumberOfSelectedIndices__ = builder_.createAllocActivationInst(allocName,CN__->getNumberOfSelectedIndices().getType()); |
1349 | auto *V = builder_.createNonMaxSuppressionInst(N->getName(), Indices__, NumberOfSelectedIndices__, Boxes, Scores, CN__->getCenterPointBox(), CN__->getMaxOutputBoxesPerClass(), CN__->getIouThreshold(), CN__->getScoreThreshold(), CN__->getIsTFVersion4()); |
1350 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1351 | registerIR(CN__->getIndices(), V->getIndices()); |
1352 | registerIR(CN__->getNumberOfSelectedIndices(), V->getNumberOfSelectedIndices()); |
1353 | nodeToInstr_[N] = V; |
1354 | break; |
1355 | } |
1356 | case glow::Kinded::Kind::TFLiteDetectionPostProcessNodeKind: { |
1357 | auto *CN__ = cast<TFLiteDetectionPostProcessNode>(N); |
1358 | auto *Boxes = valueForNode(CN__->getBoxes()); |
1359 | auto *Scores = valueForNode(CN__->getScores()); |
1360 | auto *Anchors = valueForNode(CN__->getAnchors()); |
1361 | std::string allocName = std::string(N->getName()) + ".res" ; |
1362 | auto *DetectionBoxes__ = builder_.createAllocActivationInst(allocName,CN__->getDetectionBoxes().getType()); |
1363 | auto *DetectionClasses__ = builder_.createAllocActivationInst(allocName,CN__->getDetectionClasses().getType()); |
1364 | auto *DetectionScores__ = builder_.createAllocActivationInst(allocName,CN__->getDetectionScores().getType()); |
1365 | auto *NumDetections__ = builder_.createAllocActivationInst(allocName,CN__->getNumDetections().getType()); |
1366 | auto *V = builder_.createTFLiteDetectionPostProcessInst(N->getName(), DetectionBoxes__, DetectionClasses__, DetectionScores__, NumDetections__, Boxes, Scores, Anchors, CN__->getNumClasses(), CN__->getMaxDetections(), CN__->getMaxClassesPerDetection(), CN__->getMaxDetectionsPerClass(), CN__->getIouThreshold(), CN__->getScoreThreshold(), CN__->getXScale(), CN__->getYScale(), CN__->getHScale(), CN__->getWScale(), CN__->getRegularNMS()); |
1367 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1368 | registerIR(CN__->getDetectionBoxes(), V->getDetectionBoxes()); |
1369 | registerIR(CN__->getDetectionClasses(), V->getDetectionClasses()); |
1370 | registerIR(CN__->getDetectionScores(), V->getDetectionScores()); |
1371 | registerIR(CN__->getNumDetections(), V->getNumDetections()); |
1372 | nodeToInstr_[N] = V; |
1373 | break; |
1374 | } |
1375 | case glow::Kinded::Kind::ROIAlignNodeKind: { |
1376 | auto *CN__ = cast<ROIAlignNode>(N); |
1377 | auto *FeatureMap = valueForNode(CN__->getFeatureMap()); |
1378 | auto *Boxes = valueForNode(CN__->getBoxes()); |
1379 | auto *BatchIndices = valueForNode(CN__->getBatchIndices()); |
1380 | std::string allocName = std::string(N->getName()) + ".res" ; |
1381 | auto *Result__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1382 | auto *V = builder_.createROIAlignInst(N->getName(), Result__, FeatureMap, Boxes, BatchIndices, CN__->getMode(), CN__->getOutputHeight(), CN__->getOutputWidth(), CN__->getSamplingRatio(), CN__->getSpatialScale(), CN__->getAligned(), CN__->getRotated()); |
1383 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1384 | registerIR(CN__->getResult(), V->getResult()); |
1385 | nodeToInstr_[N] = V; |
1386 | break; |
1387 | } |
1388 | case glow::Kinded::Kind::BBoxTransformNodeKind: { |
1389 | auto *CN__ = cast<BBoxTransformNode>(N); |
1390 | auto *Rois = valueForNode(CN__->getRois()); |
1391 | auto *Deltas = valueForNode(CN__->getDeltas()); |
1392 | auto *ImInfo = valueForNode(CN__->getImInfo()); |
1393 | std::string allocName = std::string(N->getName()) + ".res" ; |
1394 | auto *BoxOut__ = builder_.createAllocActivationInst(allocName,CN__->getBoxOut().getType()); |
1395 | auto *RoiBatchSplits__ = builder_.createAllocActivationInst(allocName,CN__->getRoiBatchSplits().getType()); |
1396 | auto *V = builder_.createBBoxTransformInst(N->getName(), BoxOut__, RoiBatchSplits__, Rois, Deltas, ImInfo, CN__->getWeights(), CN__->getApplyScale(), CN__->getRotated(), CN__->getAngleBoundOn(), CN__->getAngleBoundLo(), CN__->getAngleBoundHi(), CN__->getClipAngleThresh(), CN__->getLegacyPlusOne()); |
1397 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1398 | registerIR(CN__->getBoxOut(), V->getBoxOut()); |
1399 | registerIR(CN__->getRoiBatchSplits(), V->getRoiBatchSplits()); |
1400 | nodeToInstr_[N] = V; |
1401 | break; |
1402 | } |
1403 | case glow::Kinded::Kind::LookupTableNodeKind: { |
1404 | auto *CN__ = cast<LookupTableNode>(N); |
1405 | auto *Src = valueForNode(CN__->getInput()); |
1406 | auto *Table = valueForNode(CN__->getTable()); |
1407 | auto *TableIdx = valueForNode(CN__->getTableIdx()); |
1408 | std::string allocName = std::string(N->getName()) + ".res" ; |
1409 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1410 | auto *V = builder_.createLookupTableInst(N->getName(), Dest__, Src, Table, TableIdx, CN__->getOperator(), CN__->getOperatorArgs()); |
1411 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1412 | registerIR(CN__->getResult(), V->getDest()); |
1413 | nodeToInstr_[N] = V; |
1414 | break; |
1415 | } |
1416 | case glow::Kinded::Kind::CPUMaxSplatNodeKind: { |
1417 | auto *CN__ = cast<CPUMaxSplatNode>(N); |
1418 | auto *Src = valueForNode(CN__->getInput()); |
1419 | std::string allocName = std::string(N->getName()) + ".res" ; |
1420 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1421 | auto *V = builder_.createCPUMaxSplatInst(N->getName(), Dest__, Src, CN__->getSplatValue()); |
1422 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1423 | registerIR(CN__->getResult(), V->getDest()); |
1424 | nodeToInstr_[N] = V; |
1425 | break; |
1426 | } |
1427 | case glow::Kinded::Kind::CPUConvDKKC8NodeKind: { |
1428 | auto *CN__ = cast<CPUConvDKKC8Node>(N); |
1429 | auto *Src = valueForNode(CN__->getInput()); |
1430 | auto *Filter = valueForNode(CN__->getFilter()); |
1431 | auto *Bias = valueForNode(CN__->getBias()); |
1432 | std::string allocName = std::string(N->getName()) + ".res" ; |
1433 | auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType()); |
1434 | auto *V = builder_.createCPUConvDKKC8Inst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup()); |
1435 | if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); } |
1436 | registerIR(CN__->getResult(), V->getDest()); |
1437 | nodeToInstr_[N] = V; |
1438 | break; |
1439 | } |
1440 | |