Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 2b4d88e34ac1f965417fd236fd4786f26bae2042 / . / src / backends / reference / RefLayerSupport.cpp
blob: 78e44bd6a34c3f67fdc671788663122d77952039 [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
206bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
207 const TensorInfo& input1,
208 const TensorInfo& output,
209 Optional<std::string&> reasonIfUnsupported) const
210{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]211 ignore_unused(input1);
212 ignore_unused(output);
213 return IsSupportedForDataTypeRef(reasonIfUnsupported,
214 input0.GetDataType(),
215 &TrueFunc<>,
216 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]217}
218
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]219bool RefLayerSupport::IsEqualSupported(const TensorInfo& input0,
220 const TensorInfo& input1,
221 const TensorInfo& output,
222 Optional<std::string&> reasonIfUnsupported) const
223{
224 ignore_unused(input0);
225 ignore_unused(input1);
226 ignore_unused(output);
227 ignore_unused(reasonIfUnsupported);
228 return IsSupportedForDataTypeRef(reasonIfUnsupported,
229 input0.GetDataType(),
230 &TrueFunc<>,
231 &TrueFunc<>);
232}
233
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]234bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
235 const FakeQuantizationDescriptor& descriptor,
236 Optional<std::string&> reasonIfUnsupported) const
237{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]238 ignore_unused(descriptor);
239 return IsSupportedForDataTypeRef(reasonIfUnsupported,
240 input.GetDataType(),
241 &TrueFunc<>,
242 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]243}
244
245bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
246 const TensorInfo& output,
247 Optional<std::string&> reasonIfUnsupported) const
248{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]249 ignore_unused(output);
250 return IsSupportedForDataTypeRef(reasonIfUnsupported,
251 input.GetDataType(),
252 &TrueFunc<>,
253 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]254}
255
256bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
257 const TensorInfo& output,
258 const TensorInfo& weights,
259 const TensorInfo& biases,
260 const FullyConnectedDescriptor& descriptor,
261 Optional<std::string&> reasonIfUnsupported) const
262{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]263 ignore_unused(output);
264 ignore_unused(weights);
265 ignore_unused(biases);
266 ignore_unused(descriptor);
267 return IsSupportedForDataTypeRef(reasonIfUnsupported,
268 input.GetDataType(),
269 &TrueFunc<>,
270 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]271}
272
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]273bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0,
274 const armnn::TensorInfo& input1,
275 const armnn::TensorInfo& output,
276 armnn::Optional<std::string&> reasonIfUnsupported) const
277{
278 ignore_unused(input1);
279 ignore_unused(output);
280 return IsSupportedForDataTypeRef(reasonIfUnsupported,
281 input0.GetDataType(),
282 &TrueFunc<>,
283 &TrueFunc<>);
284}
285
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]286bool RefLayerSupport::IsGreaterSupported(const TensorInfo& input0,
287 const TensorInfo& input1,
288 const TensorInfo& output,
289 Optional<std::string&> reasonIfUnsupported) const
290{
291 ignore_unused(input0);
292 ignore_unused(input1);
293 ignore_unused(output);
294 ignore_unused(reasonIfUnsupported);
295 return IsSupportedForDataTypeRef(reasonIfUnsupported,
296 input0.GetDataType(),
297 &TrueFunc<>,
298 &TrueFunc<>);
299}
300
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]301bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
302 Optional<std::string&> reasonIfUnsupported) const
303{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]304 return IsSupportedForDataTypeRef(reasonIfUnsupported,
305 input.GetDataType(),
306 &TrueFunc<>,
307 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]308}
309
310bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
311 const TensorInfo& output,
312 const L2NormalizationDescriptor& descriptor,
313 Optional<std::string&> reasonIfUnsupported) const
314{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]315 ignore_unused(output);
316 ignore_unused(descriptor);
317 return IsSupportedForDataTypeRef(reasonIfUnsupported,
318 input.GetDataType(),
319 &TrueFunc<>,
320 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]321}
322
323bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
324 const TensorInfo& outputStateIn,
325 const TensorInfo& cellStateIn,
326 const TensorInfo& scratchBuffer,
327 const TensorInfo& outputStateOut,
328 const TensorInfo& cellStateOut,
329 const TensorInfo& output,
330 const LstmDescriptor& descriptor,
331 const TensorInfo& inputToForgetWeights,
332 const TensorInfo& inputToCellWeights,
333 const TensorInfo& inputToOutputWeights,
334 const TensorInfo& recurrentToForgetWeights,
335 const TensorInfo& recurrentToCellWeights,
336 const TensorInfo& recurrentToOutputWeights,
337 const TensorInfo& forgetGateBias,
338 const TensorInfo& cellBias,
339 const TensorInfo& outputGateBias,
340 const TensorInfo* inputToInputWeights,
341 const TensorInfo* recurrentToInputWeights,
342 const TensorInfo* cellToInputWeights,
343 const TensorInfo* inputGateBias,
344 const TensorInfo* projectionWeights,
345 const TensorInfo* projectionBias,
346 const TensorInfo* cellToForgetWeights,
347 const TensorInfo* cellToOutputWeights,
348 Optional<std::string&> reasonIfUnsupported) const
349{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]350 ignore_unused(outputStateIn);
351 ignore_unused(cellStateIn);
352 ignore_unused(scratchBuffer);
353 ignore_unused(outputStateOut);
354 ignore_unused(cellStateOut);
355 ignore_unused(output);
356 ignore_unused(descriptor);
357 ignore_unused(inputToForgetWeights);
358 ignore_unused(inputToCellWeights);
359 ignore_unused(inputToOutputWeights);
360 ignore_unused(recurrentToForgetWeights);
361 ignore_unused(recurrentToCellWeights);
362 ignore_unused(recurrentToOutputWeights);
363 ignore_unused(forgetGateBias);
364 ignore_unused(cellBias);
365 ignore_unused(outputGateBias);
366 ignore_unused(inputToInputWeights);
367 ignore_unused(recurrentToInputWeights);
368 ignore_unused(cellToInputWeights);
369 ignore_unused(inputGateBias);
370 ignore_unused(projectionWeights);
371 ignore_unused(projectionBias);
372 ignore_unused(cellToForgetWeights);
373 ignore_unused(cellToOutputWeights);
Matteo Martincigha65b7ae2018-11-14 12:39:55 +0000[diff] [blame]374 return IsSupportedForDataTypeRef(reasonIfUnsupported,
375 input.GetDataType(),
376 &TrueFunc<>,
377 &FalseFuncU8<>);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]378}
379
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]380bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
381 const TensorInfo& input1,
382 const TensorInfo& output,
383 Optional<std::string&> reasonIfUnsupported) const
384{
385 ignore_unused(input1);
386 ignore_unused(output);
387 return IsSupportedForDataTypeRef(reasonIfUnsupported,
388 input0.GetDataType(),
389 &TrueFunc<>,
390 &TrueFunc<>);
391}
392
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]393bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
394 const TensorInfo& output,
395 const MeanDescriptor& descriptor,
396 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]397{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]398 ignore_unused(output);
399 ignore_unused(descriptor);
400 return IsSupportedForDataTypeRef(reasonIfUnsupported,
401 input.GetDataType(),
402 &TrueFunc<>,
403 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]404}
405
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]406bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]407 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]408 const OriginsDescriptor& descriptor,
409 Optional<std::string&> reasonIfUnsupported) const
410{
411 ignore_unused(descriptor);
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]412 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]413 return IsSupportedForDataTypeRef(reasonIfUnsupported,
414 inputs[0]->GetDataType(),
415 &TrueFunc<>,
416 &TrueFunc<>);
417}
418
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]419bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
420 const TensorInfo &output,
421 Optional<std::string &> reasonIfUnsupported) const
422{
423 ignore_unused(output);
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame^]424 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
425 input.GetDataType(),
426 &TrueFunc<>,
427 &TrueFunc<>,
428 &TrueFunc<>,
429 &FalseFuncI32<>,
430 &TrueFunc<>);
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]431}
432
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]433bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
434 const TensorInfo& input1,
435 const TensorInfo& output,
436 Optional<std::string&> reasonIfUnsupported) const
437{
438 ignore_unused(input1);
439 ignore_unused(output);
440 return IsSupportedForDataTypeRef(reasonIfUnsupported,
441 input0.GetDataType(),
442 &TrueFunc<>,
443 &TrueFunc<>);
444}
445
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]446bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
447 const TensorInfo& input1,
448 const TensorInfo& output,
449 Optional<std::string&> reasonIfUnsupported) const
450{
451 ignore_unused(input1);
452 ignore_unused(output);
453 return IsSupportedForDataTypeRef(reasonIfUnsupported,
454 input0.GetDataType(),
455 &TrueFunc<>,
456 &TrueFunc<>);
457}
458
459bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
460 const TensorInfo& output,
461 const NormalizationDescriptor& descriptor,
462 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]463{
464 ignore_unused(output);
465 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]466 return IsSupportedForDataTypeRef(reasonIfUnsupported,
467 input.GetDataType(),
468 &TrueFunc<>,
469 &FalseFuncU8<>);
470}
471
472bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
473 Optional<std::string&> reasonIfUnsupported) const
474{
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame^]475 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
476 output.GetDataType(),
477 &TrueFunc<>,
478 &TrueFunc<>,
479 &TrueFunc<>,
480 &FalseFuncI32<>,
481 &TrueFunc<>);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]482}
483
484bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
485 const TensorInfo& output,
486 const PadDescriptor& descriptor,
487 Optional<std::string&> reasonIfUnsupported) const
488{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]489 ignore_unused(output);
490 ignore_unused(descriptor);
jimfly01f6ba7472018-12-04 10:09:52 +0000[diff] [blame]491 return IsSupportedForDataTypeRef(reasonIfUnsupported,
492 input.GetDataType(),
493 &TrueFunc<>,
494 &TrueFunc<>);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]495}
496
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]497bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
498 const TensorInfo& output,
499 const PermuteDescriptor& descriptor,
500 Optional<std::string&> reasonIfUnsupported) const
501{
502 ignore_unused(output);
503 ignore_unused(descriptor);
504 return IsSupportedForDataTypeRef(reasonIfUnsupported,
505 input.GetDataType(),
506 &TrueFunc<>,
507 &TrueFunc<>);
508}
509
510bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
511 const TensorInfo& output,
512 const Pooling2dDescriptor& descriptor,
513 Optional<std::string&> reasonIfUnsupported) const
514{
515 ignore_unused(output);
516 ignore_unused(descriptor);
517 return IsSupportedForDataTypeRef(reasonIfUnsupported,
518 input.GetDataType(),
519 &TrueFunc<>,
520 &TrueFunc<>);
521}
522
523bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]524 const ReshapeDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]525 Optional<std::string&> reasonIfUnsupported) const
526{
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]527 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]528 return IsSupportedForDataTypeRef(reasonIfUnsupported,
529 input.GetDataType(),
530 &TrueFunc<>,
531 &TrueFunc<>);
532}
533
534bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]535 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]536 Optional<std::string&> reasonIfUnsupported) const
537{
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]538 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]539 return IsSupportedForDataTypeRef(reasonIfUnsupported,
540 input.GetDataType(),
541 &TrueFunc<>,
542 &TrueFunc<>);
543}
544
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]545bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input,
546 const TensorInfo& output,
547 Optional<std::string&> reasonIfUnsupported) const
548{
549 ignore_unused(output);
550 return IsSupportedForDataTypeRef(reasonIfUnsupported,
551 input.GetDataType(),
552 &TrueFunc<>,
553 &FalseFuncU8<>);
554}
555
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]556bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
557 const TensorInfo& output,
558 const SoftmaxDescriptor& descriptor,
559 Optional<std::string&> reasonIfUnsupported) const
560{
561 ignore_unused(output);
562 ignore_unused(descriptor);
563 return IsSupportedForDataTypeRef(reasonIfUnsupported,
564 input.GetDataType(),
565 &TrueFunc<>,
566 &TrueFunc<>);
567}
568
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]569bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
570 const TensorInfo& output,
571 const SpaceToBatchNdDescriptor& descriptor,
572 Optional<std::string&> reasonIfUnsupported) const
573{
574 ignore_unused(output);
575 ignore_unused(descriptor);
576 return IsSupportedForDataTypeRef(reasonIfUnsupported,
577 input.GetDataType(),
578 &TrueFunc<>,
579 &TrueFunc<>);
580}
581
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]582bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
583 const ViewsDescriptor& descriptor,
584 Optional<std::string&> reasonIfUnsupported) const
585{
586 ignore_unused(descriptor);
587 return IsSupportedForDataTypeRef(reasonIfUnsupported,
588 input.GetDataType(),
589 &TrueFunc<>,
590 &TrueFunc<>);
591}
592
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]593bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
594 const TensorInfo& output,
595 const StridedSliceDescriptor& descriptor,
596 Optional<std::string&> reasonIfUnsupported) const
597{
598 ignore_unused(output);
599 ignore_unused(descriptor);
600 return IsSupportedForDataTypeRef(reasonIfUnsupported,
601 input.GetDataType(),
602 &TrueFunc<>,
603 &TrueFunc<>);
604}
605
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]606bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
607 const TensorInfo& input1,
608 const TensorInfo& output,
609 Optional<std::string&> reasonIfUnsupported) const
610{
611 ignore_unused(input1);
612 ignore_unused(output);
613 return IsSupportedForDataTypeRef(reasonIfUnsupported,
614 input0.GetDataType(),
615 &TrueFunc<>,
616 &TrueFunc<>);
617}
618
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]619} // namespace armnn