Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / bc67cef3e3dc9e7fe9c4331495009eda48c89527 / . / src / backends / reference / RefLayerSupport.cpp
blob: 4b32a8938dffda3eb778ed97d15006764590bafa [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,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]37 &FalseFunc<Params...>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]38 &FalseFunc<Params...>,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]39 std::forward<Params>(params)...);
40}
41
42} // anonymous namespace
43
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]44bool RefLayerSupport::IsActivationSupported(const TensorInfo& input,
45 const TensorInfo& output,
46 const ActivationDescriptor& descriptor,
47 Optional<std::string&> reasonIfUnsupported) const
48{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]49 ignore_unused(output);
50 ignore_unused(descriptor);
51 return IsSupportedForDataTypeRef(reasonIfUnsupported,
52 input.GetDataType(),
53 &TrueFunc<>,
54 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]55}
56
57bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0,
58 const TensorInfo& input1,
59 const TensorInfo& output,
60 Optional<std::string&> reasonIfUnsupported) const
61{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]62 ignore_unused(input1);
63 ignore_unused(output);
64 return IsSupportedForDataTypeRef(reasonIfUnsupported,
65 input0.GetDataType(),
66 &TrueFunc<>,
67 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]68}
69
70bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
71 const TensorInfo& output,
72 const TensorInfo& mean,
73 const TensorInfo& var,
74 const TensorInfo& beta,
75 const TensorInfo& gamma,
76 const BatchNormalizationDescriptor& descriptor,
77 Optional<std::string&> reasonIfUnsupported) const
78{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]79 ignore_unused(output);
80 ignore_unused(mean);
81 ignore_unused(var);
82 ignore_unused(beta);
83 ignore_unused(gamma);
84 ignore_unused(descriptor);
85 return IsSupportedForDataTypeRef(reasonIfUnsupported,
86 input.GetDataType(),
87 &TrueFunc<>,
88 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]89}
90
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]91bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
92 const TensorInfo& output,
93 const BatchToSpaceNdDescriptor& descriptor,
94 Optional<std::string&> reasonIfUnsupported) const
95{
96 ignore_unused(descriptor);
97 return (IsSupportedForDataTypeRef(reasonIfUnsupported,
98 input.GetDataType(),
99 &TrueFunc<>,
100 &TrueFunc<>) &&
101 IsSupportedForDataTypeRef(reasonIfUnsupported,
102 output.GetDataType(),
103 &TrueFunc<>,
104 &TrueFunc<>));
105}
106
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]107bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
108 Optional<std::string&> reasonIfUnsupported) const
109{
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]110 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
111 output.GetDataType(),
112 &FalseFunc<>,
113 &TrueFunc<>,
114 &TrueFunc<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]115 &TrueFunc<>,
116 &FalseFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]117}
118
119bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
120 const TensorInfo& output,
121 Optional<std::string&> reasonIfUnsupported) const
122{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]123 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
124 input.GetDataType(),
125 &TrueFunc<>,
126 &FalseInputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]127 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]128 &FalseFuncI32<>,
129 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]130 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
131 output.GetDataType(),
132 &FalseOutputFuncF16<>,
133 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]134 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]135 &FalseFuncI32<>,
136 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]137}
138
139bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
140 const TensorInfo& output,
141 Optional<std::string&> reasonIfUnsupported) const
142{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]143 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
144 input.GetDataType(),
145 &FalseInputFuncF16<>,
146 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]147 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]148 &FalseFuncI32<>,
149 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]150 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
151 output.GetDataType(),
152 &TrueFunc<>,
153 &FalseOutputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]154 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]155 &FalseFuncI32<>,
156 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]157}
158
159bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
160 const TensorInfo& output,
161 const Convolution2dDescriptor& descriptor,
162 const TensorInfo& weights,
163 const Optional<TensorInfo>& biases,
164 Optional<std::string&> reasonIfUnsupported) const
165{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]166 ignore_unused(output);
167 ignore_unused(descriptor);
168 ignore_unused(weights);
169 ignore_unused(biases);
170 return IsSupportedForDataTypeRef(reasonIfUnsupported,
171 input.GetDataType(),
172 &TrueFunc<>,
173 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]174}
175
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]176bool RefLayerSupport::IsDebugSupported(const TensorInfo& input,
177 const TensorInfo& output,
178 const DebugDescriptor& descriptor,
179 Optional<std::string&> reasonIfUnsupported) const
180{
181 ignore_unused(output);
182 ignore_unused(descriptor);
183 return IsSupportedForDataTypeRef(reasonIfUnsupported,
184 input.GetDataType(),
185 &TrueFunc<>,
186 &TrueFunc<>);
187}
188
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]189bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
190 const TensorInfo& output,
191 const DepthwiseConvolution2dDescriptor& descriptor,
192 const TensorInfo& weights,
193 const Optional<TensorInfo>& biases,
194 Optional<std::string&> reasonIfUnsupported) const
195{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]196 ignore_unused(output);
197 ignore_unused(descriptor);
198 ignore_unused(weights);
199 ignore_unused(biases);
200 return IsSupportedForDataTypeRef(reasonIfUnsupported,
201 input.GetDataType(),
202 &TrueFunc<>,
203 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]204}
205
Narumol Prangnawaratbc67cef2019-01-31 15:31:54 +0000[diff] [blame^]206bool RefLayerSupport::IsDetectionPostProcessSupported(const armnn::TensorInfo& input0,
207 const armnn::TensorInfo& input1,
208 const armnn::DetectionPostProcessDescriptor& descriptor,
209 armnn::Optional<std::string&> reasonIfUnsupported) const
210{
211 ignore_unused(input1);
212 return IsSupportedForDataTypeRef(reasonIfUnsupported,
213 input0.GetDataType(),
214 &TrueFunc<>,
215 &TrueFunc<>);
216}
217
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]218bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
219 const TensorInfo& input1,
220 const TensorInfo& output,
221 Optional<std::string&> reasonIfUnsupported) const
222{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]223 ignore_unused(input1);
224 ignore_unused(output);
225 return IsSupportedForDataTypeRef(reasonIfUnsupported,
226 input0.GetDataType(),
227 &TrueFunc<>,
228 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]229}
230
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]231bool RefLayerSupport::IsEqualSupported(const TensorInfo& input0,
232 const TensorInfo& input1,
233 const TensorInfo& output,
234 Optional<std::string&> reasonIfUnsupported) const
235{
236 ignore_unused(input0);
237 ignore_unused(input1);
238 ignore_unused(output);
239 ignore_unused(reasonIfUnsupported);
240 return IsSupportedForDataTypeRef(reasonIfUnsupported,
241 input0.GetDataType(),
242 &TrueFunc<>,
243 &TrueFunc<>);
244}
245
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]246bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
247 const FakeQuantizationDescriptor& descriptor,
248 Optional<std::string&> reasonIfUnsupported) const
249{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]250 ignore_unused(descriptor);
251 return IsSupportedForDataTypeRef(reasonIfUnsupported,
252 input.GetDataType(),
253 &TrueFunc<>,
254 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]255}
256
257bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
258 const TensorInfo& output,
259 Optional<std::string&> reasonIfUnsupported) const
260{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]261 ignore_unused(output);
262 return IsSupportedForDataTypeRef(reasonIfUnsupported,
263 input.GetDataType(),
264 &TrueFunc<>,
265 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]266}
267
268bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
269 const TensorInfo& output,
270 const TensorInfo& weights,
271 const TensorInfo& biases,
272 const FullyConnectedDescriptor& descriptor,
273 Optional<std::string&> reasonIfUnsupported) const
274{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]275 ignore_unused(output);
276 ignore_unused(weights);
277 ignore_unused(biases);
278 ignore_unused(descriptor);
279 return IsSupportedForDataTypeRef(reasonIfUnsupported,
280 input.GetDataType(),
281 &TrueFunc<>,
282 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]283}
284
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]285bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0,
286 const armnn::TensorInfo& input1,
287 const armnn::TensorInfo& output,
288 armnn::Optional<std::string&> reasonIfUnsupported) const
289{
290 ignore_unused(input1);
291 ignore_unused(output);
292 return IsSupportedForDataTypeRef(reasonIfUnsupported,
293 input0.GetDataType(),
294 &TrueFunc<>,
295 &TrueFunc<>);
296}
297
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]298bool RefLayerSupport::IsGreaterSupported(const TensorInfo& input0,
299 const TensorInfo& input1,
300 const TensorInfo& output,
301 Optional<std::string&> reasonIfUnsupported) const
302{
303 ignore_unused(input0);
304 ignore_unused(input1);
305 ignore_unused(output);
306 ignore_unused(reasonIfUnsupported);
307 return IsSupportedForDataTypeRef(reasonIfUnsupported,
308 input0.GetDataType(),
309 &TrueFunc<>,
310 &TrueFunc<>);
311}
312
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]313bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
314 Optional<std::string&> reasonIfUnsupported) const
315{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]316 return IsSupportedForDataTypeRef(reasonIfUnsupported,
317 input.GetDataType(),
318 &TrueFunc<>,
319 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]320}
321
322bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
323 const TensorInfo& output,
324 const L2NormalizationDescriptor& descriptor,
325 Optional<std::string&> reasonIfUnsupported) const
326{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]327 ignore_unused(output);
328 ignore_unused(descriptor);
329 return IsSupportedForDataTypeRef(reasonIfUnsupported,
330 input.GetDataType(),
331 &TrueFunc<>,
332 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]333}
334
335bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
336 const TensorInfo& outputStateIn,
337 const TensorInfo& cellStateIn,
338 const TensorInfo& scratchBuffer,
339 const TensorInfo& outputStateOut,
340 const TensorInfo& cellStateOut,
341 const TensorInfo& output,
342 const LstmDescriptor& descriptor,
343 const TensorInfo& inputToForgetWeights,
344 const TensorInfo& inputToCellWeights,
345 const TensorInfo& inputToOutputWeights,
346 const TensorInfo& recurrentToForgetWeights,
347 const TensorInfo& recurrentToCellWeights,
348 const TensorInfo& recurrentToOutputWeights,
349 const TensorInfo& forgetGateBias,
350 const TensorInfo& cellBias,
351 const TensorInfo& outputGateBias,
352 const TensorInfo* inputToInputWeights,
353 const TensorInfo* recurrentToInputWeights,
354 const TensorInfo* cellToInputWeights,
355 const TensorInfo* inputGateBias,
356 const TensorInfo* projectionWeights,
357 const TensorInfo* projectionBias,
358 const TensorInfo* cellToForgetWeights,
359 const TensorInfo* cellToOutputWeights,
360 Optional<std::string&> reasonIfUnsupported) const
361{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]362 ignore_unused(outputStateIn);
363 ignore_unused(cellStateIn);
364 ignore_unused(scratchBuffer);
365 ignore_unused(outputStateOut);
366 ignore_unused(cellStateOut);
367 ignore_unused(output);
368 ignore_unused(descriptor);
369 ignore_unused(inputToForgetWeights);
370 ignore_unused(inputToCellWeights);
371 ignore_unused(inputToOutputWeights);
372 ignore_unused(recurrentToForgetWeights);
373 ignore_unused(recurrentToCellWeights);
374 ignore_unused(recurrentToOutputWeights);
375 ignore_unused(forgetGateBias);
376 ignore_unused(cellBias);
377 ignore_unused(outputGateBias);
378 ignore_unused(inputToInputWeights);
379 ignore_unused(recurrentToInputWeights);
380 ignore_unused(cellToInputWeights);
381 ignore_unused(inputGateBias);
382 ignore_unused(projectionWeights);
383 ignore_unused(projectionBias);
384 ignore_unused(cellToForgetWeights);
385 ignore_unused(cellToOutputWeights);
Matteo Martincigha65b7ae2018-11-14 12:39:55 +0000[diff] [blame]386 return IsSupportedForDataTypeRef(reasonIfUnsupported,
387 input.GetDataType(),
388 &TrueFunc<>,
389 &FalseFuncU8<>);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]390}
391
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]392bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
393 const TensorInfo& input1,
394 const TensorInfo& output,
395 Optional<std::string&> reasonIfUnsupported) const
396{
397 ignore_unused(input1);
398 ignore_unused(output);
399 return IsSupportedForDataTypeRef(reasonIfUnsupported,
400 input0.GetDataType(),
401 &TrueFunc<>,
402 &TrueFunc<>);
403}
404
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]405bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
406 const TensorInfo& output,
407 const MeanDescriptor& descriptor,
408 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]409{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]410 ignore_unused(output);
411 ignore_unused(descriptor);
412 return IsSupportedForDataTypeRef(reasonIfUnsupported,
413 input.GetDataType(),
414 &TrueFunc<>,
415 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]416}
417
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]418bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]419 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]420 const OriginsDescriptor& descriptor,
421 Optional<std::string&> reasonIfUnsupported) const
422{
423 ignore_unused(descriptor);
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]424 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]425 return IsSupportedForDataTypeRef(reasonIfUnsupported,
426 inputs[0]->GetDataType(),
427 &TrueFunc<>,
428 &TrueFunc<>);
429}
430
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]431bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
432 const TensorInfo &output,
433 Optional<std::string &> reasonIfUnsupported) const
434{
435 ignore_unused(output);
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]436 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
437 input.GetDataType(),
438 &TrueFunc<>,
439 &TrueFunc<>,
440 &TrueFunc<>,
441 &FalseFuncI32<>,
442 &TrueFunc<>);
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]443}
444
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]445bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
446 const TensorInfo& input1,
447 const TensorInfo& output,
448 Optional<std::string&> reasonIfUnsupported) const
449{
450 ignore_unused(input1);
451 ignore_unused(output);
452 return IsSupportedForDataTypeRef(reasonIfUnsupported,
453 input0.GetDataType(),
454 &TrueFunc<>,
455 &TrueFunc<>);
456}
457
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]458bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
459 const TensorInfo& input1,
460 const TensorInfo& output,
461 Optional<std::string&> reasonIfUnsupported) const
462{
463 ignore_unused(input1);
464 ignore_unused(output);
465 return IsSupportedForDataTypeRef(reasonIfUnsupported,
466 input0.GetDataType(),
467 &TrueFunc<>,
468 &TrueFunc<>);
469}
470
471bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
472 const TensorInfo& output,
473 const NormalizationDescriptor& descriptor,
474 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]475{
476 ignore_unused(output);
477 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]478 return IsSupportedForDataTypeRef(reasonIfUnsupported,
479 input.GetDataType(),
480 &TrueFunc<>,
481 &FalseFuncU8<>);
482}
483
484bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
485 Optional<std::string&> reasonIfUnsupported) const
486{
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]487 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
488 output.GetDataType(),
489 &TrueFunc<>,
490 &TrueFunc<>,
491 &TrueFunc<>,
492 &FalseFuncI32<>,
493 &TrueFunc<>);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]494}
495
496bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
497 const TensorInfo& output,
498 const PadDescriptor& descriptor,
499 Optional<std::string&> reasonIfUnsupported) const
500{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]501 ignore_unused(output);
502 ignore_unused(descriptor);
jimfly01f6ba7472018-12-04 10:09:52 +0000[diff] [blame]503 return IsSupportedForDataTypeRef(reasonIfUnsupported,
504 input.GetDataType(),
505 &TrueFunc<>,
506 &TrueFunc<>);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]507}
508
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]509bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
510 const TensorInfo& output,
511 const PermuteDescriptor& descriptor,
512 Optional<std::string&> reasonIfUnsupported) const
513{
514 ignore_unused(output);
515 ignore_unused(descriptor);
516 return IsSupportedForDataTypeRef(reasonIfUnsupported,
517 input.GetDataType(),
518 &TrueFunc<>,
519 &TrueFunc<>);
520}
521
522bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
523 const TensorInfo& output,
524 const Pooling2dDescriptor& descriptor,
525 Optional<std::string&> reasonIfUnsupported) const
526{
527 ignore_unused(output);
528 ignore_unused(descriptor);
529 return IsSupportedForDataTypeRef(reasonIfUnsupported,
530 input.GetDataType(),
531 &TrueFunc<>,
532 &TrueFunc<>);
533}
534
535bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]536 const ReshapeDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]537 Optional<std::string&> reasonIfUnsupported) const
538{
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]539 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]540 return IsSupportedForDataTypeRef(reasonIfUnsupported,
541 input.GetDataType(),
542 &TrueFunc<>,
543 &TrueFunc<>);
544}
545
546bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]547 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]548 Optional<std::string&> reasonIfUnsupported) const
549{
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]550 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]551 return IsSupportedForDataTypeRef(reasonIfUnsupported,
552 input.GetDataType(),
553 &TrueFunc<>,
554 &TrueFunc<>);
555}
556
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]557bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input,
558 const TensorInfo& output,
559 Optional<std::string&> reasonIfUnsupported) const
560{
561 ignore_unused(output);
562 return IsSupportedForDataTypeRef(reasonIfUnsupported,
563 input.GetDataType(),
564 &TrueFunc<>,
565 &FalseFuncU8<>);
566}
567
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]568bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
569 const TensorInfo& output,
570 const SoftmaxDescriptor& descriptor,
571 Optional<std::string&> reasonIfUnsupported) const
572{
573 ignore_unused(output);
574 ignore_unused(descriptor);
575 return IsSupportedForDataTypeRef(reasonIfUnsupported,
576 input.GetDataType(),
577 &TrueFunc<>,
578 &TrueFunc<>);
579}
580
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]581bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
582 const TensorInfo& output,
583 const SpaceToBatchNdDescriptor& descriptor,
584 Optional<std::string&> reasonIfUnsupported) const
585{
586 ignore_unused(output);
587 ignore_unused(descriptor);
588 return IsSupportedForDataTypeRef(reasonIfUnsupported,
589 input.GetDataType(),
590 &TrueFunc<>,
591 &TrueFunc<>);
592}
593
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]594bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
595 const ViewsDescriptor& descriptor,
596 Optional<std::string&> reasonIfUnsupported) const
597{
598 ignore_unused(descriptor);
599 return IsSupportedForDataTypeRef(reasonIfUnsupported,
600 input.GetDataType(),
601 &TrueFunc<>,
602 &TrueFunc<>);
603}
604
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]605bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
606 const TensorInfo& output,
607 const StridedSliceDescriptor& descriptor,
608 Optional<std::string&> reasonIfUnsupported) const
609{
610 ignore_unused(output);
611 ignore_unused(descriptor);
612 return IsSupportedForDataTypeRef(reasonIfUnsupported,
613 input.GetDataType(),
614 &TrueFunc<>,
615 &TrueFunc<>);
616}
617
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]618bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
619 const TensorInfo& input1,
620 const TensorInfo& output,
621 Optional<std::string&> reasonIfUnsupported) const
622{
623 ignore_unused(input1);
624 ignore_unused(output);
625 return IsSupportedForDataTypeRef(reasonIfUnsupported,
626 input0.GetDataType(),
627 &TrueFunc<>,
628 &TrueFunc<>);
629}
630
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]631} // namespace armnn