xref: /aosp_15_r20/external/armnn/src/backends/reference/RefLayerSupport.hpp (revision 89c4ff92f2867872bb9e2354d150bf0c8c502810) 
1 //
2 // Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 #pragma once
6 
7 #include <backendsCommon/LayerSupportBase.hpp>
8 
9 namespace armnn
10 {
11 
12 class RefLayerSupport : public LayerSupportBase
13 {
14 public:
15     bool IsLayerSupported(const LayerType& type,
16                           const std::vector<TensorInfo>& infos,
17                           const BaseDescriptor& descriptor,
18                           const Optional<LstmInputParamsInfo>& lstmParamsInfo,
19                           const Optional<QuantizedLstmInputParamsInfo>&,
20                           Optional<std::string&> reasonIfUnsupported) const override;
21 
22     bool IsActivationSupported(const TensorInfo& input,
23                                const TensorInfo& output,
24                                const ActivationDescriptor& descriptor,
25                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
26 
27     bool IsAdditionSupported(const TensorInfo& input0,
28                              const TensorInfo& input1,
29                              const TensorInfo& output,
30                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
31 
32     bool IsArgMinMaxSupported(const TensorInfo& input,
33                               const TensorInfo& output,
34                               const ArgMinMaxDescriptor& descriptor,
35                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
36 
37     bool IsBatchMatMulSupported(const TensorInfo& inputX,
38                                 const TensorInfo& inputY,
39                                 const TensorInfo& output,
40                                 const BatchMatMulDescriptor& descriptor,
41                                 Optional<std::string &> reasonIfUnsupported = EmptyOptional()) const;
42 
43     bool IsBatchNormalizationSupported(const TensorInfo& input,
44                                        const TensorInfo& output,
45                                        const TensorInfo& mean,
46                                        const TensorInfo& var,
47                                        const TensorInfo& beta,
48                                        const TensorInfo& gamma,
49                                        const BatchNormalizationDescriptor& descriptor,
50                                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
51 
52     bool IsBatchToSpaceNdSupported(const TensorInfo& input,
53                                    const TensorInfo& output,
54                                    const BatchToSpaceNdDescriptor& descriptor,
55                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
56 
57     bool IsCastSupported(const TensorInfo& input,
58                          const TensorInfo& output,
59                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
60 
61     bool IsChannelShuffleSupported(const TensorInfo& input,
62                                    const TensorInfo& output,
63                                    const ChannelShuffleDescriptor& descriptor,
64                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
65 
66     bool IsComparisonSupported(const TensorInfo& input0,
67                                const TensorInfo& input1,
68                                const TensorInfo& output,
69                                const ComparisonDescriptor& descriptor,
70                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
71 
72     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
73                            const TensorInfo& output,
74                            const OriginsDescriptor& descriptor,
75                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
76 
77     bool IsConstantSupported(const TensorInfo& output,
78                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
79 
80     bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
81                                       const TensorInfo& output,
82                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
83 
84 
85     bool IsConvertFp32ToFp16Supported(const TensorInfo& input,
86                                       const TensorInfo& output,
87                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
88 
89     bool IsConvolution2dSupported(const TensorInfo& input,
90                                   const TensorInfo& output,
91                                   const Convolution2dDescriptor& descriptor,
92                                   const TensorInfo& weights,
93                                   const Optional<TensorInfo>& biases,
94                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
95 
96     bool IsConvolution3dSupported(const TensorInfo& input,
97                                   const TensorInfo& output,
98                                   const Convolution3dDescriptor& descriptor,
99                                   const TensorInfo& weights,
100                                   const Optional<TensorInfo>& biases,
101                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
102 
103     bool IsDebugSupported(const TensorInfo& input,
104                           const TensorInfo& output,
105                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
106 
107     bool IsDepthToSpaceSupported(const TensorInfo& input,
108                                  const TensorInfo& output,
109                                  const DepthToSpaceDescriptor& descriptor,
110                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
111 
112     bool IsDepthwiseConvolutionSupported(const TensorInfo& input,
113                                          const TensorInfo& output,
114                                          const DepthwiseConvolution2dDescriptor& descriptor,
115                                          const TensorInfo& weights,
116                                          const Optional<TensorInfo>& biases,
117                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
118 
119     bool IsDequantizeSupported(const TensorInfo& input,
120                                const TensorInfo& output,
121                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
122 
123     bool IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
124                                          const TensorInfo& scores,
125                                          const TensorInfo& anchors,
126                                          const TensorInfo& detectionBoxes,
127                                          const TensorInfo& detectionClasses,
128                                          const TensorInfo& detectionScores,
129                                          const TensorInfo& numDetections,
130                                          const DetectionPostProcessDescriptor& descriptor,
131                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
132 
133     bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
134                                                 const TensorInfo& output,
135                                                 const DepthwiseConvolution2dDescriptor& descriptor,
136                                                 const TensorInfo& weights,
137                                                 const Optional<TensorInfo>& biases,
138                                                 Optional<std::string&> reasonIfUnsupported =
139                                                     EmptyOptional()) const override;
140 
141     bool IsDivisionSupported(const TensorInfo& input0,
142                              const TensorInfo& input1,
143                              const TensorInfo& output,
144                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
145 
146     bool IsElementwiseUnarySupported(const TensorInfo& input,
147                                      const TensorInfo& output,
148                                      const ElementwiseUnaryDescriptor& descriptor,
149                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
150 
151     bool IsFakeQuantizationSupported(const TensorInfo& input,
152                                      const FakeQuantizationDescriptor& descriptor,
153                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
154 
155     bool IsFillSupported(const TensorInfo& input,
156                          const TensorInfo& output,
157                          const FillDescriptor& descriptor,
158                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
159 
160     bool IsFloorSupported(const TensorInfo& input,
161                           const TensorInfo& output,
162                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
163 
164     bool IsFullyConnectedSupported(const TensorInfo& input,
165                                    const TensorInfo& output,
166                                    const TensorInfo& weights,
167                                    const TensorInfo& biases,
168                                    const FullyConnectedDescriptor& descriptor,
169                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
170 
171     bool IsGatherNdSupported(const TensorInfo& input0,
172                              const TensorInfo& input1,
173                              const TensorInfo& output,
174                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
175 
176     bool IsGatherSupported(const TensorInfo& input0,
177                            const TensorInfo& input1,
178                            const TensorInfo& output,
179                            const GatherDescriptor& descriptor,
180                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
181 
182     bool IsInputSupported(const TensorInfo& input,
183                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
184 
185     bool IsInstanceNormalizationSupported(const TensorInfo& input,
186                                           const TensorInfo& output,
187                                           const InstanceNormalizationDescriptor& descriptor,
188                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
189 
190     bool IsL2NormalizationSupported(const TensorInfo& input,
191                                     const TensorInfo& output,
192                                     const L2NormalizationDescriptor& descriptor,
193                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
194 
195     bool IsLogicalBinarySupported(const TensorInfo& input0,
196                                   const TensorInfo& input1,
197                                   const TensorInfo& output,
198                                   const LogicalBinaryDescriptor& descriptor,
199                                   Optional<std::string&> reasonIfUnsupported) const override;
200 
201     bool IsLogSoftmaxSupported(const TensorInfo& input,
202                                const TensorInfo& output,
203                                const LogSoftmaxDescriptor& descriptor,
204                                Optional<std::string&> reasonIfUnsupported) const override;
205 
206     bool IsLstmSupported(const TensorInfo& input,
207                          const TensorInfo& outputStateIn,
208                          const TensorInfo& cellStateIn,
209                          const TensorInfo& scratchBuffer,
210                          const TensorInfo& outputStateOut,
211                          const TensorInfo& cellStateOut,
212                          const TensorInfo& output,
213                          const LstmDescriptor& descriptor,
214                          const LstmInputParamsInfo& paramsInfo,
215                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
216 
217     bool IsMaximumSupported(const TensorInfo& input0,
218                             const TensorInfo& input1,
219                             const TensorInfo& output,
220                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
221 
222     bool IsMeanSupported(const TensorInfo& input,
223                          const TensorInfo& output,
224                          const MeanDescriptor& descriptor,
225                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
226 
227     bool IsMemCopySupported(const TensorInfo& input,
228                             const TensorInfo& output,
229                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
230 
231     bool IsMinimumSupported(const TensorInfo& input0,
232                             const TensorInfo& input1,
233                             const TensorInfo& output,
234                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
235 
236     bool IsMultiplicationSupported(const TensorInfo& input0,
237                                    const TensorInfo& input1,
238                                    const TensorInfo& output,
239                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
240 
241     bool IsNormalizationSupported(const TensorInfo& input,
242                                   const TensorInfo& output,
243                                   const NormalizationDescriptor& descriptor,
244                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
245 
246     bool IsOutputSupported(const TensorInfo& output,
247                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
248 
249     bool IsPadSupported(const TensorInfo& input,
250                         const TensorInfo& output,
251                         const PadDescriptor& descriptor,
252                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
253 
254     bool IsPermuteSupported(const TensorInfo& input,
255                             const TensorInfo& output,
256                             const PermuteDescriptor& descriptor,
257                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
258 
259     bool IsPooling2dSupported(const TensorInfo& input,
260                               const TensorInfo& output,
261                               const Pooling2dDescriptor& descriptor,
262                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
263 
264     bool IsPooling3dSupported(const TensorInfo& input,
265                               const TensorInfo& output,
266                               const Pooling3dDescriptor& descriptor,
267                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
268 
269     bool IsQuantizeSupported(const TensorInfo& input,
270                              const TensorInfo& output,
271                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
272 
273     bool IsQLstmSupported(const TensorInfo& input,
274                           const TensorInfo& previousOutputIn,
275                           const TensorInfo& previousCellStateIn,
276                           const TensorInfo& outputStateOut,
277                           const TensorInfo& cellStateOut,
278                           const TensorInfo& output,
279                           const QLstmDescriptor& descriptor,
280                           const LstmInputParamsInfo& paramsInfo,
281                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
282 
283     bool IsRankSupported(const TensorInfo& input,
284                          const TensorInfo& output,
285                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
286 
287     bool IsReduceSupported(const TensorInfo& input,
288                            const TensorInfo& output,
289                            const ReduceDescriptor& descriptor,
290                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
291 
292     bool IsReshapeSupported(const TensorInfo& input,
293                             const TensorInfo& output,
294                             const ReshapeDescriptor& descriptor,
295                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
296 
297     bool IsResizeSupported(const TensorInfo& input,
298                            const TensorInfo& output,
299                            const ResizeDescriptor& descriptor,
300                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
301 
302     bool IsShapeSupported(const TensorInfo& input,
303                           const TensorInfo& output,
304                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
305 
306     bool IsSliceSupported(const TensorInfo& input,
307                           const TensorInfo& output,
308                           const SliceDescriptor& descriptor,
309                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
310 
311     bool IsSoftmaxSupported(const TensorInfo& input,
312                             const TensorInfo& output,
313                             const SoftmaxDescriptor& descriptor,
314                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
315 
316     bool IsSpaceToBatchNdSupported(const TensorInfo& input,
317                                    const TensorInfo& output,
318                                    const SpaceToBatchNdDescriptor& descriptor,
319                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
320 
321     bool IsSpaceToDepthSupported(const TensorInfo& input,
322                                  const TensorInfo& output,
323                                  const SpaceToDepthDescriptor& descriptor,
324                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional())
325                                  const override;
326 
327     bool IsSplitterSupported(const TensorInfo& input,
328                              const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
329                              const ViewsDescriptor& descriptor,
330                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
331 
332     bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
333                           const TensorInfo& output,
334                           const StackDescriptor& descriptor,
335                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
336 
337     bool IsStridedSliceSupported(const TensorInfo& input,
338                                  const TensorInfo& output,
339                                  const StridedSliceDescriptor& descriptor,
340                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
341 
342     bool IsSubtractionSupported(const TensorInfo& input0,
343                                 const TensorInfo& input1,
344                                 const TensorInfo& output,
345                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
346 
347     bool IsPreluSupported(const TensorInfo& input,
348                           const TensorInfo& alpha,
349                           const TensorInfo& output,
350                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
351 
352     bool IsTransposeConvolution2dSupported(
353         const TensorInfo& input,
354         const TensorInfo& output,
355         const TransposeConvolution2dDescriptor& descriptor,
356         const TensorInfo& weights,
357         const Optional<TensorInfo>& biases,
358         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
359 
360     bool IsTransposeSupported(const TensorInfo& input,
361                               const TensorInfo& output,
362                               const TransposeDescriptor& descriptor,
363                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
364 
365     bool IsUnidirectionalSequenceLstmSupported(
366         const TensorInfo& input,
367         const TensorInfo& outputStateIn,
368         const TensorInfo& cellStateIn,
369         const TensorInfo& outputStateOut,
370         const TensorInfo& cellStateOut,
371         const TensorInfo& output,
372         const UnidirectionalSequenceLstmDescriptor& descriptor,
373         const LstmInputParamsInfo& paramsInfo,
374         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
375 };
376 
377 } // namespace armnn
378