src/armnn/BackendHelper.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include <armnn/BackendHelper.hpp>
   7 #include <armnn/BackendRegistry.hpp>
   8
   9 #include <armnn/backends/IBackendInternal.hpp>
  10
  11 namespace armnn
  12 {
  13
  14 // Return LayerSupportHandle instead of the previous pointer to ILayerSupport.
  15 LayerSupportHandle GetILayerSupportByBackendId(const armnn::BackendId& backend)
  16 {
  17     BackendRegistry& backendRegistry = armnn::BackendRegistryInstance();
  18
  19     if (!backendRegistry.IsBackendRegistered(backend))
  20     {
  21         return LayerSupportHandle(nullptr);
  22     }
  23
  24     auto factoryFunc = backendRegistry.GetFactory(backend);
  25     auto backendObject = factoryFunc();
  26     return LayerSupportHandle(backendObject->GetLayerSupport());
  27 }
  28
  29 bool LayerSupportHandle::IsBackendRegistered() const
  30 {
  31     if (m_LayerSupport)
  32     {
  33         return true;
  34     }
  35
  36     return false;
  37 }
  38
  39
  40 bool LayerSupportHandle::IsAbsSupported(const TensorInfo& input,
  41                                         const TensorInfo& output,
  42                                         Optional<std::string&> reasonIfUnsupported)
  43 {
  44     // Call the IsXXXLayerSupport function of the specific backend.
  45     return m_LayerSupport->IsAbsSupported(input, output, reasonIfUnsupported.value());
  46 }
  47
  48 bool LayerSupportHandle::IsActivationSupported(const TensorInfo& input,
  49                                                const TensorInfo& output,
  50                                                const ActivationDescriptor& descriptor,
  51                                                Optional<std::string&> reasonIfUnsupported)
  52 {
  53     return m_LayerSupport->IsActivationSupported(input, output, descriptor, reasonIfUnsupported.value());
  54 }
  55
  56 bool LayerSupportHandle::IsAdditionSupported(const TensorInfo& input0,
  57                                              const TensorInfo& input1,
  58                                              const TensorInfo& output,
  59                                              Optional<std::string&> reasonIfUnsupported)
  60 {
  61     return m_LayerSupport->IsAdditionSupported(input0, input1, output, reasonIfUnsupported.value());
  62 }
  63
  64 bool LayerSupportHandle::IsArgMinMaxSupported(const TensorInfo& input,
  65                                               const TensorInfo& output,
  66                                               const ArgMinMaxDescriptor& descriptor,
  67                                               Optional<std::string&> reasonIfUnsupported)
  68 {
  69     return m_LayerSupport->IsArgMinMaxSupported(input, output, descriptor, reasonIfUnsupported.value());
  70 }
  71
  72 bool LayerSupportHandle::IsBatchNormalizationSupported(const TensorInfo& input,
  73                                                        const TensorInfo& output,
  74                                                        const TensorInfo& mean,
  75                                                        const TensorInfo& var,
  76                                                        const TensorInfo& beta,
  77                                                        const TensorInfo& gamma,
  78                                                        const BatchNormalizationDescriptor& descriptor,
  79                                                        Optional<std::string&> reasonIfUnsupported)
  80 {
  81     return m_LayerSupport->IsBatchNormalizationSupported(input,
  82                                                          output,
  83                                                          mean,
  84                                                          var,
  85                                                          beta,
  86                                                          gamma,
  87                                                          descriptor,
  88                                                          reasonIfUnsupported.value());
  89 }
  90
  91 bool LayerSupportHandle::IsBatchToSpaceNdSupported(const TensorInfo& input,
  92                                                    const TensorInfo& output,
  93                                                    const BatchToSpaceNdDescriptor& descriptor,
  94                                                    Optional<std::string&> reasonIfUnsupported)
  95 {
  96     return m_LayerSupport->IsBatchToSpaceNdSupported(input,
  97                                                      output,
  98                                                      descriptor,
  99                                                      reasonIfUnsupported.value());
 100 }
 101
 102 bool LayerSupportHandle::IsComparisonSupported(const TensorInfo& input0,
 103                                                const TensorInfo& input1,
 104                                                const TensorInfo& output,
 105                                                const ComparisonDescriptor& descriptor,
 106                                                Optional<std::string&> reasonIfUnsupported)
 107 {
 108     return m_LayerSupport->IsComparisonSupported(input0, input1, output, descriptor, reasonIfUnsupported.value());
 109 }
 110
 111 bool LayerSupportHandle::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
 112                                            const TensorInfo& output,
 113                                            const OriginsDescriptor& descriptor,
 114                                            Optional<std::string&> reasonIfUnsupported)
 115 {
 116     return m_LayerSupport->IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported.value());
 117 }
 118
 119 bool LayerSupportHandle::IsConstantSupported(const TensorInfo& output,
 120                                              Optional<std::string&> reasonIfUnsupported)
 121 {
 122     return m_LayerSupport->IsConstantSupported(output, reasonIfUnsupported.value());
 123 }
 124
 125 bool LayerSupportHandle::IsConvertBf16ToFp32Supported(const TensorInfo& input,
 126                                                       const TensorInfo& output,
 127                                                       Optional<std::string&> reasonIfUnsupported)
 128 {
 129     return m_LayerSupport->IsConvertBf16ToFp32Supported(input, output, reasonIfUnsupported.value());
 130 }
 131
 132 bool LayerSupportHandle::IsConvertFp32ToBf16Supported(const TensorInfo& input,
 133                                                       const TensorInfo& output,
 134                                                       Optional<std::string&> reasonIfUnsupported)
 135 {
 136     return m_LayerSupport->IsConvertFp32ToBf16Supported(input, output, reasonIfUnsupported.value());
 137 }
 138
 139 bool LayerSupportHandle::IsConvertFp16ToFp32Supported(const TensorInfo& input,
 140                                                       const TensorInfo& output,
 141                                                       Optional<std::string&> reasonIfUnsupported)
 142 {
 143     return m_LayerSupport->IsConvertFp16ToFp32Supported(input, output, reasonIfUnsupported.value());
 144 }
 145
 146 bool LayerSupportHandle::IsConvertFp32ToFp16Supported(const TensorInfo& input,
 147                                                       const TensorInfo& output,
 148                                                       Optional<std::string&> reasonIfUnsupported)
 149 {
 150     return m_LayerSupport->IsConvertFp32ToFp16Supported(input, output, reasonIfUnsupported.value());
 151 }
 152
 153 bool LayerSupportHandle::IsConvolution2dSupported(const TensorInfo& input,
 154                                                   const TensorInfo& output,
 155                                                   const Convolution2dDescriptor& descriptor,
 156                                                   const TensorInfo& weights,
 157                                                   const Optional<TensorInfo>& biases,
 158                                                   Optional<std::string&> reasonIfUnsupported)
 159 {
 160     return m_LayerSupport->IsConvolution2dSupported(input,
 161                                                     output,
 162                                                     descriptor,
 163                                                     weights,
 164                                                     biases,
 165                                                     reasonIfUnsupported.value());
 166 }
 167
 168 bool LayerSupportHandle::IsDebugSupported(const TensorInfo& input,
 169                                           const TensorInfo& output,
 170                                           Optional<std::string&> reasonIfUnsupported)
 171 {
 172     return m_LayerSupport->IsDebugSupported(input, output, reasonIfUnsupported.value());
 173 }
 174
 175 bool LayerSupportHandle::IsDepthToSpaceSupported(const TensorInfo& input,
 176                                                  const TensorInfo& output,
 177                                                  const DepthToSpaceDescriptor& descriptor,
 178                                                  Optional<std::string&> reasonIfUnsupported)
 179 {
 180     return m_LayerSupport->IsDepthToSpaceSupported(input, output, descriptor, reasonIfUnsupported.value());
 181 }
 182
 183 bool LayerSupportHandle::IsDepthwiseConvolutionSupported(
 184         const TensorInfo& input,
 185         const TensorInfo& output,
 186         const DepthwiseConvolution2dDescriptor& descriptor,
 187         const TensorInfo& weights,
 188         const Optional<TensorInfo>& biases,
 189         Optional<std::string&> reasonIfUnsupported)
 190 {
 191     return m_LayerSupport->IsDepthwiseConvolutionSupported(input,
 192                                                            output,
 193                                                            descriptor,
 194                                                            weights,
 195                                                            biases,
 196                                                            reasonIfUnsupported.value());
 197 }
 198
 199 bool LayerSupportHandle::IsDequantizeSupported(const TensorInfo& input,
 200                                                const TensorInfo& output,
 201                                                Optional<std::string&> reasonIfUnsupported)
 202 {
 203     return m_LayerSupport->IsDequantizeSupported(input, output, reasonIfUnsupported.value());
 204 }
 205
 206 bool LayerSupportHandle::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
 207                                                          const TensorInfo& scores,
 208                                                          const TensorInfo& anchors,
 209                                                          const TensorInfo& detectionBoxes,
 210                                                          const TensorInfo& detectionClasses,
 211                                                          const TensorInfo& detectionScores,
 212                                                          const TensorInfo& numDetections,
 213                                                          const DetectionPostProcessDescriptor& descriptor,
 214                                                          Optional<std::string&> reasonIfUnsupported)
 215 {
 216     return m_LayerSupport->IsDetectionPostProcessSupported(boxEncodings,
 217                                                            scores,
 218                                                            anchors,
 219                                                            detectionBoxes,
 220                                                            detectionClasses,
 221                                                            detectionScores,
 222                                                            numDetections,
 223                                                            descriptor,
 224                                                            reasonIfUnsupported);
 225 }
 226
 227 bool LayerSupportHandle::IsDilatedDepthwiseConvolutionSupported(
 228         const TensorInfo& input,
 229         const TensorInfo& output,
 230         const DepthwiseConvolution2dDescriptor& descriptor,
 231         const TensorInfo& weights,
 232         const Optional<TensorInfo>& biases,
 233         Optional<std::string&> reasonIfUnsupported)
 234 {
 235     return m_LayerSupport->IsDilatedDepthwiseConvolutionSupported(input,
 236                                                                   output,
 237                                                                   descriptor,
 238                                                                   weights,
 239                                                                   biases,
 240                                                                   reasonIfUnsupported);
 241 }
 242
 243 bool LayerSupportHandle::IsDivisionSupported(const TensorInfo& input0,
 244                                              const TensorInfo& input1,
 245                                              const TensorInfo& output,
 246                                              Optional<std::string&> reasonIfUnsupported)
 247 {
 248     return m_LayerSupport->IsDivisionSupported(input0, input1, output, reasonIfUnsupported.value());
 249 }
 250
 251 bool LayerSupportHandle::IsElementwiseUnarySupported(const TensorInfo& input,
 252                                                      const TensorInfo& output,
 253                                                      const ElementwiseUnaryDescriptor& descriptor,
 254                                                      Optional<std::string&> reasonIfUnsupported)
 255 {
 256     return m_LayerSupport->IsElementwiseUnarySupported(input, output, descriptor, reasonIfUnsupported.value());
 257 }
 258
 259 bool LayerSupportHandle::IsEqualSupported(const TensorInfo& input0,
 260                                           const TensorInfo& input1,
 261                                           const TensorInfo& output,
 262                                           Optional<std::string&> reasonIfUnsupported)
 263 {
 264     return m_LayerSupport->IsEqualSupported(input0, input1, output, reasonIfUnsupported.value());
 265 }
 266
 267 bool LayerSupportHandle::IsFakeQuantizationSupported(const TensorInfo& input,
 268                                                      const FakeQuantizationDescriptor& descriptor,
 269                                                      Optional<std::string&> reasonIfUnsupported)
 270 {
 271     return m_LayerSupport->IsFakeQuantizationSupported(input, descriptor, reasonIfUnsupported.value());
 272 }
 273
 274 bool LayerSupportHandle::IsFillSupported(const TensorInfo& input,
 275                                          const TensorInfo& output,
 276                                          const FillDescriptor& descriptor,
 277                                          Optional<std::string&> reasonIfUnsupported)
 278 {
 279     return m_LayerSupport->IsFillSupported(input, output, descriptor, reasonIfUnsupported.value());
 280 }
 281
 282 bool LayerSupportHandle::IsFloorSupported(const TensorInfo& input,
 283                                           const TensorInfo& output,
 284                                           Optional<std::string&> reasonIfUnsupported)
 285 {
 286     return m_LayerSupport->IsFloorSupported(input, output, reasonIfUnsupported.value());
 287 }
 288
 289 bool LayerSupportHandle::IsFullyConnectedSupported(const TensorInfo& input,
 290                                                    const TensorInfo& output,
 291                                                    const TensorInfo& weights,
 292                                                    const TensorInfo& biases,
 293                                                    const FullyConnectedDescriptor& descriptor,
 294                                                    Optional<std::string&> reasonIfUnsupported)
 295 {
 296     return m_LayerSupport->IsFullyConnectedSupported(input,
 297                                                     output,
 298                                                     weights,
 299                                                     biases,
 300                                                     descriptor,
 301                                                     reasonIfUnsupported.value());
 302 }
 303
 304 bool LayerSupportHandle::IsGatherSupported(const TensorInfo& input0,
 305                                            const TensorInfo& input1,
 306                                            const TensorInfo& output,
 307                                            Optional<std::string&> reasonIfUnsupported)
 308 {
 309     return m_LayerSupport->IsGatherSupported(input0, input1, output, reasonIfUnsupported.value());
 310 }
 311
 312 bool LayerSupportHandle::IsGatherSupported(const TensorInfo& input0,
 313                                            const TensorInfo& input1,
 314                                            const TensorInfo& output,
 315                                            const GatherDescriptor& descriptor,
 316                                            Optional<std::string&> reasonIfUnsupported)
 317 {
 318     return m_LayerSupport->IsGatherSupported(input0, input1, output, descriptor, reasonIfUnsupported.value());
 319 }
 320
 321 bool LayerSupportHandle::IsGreaterSupported(const TensorInfo& input0,
 322                                             const TensorInfo& input1,
 323                                             const TensorInfo& ouput,
 324                                             Optional<std::string&> reasonIfUnsupported)
 325 {
 326     return m_LayerSupport->IsGreaterSupported(input0, input1, ouput, reasonIfUnsupported.value());
 327 }
 328
 329 bool LayerSupportHandle::IsInputSupported(const TensorInfo& input,
 330                                           Optional<std::string&> reasonIfUnsupported)
 331 {
 332     return m_LayerSupport->IsInputSupported(input, reasonIfUnsupported.value());
 333 }
 334
 335 bool LayerSupportHandle::IsInstanceNormalizationSupported(
 336         const TensorInfo& input,
 337         const TensorInfo& output,
 338         const InstanceNormalizationDescriptor& descriptor,
 339         Optional<std::string&> reasonIfUnsupported)
 340 {
 341     return m_LayerSupport->IsInstanceNormalizationSupported(input, output, descriptor, reasonIfUnsupported.value());
 342 }
 343
 344 bool LayerSupportHandle::IsL2NormalizationSupported(const TensorInfo& input,
 345                                                     const TensorInfo& output,
 346                                                     const L2NormalizationDescriptor& descriptor,
 347                                                     Optional<std::string&> reasonIfUnsupported)
 348 {
 349     return m_LayerSupport->IsL2NormalizationSupported(input, output, descriptor, reasonIfUnsupported.value());
 350 }
 351
 352 bool LayerSupportHandle::IsLogicalBinarySupported(const TensorInfo& input0,
 353                                                   const TensorInfo& input1,
 354                                                   const TensorInfo& output,
 355                                                   const LogicalBinaryDescriptor& descriptor,
 356                                                   Optional<std::string&> reasonIfUnsupported)
 357 {
 358     return m_LayerSupport->IsLogicalBinarySupported(input0,
 359                                                     input1,
 360                                                     output,
 361                                                     descriptor,
 362                                                     reasonIfUnsupported.value());
 363 }
 364
 365 bool LayerSupportHandle::IsLogicalUnarySupported(const TensorInfo& input,
 366                                                  const TensorInfo& output,
 367                                                  const ElementwiseUnaryDescriptor& descriptor,
 368                                                  Optional<std::string&> reasonIfUnsupported)
 369 {
 370     return m_LayerSupport->IsLogicalUnarySupported(input, output, descriptor, reasonIfUnsupported.value());
 371 }
 372
 373 bool LayerSupportHandle::IsLogSoftmaxSupported(const TensorInfo& input,
 374                                                const TensorInfo& output,
 375                                                const LogSoftmaxDescriptor& descriptor,
 376                                                Optional<std::string&> reasonIfUnsupported)
 377 {
 378     return m_LayerSupport->IsLogSoftmaxSupported(input, output, descriptor, reasonIfUnsupported.value());
 379 }
 380
 381 bool LayerSupportHandle::IsLstmSupported(const TensorInfo& input,
 382                                          const TensorInfo& outputStateIn,
 383                                          const TensorInfo& cellStateIn,
 384                                          const TensorInfo& scratchBuffer,
 385                                          const TensorInfo& outputStateOut,
 386                                          const TensorInfo& cellStateOut,
 387                                          const TensorInfo& output,
 388                                          const LstmDescriptor& descriptor,
 389                                          const LstmInputParamsInfo& paramsInfo,
 390                                          Optional<std::string&> reasonIfUnsupported)
 391 {
 392     return m_LayerSupport->IsLstmSupported(input,
 393                                            outputStateIn,
 394                                            cellStateIn,
 395                                            scratchBuffer,
 396                                            outputStateOut,
 397                                            cellStateOut,
 398                                            output,
 399                                            descriptor,
 400                                            paramsInfo,
 401                                            reasonIfUnsupported);
 402 }
 403
 404 bool LayerSupportHandle::IsMaximumSupported(const TensorInfo& input0,
 405                                             const TensorInfo& input1,
 406                                             const TensorInfo& output,
 407                                             Optional<std::string&> reasonIfUnsupported)
 408 {
 409     return m_LayerSupport->IsMaximumSupported(input0, input1, output, reasonIfUnsupported.value());
 410 }
 411
 412 bool LayerSupportHandle::IsMeanSupported(const TensorInfo& input,
 413                                          const TensorInfo& output,
 414                                          const MeanDescriptor& descriptor,
 415                                          Optional<std::string&> reasonIfUnsupported)
 416 {
 417     return m_LayerSupport->IsMeanSupported(input, output, descriptor, reasonIfUnsupported.value());
 418 }
 419
 420 bool LayerSupportHandle::IsMemCopySupported(const TensorInfo& input,
 421                                             const TensorInfo& output,
 422                                             Optional<std::string&> reasonIfUnsupported)
 423 {
 424     return m_LayerSupport->IsMemCopySupported(input, output, reasonIfUnsupported.value());
 425 }
 426
 427 bool LayerSupportHandle::IsMemImportSupported(const TensorInfo& input,
 428                                               const TensorInfo& output,
 429                                               Optional<std::string&> reasonIfUnsupported)
 430 {
 431     return m_LayerSupport->IsMemImportSupported(input, output, reasonIfUnsupported.value());
 432 }
 433
 434 bool LayerSupportHandle::IsMergeSupported(const TensorInfo& input0,
 435                                           const TensorInfo& input1,
 436                                           const TensorInfo& output,
 437                                           Optional<std::string&> reasonIfUnsupported)
 438 {
 439     return m_LayerSupport->IsMergeSupported(input0, input1, output, reasonIfUnsupported.value());
 440 }
 441
 442 bool LayerSupportHandle::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
 443                                            const TensorInfo& output,
 444                                            const OriginsDescriptor& descriptor,
 445                                            Optional<std::string&> reasonIfUnsupported)
 446 {
 447     return m_LayerSupport->IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported.value());
 448 }
 449
 450 bool LayerSupportHandle::IsMinimumSupported(const TensorInfo& input0,
 451                                             const TensorInfo& input1,
 452                                             const TensorInfo& output,
 453                                             Optional<std::string&> reasonIfUnsupported)
 454 {
 455     return m_LayerSupport->IsMinimumSupported(input0, input1, output, reasonIfUnsupported.value());
 456 }
 457
 458 bool LayerSupportHandle::IsMultiplicationSupported(const TensorInfo& input0,
 459                                                    const TensorInfo& input1,
 460                                                    const TensorInfo& output,
 461                                                    Optional<std::string&> reasonIfUnsupported)
 462 {
 463     return m_LayerSupport->IsMultiplicationSupported(input0, input1, output, reasonIfUnsupported.value());
 464 }
 465
 466 bool LayerSupportHandle::IsNormalizationSupported(const TensorInfo& input,
 467                                                   const TensorInfo& output,
 468                                                   const NormalizationDescriptor& descriptor,
 469                                                   Optional<std::string&> reasonIfUnsupported)
 470 {
 471     return m_LayerSupport->IsNormalizationSupported(input, output, descriptor, reasonIfUnsupported.value());
 472 }
 473
 474 bool LayerSupportHandle::IsOutputSupported(const TensorInfo& output,
 475                                            Optional<std::string&> reasonIfUnsupported)
 476 {
 477     return m_LayerSupport->IsOutputSupported(output, reasonIfUnsupported.value());
 478 }
 479
 480 bool LayerSupportHandle::IsPadSupported(const TensorInfo& input,
 481                                         const TensorInfo& output,
 482                                         const PadDescriptor& descriptor,
 483                                         Optional<std::string&> reasonIfUnsupported)
 484 {
 485     return m_LayerSupport->IsPadSupported(input, output, descriptor, reasonIfUnsupported.value());
 486 }
 487
 488 bool LayerSupportHandle::IsPermuteSupported(const TensorInfo& input,
 489                                             const TensorInfo& output,
 490                                             const PermuteDescriptor& descriptor,
 491                                             Optional<std::string&> reasonIfUnsupported)
 492 {
 493     return m_LayerSupport->IsPermuteSupported(input, output, descriptor, reasonIfUnsupported.value());
 494 }
 495
 496 bool LayerSupportHandle::IsPooling2dSupported(const TensorInfo& input,
 497                                               const TensorInfo& output,
 498                                               const Pooling2dDescriptor& descriptor,
 499                                               Optional<std::string&> reasonIfUnsupported)
 500 {
 501     return m_LayerSupport->IsPooling2dSupported(input, output, descriptor, reasonIfUnsupported.value());
 502 }
 503
 504 bool LayerSupportHandle::IsPreCompiledSupported(const TensorInfo& input,
 505                                                 const PreCompiledDescriptor& descriptor,
 506                                                 Optional<std::string&> reasonIfUnsupported)
 507 {
 508     return m_LayerSupport->IsPreCompiledSupported(input, descriptor, reasonIfUnsupported.value());
 509 }
 510
 511 bool LayerSupportHandle::IsPreluSupported(const TensorInfo& input,
 512                                           const TensorInfo& alpha,
 513                                           const TensorInfo& output,
 514                                           Optional<std::string&> reasonIfUnsupported)
 515 {
 516     return m_LayerSupport->IsPreluSupported(input, alpha, output, reasonIfUnsupported.value());
 517 }
 518
 519 bool LayerSupportHandle::IsQuantizeSupported(const TensorInfo& input,
 520                                              const TensorInfo& output,
 521                                              Optional<std::string&> reasonIfUnsupported)
 522 {
 523     return m_LayerSupport->IsQuantizeSupported(input, output, reasonIfUnsupported.value());
 524 }
 525
 526 bool LayerSupportHandle::IsQLstmSupported(const TensorInfo& input,
 527                                           const TensorInfo& previousOutputIn,
 528                                           const TensorInfo& previousCellStateIn,
 529                                           const TensorInfo& outputStateOut,
 530                                           const TensorInfo& cellStateOut,
 531                                           const TensorInfo& output,
 532                                           const QLstmDescriptor& descriptor,
 533                                           const LstmInputParamsInfo& paramsInfo,
 534                                           Optional<std::string&> reasonIfUnsupported)
 535 {
 536     return m_LayerSupport->IsQLstmSupported(input,
 537                                             previousOutputIn,
 538                                             previousCellStateIn,
 539                                             outputStateOut,
 540                                             cellStateOut,
 541                                             output,
 542                                             descriptor,
 543                                             paramsInfo,
 544                                             reasonIfUnsupported);
 545 }
 546
 547 bool LayerSupportHandle::IsQuantizedLstmSupported(const TensorInfo& input,
 548                                                   const TensorInfo& previousCellStateIn,
 549                                                   const TensorInfo& previousOutputIn,
 550                                                   const TensorInfo& cellStateOut,
 551                                                   const TensorInfo& output,
 552                                                   const QuantizedLstmInputParamsInfo& paramsInfo,
 553                                                   Optional<std::string&> reasonIfUnsupported)
 554 {
 555     return m_LayerSupport->IsQuantizedLstmSupported(input,
 556                                                     previousCellStateIn,
 557                                                     previousOutputIn,
 558                                                     cellStateOut,
 559                                                     output,
 560                                                     paramsInfo,
 561                                                     reasonIfUnsupported);
 562 }
 563
 564 bool LayerSupportHandle::IsRankSupported(const TensorInfo& input,
 565                                          const TensorInfo& output,
 566                                          Optional<std::string&> reasonIfUnsupported)
 567 {
 568     return m_LayerSupport->IsRankSupported(input, output, reasonIfUnsupported.value());
 569 }
 570
 571 bool LayerSupportHandle::IsReshapeSupported(const TensorInfo& input,
 572                                             const TensorInfo& output,
 573                                             const ReshapeDescriptor& descriptor,
 574                                             Optional<std::string&> reasonIfUnsupported)
 575 {
 576     return m_LayerSupport->IsReshapeSupported(input, output, descriptor, reasonIfUnsupported.value());
 577 }
 578
 579 bool LayerSupportHandle::IsResizeBilinearSupported(const TensorInfo& input,
 580                                                    const TensorInfo& output,
 581                                                    Optional<std::string&> reasonIfUnsupported)
 582 {
 583     return m_LayerSupport->IsResizeBilinearSupported(input, output, reasonIfUnsupported.value());
 584 }
 585
 586 bool LayerSupportHandle::IsResizeSupported(const TensorInfo& input,
 587                                            const TensorInfo& output,
 588                                            const ResizeDescriptor& descriptor,
 589                                            Optional<std::string&> reasonIfUnsupported)
 590 {
 591     return m_LayerSupport->IsResizeSupported(input, output, descriptor, reasonIfUnsupported.value());
 592 }
 593
 594 bool LayerSupportHandle::IsRsqrtSupported(const TensorInfo& input,
 595                                           const TensorInfo& output,
 596                                           Optional<std::string&> reasonIfUnsupported)
 597 {
 598     return m_LayerSupport->IsRsqrtSupported(input, output, reasonIfUnsupported.value());
 599 }
 600
 601 bool LayerSupportHandle::IsSliceSupported(const TensorInfo& input,
 602                                           const TensorInfo& output,
 603                                           const SliceDescriptor& descriptor,
 604                                           Optional<std::string&> reasonIfUnsupported)
 605 {
 606     return m_LayerSupport->IsSliceSupported(input, output, descriptor, reasonIfUnsupported.value());
 607 }
 608
 609 bool LayerSupportHandle::IsSoftmaxSupported(const TensorInfo& input,
 610                                             const TensorInfo& output,
 611                                             const SoftmaxDescriptor& descriptor,
 612                                             Optional<std::string&> reasonIfUnsupported)
 613 {
 614     return m_LayerSupport->IsSoftmaxSupported(input, output, descriptor, reasonIfUnsupported.value());
 615 }
 616
 617 bool LayerSupportHandle::IsSpaceToBatchNdSupported(const TensorInfo& input,
 618                                                    const TensorInfo& output,
 619                                                    const SpaceToBatchNdDescriptor& descriptor,
 620                                                    Optional<std::string&> reasonIfUnsupported)
 621 {
 622     return m_LayerSupport->IsSpaceToBatchNdSupported(input, output, descriptor, reasonIfUnsupported.value());
 623 }
 624
 625 bool LayerSupportHandle::IsSpaceToDepthSupported(const TensorInfo& input,
 626                                                  const TensorInfo& output,
 627                                                  const SpaceToDepthDescriptor& descriptor,
 628                                                  Optional<std::string&> reasonIfUnsupported)
 629 {
 630     return m_LayerSupport->IsSpaceToDepthSupported(input, output, descriptor, reasonIfUnsupported.value());
 631 }
 632
 633 bool LayerSupportHandle::IsSplitterSupported(const TensorInfo& input,
 634                                              const ViewsDescriptor& descriptor,
 635                                              Optional<std::string&> reasonIfUnsupported)
 636 {
 637     return m_LayerSupport->IsSplitterSupported(input, descriptor, reasonIfUnsupported.value());
 638 }
 639
 640 bool LayerSupportHandle::IsSplitterSupported(const TensorInfo& input,
 641                                              const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
 642                                              const ViewsDescriptor& descriptor,
 643                                              Optional<std::string&> reasonIfUnsupported)
 644 {
 645     return m_LayerSupport->IsSplitterSupported(input, outputs, descriptor, reasonIfUnsupported.value());
 646 }
 647
 648 bool LayerSupportHandle::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
 649                                           const TensorInfo& output,
 650                                           const StackDescriptor& descriptor,
 651                                           Optional<std::string&> reasonIfUnsupported)
 652 {
 653     return m_LayerSupport->IsStackSupported(inputs, output, descriptor, reasonIfUnsupported.value());
 654 }
 655
 656 bool LayerSupportHandle::IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
 657                                             const std::vector<const TensorInfo*>& outputs,
 658                                             const StandInDescriptor& descriptor,
 659                                             Optional<std::string&> reasonIfUnsupported)
 660 {
 661     return m_LayerSupport->IsStandInSupported(inputs, outputs, descriptor, reasonIfUnsupported.value());
 662 }
 663
 664
 665 bool LayerSupportHandle::IsStridedSliceSupported(const TensorInfo& input,
 666                                                  const TensorInfo& output,
 667                                                  const StridedSliceDescriptor& descriptor,
 668                                                  Optional<std::string&> reasonIfUnsupported)
 669 {
 670     return m_LayerSupport->IsStridedSliceSupported(input, output, descriptor, reasonIfUnsupported.value());
 671 }
 672
 673 bool LayerSupportHandle::IsSubtractionSupported(const TensorInfo& input0,
 674                                                 const TensorInfo& input1,
 675                                                 const TensorInfo& output,
 676                                                 Optional<std::string&> reasonIfUnsupported)
 677 {
 678     return m_LayerSupport->IsSubtractionSupported(input0, input1, output, reasonIfUnsupported.value());
 679 }
 680
 681 bool LayerSupportHandle::IsSwitchSupported(const TensorInfo& input0,
 682                                            const TensorInfo& input1,
 683                                            const TensorInfo& output0,
 684                                            const TensorInfo& output1,
 685                                            Optional<std::string&> reasonIfUnsupported)
 686 {
 687     return m_LayerSupport->IsSwitchSupported(input0, input1, output0, output1, reasonIfUnsupported.value());
 688 }
 689
 690 bool LayerSupportHandle::IsTransposeConvolution2dSupported(
 691         const TensorInfo& input,
 692         const TensorInfo& output,
 693         const TransposeConvolution2dDescriptor& descriptor,
 694         const TensorInfo& weights,
 695         const Optional<TensorInfo>& biases,
 696         Optional<std::string&> reasonIfUnsupported)
 697 {
 698     return m_LayerSupport->IsTransposeConvolution2dSupported(input,
 699                                                              output,
 700                                                              descriptor,
 701                                                              weights,
 702                                                              biases,
 703                                                              reasonIfUnsupported.value());
 704 }
 705
 706 bool LayerSupportHandle::IsTransposeSupported(const TensorInfo& input,
 707                                               const TensorInfo& output,
 708                                               const TransposeDescriptor& descriptor,
 709                                               Optional<std::string&> reasonIfUnsupported)
 710 {
 711     return m_LayerSupport->IsTransposeSupported(input, output, descriptor, reasonIfUnsupported.value());
 712 }
 713
 714 }