Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 111b5d94d7e854c21377f8d2c0b4234317a903f6 / . / src / backends / reference / RefLayerSupport.cpp
blob: d6c1e66626f0b6376ed09bcd5919b923a17eb240 [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(input);
282 ignore_unused(outputStateIn);
283 ignore_unused(cellStateIn);
284 ignore_unused(scratchBuffer);
285 ignore_unused(outputStateOut);
286 ignore_unused(cellStateOut);
287 ignore_unused(output);
288 ignore_unused(descriptor);
289 ignore_unused(inputToForgetWeights);
290 ignore_unused(inputToCellWeights);
291 ignore_unused(inputToOutputWeights);
292 ignore_unused(recurrentToForgetWeights);
293 ignore_unused(recurrentToCellWeights);
294 ignore_unused(recurrentToOutputWeights);
295 ignore_unused(forgetGateBias);
296 ignore_unused(cellBias);
297 ignore_unused(outputGateBias);
298 ignore_unused(inputToInputWeights);
299 ignore_unused(recurrentToInputWeights);
300 ignore_unused(cellToInputWeights);
301 ignore_unused(inputGateBias);
302 ignore_unused(projectionWeights);
303 ignore_unused(projectionBias);
304 ignore_unused(cellToForgetWeights);
305 ignore_unused(cellToOutputWeights);
arovir01085f0a42018-10-08 14:48:19 +0100[diff] [blame]306 ignore_unused(reasonIfUnsupported);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]307 return false;
308}
309
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]310bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
311 const TensorInfo& output,
312 const MeanDescriptor& descriptor,
313 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]314{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]315 ignore_unused(output);
316 ignore_unused(descriptor);
317 return IsSupportedForDataTypeRef(reasonIfUnsupported,
318 input.GetDataType(),
319 &TrueFunc<>,
320 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]321}
322
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]323bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
324 const OriginsDescriptor& descriptor,
325 Optional<std::string&> reasonIfUnsupported) const
326{
327 ignore_unused(descriptor);
328 return IsSupportedForDataTypeRef(reasonIfUnsupported,
329 inputs[0]->GetDataType(),
330 &TrueFunc<>,
331 &TrueFunc<>);
332}
333
334bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
335 const TensorInfo& input1,
336 const TensorInfo& output,
337 Optional<std::string&> reasonIfUnsupported) const
338{
339 ignore_unused(input1);
340 ignore_unused(output);
341 return IsSupportedForDataTypeRef(reasonIfUnsupported,
342 input0.GetDataType(),
343 &TrueFunc<>,
344 &TrueFunc<>);
345}
346
347bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
348 const TensorInfo& output,
349 const NormalizationDescriptor& descriptor,
350 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]351{
352 ignore_unused(output);
353 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]354 return IsSupportedForDataTypeRef(reasonIfUnsupported,
355 input.GetDataType(),
356 &TrueFunc<>,
357 &FalseFuncU8<>);
358}
359
360bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
361 Optional<std::string&> reasonIfUnsupported) const
362{
363 return IsSupportedForDataTypeRef(reasonIfUnsupported,
364 output.GetDataType(),
365 &TrueFunc<>,
366 &TrueFunc<>);
367}
368
369bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
370 const TensorInfo& output,
371 const PadDescriptor& descriptor,
372 Optional<std::string&> reasonIfUnsupported) const
373{
374 ignore_unused(input);
375 ignore_unused(output);
376 ignore_unused(descriptor);
377 ignore_unused(reasonIfUnsupported);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]378 return false;
379}
380
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]381bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
382 const TensorInfo& output,
383 const PermuteDescriptor& descriptor,
384 Optional<std::string&> reasonIfUnsupported) const
385{
386 ignore_unused(output);
387 ignore_unused(descriptor);
388 return IsSupportedForDataTypeRef(reasonIfUnsupported,
389 input.GetDataType(),
390 &TrueFunc<>,
391 &TrueFunc<>);
392}
393
394bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
395 const TensorInfo& output,
396 const Pooling2dDescriptor& descriptor,
397 Optional<std::string&> reasonIfUnsupported) const
398{
399 ignore_unused(output);
400 ignore_unused(descriptor);
401 return IsSupportedForDataTypeRef(reasonIfUnsupported,
402 input.GetDataType(),
403 &TrueFunc<>,
404 &TrueFunc<>);
405}
406
407bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
408 Optional<std::string&> reasonIfUnsupported) const
409{
410 return IsSupportedForDataTypeRef(reasonIfUnsupported,
411 input.GetDataType(),
412 &TrueFunc<>,
413 &TrueFunc<>);
414}
415
416bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
417 Optional<std::string&> reasonIfUnsupported) const
418{
419 return IsSupportedForDataTypeRef(reasonIfUnsupported,
420 input.GetDataType(),
421 &TrueFunc<>,
422 &TrueFunc<>);
423}
424
425bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
426 const TensorInfo& output,
427 const SoftmaxDescriptor& descriptor,
428 Optional<std::string&> reasonIfUnsupported) const
429{
430 ignore_unused(output);
431 ignore_unused(descriptor);
432 return IsSupportedForDataTypeRef(reasonIfUnsupported,
433 input.GetDataType(),
434 &TrueFunc<>,
435 &TrueFunc<>);
436}
437
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]438bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
439 const TensorInfo& output,
440 const SpaceToBatchNdDescriptor& descriptor,
441 Optional<std::string&> reasonIfUnsupported) const
442{
443 ignore_unused(output);
444 ignore_unused(descriptor);
445 return IsSupportedForDataTypeRef(reasonIfUnsupported,
446 input.GetDataType(),
447 &TrueFunc<>,
448 &TrueFunc<>);
449}
450
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]451bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
452 const ViewsDescriptor& descriptor,
453 Optional<std::string&> reasonIfUnsupported) const
454{
455 ignore_unused(descriptor);
456 return IsSupportedForDataTypeRef(reasonIfUnsupported,
457 input.GetDataType(),
458 &TrueFunc<>,
459 &TrueFunc<>);
460}
461
462bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
463 const TensorInfo& input1,
464 const TensorInfo& output,
465 Optional<std::string&> reasonIfUnsupported) const
466{
467 ignore_unused(input1);
468 ignore_unused(output);
469 return IsSupportedForDataTypeRef(reasonIfUnsupported,
470 input0.GetDataType(),
471 &TrueFunc<>,
472 &TrueFunc<>);
473}
474
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]475} // namespace armnn