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