Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / a65b7aeafc0ef6acf40e4a8a6d36206bf53d717c / . / src / backends / reference / RefLayerSupport.cpp
blob: 167cba54e8fee2a2a3fe44f7bf3857d3cb03729c [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
163bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
164 const TensorInfo& output,
165 const DepthwiseConvolution2dDescriptor& descriptor,
166 const TensorInfo& weights,
167 const Optional<TensorInfo>& biases,
168 Optional<std::string&> reasonIfUnsupported) const
169{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]170 ignore_unused(output);
171 ignore_unused(descriptor);
172 ignore_unused(weights);
173 ignore_unused(biases);
174 return IsSupportedForDataTypeRef(reasonIfUnsupported,
175 input.GetDataType(),
176 &TrueFunc<>,
177 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]178}
179
180bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
181 const TensorInfo& input1,
182 const TensorInfo& output,
183 Optional<std::string&> reasonIfUnsupported) const
184{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]185 ignore_unused(input1);
186 ignore_unused(output);
187 return IsSupportedForDataTypeRef(reasonIfUnsupported,
188 input0.GetDataType(),
189 &TrueFunc<>,
190 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]191}
192
193bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
194 const FakeQuantizationDescriptor& descriptor,
195 Optional<std::string&> reasonIfUnsupported) const
196{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]197 ignore_unused(descriptor);
198 return IsSupportedForDataTypeRef(reasonIfUnsupported,
199 input.GetDataType(),
200 &TrueFunc<>,
201 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]202}
203
204bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
205 const TensorInfo& output,
206 Optional<std::string&> reasonIfUnsupported) const
207{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]208 ignore_unused(output);
209 return IsSupportedForDataTypeRef(reasonIfUnsupported,
210 input.GetDataType(),
211 &TrueFunc<>,
212 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]213}
214
215bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
216 const TensorInfo& output,
217 const TensorInfo& weights,
218 const TensorInfo& biases,
219 const FullyConnectedDescriptor& descriptor,
220 Optional<std::string&> reasonIfUnsupported) const
221{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]222 ignore_unused(output);
223 ignore_unused(weights);
224 ignore_unused(biases);
225 ignore_unused(descriptor);
226 return IsSupportedForDataTypeRef(reasonIfUnsupported,
227 input.GetDataType(),
228 &TrueFunc<>,
229 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]230}
231
232bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
233 Optional<std::string&> reasonIfUnsupported) const
234{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]235 return IsSupportedForDataTypeRef(reasonIfUnsupported,
236 input.GetDataType(),
237 &TrueFunc<>,
238 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]239}
240
241bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
242 const TensorInfo& output,
243 const L2NormalizationDescriptor& descriptor,
244 Optional<std::string&> reasonIfUnsupported) const
245{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]246 ignore_unused(output);
247 ignore_unused(descriptor);
248 return IsSupportedForDataTypeRef(reasonIfUnsupported,
249 input.GetDataType(),
250 &TrueFunc<>,
251 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]252}
253
254bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
255 const TensorInfo& outputStateIn,
256 const TensorInfo& cellStateIn,
257 const TensorInfo& scratchBuffer,
258 const TensorInfo& outputStateOut,
259 const TensorInfo& cellStateOut,
260 const TensorInfo& output,
261 const LstmDescriptor& descriptor,
262 const TensorInfo& inputToForgetWeights,
263 const TensorInfo& inputToCellWeights,
264 const TensorInfo& inputToOutputWeights,
265 const TensorInfo& recurrentToForgetWeights,
266 const TensorInfo& recurrentToCellWeights,
267 const TensorInfo& recurrentToOutputWeights,
268 const TensorInfo& forgetGateBias,
269 const TensorInfo& cellBias,
270 const TensorInfo& outputGateBias,
271 const TensorInfo* inputToInputWeights,
272 const TensorInfo* recurrentToInputWeights,
273 const TensorInfo* cellToInputWeights,
274 const TensorInfo* inputGateBias,
275 const TensorInfo* projectionWeights,
276 const TensorInfo* projectionBias,
277 const TensorInfo* cellToForgetWeights,
278 const TensorInfo* cellToOutputWeights,
279 Optional<std::string&> reasonIfUnsupported) const
280{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]281 ignore_unused(outputStateIn);
282 ignore_unused(cellStateIn);
283 ignore_unused(scratchBuffer);
284 ignore_unused(outputStateOut);
285 ignore_unused(cellStateOut);
286 ignore_unused(output);
287 ignore_unused(descriptor);
288 ignore_unused(inputToForgetWeights);
289 ignore_unused(inputToCellWeights);
290 ignore_unused(inputToOutputWeights);
291 ignore_unused(recurrentToForgetWeights);
292 ignore_unused(recurrentToCellWeights);
293 ignore_unused(recurrentToOutputWeights);
294 ignore_unused(forgetGateBias);
295 ignore_unused(cellBias);
296 ignore_unused(outputGateBias);
297 ignore_unused(inputToInputWeights);
298 ignore_unused(recurrentToInputWeights);
299 ignore_unused(cellToInputWeights);
300 ignore_unused(inputGateBias);
301 ignore_unused(projectionWeights);
302 ignore_unused(projectionBias);
303 ignore_unused(cellToForgetWeights);
304 ignore_unused(cellToOutputWeights);
Matteo Martincigha65b7ae2018-11-14 12:39:55 +0000[diff] [blame^]305 return IsSupportedForDataTypeRef(reasonIfUnsupported,
306 input.GetDataType(),
307 &TrueFunc<>,
308 &FalseFuncU8<>);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]309}
310
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]311bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
312 const TensorInfo& output,
313 const MeanDescriptor& descriptor,
314 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]315{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]316 ignore_unused(output);
317 ignore_unused(descriptor);
318 return IsSupportedForDataTypeRef(reasonIfUnsupported,
319 input.GetDataType(),
320 &TrueFunc<>,
321 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]322}
323
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]324bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
325 const OriginsDescriptor& descriptor,
326 Optional<std::string&> reasonIfUnsupported) const
327{
328 ignore_unused(descriptor);
329 return IsSupportedForDataTypeRef(reasonIfUnsupported,
330 inputs[0]->GetDataType(),
331 &TrueFunc<>,
332 &TrueFunc<>);
333}
334
335bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
336 const TensorInfo& input1,
337 const TensorInfo& output,
338 Optional<std::string&> reasonIfUnsupported) const
339{
340 ignore_unused(input1);
341 ignore_unused(output);
342 return IsSupportedForDataTypeRef(reasonIfUnsupported,
343 input0.GetDataType(),
344 &TrueFunc<>,
345 &TrueFunc<>);
346}
347
348bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
349 const TensorInfo& output,
350 const NormalizationDescriptor& descriptor,
351 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]352{
353 ignore_unused(output);
354 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]355 return IsSupportedForDataTypeRef(reasonIfUnsupported,
356 input.GetDataType(),
357 &TrueFunc<>,
358 &FalseFuncU8<>);
359}
360
361bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
362 Optional<std::string&> reasonIfUnsupported) const
363{
364 return IsSupportedForDataTypeRef(reasonIfUnsupported,
365 output.GetDataType(),
366 &TrueFunc<>,
367 &TrueFunc<>);
368}
369
370bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
371 const TensorInfo& output,
372 const PadDescriptor& descriptor,
373 Optional<std::string&> reasonIfUnsupported) const
374{
375 ignore_unused(input);
376 ignore_unused(output);
377 ignore_unused(descriptor);
378 ignore_unused(reasonIfUnsupported);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]379 return false;
380}
381
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]382bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
383 const TensorInfo& output,
384 const PermuteDescriptor& descriptor,
385 Optional<std::string&> reasonIfUnsupported) const
386{
387 ignore_unused(output);
388 ignore_unused(descriptor);
389 return IsSupportedForDataTypeRef(reasonIfUnsupported,
390 input.GetDataType(),
391 &TrueFunc<>,
392 &TrueFunc<>);
393}
394
395bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
396 const TensorInfo& output,
397 const Pooling2dDescriptor& descriptor,
398 Optional<std::string&> reasonIfUnsupported) const
399{
400 ignore_unused(output);
401 ignore_unused(descriptor);
402 return IsSupportedForDataTypeRef(reasonIfUnsupported,
403 input.GetDataType(),
404 &TrueFunc<>,
405 &TrueFunc<>);
406}
407
408bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
409 Optional<std::string&> reasonIfUnsupported) const
410{
411 return IsSupportedForDataTypeRef(reasonIfUnsupported,
412 input.GetDataType(),
413 &TrueFunc<>,
414 &TrueFunc<>);
415}
416
417bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
418 Optional<std::string&> reasonIfUnsupported) const
419{
420 return IsSupportedForDataTypeRef(reasonIfUnsupported,
421 input.GetDataType(),
422 &TrueFunc<>,
423 &TrueFunc<>);
424}
425
426bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
427 const TensorInfo& output,
428 const SoftmaxDescriptor& descriptor,
429 Optional<std::string&> reasonIfUnsupported) const
430{
431 ignore_unused(output);
432 ignore_unused(descriptor);
433 return IsSupportedForDataTypeRef(reasonIfUnsupported,
434 input.GetDataType(),
435 &TrueFunc<>,
436 &TrueFunc<>);
437}
438
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]439bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
440 const TensorInfo& output,
441 const SpaceToBatchNdDescriptor& 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
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]452bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
453 const ViewsDescriptor& descriptor,
454 Optional<std::string&> reasonIfUnsupported) const
455{
456 ignore_unused(descriptor);
457 return IsSupportedForDataTypeRef(reasonIfUnsupported,
458 input.GetDataType(),
459 &TrueFunc<>,
460 &TrueFunc<>);
461}
462
463bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
464 const TensorInfo& input1,
465 const TensorInfo& output,
466 Optional<std::string&> reasonIfUnsupported) const
467{
468 ignore_unused(input1);
469 ignore_unused(output);
470 return IsSupportedForDataTypeRef(reasonIfUnsupported,
471 input0.GetDataType(),
472 &TrueFunc<>,
473 &TrueFunc<>);
474}
475
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]476} // namespace armnn