diff options
Diffstat (limited to 'src/armnn')
-rw-r--r-- | src/armnn/BackendHelper.cpp | 692 | ||||
-rw-r--r-- | src/armnn/test/UtilsTests.cpp | 14 |
2 files changed, 703 insertions, 3 deletions
diff --git a/src/armnn/BackendHelper.cpp b/src/armnn/BackendHelper.cpp index 84889b80e4..fb74877049 100644 --- a/src/armnn/BackendHelper.cpp +++ b/src/armnn/BackendHelper.cpp @@ -11,18 +11,704 @@ namespace armnn { -std::shared_ptr<ILayerSupport> GetILayerSupportByBackendId(const armnn::BackendId& backend) +// Return LayerSupportHandle instead of the previous pointer to ILayerSupport. +LayerSupportHandle GetILayerSupportByBackendId(const armnn::BackendId& backend) { BackendRegistry& backendRegistry = armnn::BackendRegistryInstance(); if (!backendRegistry.IsBackendRegistered(backend)) { - return nullptr; + return LayerSupportHandle(nullptr); } auto factoryFunc = backendRegistry.GetFactory(backend); auto backendObject = factoryFunc(); - return backendObject->GetLayerSupport(); + return LayerSupportHandle(backendObject->GetLayerSupport()); } +bool LayerSupportHandle::IsBackendRegistered() const +{ + if (m_LayerSupport) + { + return true; + } + + return false; +} + + +bool LayerSupportHandle::IsAbsSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + // Call the IsXXXLayerSupport function of the specific backend. + return m_LayerSupport->IsAbsSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsActivationSupported(const TensorInfo& input, + const TensorInfo& output, + const ActivationDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsActivationSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsAdditionSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsAdditionSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsArgMinMaxSupported(const TensorInfo& input, + const TensorInfo& output, + const ArgMinMaxDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsArgMinMaxSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsBatchNormalizationSupported(const TensorInfo& input, + const TensorInfo& output, + const TensorInfo& mean, + const TensorInfo& var, + const TensorInfo& beta, + const TensorInfo& gamma, + const BatchNormalizationDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsBatchNormalizationSupported(input, + output, + mean, + var, + beta, + gamma, + descriptor, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsBatchToSpaceNdSupported(const TensorInfo& input, + const TensorInfo& output, + const BatchToSpaceNdDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsBatchToSpaceNdSupported(input, + output, + descriptor, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsComparisonSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + const ComparisonDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsComparisonSupported(input0, input1, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConcatSupported(const std::vector<const TensorInfo*> inputs, + const TensorInfo& output, + const OriginsDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConstantSupported(const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConstantSupported(output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConvertBf16ToFp32Supported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConvertBf16ToFp32Supported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConvertFp32ToBf16Supported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConvertFp32ToBf16Supported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConvertFp16ToFp32Supported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConvertFp16ToFp32Supported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConvertFp32ToFp16Supported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConvertFp32ToFp16Supported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsConvolution2dSupported(const TensorInfo& input, + const TensorInfo& output, + const Convolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional<TensorInfo>& biases, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsConvolution2dSupported(input, + output, + descriptor, + weights, + biases, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsDebugSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDebugSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsDepthToSpaceSupported(const TensorInfo& input, + const TensorInfo& output, + const DepthToSpaceDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDepthToSpaceSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsDepthwiseConvolutionSupported( + const TensorInfo& input, + const TensorInfo& output, + const DepthwiseConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional<TensorInfo>& biases, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDepthwiseConvolutionSupported(input, + output, + descriptor, + weights, + biases, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsDequantizeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDequantizeSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings, + const TensorInfo& scores, + const TensorInfo& anchors, + const TensorInfo& detectionBoxes, + const TensorInfo& detectionClasses, + const TensorInfo& detectionScores, + const TensorInfo& numDetections, + const DetectionPostProcessDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDetectionPostProcessSupported(boxEncodings, + scores, + anchors, + detectionBoxes, + detectionClasses, + detectionScores, + numDetections, + descriptor, + reasonIfUnsupported); +} + +bool LayerSupportHandle::IsDilatedDepthwiseConvolutionSupported( + const TensorInfo& input, + const TensorInfo& output, + const DepthwiseConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional<TensorInfo>& biases, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDilatedDepthwiseConvolutionSupported(input, + output, + descriptor, + weights, + biases, + reasonIfUnsupported); +} + +bool LayerSupportHandle::IsDivisionSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsDivisionSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsElementwiseUnarySupported(const TensorInfo& input, + const TensorInfo& output, + const ElementwiseUnaryDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsElementwiseUnarySupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsEqualSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsEqualSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsFakeQuantizationSupported(const TensorInfo& input, + const FakeQuantizationDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsFakeQuantizationSupported(input, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsFillSupported(const TensorInfo& input, + const TensorInfo& output, + const FillDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsFillSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsFloorSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsFloorSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsFullyConnectedSupported(const TensorInfo& input, + const TensorInfo& output, + const TensorInfo& weights, + const TensorInfo& biases, + const FullyConnectedDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsFullyConnectedSupported(input, + output, + weights, + biases, + descriptor, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsGatherSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsGatherSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsGatherSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + const GatherDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsGatherSupported(input0, input1, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsGreaterSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& ouput, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsGreaterSupported(input0, input1, ouput, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsInputSupported(const TensorInfo& input, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsInputSupported(input, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsInstanceNormalizationSupported( + const TensorInfo& input, + const TensorInfo& output, + const InstanceNormalizationDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsInstanceNormalizationSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsL2NormalizationSupported(const TensorInfo& input, + const TensorInfo& output, + const L2NormalizationDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsL2NormalizationSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsLogicalBinarySupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + const LogicalBinaryDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsLogicalBinarySupported(input0, + input1, + output, + descriptor, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsLogicalUnarySupported(const TensorInfo& input, + const TensorInfo& output, + const ElementwiseUnaryDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsLogicalUnarySupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsLogSoftmaxSupported(const TensorInfo& input, + const TensorInfo& output, + const LogSoftmaxDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsLogSoftmaxSupported(input, output, descriptor, reasonIfUnsupported.value()); } + +bool LayerSupportHandle::IsLstmSupported(const TensorInfo& input, + const TensorInfo& outputStateIn, + const TensorInfo& cellStateIn, + const TensorInfo& scratchBuffer, + const TensorInfo& outputStateOut, + const TensorInfo& cellStateOut, + const TensorInfo& output, + const LstmDescriptor& descriptor, + const LstmInputParamsInfo& paramsInfo, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsLstmSupported(input, + outputStateIn, + cellStateIn, + scratchBuffer, + outputStateOut, + cellStateOut, + output, + descriptor, + paramsInfo, + reasonIfUnsupported); +} + +bool LayerSupportHandle::IsMaximumSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMaximumSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMeanSupported(const TensorInfo& input, + const TensorInfo& output, + const MeanDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMeanSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMemCopySupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMemCopySupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMemImportSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMemImportSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMergeSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMergeSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMergerSupported(const std::vector<const TensorInfo*> inputs, + const TensorInfo& output, + const OriginsDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMinimumSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMinimumSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsMultiplicationSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsMultiplicationSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsNormalizationSupported(const TensorInfo& input, + const TensorInfo& output, + const NormalizationDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsNormalizationSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsOutputSupported(const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsOutputSupported(output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsPadSupported(const TensorInfo& input, + const TensorInfo& output, + const PadDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsPadSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsPermuteSupported(const TensorInfo& input, + const TensorInfo& output, + const PermuteDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsPermuteSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsPooling2dSupported(const TensorInfo& input, + const TensorInfo& output, + const Pooling2dDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsPooling2dSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsPreCompiledSupported(const TensorInfo& input, + const PreCompiledDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsPreCompiledSupported(input, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsPreluSupported(const TensorInfo& input, + const TensorInfo& alpha, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsPreluSupported(input, alpha, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsQuantizeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsQuantizeSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsQLstmSupported(const TensorInfo& input, + const TensorInfo& previousOutputIn, + const TensorInfo& previousCellStateIn, + const TensorInfo& outputStateOut, + const TensorInfo& cellStateOut, + const TensorInfo& output, + const QLstmDescriptor& descriptor, + const LstmInputParamsInfo& paramsInfo, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsQLstmSupported(input, + previousOutputIn, + previousCellStateIn, + outputStateOut, + cellStateOut, + output, + descriptor, + paramsInfo, + reasonIfUnsupported); +} + +bool LayerSupportHandle::IsQuantizedLstmSupported(const TensorInfo& input, + const TensorInfo& previousCellStateIn, + const TensorInfo& previousOutputIn, + const TensorInfo& cellStateOut, + const TensorInfo& output, + const QuantizedLstmInputParamsInfo& paramsInfo, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsQuantizedLstmSupported(input, + previousCellStateIn, + previousOutputIn, + cellStateOut, + output, + paramsInfo, + reasonIfUnsupported); +} + +bool LayerSupportHandle::IsRankSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsRankSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsReshapeSupported(const TensorInfo& input, + const TensorInfo& output, + const ReshapeDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsReshapeSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsResizeBilinearSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsResizeBilinearSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsResizeSupported(const TensorInfo& input, + const TensorInfo& output, + const ResizeDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsResizeSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsRsqrtSupported(const TensorInfo& input, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsRsqrtSupported(input, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSliceSupported(const TensorInfo& input, + const TensorInfo& output, + const SliceDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSliceSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSoftmaxSupported(const TensorInfo& input, + const TensorInfo& output, + const SoftmaxDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSoftmaxSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSpaceToBatchNdSupported(const TensorInfo& input, + const TensorInfo& output, + const SpaceToBatchNdDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSpaceToBatchNdSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSpaceToDepthSupported(const TensorInfo& input, + const TensorInfo& output, + const SpaceToDepthDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSpaceToDepthSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSplitterSupported(const TensorInfo& input, + const ViewsDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSplitterSupported(input, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSplitterSupported(const TensorInfo& input, + const std::vector<std::reference_wrapper<TensorInfo>>& outputs, + const ViewsDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSplitterSupported(input, outputs, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsStackSupported(const std::vector<const TensorInfo*>& inputs, + const TensorInfo& output, + const StackDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsStackSupported(inputs, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsStandInSupported(const std::vector<const TensorInfo*>& inputs, + const std::vector<const TensorInfo*>& outputs, + const StandInDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsStandInSupported(inputs, outputs, descriptor, reasonIfUnsupported.value()); +} + + +bool LayerSupportHandle::IsStridedSliceSupported(const TensorInfo& input, + const TensorInfo& output, + const StridedSliceDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsStridedSliceSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSubtractionSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSubtractionSupported(input0, input1, output, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsSwitchSupported(const TensorInfo& input0, + const TensorInfo& input1, + const TensorInfo& output0, + const TensorInfo& output1, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsSwitchSupported(input0, input1, output0, output1, reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsTransposeConvolution2dSupported( + const TensorInfo& input, + const TensorInfo& output, + const TransposeConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional<TensorInfo>& biases, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsTransposeConvolution2dSupported(input, + output, + descriptor, + weights, + biases, + reasonIfUnsupported.value()); +} + +bool LayerSupportHandle::IsTransposeSupported(const TensorInfo& input, + const TensorInfo& output, + const TransposeDescriptor& descriptor, + Optional<std::string&> reasonIfUnsupported) +{ + return m_LayerSupport->IsTransposeSupported(input, output, descriptor, reasonIfUnsupported.value()); +} + +}
\ No newline at end of file diff --git a/src/armnn/test/UtilsTests.cpp b/src/armnn/test/UtilsTests.cpp index fb078de32f..7776a2d3cf 100644 --- a/src/armnn/test/UtilsTests.cpp +++ b/src/armnn/test/UtilsTests.cpp @@ -5,6 +5,7 @@ #include <boost/test/unit_test.hpp> +#include <armnn/BackendHelper.hpp> #include <armnn/Utils.hpp> #include <armnn/Types.hpp> #include <armnn/TypesUtils.hpp> @@ -266,4 +267,17 @@ BOOST_AUTO_TEST_CASE(PermuteQuantizationDim) BOOST_CHECK(permuted.GetQuantizationDim().value() == 1U); } +#if defined(ARMNNREF_ENABLED) +BOOST_AUTO_TEST_CASE(LayerSupportHandle) +{ + auto layerSupportObject = armnn::GetILayerSupportByBackendId("CpuRef"); + armnn::TensorInfo input; + std::string reasonIfUnsupported; + // InputLayer always supported for CpuRef + BOOST_CHECK_EQUAL(layerSupportObject.IsInputSupported(input, reasonIfUnsupported), true); + + BOOST_CHECK(layerSupportObject.IsBackendRegistered()); +} +#endif + BOOST_AUTO_TEST_SUITE_END() |