Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 20e58806b94636f579c5e8b0ca91ab771b6310e6 / . / src / backends / reference / RefLayerSupport.cpp
blob: fffea587a040f4a80fbbb56b56b2ac1141be60f4 [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{
403 ignore_unused(input);
404 ignore_unused(output);
405 ignore_unused(descriptor);
406 ignore_unused(reasonIfUnsupported);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]407 return false;
408}
409
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]410bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
411 const TensorInfo& output,
412 const PermuteDescriptor& descriptor,
413 Optional<std::string&> reasonIfUnsupported) const
414{
415 ignore_unused(output);
416 ignore_unused(descriptor);
417 return IsSupportedForDataTypeRef(reasonIfUnsupported,
418 input.GetDataType(),
419 &TrueFunc<>,
420 &TrueFunc<>);
421}
422
423bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
424 const TensorInfo& output,
425 const Pooling2dDescriptor& descriptor,
426 Optional<std::string&> reasonIfUnsupported) const
427{
428 ignore_unused(output);
429 ignore_unused(descriptor);
430 return IsSupportedForDataTypeRef(reasonIfUnsupported,
431 input.GetDataType(),
432 &TrueFunc<>,
433 &TrueFunc<>);
434}
435
436bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
437 Optional<std::string&> reasonIfUnsupported) const
438{
439 return IsSupportedForDataTypeRef(reasonIfUnsupported,
440 input.GetDataType(),
441 &TrueFunc<>,
442 &TrueFunc<>);
443}
444
445bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
446 Optional<std::string&> reasonIfUnsupported) const
447{
448 return IsSupportedForDataTypeRef(reasonIfUnsupported,
449 input.GetDataType(),
450 &TrueFunc<>,
451 &TrueFunc<>);
452}
453
454bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
455 const TensorInfo& output,
456 const SoftmaxDescriptor& descriptor,
457 Optional<std::string&> reasonIfUnsupported) const
458{
459 ignore_unused(output);
460 ignore_unused(descriptor);
461 return IsSupportedForDataTypeRef(reasonIfUnsupported,
462 input.GetDataType(),
463 &TrueFunc<>,
464 &TrueFunc<>);
465}
466
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]467bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
468 const TensorInfo& output,
469 const SpaceToBatchNdDescriptor& descriptor,
470 Optional<std::string&> reasonIfUnsupported) const
471{
472 ignore_unused(output);
473 ignore_unused(descriptor);
474 return IsSupportedForDataTypeRef(reasonIfUnsupported,
475 input.GetDataType(),
476 &TrueFunc<>,
477 &TrueFunc<>);
478}
479
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]480bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
481 const ViewsDescriptor& descriptor,
482 Optional<std::string&> reasonIfUnsupported) const
483{
484 ignore_unused(descriptor);
485 return IsSupportedForDataTypeRef(reasonIfUnsupported,
486 input.GetDataType(),
487 &TrueFunc<>,
488 &TrueFunc<>);
489}
490
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]491bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
492 const TensorInfo& output,
493 const StridedSliceDescriptor& descriptor,
494 Optional<std::string&> reasonIfUnsupported) const
495{
496 ignore_unused(output);
497 ignore_unused(descriptor);
498 return IsSupportedForDataTypeRef(reasonIfUnsupported,
499 input.GetDataType(),
500 &TrueFunc<>,
501 &TrueFunc<>);
502}
503
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]504bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
505 const TensorInfo& input1,
506 const TensorInfo& output,
507 Optional<std::string&> reasonIfUnsupported) const
508{
509 ignore_unused(input1);
510 ignore_unused(output);
511 return IsSupportedForDataTypeRef(reasonIfUnsupported,
512 input0.GetDataType(),
513 &TrueFunc<>,
514 &TrueFunc<>);
515}
516
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]517} // namespace armnn