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