Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 737d9ff58b348b11234b6c2363390607d576177d / . / src / backends / backendsCommon / LayerSupportBase.cpp
blob: f202fedb4f979038eb4f5ebffb9b83762c3db44d [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
James Conroyee18dc82019-07-17 11:27:46 +0100[diff] [blame]350bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo& input,
351 const TensorInfo& previousCellStateIn,
352 const TensorInfo& previousOutputIn,
353 const TensorInfo& cellStateOut,
354 const TensorInfo& output,
355 const QuantizedLstmInputParamsInfo& paramsInfo,
356 Optional<std::string&> reasonIfUnsupported) const
357{
358 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
359}
360
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]361bool LayerSupportBase::IsReshapeSupported(const TensorInfo& input,
362 const ReshapeDescriptor& descriptor,
363 Optional<std::string&> reasonIfUnsupported) const
364{
365 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
366}
367
368bool LayerSupportBase::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]369 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]370 Optional<std::string&> reasonIfUnsupported) const
371{
372 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
373}
374
Teresa Charlina9075df2019-06-27 15:41:57 +0100[diff] [blame]375bool LayerSupportBase::IsResizeSupported(const TensorInfo& input,
376 const TensorInfo& output,
377 const ResizeDescriptor& descriptor,
378 Optional<std::string&> reasonIfUnsupported) const
379{
380 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
381}
382
Matteo Martincigh3d6898c2019-01-15 16:11:44 +0000[diff] [blame]383bool LayerSupportBase::IsRsqrtSupported(const TensorInfo &input,
384 const TensorInfo &output,
385 Optional<std::string &> reasonIfUnsupported) const
386{
387 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
388}
389
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]390bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo& input,
391 const TensorInfo& output,
392 const SoftmaxDescriptor& descriptor,
393 Optional<std::string&> reasonIfUnsupported) const
394{
395 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
396}
397
398bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo& input,
399 const TensorInfo& output,
400 const SpaceToBatchNdDescriptor& descriptor,
401 Optional<std::string&> reasonIfUnsupported) const
402{
403 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
404}
405
Aron Virginas-Tar972af152019-06-11 14:14:03 +0100[diff] [blame]406bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo& input,
407 const TensorInfo& output,
408 const SpaceToDepthDescriptor& descriptor,
409 Optional<std::string&> reasonIfUnsupported) const
410{
411 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
412}
413
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]414bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
415 const ViewsDescriptor& descriptor,
416 Optional<std::string&> reasonIfUnsupported) const
417{
418 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
419}
420
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]421bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
422 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
423 const ViewsDescriptor& descriptor,
424 Optional<std::string&> reasonIfUnsupported) const
425{
426 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
427}
428
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]429bool LayerSupportBase::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
Matthew Jackson2b8c1da2019-07-04 14:59:16 +0100[diff] [blame]430 const TensorInfo& output,
431 const StackDescriptor& descriptor,
432 Optional<std::string&> reasonIfUnsupported) const
433{
434 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
435}
436
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]437bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo& input,
438 const TensorInfo& output,
439 const StridedSliceDescriptor& descriptor,
440 Optional<std::string&> reasonIfUnsupported) const
441{
442 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
443}
444
445bool LayerSupportBase::IsSubtractionSupported(const TensorInfo& input0,
446 const TensorInfo& input1,
447 const TensorInfo& output,
448 Optional<std::string&> reasonIfUnsupported) const
449{
450 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
451}
452
Sadik Armaganeff363d2019-04-05 15:25:46 +0100[diff] [blame]453bool LayerSupportBase::IsSwitchSupported(const TensorInfo& input0,
454 const TensorInfo& input1,
455 const TensorInfo& output0,
456 const TensorInfo& output1,
457 Optional<std::string&> reasonIfUnsupported) const
458{
459 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
460}
461
Aron Virginas-Tar639fb042019-06-20 14:28:19 +0100[diff] [blame]462bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo& input,
463 const TensorInfo& output,
464 const TransposeConvolution2dDescriptor& descriptor,
465 const TensorInfo& weights,
466 const Optional<TensorInfo>& biases,
467 Optional<std::string&> reasonIfUnsupported) const
468{
469 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
470}
471
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]472} // namespace armnn