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