src/backends/backendsCommon/LayerSupportBase.cpp

   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
  10 #include <boost/core/ignore_unused.hpp>
  11
  12 namespace
  13 {
  14
  15 bool DefaultLayerSupport(const char* func,
  16                          const char* file,
  17                          unsigned int line,
  18                          armnn::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 namespace armnn
  35 {
  36
  37 bool LayerSupportBase::IsAbsSupported(const TensorInfo &input,
  38                                       const TensorInfo &output,
  39                                       Optional<std::string &> reasonIfUnsupported) const
  40 {
  41     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  42 }
  43
  44 bool LayerSupportBase::IsActivationSupported(const TensorInfo& input,
  45                                              const TensorInfo& output,
  46                                              const ActivationDescriptor& descriptor,
  47                                              Optional<std::string&> reasonIfUnsupported) const
  48 {
  49     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  50 }
  51
  52 bool LayerSupportBase::IsAdditionSupported(const TensorInfo& input0,
  53                                            const TensorInfo& input1,
  54                                            const TensorInfo& output,
  55                                            Optional<std::string&> reasonIfUnsupported) const
  56 {
  57     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  58 }
  59
  60 bool LayerSupportBase::IsBatchNormalizationSupported(const TensorInfo& input,
  61                                                      const TensorInfo& output,
  62                                                      const TensorInfo& mean,
  63                                                      const TensorInfo& var,
  64                                                      const TensorInfo& beta,
  65                                                      const TensorInfo& gamma,
  66                                                      const BatchNormalizationDescriptor& descriptor,
  67                                                      Optional<std::string&> reasonIfUnsupported) const
  68 {
  69     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  70 }
  71
  72 bool LayerSupportBase::IsBatchToSpaceNdSupported(const TensorInfo& input,
  73                                                  const TensorInfo& output,
  74                                                  const BatchToSpaceNdDescriptor& descriptor,
  75                                                  Optional<std::string&> reasonIfUnsupported) const
  76 {
  77     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  78 }
  79
  80 bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
  81                                          const TensorInfo& output,
  82                                          const OriginsDescriptor& descriptor,
  83                                          Optional<std::string&> reasonIfUnsupported) const
  84 {
  85     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  86 }
  87
  88 bool LayerSupportBase::IsConstantSupported(const TensorInfo& output,
  89                                            Optional<std::string&> reasonIfUnsupported) const
  90 {
  91     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  92 }
  93
  94 bool LayerSupportBase::IsConvertFp16ToFp32Supported(const TensorInfo& input,
  95                                                     const TensorInfo& output,
  96                                                     Optional<std::string&> reasonIfUnsupported) const
  97 {
  98     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
  99 }
 100
 101 bool LayerSupportBase::IsConvertFp32ToFp16Supported(const TensorInfo& input,
 102                                                     const TensorInfo& output,
 103                                                     Optional<std::string&> reasonIfUnsupported) const
 104 {
 105     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 106 }
 107
 108 bool LayerSupportBase::IsConvolution2dSupported(const TensorInfo& input,
 109                                                 const TensorInfo& output,
 110                                                 const Convolution2dDescriptor& descriptor,
 111                                                 const TensorInfo& weights,
 112                                                 const Optional<TensorInfo>& biases,
 113                                                 Optional<std::string&> reasonIfUnsupported) const
 114 {
 115     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 116 }
 117
 118 bool LayerSupportBase::IsDebugSupported(const TensorInfo& input,
 119                                         const TensorInfo& output,
 120                                         Optional<std::string&> reasonIfUnsupported) const
 121 {
 122     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 123 }
 124
 125 bool LayerSupportBase::IsDepthwiseConvolutionSupported(const TensorInfo& input,
 126                                                        const TensorInfo& output,
 127                                                        const DepthwiseConvolution2dDescriptor& descriptor,
 128                                                        const TensorInfo& weights,
 129                                                        const Optional<TensorInfo>& biases,
 130                                                        Optional<std::string&> reasonIfUnsupported) const
 131 {
 132     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 133 }
 134
 135 bool LayerSupportBase::IsDequantizeSupported(const TensorInfo& input,
 136                                              const TensorInfo& output,
 137                                              Optional<std::string&> reasonIfUnsupported) const
 138 {
 139     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 140 }
 141
 142 bool LayerSupportBase::IsDetectionPostProcessSupported(const armnn::TensorInfo& input0,
 143                                                        const armnn::TensorInfo& input1,
 144                                                        const armnn::DetectionPostProcessDescriptor& descriptor,
 145                                                        armnn::Optional<std::string&> reasonIfUnsupported) const
 146 {
 147     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 148 }
 149
 150 bool LayerSupportBase::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
 151                                                               const TensorInfo& output,
 152                                                               const DepthwiseConvolution2dDescriptor& descriptor,
 153                                                               const TensorInfo& weights,
 154                                                               const Optional<TensorInfo>& biases,
 155                                                               Optional<std::string&> reasonIfUnsupported) const
 156 {
 157     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 158 }
 159
 160 bool LayerSupportBase::IsDivisionSupported(const TensorInfo& input0,
 161                                            const TensorInfo& input1,
 162                                            const TensorInfo& output,
 163                                            Optional<std::string&> reasonIfUnsupported) const
 164 {
 165     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 166 }
 167
 168 bool LayerSupportBase::IsEqualSupported(const armnn::TensorInfo& input0,
 169                                         const armnn::TensorInfo& input1,
 170                                         const armnn::TensorInfo& output,
 171                                         armnn::Optional<std::string &> reasonIfUnsupported) const
 172 {
 173     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 174 }
 175
 176 bool LayerSupportBase::IsFakeQuantizationSupported(const TensorInfo& input,
 177                                                    const FakeQuantizationDescriptor& descriptor,
 178                                                    Optional<std::string&> reasonIfUnsupported) const
 179 {
 180     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 181 }
 182
 183 bool LayerSupportBase::IsFloorSupported(const TensorInfo& input,
 184                                         const TensorInfo& output,
 185                                         Optional<std::string&> reasonIfUnsupported) const
 186 {
 187     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 188 }
 189
 190 bool LayerSupportBase::IsFullyConnectedSupported(const TensorInfo& input,
 191                                                  const TensorInfo& output,
 192                                                  const TensorInfo& weights,
 193                                                  const TensorInfo& biases,
 194                                                  const FullyConnectedDescriptor& descriptor,
 195                                                  Optional<std::string&> reasonIfUnsupported) const
 196 {
 197     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 198 }
 199
 200 bool LayerSupportBase::IsGatherSupported(const armnn::TensorInfo& input0,
 201                                          const armnn::TensorInfo& input1,
 202                                          const armnn::TensorInfo& output,
 203                                          armnn::Optional<std::string&> reasonIfUnsupported) const
 204 {
 205     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 206 }
 207
 208 bool LayerSupportBase::IsGreaterSupported(const TensorInfo& input0,
 209                                           const TensorInfo& input1,
 210                                           const TensorInfo& output,
 211                                           Optional<std::string&> reasonIfUnsupported) const
 212 {
 213     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 214 }
 215
 216 bool LayerSupportBase::IsInputSupported(const TensorInfo& input,
 217                                         Optional<std::string&> reasonIfUnsupported) const
 218 {
 219     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 220 }
 221
 222 bool LayerSupportBase::IsL2NormalizationSupported(const TensorInfo& input,
 223                                                   const TensorInfo& output,
 224                                                   const L2NormalizationDescriptor& descriptor,
 225                                                   Optional<std::string&> reasonIfUnsupported) const
 226 {
 227     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 228 }
 229
 230 bool LayerSupportBase::IsLstmSupported(const TensorInfo& input,
 231                                        const TensorInfo& outputStateIn,
 232                                        const TensorInfo& cellStateIn,
 233                                        const TensorInfo& scratchBuffer,
 234                                        const TensorInfo& outputStateOut,
 235                                        const TensorInfo& cellStateOut,
 236                                        const TensorInfo& output,
 237                                        const LstmDescriptor& descriptor,
 238                                        const LstmInputParamsInfo& paramsInfo,
 239                                        Optional<std::string&> reasonIfUnsupported) const
 240 {
 241     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 242 }
 243
 244 bool LayerSupportBase::IsMaximumSupported(const TensorInfo& input0,
 245                                           const TensorInfo& input1,
 246                                           const TensorInfo& output,
 247                                           Optional<std::string&> reasonIfUnsupported) const
 248 {
 249     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 250 }
 251
 252 bool LayerSupportBase::IsMeanSupported(const TensorInfo& input,
 253                                        const TensorInfo& output,
 254                                        const MeanDescriptor& descriptor,
 255                                        Optional<std::string&> reasonIfUnsupported) const
 256 {
 257     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 258 }
 259
 260 bool LayerSupportBase::IsMemCopySupported(const armnn::TensorInfo& input,
 261                                           const armnn::TensorInfo& output,
 262                                           armnn::Optional<std::string &> reasonIfUnsupported) const
 263 {
 264     boost::ignore_unused(input);
 265     boost::ignore_unused(output);
 266     return true;
 267 }
 268
 269 bool LayerSupportBase::IsMemImportSupported(const armnn::TensorInfo& input,
 270                                             const armnn::TensorInfo& output,
 271                                             armnn::Optional<std::string &> reasonIfUnsupported) const
 272 {
 273     boost::ignore_unused(input);
 274     boost::ignore_unused(output);
 275     return true;
 276 }
 277
 278 bool LayerSupportBase::IsMergeSupported(const TensorInfo& input0,
 279                                         const TensorInfo& input1,
 280                                         const TensorInfo& output,
 281                                         Optional<std::string&> reasonIfUnsupported) const
 282 {
 283     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 284 }
 285
 286 bool LayerSupportBase::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
 287                                          const TensorInfo& output,
 288                                          const OriginsDescriptor& descriptor,
 289                                          Optional<std::string&> reasonIfUnsupported) const
 290 {
 291     return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
 292 }
 293
 294 bool LayerSupportBase::IsMinimumSupported(const TensorInfo& input0,
 295                                           const TensorInfo& input1,
 296                                           const TensorInfo& output,
 297                                           Optional<std::string&> reasonIfUnsupported) const
 298 {
 299     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 300 }
 301
 302 bool LayerSupportBase::IsMultiplicationSupported(const TensorInfo& input0,
 303                                                  const TensorInfo& input1,
 304                                                  const TensorInfo& output,
 305                                                  Optional<std::string&> reasonIfUnsupported) const
 306 {
 307     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 308 }
 309
 310 bool LayerSupportBase::IsNormalizationSupported(const TensorInfo& input,
 311                                                 const TensorInfo& output,
 312                                                 const NormalizationDescriptor& descriptor,
 313                                                 Optional<std::string&> reasonIfUnsupported) const
 314 {
 315     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 316 }
 317
 318 bool LayerSupportBase::IsOutputSupported(const TensorInfo& output,
 319                                          Optional<std::string&> reasonIfUnsupported) const
 320 {
 321     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 322 }
 323
 324 bool LayerSupportBase::IsPadSupported(const TensorInfo& input,
 325                                       const TensorInfo& output,
 326                                       const PadDescriptor& descriptor,
 327                                       Optional<std::string&> reasonIfUnsupported) const
 328 {
 329     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 330 }
 331
 332 bool LayerSupportBase::IsPermuteSupported(const TensorInfo& input,
 333                                           const TensorInfo& output,
 334                                           const PermuteDescriptor& descriptor,
 335                                           Optional<std::string&> reasonIfUnsupported) const
 336 {
 337     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 338 }
 339
 340 bool LayerSupportBase::IsPooling2dSupported(const TensorInfo& input,
 341                                             const TensorInfo& output,
 342                                             const Pooling2dDescriptor& descriptor,
 343                                             Optional<std::string&> reasonIfUnsupported) const
 344 {
 345     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 346 }
 347
 348 bool LayerSupportBase::IsPreCompiledSupported(const TensorInfo& input,
 349                                               const PreCompiledDescriptor& descriptor,
 350                                               Optional<std::string&> reasonIfUnsupported) const
 351 {
 352     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 353 }
 354
 355 bool LayerSupportBase::IsPreluSupported(const TensorInfo& input,
 356                                         const TensorInfo& alpha,
 357                                         const TensorInfo& output,
 358                                         Optional<std::string &> reasonIfUnsupported) const
 359 {
 360     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 361 }
 362
 363 bool LayerSupportBase::IsQuantizeSupported(const armnn::TensorInfo& input,
 364                                            const armnn::TensorInfo& output,
 365                                            armnn::Optional<std::string&> reasonIfUnsupported) const
 366 {
 367     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 368 }
 369
 370 bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo& input,
 371                                                 const TensorInfo& previousCellStateIn,
 372                                                 const TensorInfo& previousOutputIn,
 373                                                 const TensorInfo& cellStateOut,
 374                                                 const TensorInfo& output,
 375                                                 const QuantizedLstmInputParamsInfo& paramsInfo,
 376                                                 Optional<std::string&> reasonIfUnsupported) const
 377 {
 378     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 379 }
 380
 381 bool LayerSupportBase::IsReshapeSupported(const TensorInfo& input,
 382                                           const ReshapeDescriptor& descriptor,
 383                                           Optional<std::string&> reasonIfUnsupported) const
 384 {
 385     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 386 }
 387
 388 bool LayerSupportBase::IsResizeBilinearSupported(const TensorInfo& input,
 389                                                  const TensorInfo& output,
 390                                                  Optional<std::string&> reasonIfUnsupported) const
 391 {
 392     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 393 }
 394
 395 bool LayerSupportBase::IsResizeSupported(const TensorInfo& input,
 396                                          const TensorInfo& output,
 397                                          const ResizeDescriptor& descriptor,
 398                                          Optional<std::string&> reasonIfUnsupported) const
 399 {
 400     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 401 }
 402
 403 bool LayerSupportBase::IsRsqrtSupported(const TensorInfo &input,
 404                                         const TensorInfo &output,
 405                                         Optional<std::string &> reasonIfUnsupported) const
 406 {
 407     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 408 }
 409
 410 bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo& input,
 411                                           const TensorInfo& output,
 412                                           const SoftmaxDescriptor& descriptor,
 413                                           Optional<std::string&> reasonIfUnsupported) const
 414 {
 415     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 416 }
 417
 418 bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo& input,
 419                                                  const TensorInfo& output,
 420                                                  const SpaceToBatchNdDescriptor& descriptor,
 421                                                  Optional<std::string&> reasonIfUnsupported) const
 422 {
 423     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 424 }
 425
 426 bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo& input,
 427                                                const TensorInfo& output,
 428                                                const SpaceToDepthDescriptor& descriptor,
 429                                                Optional<std::string&> reasonIfUnsupported) const
 430 {
 431     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 432 }
 433
 434 bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
 435                                            const ViewsDescriptor& descriptor,
 436                                            Optional<std::string&> reasonIfUnsupported) const
 437 {
 438     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 439 }
 440
 441 bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
 442                                            const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
 443                                            const ViewsDescriptor& descriptor,
 444                                            Optional<std::string&> reasonIfUnsupported) const
 445 {
 446     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 447 }
 448
 449 bool LayerSupportBase::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
 450                                         const TensorInfo& output,
 451                                         const StackDescriptor& descriptor,
 452                                         Optional<std::string&> reasonIfUnsupported) const
 453 {
 454     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 455 }
 456
 457 bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo& input,
 458                                                const TensorInfo& output,
 459                                                const StridedSliceDescriptor& descriptor,
 460                                                Optional<std::string&> reasonIfUnsupported) const
 461 {
 462     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 463 }
 464
 465 bool LayerSupportBase::IsSubtractionSupported(const TensorInfo& input0,
 466                                               const TensorInfo& input1,
 467                                               const TensorInfo& output,
 468                                               Optional<std::string&> reasonIfUnsupported) const
 469 {
 470     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 471 }
 472
 473 bool LayerSupportBase::IsSwitchSupported(const TensorInfo& input0,
 474                                          const TensorInfo& input1,
 475                                          const TensorInfo& output0,
 476                                          const TensorInfo& output1,
 477                                          Optional<std::string&> reasonIfUnsupported) const
 478 {
 479     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 480 }
 481
 482 bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo& input,
 483                                                          const TensorInfo& output,
 484                                                          const TransposeConvolution2dDescriptor& descriptor,
 485                                                          const TensorInfo& weights,
 486                                                          const Optional<TensorInfo>& biases,
 487                                                          Optional<std::string&> reasonIfUnsupported) const
 488 {
 489     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 490 }
 491
 492 } // namespace armnn