src/backends/backendsCommon/ILayerSupport.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include <armnn/ILayerSupport.hpp>
   7 #include <armnn/Exceptions.hpp>
   8
   9 namespace armnn
  10 {
  11
  12 namespace
  13 {
  14
  15 bool DefaultLayerSupport(const char* func,
  16                          const char* file,
  17                          unsigned int line,
  18                          Optional<std::string&> reasonIfUnsupported)
  19 {
  20     // NOTE: We only need to return the reason if the optional parameter is not empty
  21     if (reasonIfUnsupported)
  22     {
  23         std::stringstream message;
  24         message << func << "is not implemented [" << file << ":" << line << "]";
  25
  26         reasonIfUnsupported.value() = message.str();
  27     }
  28
  29     return false;
  30 }
  31
  32 } // anonymous namespace
  33
  34 bool ILayerSupport::IsActivationSupported(const TensorInfo& input,
  35                                           const TensorInfo& output,
  36                                           const ActivationDescriptor& descriptor,
  37                                           Optional<std::string&> reasonIfUnsupported) const
  38 {
  39     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  40 }
  41
  42 bool ILayerSupport::IsAdditionSupported(const TensorInfo& input0,
  43                                         const TensorInfo& input1,
  44                                         const TensorInfo& output,
  45                                         Optional<std::string&> reasonIfUnsupported) const
  46 {
  47     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  48 }
  49
  50 bool ILayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
  51                                                   const TensorInfo& output,
  52                                                   const TensorInfo& mean,
  53                                                   const TensorInfo& var,
  54                                                   const TensorInfo& beta,
  55                                                   const TensorInfo& gamma,
  56                                                   const BatchNormalizationDescriptor& descriptor,
  57                                                   Optional<std::string&> reasonIfUnsupported) const
  58 {
  59     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  60 }
  61
  62 bool ILayerSupport::IsConstantSupported(const TensorInfo& output,
  63                                         Optional<std::string&> reasonIfUnsupported) const
  64 {
  65     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  66 }
  67
  68 bool ILayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
  69                                                  const TensorInfo& output,
  70                                                  Optional<std::string&> reasonIfUnsupported) const
  71 {
  72     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  73 }
  74
  75 bool ILayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
  76                                                  const TensorInfo& output,
  77                                                  Optional<std::string&> reasonIfUnsupported) const
  78 {
  79     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  80 }
  81
  82 bool ILayerSupport::IsConvolution2dSupported(const TensorInfo& input,
  83                                              const TensorInfo& output,
  84                                              const Convolution2dDescriptor& descriptor,
  85                                              const TensorInfo& weights,
  86                                              const Optional<TensorInfo>& biases,
  87                                              Optional<std::string&> reasonIfUnsupported) const
  88 {
  89     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  90 }
  91
  92 bool ILayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
  93                                                     const TensorInfo& output,
  94                                                     const DepthwiseConvolution2dDescriptor& descriptor,
  95                                                     const TensorInfo& weights,
  96                                                     const Optional<TensorInfo>& biases,
  97                                                     Optional<std::string&> reasonIfUnsupported) const
  98 {
  99     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 100 }
 101
 102 bool ILayerSupport::IsDivisionSupported(const TensorInfo& input0,
 103                                         const TensorInfo& input1,
 104                                         const TensorInfo& output,
 105                                         Optional<std::string&> reasonIfUnsupported) const
 106 {
 107     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 108 }
 109
 110 bool ILayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
 111                                                 const FakeQuantizationDescriptor& descriptor,
 112                                                 Optional<std::string&> reasonIfUnsupported) const
 113 {
 114     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 115 }
 116
 117 bool ILayerSupport::IsFloorSupported(const TensorInfo& input,
 118                                      const TensorInfo& output,
 119                                      Optional<std::string&> reasonIfUnsupported) const
 120 {
 121     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 122 }
 123
 124 bool ILayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
 125                                               const TensorInfo& output,
 126                                               const TensorInfo& weights,
 127                                               const TensorInfo& biases,
 128                                               const FullyConnectedDescriptor& descriptor,
 129                                               Optional<std::string&> reasonIfUnsupported) const
 130 {
 131     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 132 }
 133
 134 bool ILayerSupport::IsInputSupported(const TensorInfo& input,
 135                                      Optional<std::string&> reasonIfUnsupported) const
 136 {
 137     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 138 }
 139
 140 bool ILayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
 141                                                const TensorInfo& output,
 142                                                const L2NormalizationDescriptor& descriptor,
 143                                                Optional<std::string&> reasonIfUnsupported) const
 144 {
 145     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 146 }
 147
 148 bool ILayerSupport::IsLstmSupported(const TensorInfo& input,
 149                                     const TensorInfo& outputStateIn,
 150                                     const TensorInfo& cellStateIn,
 151                                     const TensorInfo& scratchBuffer,
 152                                     const TensorInfo& outputStateOut,
 153                                     const TensorInfo& cellStateOut,
 154                                     const TensorInfo& output,
 155                                     const LstmDescriptor& descriptor,
 156                                     const TensorInfo& inputToForgetWeights,
 157                                     const TensorInfo& inputToCellWeights,
 158                                     const TensorInfo& inputToOutputWeights,
 159                                     const TensorInfo& recurrentToForgetWeights,
 160                                     const TensorInfo& recurrentToCellWeights,
 161                                     const TensorInfo& recurrentToOutputWeights,
 162                                     const TensorInfo& forgetGateBias,
 163                                     const TensorInfo& cellBias,
 164                                     const TensorInfo& outputGateBias,
 165                                     const TensorInfo* inputToInputWeights,
 166                                     const TensorInfo* recurrentToInputWeights,
 167                                     const TensorInfo* cellToInputWeights,
 168                                     const TensorInfo* inputGateBias,
 169                                     const TensorInfo* projectionWeights,
 170                                     const TensorInfo* projectionBias,
 171                                     const TensorInfo* cellToForgetWeights,
 172                                     const TensorInfo* cellToOutputWeights,
 173                                     Optional<std::string&> reasonIfUnsupported) const
 174 {
 175     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 176 }
 177
 178 bool ILayerSupport::IsMeanSupported(const TensorInfo& input,
 179                                     const TensorInfo& output,
 180                                     const MeanDescriptor& descriptor,
 181                                     Optional<std::string&> reasonIfUnsupported) const
 182 {
 183     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 184 }
 185
 186 bool ILayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
 187                                       const OriginsDescriptor& descriptor,
 188                                       Optional<std::string&> reasonIfUnsupported) const
 189 {
 190     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 191 }
 192
 193 bool ILayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
 194                                               const TensorInfo& input1,
 195                                               const TensorInfo& output,
 196                                               Optional<std::string&> reasonIfUnsupported) const
 197 {
 198     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 199 }
 200
 201 bool ILayerSupport::IsNormalizationSupported(const TensorInfo& input,
 202                                              const TensorInfo& output,
 203                                              const NormalizationDescriptor& descriptor,
 204                                              Optional<std::string&> reasonIfUnsupported) const
 205 {
 206     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 207 }
 208
 209 bool ILayerSupport::IsOutputSupported(const TensorInfo& output,
 210                                       Optional<std::string&> reasonIfUnsupported) const
 211 {
 212     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 213 }
 214
 215 bool ILayerSupport::IsPadSupported(const TensorInfo& input,
 216                                    const TensorInfo& output,
 217                                    const PadDescriptor& descriptor,
 218                                    Optional<std::string&> reasonIfUnsupported) const
 219 {
 220     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 221 }
 222
 223 bool ILayerSupport::IsPermuteSupported(const TensorInfo& input,
 224                                        const TensorInfo& output,
 225                                        const PermuteDescriptor& descriptor,
 226                                        Optional<std::string&> reasonIfUnsupported) const
 227 {
 228     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 229 }
 230
 231 bool ILayerSupport::IsPooling2dSupported(const TensorInfo& input,
 232                                          const TensorInfo& output,
 233                                          const Pooling2dDescriptor& descriptor,
 234                                          Optional<std::string&> reasonIfUnsupported) const
 235 {
 236     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 237 }
 238
 239 bool ILayerSupport::IsReshapeSupported(const TensorInfo& input,
 240                                        Optional<std::string&> reasonIfUnsupported) const
 241 {
 242     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 243 }
 244
 245 bool ILayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
 246                                               Optional<std::string&> reasonIfUnsupported) const
 247 {
 248     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 249 }
 250
 251 bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,
 252                                        const TensorInfo& output,
 253                                        const SoftmaxDescriptor& descriptor,
 254                                        Optional<std::string&> reasonIfUnsupported) const
 255 {
 256     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 257 }
 258
 259 bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
 260                                               const TensorInfo& output,
 261                                               const SpaceToBatchNdDescriptor& descriptor,
 262                                               Optional<std::string&> reasonIfUnsupported) const
 263 {
 264     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 265 }
 266
 267 bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,
 268                                         const ViewsDescriptor& descriptor,
 269                                         Optional<std::string&> reasonIfUnsupported) const
 270 {
 271     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 272 }
 273
 274 bool ILayerSupport::IsSubtractionSupported(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
 282 } // namespace armnn