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