Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 992d6dc57d8463729910b688f0fb5825d0d3ccf2 / . / src / backends / reference / RefLayerSupport.cpp
blob: 61a34f957e74e63503e363b2763c8113e047115c [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
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]260bool RefLayerSupport::IsGreaterSupported(const TensorInfo& input0,
261 const TensorInfo& input1,
262 const TensorInfo& output,
263 Optional<std::string&> reasonIfUnsupported) const
264{
265 ignore_unused(input0);
266 ignore_unused(input1);
267 ignore_unused(output);
268 ignore_unused(reasonIfUnsupported);
269 return IsSupportedForDataTypeRef(reasonIfUnsupported,
270 input0.GetDataType(),
271 &TrueFunc<>,
272 &TrueFunc<>);
273}
274
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]275bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
276 Optional<std::string&> reasonIfUnsupported) const
277{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]278 return IsSupportedForDataTypeRef(reasonIfUnsupported,
279 input.GetDataType(),
280 &TrueFunc<>,
281 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]282}
283
284bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
285 const TensorInfo& output,
286 const L2NormalizationDescriptor& descriptor,
287 Optional<std::string&> reasonIfUnsupported) const
288{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]289 ignore_unused(output);
290 ignore_unused(descriptor);
291 return IsSupportedForDataTypeRef(reasonIfUnsupported,
292 input.GetDataType(),
293 &TrueFunc<>,
294 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]295}
296
297bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
298 const TensorInfo& outputStateIn,
299 const TensorInfo& cellStateIn,
300 const TensorInfo& scratchBuffer,
301 const TensorInfo& outputStateOut,
302 const TensorInfo& cellStateOut,
303 const TensorInfo& output,
304 const LstmDescriptor& descriptor,
305 const TensorInfo& inputToForgetWeights,
306 const TensorInfo& inputToCellWeights,
307 const TensorInfo& inputToOutputWeights,
308 const TensorInfo& recurrentToForgetWeights,
309 const TensorInfo& recurrentToCellWeights,
310 const TensorInfo& recurrentToOutputWeights,
311 const TensorInfo& forgetGateBias,
312 const TensorInfo& cellBias,
313 const TensorInfo& outputGateBias,
314 const TensorInfo* inputToInputWeights,
315 const TensorInfo* recurrentToInputWeights,
316 const TensorInfo* cellToInputWeights,
317 const TensorInfo* inputGateBias,
318 const TensorInfo* projectionWeights,
319 const TensorInfo* projectionBias,
320 const TensorInfo* cellToForgetWeights,
321 const TensorInfo* cellToOutputWeights,
322 Optional<std::string&> reasonIfUnsupported) const
323{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]324 ignore_unused(outputStateIn);
325 ignore_unused(cellStateIn);
326 ignore_unused(scratchBuffer);
327 ignore_unused(outputStateOut);
328 ignore_unused(cellStateOut);
329 ignore_unused(output);
330 ignore_unused(descriptor);
331 ignore_unused(inputToForgetWeights);
332 ignore_unused(inputToCellWeights);
333 ignore_unused(inputToOutputWeights);
334 ignore_unused(recurrentToForgetWeights);
335 ignore_unused(recurrentToCellWeights);
336 ignore_unused(recurrentToOutputWeights);
337 ignore_unused(forgetGateBias);
338 ignore_unused(cellBias);
339 ignore_unused(outputGateBias);
340 ignore_unused(inputToInputWeights);
341 ignore_unused(recurrentToInputWeights);
342 ignore_unused(cellToInputWeights);
343 ignore_unused(inputGateBias);
344 ignore_unused(projectionWeights);
345 ignore_unused(projectionBias);
346 ignore_unused(cellToForgetWeights);
347 ignore_unused(cellToOutputWeights);
Matteo Martincigha65b7ae2018-11-14 12:39:55 +0000[diff] [blame]348 return IsSupportedForDataTypeRef(reasonIfUnsupported,
349 input.GetDataType(),
350 &TrueFunc<>,
351 &FalseFuncU8<>);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]352}
353
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]354bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
355 const TensorInfo& input1,
356 const TensorInfo& output,
357 Optional<std::string&> reasonIfUnsupported) const
358{
359 ignore_unused(input1);
360 ignore_unused(output);
361 return IsSupportedForDataTypeRef(reasonIfUnsupported,
362 input0.GetDataType(),
363 &TrueFunc<>,
364 &TrueFunc<>);
365}
366
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]367bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
368 const TensorInfo& output,
369 const MeanDescriptor& descriptor,
370 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]371{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]372 ignore_unused(output);
373 ignore_unused(descriptor);
374 return IsSupportedForDataTypeRef(reasonIfUnsupported,
375 input.GetDataType(),
376 &TrueFunc<>,
377 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]378}
379
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]380bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]381 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]382 const OriginsDescriptor& descriptor,
383 Optional<std::string&> reasonIfUnsupported) const
384{
385 ignore_unused(descriptor);
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]386 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]387 return IsSupportedForDataTypeRef(reasonIfUnsupported,
388 inputs[0]->GetDataType(),
389 &TrueFunc<>,
390 &TrueFunc<>);
391}
392
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame^]393bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
394 const TensorInfo &output,
395 Optional<std::string &> reasonIfUnsupported) const
396{
397 ignore_unused(output);
398 return IsSupportedForDataTypeRef(reasonIfUnsupported,
399 input.GetDataType(),
400 &TrueFunc<>,
401 &TrueFunc<>);
402}
403
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]404bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
405 const TensorInfo& input1,
406 const TensorInfo& output,
407 Optional<std::string&> reasonIfUnsupported) const
408{
409 ignore_unused(input1);
410 ignore_unused(output);
411 return IsSupportedForDataTypeRef(reasonIfUnsupported,
412 input0.GetDataType(),
413 &TrueFunc<>,
414 &TrueFunc<>);
415}
416
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]417bool RefLayerSupport::IsMultiplicationSupported(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
430bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
431 const TensorInfo& output,
432 const NormalizationDescriptor& descriptor,
433 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]434{
435 ignore_unused(output);
436 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]437 return IsSupportedForDataTypeRef(reasonIfUnsupported,
438 input.GetDataType(),
439 &TrueFunc<>,
440 &FalseFuncU8<>);
441}
442
443bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
444 Optional<std::string&> reasonIfUnsupported) const
445{
446 return IsSupportedForDataTypeRef(reasonIfUnsupported,
447 output.GetDataType(),
448 &TrueFunc<>,
449 &TrueFunc<>);
450}
451
452bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
453 const TensorInfo& output,
454 const PadDescriptor& descriptor,
455 Optional<std::string&> reasonIfUnsupported) const
456{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]457 ignore_unused(output);
458 ignore_unused(descriptor);
jimfly01f6ba7472018-12-04 10:09:52 +0000[diff] [blame]459 return IsSupportedForDataTypeRef(reasonIfUnsupported,
460 input.GetDataType(),
461 &TrueFunc<>,
462 &TrueFunc<>);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]463}
464
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]465bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
466 const TensorInfo& output,
467 const PermuteDescriptor& descriptor,
468 Optional<std::string&> reasonIfUnsupported) const
469{
470 ignore_unused(output);
471 ignore_unused(descriptor);
472 return IsSupportedForDataTypeRef(reasonIfUnsupported,
473 input.GetDataType(),
474 &TrueFunc<>,
475 &TrueFunc<>);
476}
477
478bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
479 const TensorInfo& output,
480 const Pooling2dDescriptor& 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::IsReshapeSupported(const TensorInfo& input,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame^]492 const ReshapeDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]493 Optional<std::string&> reasonIfUnsupported) const
494{
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame^]495 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]496 return IsSupportedForDataTypeRef(reasonIfUnsupported,
497 input.GetDataType(),
498 &TrueFunc<>,
499 &TrueFunc<>);
500}
501
502bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
503 Optional<std::string&> reasonIfUnsupported) const
504{
505 return IsSupportedForDataTypeRef(reasonIfUnsupported,
506 input.GetDataType(),
507 &TrueFunc<>,
508 &TrueFunc<>);
509}
510
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]511bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input,
512 const TensorInfo& output,
513 Optional<std::string&> reasonIfUnsupported) const
514{
515 ignore_unused(output);
516 return IsSupportedForDataTypeRef(reasonIfUnsupported,
517 input.GetDataType(),
518 &TrueFunc<>,
519 &FalseFuncU8<>);
520}
521
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]522bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
523 const TensorInfo& output,
524 const SoftmaxDescriptor& 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
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]535bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
536 const TensorInfo& output,
537 const SpaceToBatchNdDescriptor& 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
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]548bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
549 const ViewsDescriptor& descriptor,
550 Optional<std::string&> reasonIfUnsupported) const
551{
552 ignore_unused(descriptor);
553 return IsSupportedForDataTypeRef(reasonIfUnsupported,
554 input.GetDataType(),
555 &TrueFunc<>,
556 &TrueFunc<>);
557}
558
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]559bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
560 const TensorInfo& output,
561 const StridedSliceDescriptor& descriptor,
562 Optional<std::string&> reasonIfUnsupported) const
563{
564 ignore_unused(output);
565 ignore_unused(descriptor);
566 return IsSupportedForDataTypeRef(reasonIfUnsupported,
567 input.GetDataType(),
568 &TrueFunc<>,
569 &TrueFunc<>);
570}
571
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]572bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
573 const TensorInfo& input1,
574 const TensorInfo& output,
575 Optional<std::string&> reasonIfUnsupported) const
576{
577 ignore_unused(input1);
578 ignore_unused(output);
579 return IsSupportedForDataTypeRef(reasonIfUnsupported,
580 input0.GetDataType(),
581 &TrueFunc<>,
582 &TrueFunc<>);
583}
584
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]585} // namespace armnn