src/backends/backendsCommon/LayerSupportBase.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #pragma once
   7
   8 #include <armnn/ILayerSupport.hpp>
   9
  10 namespace armnn
  11 {
  12
  13 class LayerSupportBase : public ILayerSupport
  14 {
  15 public:
  16     bool IsAbsSupported(const TensorInfo& input,
  17                         const TensorInfo& output,
  18                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  19
  20     bool IsActivationSupported(const TensorInfo& input,
  21                                const TensorInfo& output,
  22                                const ActivationDescriptor& descriptor,
  23                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  24
  25     bool IsAdditionSupported(const TensorInfo& input0,
  26                              const TensorInfo& input1,
  27                              const TensorInfo& output,
  28                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  29
  30     bool IsArgMinMaxSupported(const TensorInfo& input,
  31                               const TensorInfo& output,
  32                               const ArgMinMaxDescriptor& descriptor,
  33                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  34
  35     bool IsBatchNormalizationSupported(const TensorInfo& input,
  36                                        const TensorInfo& output,
  37                                        const TensorInfo& mean,
  38                                        const TensorInfo& var,
  39                                        const TensorInfo& beta,
  40                                        const TensorInfo& gamma,
  41                                        const BatchNormalizationDescriptor& descriptor,
  42                                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  43
  44     bool IsBatchToSpaceNdSupported(const TensorInfo& input,
  45                                    const TensorInfo& output,
  46                                    const BatchToSpaceNdDescriptor& descriptor,
  47                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  48
  49     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
  50                            const TensorInfo& output,
  51                            const OriginsDescriptor& descriptor,
  52                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  53
  54     bool IsConstantSupported(const TensorInfo& output,
  55                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  56
  57     bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
  58                                       const TensorInfo& output,
  59                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  60
  61     bool IsConvertFp32ToFp16Supported(
  62             const TensorInfo& input,
  63             const TensorInfo& output,
  64             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  65
  66     bool IsConvolution2dSupported(const TensorInfo& input,
  67                                   const TensorInfo& output,
  68                                   const Convolution2dDescriptor& descriptor,
  69                                   const TensorInfo& weights,
  70                                   const Optional<TensorInfo>& biases,
  71                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  72
  73     bool IsDebugSupported(const TensorInfo& input,
  74                           const TensorInfo& output,
  75                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  76
  77     bool IsDepthwiseConvolutionSupported(const TensorInfo& input,
  78                                          const TensorInfo& output,
  79                                          const DepthwiseConvolution2dDescriptor& descriptor,
  80                                          const TensorInfo& weights,
  81                                          const Optional<TensorInfo>& biases,
  82                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  83
  84     bool IsDequantizeSupported(const TensorInfo& input,
  85                                const TensorInfo& output,
  86                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  87
  88     bool IsDetectionPostProcessSupported(const TensorInfo& input0,
  89                                          const TensorInfo& input1,
  90                                          const DetectionPostProcessDescriptor& descriptor,
  91                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
  92
  93     bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
  94                                                 const TensorInfo& output,
  95                                                 const DepthwiseConvolution2dDescriptor& descriptor,
  96                                                 const TensorInfo& weights,
  97                                                 const Optional<TensorInfo>& biases,
  98                                                 Optional<std::string&> reasonIfUnsupported =
  99                                                     EmptyOptional()) const override;
 100
 101     bool IsDivisionSupported(const TensorInfo& input0,
 102                              const TensorInfo& input1,
 103                              const TensorInfo& output,
 104                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 105
 106     bool IsEqualSupported(const TensorInfo& input0,
 107                           const TensorInfo& input1,
 108                           const TensorInfo& output,
 109                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 110
 111     bool IsFakeQuantizationSupported(const TensorInfo& input,
 112                                      const FakeQuantizationDescriptor& descriptor,
 113                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 114
 115     bool IsFloorSupported(const TensorInfo& input,
 116                           const TensorInfo& output,
 117                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 118
 119     bool IsFullyConnectedSupported(const TensorInfo& input,
 120                                    const TensorInfo& output,
 121                                    const TensorInfo& weights,
 122                                    const TensorInfo& biases,
 123                                    const FullyConnectedDescriptor& descriptor,
 124                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 125
 126     bool IsGatherSupported(const TensorInfo& input0,
 127                            const TensorInfo& input1,
 128                            const TensorInfo& output,
 129                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 130
 131     bool IsGreaterSupported(const TensorInfo& input0,
 132                             const TensorInfo& input1,
 133                             const TensorInfo& output,
 134                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 135
 136     bool IsInputSupported(const TensorInfo& input,
 137                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 138
 139     bool IsL2NormalizationSupported(const TensorInfo& input,
 140                                     const TensorInfo& output,
 141                                     const L2NormalizationDescriptor& descriptor,
 142                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 143
 144     bool IsLstmSupported(const TensorInfo& input,
 145                          const TensorInfo& outputStateIn,
 146                          const TensorInfo& cellStateIn,
 147                          const TensorInfo& scratchBuffer,
 148                          const TensorInfo& outputStateOut,
 149                          const TensorInfo& cellStateOut,
 150                          const TensorInfo& output,
 151                          const LstmDescriptor& descriptor,
 152                          const LstmInputParamsInfo& paramsInfo,
 153                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 154
 155     bool IsMaximumSupported(const TensorInfo& input0,
 156                             const TensorInfo& input1,
 157                             const TensorInfo& output,
 158                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 159
 160     bool IsMeanSupported(const TensorInfo& input,
 161                          const TensorInfo& output,
 162                          const MeanDescriptor& descriptor,
 163                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 164
 165     bool IsMemCopySupported(const TensorInfo& input,
 166                             const TensorInfo& output,
 167                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 168
 169     bool IsMemImportSupported(const TensorInfo& input,
 170                               const TensorInfo& output,
 171                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 172
 173     bool IsMergeSupported(const TensorInfo& input0,
 174                           const TensorInfo& input1,
 175                           const TensorInfo& output,
 176                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 177
 178     ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
 179     bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,
 180                            const TensorInfo& output,
 181                            const OriginsDescriptor& descriptor,
 182                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 183
 184     bool IsMinimumSupported(const TensorInfo& input0,
 185                             const TensorInfo& input1,
 186                             const TensorInfo& output,
 187                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 188
 189     bool IsMultiplicationSupported(const TensorInfo& input0,
 190                                    const TensorInfo& input1,
 191                                    const TensorInfo& output,
 192                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 193
 194     bool IsNormalizationSupported(const TensorInfo& input,
 195                                   const TensorInfo& output,
 196                                   const NormalizationDescriptor& descriptor,
 197                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 198
 199     bool IsOutputSupported(const TensorInfo& output,
 200                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 201
 202     bool IsPadSupported(const TensorInfo& input,
 203                         const TensorInfo& output,
 204                         const PadDescriptor& descriptor,
 205                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 206
 207     bool IsPermuteSupported(const TensorInfo& input,
 208                             const TensorInfo& output,
 209                             const PermuteDescriptor& descriptor,
 210                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 211
 212     bool IsPooling2dSupported(const TensorInfo& input,
 213                               const TensorInfo& output,
 214                               const Pooling2dDescriptor& descriptor,
 215                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 216
 217     bool IsPreCompiledSupported(const TensorInfo& input,
 218                                 const PreCompiledDescriptor& descriptor,
 219                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 220
 221     bool IsPreluSupported(const TensorInfo& input,
 222                           const TensorInfo& alpha,
 223                           const TensorInfo& output,
 224                           Optional<std::string &> reasonIfUnsupported) const override;
 225
 226     bool IsQuantizeSupported(const TensorInfo& input,
 227                              const TensorInfo& output,
 228                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 229
 230     bool IsQuantizedLstmSupported(const TensorInfo& input,
 231                                   const TensorInfo& previousCellStateIn,
 232                                   const TensorInfo& previousOutputIn,
 233                                   const TensorInfo& cellStateOut,
 234                                   const TensorInfo& output,
 235                                   const QuantizedLstmInputParamsInfo& paramsInfo,
 236                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 237
 238     bool IsReshapeSupported(const TensorInfo& input,
 239                             const ReshapeDescriptor& descriptor,
 240                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 241
 242     bool IsResizeSupported(const TensorInfo& input,
 243                            const TensorInfo& output,
 244                            const ResizeDescriptor& descriptor,
 245                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 246
 247     ARMNN_DEPRECATED_MSG("Use IsResizeSupported instead")
 248     bool IsResizeBilinearSupported(const TensorInfo& input,
 249                                    const TensorInfo& output,
 250                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 251
 252     bool IsRsqrtSupported(const TensorInfo& input,
 253                           const TensorInfo& output,
 254                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 255
 256     bool IsSoftmaxSupported(const TensorInfo& input,
 257                             const TensorInfo& output,
 258                             const SoftmaxDescriptor& descriptor,
 259                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 260
 261     bool IsSpaceToBatchNdSupported(const TensorInfo& input,
 262                                    const TensorInfo& output,
 263                                    const SpaceToBatchNdDescriptor& descriptor,
 264                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 265
 266     bool IsSpaceToDepthSupported(const TensorInfo& input,
 267                                  const TensorInfo& output,
 268                                  const SpaceToDepthDescriptor& descriptor,
 269                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 270
 271     ARMNN_DEPRECATED_MSG("Use IsSplitterSupported with outputs instead")
 272     bool IsSplitterSupported(const TensorInfo& input,
 273                              const ViewsDescriptor& descriptor,
 274                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 275
 276     bool IsSplitterSupported(const TensorInfo& input,
 277                              const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
 278                              const ViewsDescriptor& descriptor,
 279                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 280
 281     bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
 282                           const TensorInfo& output,
 283                           const StackDescriptor& descriptor,
 284                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 285
 286     bool IsStridedSliceSupported(const TensorInfo& input,
 287                                  const TensorInfo& output,
 288                                  const StridedSliceDescriptor& descriptor,
 289                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 290
 291     bool IsSubtractionSupported(const TensorInfo& input0,
 292                                 const TensorInfo& input1,
 293                                 const TensorInfo& output,
 294                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 295
 296     bool IsSwitchSupported(const TensorInfo& input0,
 297                            const TensorInfo& input1,
 298                            const TensorInfo& output0,
 299                            const TensorInfo& output1,
 300                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 301
 302     bool IsTransposeConvolution2dSupported(
 303         const TensorInfo& input,
 304         const TensorInfo& output,
 305         const TransposeConvolution2dDescriptor& descriptor,
 306         const TensorInfo& weights,
 307         const Optional<TensorInfo>& biases,
 308         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 309 };
 310
 311 } // namespace armnn