Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / d01a83c8de77c44a938a618918d17385da3baa88 / . / src / backends / backendsCommon / LayerSupportBase.cpp
blob: ea22fac9ce2ba81b1041d1513b235d5f9de2f173 [file] [log] [blame]
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1//
2// Copyright © 2017 Arm Ltd. All rights reserved.
3// SPDX-License-Identifier: MIT
4//
5
6#include "LayerSupportBase.hpp"
7
8#include <armnn/Exceptions.hpp>
9
10namespace
11{
12
13bool DefaultLayerSupport(const char* func,
14 const char* file,
15 unsigned int line,
16 armnn::Optional<std::string&> reasonIfUnsupported)
17{
18 // NOTE: We only need to return the reason if the optional parameter is not empty
19 if (reasonIfUnsupported)
20 {
21 std::stringstream message;
22 message << func << " is not implemented [" << file << ":" << line << "]";
23
24 reasonIfUnsupported.value() = message.str();
25 }
26
27 return false;
28}
29
30} // anonymous namespace
31
32namespace armnn
33{
34
35bool LayerSupportBase::IsActivationSupported(const TensorInfo& input,
36 const TensorInfo& output,
37 const ActivationDescriptor& descriptor,
38 Optional<std::string&> reasonIfUnsupported) const
39{
40 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
41}
42
43bool LayerSupportBase::IsAdditionSupported(const TensorInfo& input0,
44 const TensorInfo& input1,
45 const TensorInfo& output,
46 Optional<std::string&> reasonIfUnsupported) const
47{
48 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
49}
50
51bool LayerSupportBase::IsBatchNormalizationSupported(const TensorInfo& input,
52 const TensorInfo& output,
53 const TensorInfo& mean,
54 const TensorInfo& var,
55 const TensorInfo& beta,
56 const TensorInfo& gamma,
57 const BatchNormalizationDescriptor& descriptor,
58 Optional<std::string&> reasonIfUnsupported) const
59{
60 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
61}
62
63bool LayerSupportBase::IsBatchToSpaceNdSupported(const TensorInfo& input,
64 const TensorInfo& output,
65 const BatchToSpaceNdDescriptor& descriptor,
66 Optional<std::string&> reasonIfUnsupported) const
67{
68 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
69}
70
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]71bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
72 const TensorInfo& output,
73 const OriginsDescriptor& descriptor,
74 Optional<std::string&> reasonIfUnsupported) const
75{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]76 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]77}
78
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]79bool LayerSupportBase::IsConstantSupported(const TensorInfo& output,
80 Optional<std::string&> reasonIfUnsupported) const
81{
82 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
83}
84
85bool LayerSupportBase::IsConvertFp16ToFp32Supported(const TensorInfo& input,
86 const TensorInfo& output,
87 Optional<std::string&> reasonIfUnsupported) const
88{
89 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
90}
91
92bool LayerSupportBase::IsConvertFp32ToFp16Supported(const TensorInfo& input,
93 const TensorInfo& output,
94 Optional<std::string&> reasonIfUnsupported) const
95{
96 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
97}
98
99bool LayerSupportBase::IsConvolution2dSupported(const TensorInfo& input,
100 const TensorInfo& output,
101 const Convolution2dDescriptor& descriptor,
102 const TensorInfo& weights,
103 const Optional<TensorInfo>& biases,
104 Optional<std::string&> reasonIfUnsupported) const
105{
106 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
107}
108
109bool LayerSupportBase::IsDebugSupported(const TensorInfo& input,
110 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]111 Optional<std::string&> reasonIfUnsupported) const
112{
113 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
114}
115
116bool LayerSupportBase::IsDepthwiseConvolutionSupported(const TensorInfo& input,
117 const TensorInfo& output,
118 const DepthwiseConvolution2dDescriptor& descriptor,
119 const TensorInfo& weights,
120 const Optional<TensorInfo>& biases,
121 Optional<std::string&> reasonIfUnsupported) const
122{
123 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
124}
125
Nattapat Chaimanowonge4294fd2019-03-28 09:56:53 +0000[diff] [blame]126bool LayerSupportBase::IsDequantizeSupported(const TensorInfo& input,
127 const TensorInfo& output,
128 Optional<std::string&> reasonIfUnsupported) const
129{
130 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
131}
132
Narumol Prangnawarat94dd5d82019-01-23 18:06:26 +0000[diff] [blame]133bool LayerSupportBase::IsDetectionPostProcessSupported(const armnn::TensorInfo& input0,
134 const armnn::TensorInfo& input1,
135 const armnn::DetectionPostProcessDescriptor& descriptor,
136 armnn::Optional<std::string&> reasonIfUnsupported) const
137{
138 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
139}
140
Matteo Martincigheac246d2019-05-14 09:11:03 +0100[diff] [blame]141bool LayerSupportBase::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
142 const TensorInfo& output,
143 const DepthwiseConvolution2dDescriptor& descriptor,
144 const TensorInfo& weights,
145 const Optional<TensorInfo>& biases,
146 Optional<std::string&> reasonIfUnsupported) const
147{
148 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
149}
150
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]151bool LayerSupportBase::IsDivisionSupported(const TensorInfo& input0,
152 const TensorInfo& input1,
153 const TensorInfo& output,
154 Optional<std::string&> reasonIfUnsupported) const
155{
156 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
157}
158
159bool LayerSupportBase::IsEqualSupported(const armnn::TensorInfo& input0,
160 const armnn::TensorInfo& input1,
161 const armnn::TensorInfo& output,
162 armnn::Optional<std::string &> reasonIfUnsupported) const
163{
164 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
165}
166
167bool LayerSupportBase::IsFakeQuantizationSupported(const TensorInfo& input,
168 const FakeQuantizationDescriptor& descriptor,
169 Optional<std::string&> reasonIfUnsupported) const
170{
171 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
172}
173
174bool LayerSupportBase::IsFloorSupported(const TensorInfo& input,
175 const TensorInfo& output,
176 Optional<std::string&> reasonIfUnsupported) const
177{
178 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
179}
180
181bool LayerSupportBase::IsFullyConnectedSupported(const TensorInfo& input,
182 const TensorInfo& output,
183 const TensorInfo& weights,
184 const TensorInfo& biases,
185 const FullyConnectedDescriptor& descriptor,
186 Optional<std::string&> reasonIfUnsupported) const
187{
188 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
189}
190
narpra01b89b05f2019-01-16 09:53:09 +0000[diff] [blame]191bool LayerSupportBase::IsGatherSupported(const armnn::TensorInfo& input0,
192 const armnn::TensorInfo& input1,
193 const armnn::TensorInfo& output,
194 armnn::Optional<std::string&> reasonIfUnsupported) const
195{
196 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
197}
198
Matteo Martincigh3d6898c2019-01-15 16:11:44 +0000[diff] [blame]199bool LayerSupportBase::IsGreaterSupported(const TensorInfo& input0,
200 const TensorInfo& input1,
201 const TensorInfo& output,
202 Optional<std::string&> reasonIfUnsupported) const
203{
204 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
205}
206
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]207bool LayerSupportBase::IsInputSupported(const TensorInfo& input,
208 Optional<std::string&> reasonIfUnsupported) const
209{
210 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
211}
212
213bool LayerSupportBase::IsL2NormalizationSupported(const TensorInfo& input,
214 const TensorInfo& output,
215 const L2NormalizationDescriptor& descriptor,
216 Optional<std::string&> reasonIfUnsupported) const
217{
218 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
219}
220
221bool LayerSupportBase::IsLstmSupported(const TensorInfo& input,
222 const TensorInfo& outputStateIn,
223 const TensorInfo& cellStateIn,
224 const TensorInfo& scratchBuffer,
225 const TensorInfo& outputStateOut,
226 const TensorInfo& cellStateOut,
227 const TensorInfo& output,
228 const LstmDescriptor& descriptor,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame^]229 const LstmInputParamsInfo& paramsInfo,
230 Optional<std::string&> reasonIfUnsupported) const
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]231{
232 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
233}
234
235bool LayerSupportBase::IsMaximumSupported(const TensorInfo& input0,
236 const TensorInfo& input1,
237 const TensorInfo& output,
238 Optional<std::string&> reasonIfUnsupported) const
239{
240 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
241}
242
243bool LayerSupportBase::IsMeanSupported(const TensorInfo& input,
244 const TensorInfo& output,
245 const MeanDescriptor& descriptor,
246 Optional<std::string&> reasonIfUnsupported) const
247{
248 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
249}
250
251bool LayerSupportBase::IsMemCopySupported(const armnn::TensorInfo& input,
252 const armnn::TensorInfo& output,
253 armnn::Optional<std::string &> reasonIfUnsupported) const
254{
255 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
256}
257
Nattapat Chaimanowong1f886302019-04-05 13:37:19 +0100[diff] [blame]258bool LayerSupportBase::IsMergeSupported(const TensorInfo& input0,
259 const TensorInfo& input1,
260 const TensorInfo& output,
261 Optional<std::string&> reasonIfUnsupported) const
262{
263 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
264}
265
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]266bool LayerSupportBase::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
267 const TensorInfo& output,
268 const OriginsDescriptor& descriptor,
269 Optional<std::string&> reasonIfUnsupported) const
270{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]271 return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]272}
273
274bool LayerSupportBase::IsMinimumSupported(const TensorInfo& input0,
275 const TensorInfo& input1,
276 const TensorInfo& output,
277 Optional<std::string&> reasonIfUnsupported) const
278{
279 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
280}
281
282bool LayerSupportBase::IsMultiplicationSupported(const TensorInfo& input0,
283 const TensorInfo& input1,
284 const TensorInfo& output,
285 Optional<std::string&> reasonIfUnsupported) const
286{
287 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
288}
289
290bool LayerSupportBase::IsNormalizationSupported(const TensorInfo& input,
291 const TensorInfo& output,
292 const NormalizationDescriptor& descriptor,
293 Optional<std::string&> reasonIfUnsupported) const
294{
295 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
296}
297
298bool LayerSupportBase::IsOutputSupported(const TensorInfo& output,
299 Optional<std::string&> reasonIfUnsupported) const
300{
301 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
302}
303
304bool LayerSupportBase::IsPadSupported(const TensorInfo& input,
305 const TensorInfo& output,
306 const PadDescriptor& descriptor,
307 Optional<std::string&> reasonIfUnsupported) const
308{
309 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
310}
311
312bool LayerSupportBase::IsPermuteSupported(const TensorInfo& input,
313 const TensorInfo& output,
314 const PermuteDescriptor& descriptor,
315 Optional<std::string&> reasonIfUnsupported) const
316{
317 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
318}
319
320bool LayerSupportBase::IsPooling2dSupported(const TensorInfo& input,
321 const TensorInfo& output,
322 const Pooling2dDescriptor& descriptor,
323 Optional<std::string&> reasonIfUnsupported) const
324{
325 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
326}
327
Matteo Martincigh49124022019-01-11 13:25:59 +0000[diff] [blame]328bool LayerSupportBase::IsPreCompiledSupported(const TensorInfo& input,
329 const PreCompiledDescriptor& descriptor,
330 Optional<std::string&> reasonIfUnsupported) const
331{
332 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
333}
334
Matteo Martincigh0e406ee2019-06-12 15:42:18 +0100[diff] [blame]335bool LayerSupportBase::IsPreluSupported(const TensorInfo& input,
336 const TensorInfo& alpha,
337 const TensorInfo& output,
338 Optional<std::string &> reasonIfUnsupported) const
339{
340 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
341}
342
Derek Lambertia9cca6a2019-03-25 15:41:58 +0000[diff] [blame]343bool LayerSupportBase::IsQuantizeSupported(const armnn::TensorInfo& input,
344 const armnn::TensorInfo& output,
345 armnn::Optional<std::string&> reasonIfUnsupported) const
346{
347 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
348}
349
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]350bool LayerSupportBase::IsReshapeSupported(const TensorInfo& input,
351 const ReshapeDescriptor& descriptor,
352 Optional<std::string&> reasonIfUnsupported) const
353{
354 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
355}
356
357bool LayerSupportBase::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]358 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]359 Optional<std::string&> reasonIfUnsupported) const
360{
361 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
362}
363
Teresa Charlina9075df2019-06-27 15:41:57 +0100[diff] [blame]364bool LayerSupportBase::IsResizeSupported(const TensorInfo& input,
365 const TensorInfo& output,
366 const ResizeDescriptor& descriptor,
367 Optional<std::string&> reasonIfUnsupported) const
368{
369 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
370}
371
Matteo Martincigh3d6898c2019-01-15 16:11:44 +0000[diff] [blame]372bool LayerSupportBase::IsRsqrtSupported(const TensorInfo &input,
373 const TensorInfo &output,
374 Optional<std::string &> reasonIfUnsupported) const
375{
376 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
377}
378
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]379bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo& input,
380 const TensorInfo& output,
381 const SoftmaxDescriptor& descriptor,
382 Optional<std::string&> reasonIfUnsupported) const
383{
384 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
385}
386
387bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo& input,
388 const TensorInfo& output,
389 const SpaceToBatchNdDescriptor& descriptor,
390 Optional<std::string&> reasonIfUnsupported) const
391{
392 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
393}
394
Aron Virginas-Tar972af152019-06-11 14:14:03 +0100[diff] [blame]395bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo& input,
396 const TensorInfo& output,
397 const SpaceToDepthDescriptor& descriptor,
398 Optional<std::string&> reasonIfUnsupported) const
399{
400 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
401}
402
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]403bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
404 const ViewsDescriptor& descriptor,
405 Optional<std::string&> reasonIfUnsupported) const
406{
407 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
408}
409
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]410bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
411 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
412 const ViewsDescriptor& descriptor,
413 Optional<std::string&> reasonIfUnsupported) const
414{
415 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
416}
417
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]418bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo& input,
419 const TensorInfo& output,
420 const StridedSliceDescriptor& descriptor,
421 Optional<std::string&> reasonIfUnsupported) const
422{
423 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
424}
425
426bool LayerSupportBase::IsSubtractionSupported(const TensorInfo& input0,
427 const TensorInfo& input1,
428 const TensorInfo& output,
429 Optional<std::string&> reasonIfUnsupported) const
430{
431 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
432}
433
Sadik Armaganeff363d2019-04-05 15:25:46 +0100[diff] [blame]434bool LayerSupportBase::IsSwitchSupported(const TensorInfo& input0,
435 const TensorInfo& input1,
436 const TensorInfo& output0,
437 const TensorInfo& output1,
438 Optional<std::string&> reasonIfUnsupported) const
439{
440 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
441}
442
Aron Virginas-Tar639fb042019-06-20 14:28:19 +0100[diff] [blame]443bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo& input,
444 const TensorInfo& output,
445 const TransposeConvolution2dDescriptor& descriptor,
446 const TensorInfo& weights,
447 const Optional<TensorInfo>& biases,
448 Optional<std::string&> reasonIfUnsupported) const
449{
450 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
451}
452
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]453} // namespace armnn