Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 23be07e855c066f192c1007d529064462853a27c / . / src / backends / reference / RefLayerSupport.cpp
blob: 3b49fa0e51b66b7ebcb4f7b3821e0c4bffa651e7 [file] [log] [blame]
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]1//
2// Copyright © 2017 Arm Ltd. All rights reserved.
David Beckecb56cd2018-09-05 12:52:57 +0100[diff] [blame]3// SPDX-License-Identifier: MIT
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]4//
5
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]6#include "RefLayerSupport.hpp"
David Beck3e9e1152018-10-17 14:17:50 +0100[diff] [blame]7#include "RefBackendId.hpp"
David Beck3cc9a622018-10-12 10:38:31 +0100[diff] [blame]8
Aron Virginas-Tarc9cc8042018-11-01 16:15:57 +0000[diff] [blame]9#include <InternalTypes.hpp>
10#include <LayerSupportCommon.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]11#include <armnn/Types.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]12
David Beck111b5d92018-11-12 14:59:37 +0000[diff] [blame]13#include <backendsCommon/BackendRegistry.hpp>
David Beck3e9e1152018-10-17 14:17:50 +0100[diff] [blame]14
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]15#include <boost/core/ignore_unused.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]16
17using namespace boost;
18
19namespace armnn
20{
21
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]22namespace
23{
24
25template<typename Float32Func, typename Uint8Func, typename ... Params>
26bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported,
27 DataType dataType,
28 Float32Func floatFuncPtr,
29 Uint8Func uint8FuncPtr,
30 Params&&... params)
31{
32 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
33 dataType,
34 &FalseFunc<Params...>,
35 floatFuncPtr,
36 uint8FuncPtr,
37 std::forward<Params>(params)...);
38}
39
40} // anonymous namespace
41
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]42bool RefLayerSupport::IsActivationSupported(const TensorInfo& input,
43 const TensorInfo& output,
44 const ActivationDescriptor& descriptor,
45 Optional<std::string&> reasonIfUnsupported) const
46{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]47 ignore_unused(output);
48 ignore_unused(descriptor);
49 return IsSupportedForDataTypeRef(reasonIfUnsupported,
50 input.GetDataType(),
51 &TrueFunc<>,
52 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]53}
54
55bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0,
56 const TensorInfo& input1,
57 const TensorInfo& output,
58 Optional<std::string&> reasonIfUnsupported) const
59{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]60 ignore_unused(input1);
61 ignore_unused(output);
62 return IsSupportedForDataTypeRef(reasonIfUnsupported,
63 input0.GetDataType(),
64 &TrueFunc<>,
65 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]66}
67
68bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
69 const TensorInfo& output,
70 const TensorInfo& mean,
71 const TensorInfo& var,
72 const TensorInfo& beta,
73 const TensorInfo& gamma,
74 const BatchNormalizationDescriptor& descriptor,
75 Optional<std::string&> reasonIfUnsupported) const
76{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]77 ignore_unused(output);
78 ignore_unused(mean);
79 ignore_unused(var);
80 ignore_unused(beta);
81 ignore_unused(gamma);
82 ignore_unused(descriptor);
83 return IsSupportedForDataTypeRef(reasonIfUnsupported,
84 input.GetDataType(),
85 &TrueFunc<>,
86 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]87}
88
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]89bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
90 const TensorInfo& output,
91 const BatchToSpaceNdDescriptor& descriptor,
92 Optional<std::string&> reasonIfUnsupported) const
93{
94 ignore_unused(descriptor);
95 return (IsSupportedForDataTypeRef(reasonIfUnsupported,
96 input.GetDataType(),
97 &TrueFunc<>,
98 &TrueFunc<>) &&
99 IsSupportedForDataTypeRef(reasonIfUnsupported,
100 output.GetDataType(),
101 &TrueFunc<>,
102 &TrueFunc<>));
103}
104
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]105bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
106 Optional<std::string&> reasonIfUnsupported) const
107{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]108 return IsSupportedForDataTypeRef(reasonIfUnsupported,
109 output.GetDataType(),
110 &TrueFunc<>,
111 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]112}
113
114bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
115 const TensorInfo& output,
116 Optional<std::string&> reasonIfUnsupported) const
117{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]118 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
119 input.GetDataType(),
120 &TrueFunc<>,
121 &FalseInputFuncF32<>,
122 &FalseFuncU8<>) &&
123 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
124 output.GetDataType(),
125 &FalseOutputFuncF16<>,
126 &TrueFunc<>,
127 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]128}
129
130bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
131 const TensorInfo& output,
132 Optional<std::string&> reasonIfUnsupported) const
133{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]134 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
135 input.GetDataType(),
136 &FalseInputFuncF16<>,
137 &TrueFunc<>,
138 &FalseFuncU8<>) &&
139 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
140 output.GetDataType(),
141 &TrueFunc<>,
142 &FalseOutputFuncF32<>,
143 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]144}
145
146bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
147 const TensorInfo& output,
148 const Convolution2dDescriptor& descriptor,
149 const TensorInfo& weights,
150 const Optional<TensorInfo>& biases,
151 Optional<std::string&> reasonIfUnsupported) const
152{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]153 ignore_unused(output);
154 ignore_unused(descriptor);
155 ignore_unused(weights);
156 ignore_unused(biases);
157 return IsSupportedForDataTypeRef(reasonIfUnsupported,
158 input.GetDataType(),
159 &TrueFunc<>,
160 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]161}
162
163bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
164 const TensorInfo& output,
165 const DepthwiseConvolution2dDescriptor& descriptor,
166 const TensorInfo& weights,
167 const Optional<TensorInfo>& biases,
168 Optional<std::string&> reasonIfUnsupported) const
169{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]170 ignore_unused(output);
171 ignore_unused(descriptor);
172 ignore_unused(weights);
173 ignore_unused(biases);
174 return IsSupportedForDataTypeRef(reasonIfUnsupported,
175 input.GetDataType(),
176 &TrueFunc<>,
177 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]178}
179
180bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
181 const TensorInfo& input1,
182 const TensorInfo& output,
183 Optional<std::string&> reasonIfUnsupported) const
184{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]185 ignore_unused(input1);
186 ignore_unused(output);
187 return IsSupportedForDataTypeRef(reasonIfUnsupported,
188 input0.GetDataType(),
189 &TrueFunc<>,
190 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]191}
192
193bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
194 const FakeQuantizationDescriptor& descriptor,
195 Optional<std::string&> reasonIfUnsupported) const
196{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]197 ignore_unused(descriptor);
198 return IsSupportedForDataTypeRef(reasonIfUnsupported,
199 input.GetDataType(),
200 &TrueFunc<>,
201 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]202}
203
204bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
205 const TensorInfo& output,
206 Optional<std::string&> reasonIfUnsupported) const
207{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]208 ignore_unused(output);
209 return IsSupportedForDataTypeRef(reasonIfUnsupported,
210 input.GetDataType(),
211 &TrueFunc<>,
212 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]213}
214
215bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
216 const TensorInfo& output,
217 const TensorInfo& weights,
218 const TensorInfo& biases,
219 const FullyConnectedDescriptor& descriptor,
220 Optional<std::string&> reasonIfUnsupported) const
221{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]222 ignore_unused(output);
223 ignore_unused(weights);
224 ignore_unused(biases);
225 ignore_unused(descriptor);
226 return IsSupportedForDataTypeRef(reasonIfUnsupported,
227 input.GetDataType(),
228 &TrueFunc<>,
229 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]230}
231
232bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
233 Optional<std::string&> reasonIfUnsupported) const
234{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]235 return IsSupportedForDataTypeRef(reasonIfUnsupported,
236 input.GetDataType(),
237 &TrueFunc<>,
238 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]239}
240
241bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
242 const TensorInfo& output,
243 const L2NormalizationDescriptor& descriptor,
244 Optional<std::string&> reasonIfUnsupported) const
245{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]246 ignore_unused(output);
247 ignore_unused(descriptor);
248 return IsSupportedForDataTypeRef(reasonIfUnsupported,
249 input.GetDataType(),
250 &TrueFunc<>,
251 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]252}
253
254bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
255 const TensorInfo& outputStateIn,
256 const TensorInfo& cellStateIn,
257 const TensorInfo& scratchBuffer,
258 const TensorInfo& outputStateOut,
259 const TensorInfo& cellStateOut,
260 const TensorInfo& output,
261 const LstmDescriptor& descriptor,
262 const TensorInfo& inputToForgetWeights,
263 const TensorInfo& inputToCellWeights,
264 const TensorInfo& inputToOutputWeights,
265 const TensorInfo& recurrentToForgetWeights,
266 const TensorInfo& recurrentToCellWeights,
267 const TensorInfo& recurrentToOutputWeights,
268 const TensorInfo& forgetGateBias,
269 const TensorInfo& cellBias,
270 const TensorInfo& outputGateBias,
271 const TensorInfo* inputToInputWeights,
272 const TensorInfo* recurrentToInputWeights,
273 const TensorInfo* cellToInputWeights,
274 const TensorInfo* inputGateBias,
275 const TensorInfo* projectionWeights,
276 const TensorInfo* projectionBias,
277 const TensorInfo* cellToForgetWeights,
278 const TensorInfo* cellToOutputWeights,
279 Optional<std::string&> reasonIfUnsupported) const
280{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]281 ignore_unused(outputStateIn);
282 ignore_unused(cellStateIn);
283 ignore_unused(scratchBuffer);
284 ignore_unused(outputStateOut);
285 ignore_unused(cellStateOut);
286 ignore_unused(output);
287 ignore_unused(descriptor);
288 ignore_unused(inputToForgetWeights);
289 ignore_unused(inputToCellWeights);
290 ignore_unused(inputToOutputWeights);
291 ignore_unused(recurrentToForgetWeights);
292 ignore_unused(recurrentToCellWeights);
293 ignore_unused(recurrentToOutputWeights);
294 ignore_unused(forgetGateBias);
295 ignore_unused(cellBias);
296 ignore_unused(outputGateBias);
297 ignore_unused(inputToInputWeights);
298 ignore_unused(recurrentToInputWeights);
299 ignore_unused(cellToInputWeights);
300 ignore_unused(inputGateBias);
301 ignore_unused(projectionWeights);
302 ignore_unused(projectionBias);
303 ignore_unused(cellToForgetWeights);
304 ignore_unused(cellToOutputWeights);
Matteo Martincigha65b7ae2018-11-14 12:39:55 +0000[diff] [blame]305 return IsSupportedForDataTypeRef(reasonIfUnsupported,
306 input.GetDataType(),
307 &TrueFunc<>,
308 &FalseFuncU8<>);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]309}
310
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]311bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
312 const TensorInfo& input1,
313 const TensorInfo& output,
314 Optional<std::string&> reasonIfUnsupported) const
315{
316 ignore_unused(input1);
317 ignore_unused(output);
318 return IsSupportedForDataTypeRef(reasonIfUnsupported,
319 input0.GetDataType(),
320 &TrueFunc<>,
321 &TrueFunc<>);
322}
323
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]324bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
325 const TensorInfo& output,
326 const MeanDescriptor& descriptor,
327 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]328{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]329 ignore_unused(output);
330 ignore_unused(descriptor);
331 return IsSupportedForDataTypeRef(reasonIfUnsupported,
332 input.GetDataType(),
333 &TrueFunc<>,
334 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]335}
336
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]337bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]338 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]339 const OriginsDescriptor& descriptor,
340 Optional<std::string&> reasonIfUnsupported) const
341{
342 ignore_unused(descriptor);
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]343 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]344 return IsSupportedForDataTypeRef(reasonIfUnsupported,
345 inputs[0]->GetDataType(),
346 &TrueFunc<>,
347 &TrueFunc<>);
348}
349
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]350bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
351 const TensorInfo& input1,
352 const TensorInfo& output,
353 Optional<std::string&> reasonIfUnsupported) const
354{
355 ignore_unused(input1);
356 ignore_unused(output);
357 return IsSupportedForDataTypeRef(reasonIfUnsupported,
358 input0.GetDataType(),
359 &TrueFunc<>,
360 &TrueFunc<>);
361}
362
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]363bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
364 const TensorInfo& input1,
365 const TensorInfo& output,
366 Optional<std::string&> reasonIfUnsupported) const
367{
368 ignore_unused(input1);
369 ignore_unused(output);
370 return IsSupportedForDataTypeRef(reasonIfUnsupported,
371 input0.GetDataType(),
372 &TrueFunc<>,
373 &TrueFunc<>);
374}
375
376bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
377 const TensorInfo& output,
378 const NormalizationDescriptor& descriptor,
379 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]380{
381 ignore_unused(output);
382 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]383 return IsSupportedForDataTypeRef(reasonIfUnsupported,
384 input.GetDataType(),
385 &TrueFunc<>,
386 &FalseFuncU8<>);
387}
388
389bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
390 Optional<std::string&> reasonIfUnsupported) const
391{
392 return IsSupportedForDataTypeRef(reasonIfUnsupported,
393 output.GetDataType(),
394 &TrueFunc<>,
395 &TrueFunc<>);
396}
397
398bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
399 const TensorInfo& output,
400 const PadDescriptor& descriptor,
401 Optional<std::string&> reasonIfUnsupported) const
402{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]403 ignore_unused(output);
404 ignore_unused(descriptor);
jimfly01f6ba7472018-12-04 10:09:52 +0000[diff] [blame]405 return IsSupportedForDataTypeRef(reasonIfUnsupported,
406 input.GetDataType(),
407 &TrueFunc<>,
408 &TrueFunc<>);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]409}
410
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]411bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
412 const TensorInfo& output,
413 const PermuteDescriptor& descriptor,
414 Optional<std::string&> reasonIfUnsupported) const
415{
416 ignore_unused(output);
417 ignore_unused(descriptor);
418 return IsSupportedForDataTypeRef(reasonIfUnsupported,
419 input.GetDataType(),
420 &TrueFunc<>,
421 &TrueFunc<>);
422}
423
424bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
425 const TensorInfo& output,
426 const Pooling2dDescriptor& descriptor,
427 Optional<std::string&> reasonIfUnsupported) const
428{
429 ignore_unused(output);
430 ignore_unused(descriptor);
431 return IsSupportedForDataTypeRef(reasonIfUnsupported,
432 input.GetDataType(),
433 &TrueFunc<>,
434 &TrueFunc<>);
435}
436
437bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
438 Optional<std::string&> reasonIfUnsupported) const
439{
440 return IsSupportedForDataTypeRef(reasonIfUnsupported,
441 input.GetDataType(),
442 &TrueFunc<>,
443 &TrueFunc<>);
444}
445
446bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
447 Optional<std::string&> reasonIfUnsupported) const
448{
449 return IsSupportedForDataTypeRef(reasonIfUnsupported,
450 input.GetDataType(),
451 &TrueFunc<>,
452 &TrueFunc<>);
453}
454
455bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
456 const TensorInfo& output,
457 const SoftmaxDescriptor& descriptor,
458 Optional<std::string&> reasonIfUnsupported) const
459{
460 ignore_unused(output);
461 ignore_unused(descriptor);
462 return IsSupportedForDataTypeRef(reasonIfUnsupported,
463 input.GetDataType(),
464 &TrueFunc<>,
465 &TrueFunc<>);
466}
467
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]468bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
469 const TensorInfo& output,
470 const SpaceToBatchNdDescriptor& descriptor,
471 Optional<std::string&> reasonIfUnsupported) const
472{
473 ignore_unused(output);
474 ignore_unused(descriptor);
475 return IsSupportedForDataTypeRef(reasonIfUnsupported,
476 input.GetDataType(),
477 &TrueFunc<>,
478 &TrueFunc<>);
479}
480
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]481bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
482 const ViewsDescriptor& descriptor,
483 Optional<std::string&> reasonIfUnsupported) const
484{
485 ignore_unused(descriptor);
486 return IsSupportedForDataTypeRef(reasonIfUnsupported,
487 input.GetDataType(),
488 &TrueFunc<>,
489 &TrueFunc<>);
490}
491
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]492bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
493 const TensorInfo& output,
494 const StridedSliceDescriptor& descriptor,
495 Optional<std::string&> reasonIfUnsupported) const
496{
497 ignore_unused(output);
498 ignore_unused(descriptor);
499 return IsSupportedForDataTypeRef(reasonIfUnsupported,
500 input.GetDataType(),
501 &TrueFunc<>,
502 &TrueFunc<>);
503}
504
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]505bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
506 const TensorInfo& input1,
507 const TensorInfo& output,
508 Optional<std::string&> reasonIfUnsupported) const
509{
510 ignore_unused(input1);
511 ignore_unused(output);
512 return IsSupportedForDataTypeRef(reasonIfUnsupported,
513 input0.GetDataType(),
514 &TrueFunc<>,
515 &TrueFunc<>);
516}
517
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]518} // namespace armnn