From f4019872c1134c6fcc1d6993e5746f55c1e79208 Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Tue, 8 Mar 2022 20:01:38 +0000 Subject: IVGCVSW-6819 Fix the directory structure and broken link to latest docu Signed-off-by: Nikhil Raj Change-Id: I05b559d15faf92c76ff536719693b361316be4f3 --- 22.02/classarmnn_1_1_neon_layer_support.xhtml | 4680 +++++++++++++++++++++++++ 1 file changed, 4680 insertions(+) create mode 100644 22.02/classarmnn_1_1_neon_layer_support.xhtml (limited to '22.02/classarmnn_1_1_neon_layer_support.xhtml') diff --git a/22.02/classarmnn_1_1_neon_layer_support.xhtml b/22.02/classarmnn_1_1_neon_layer_support.xhtml new file mode 100644 index 0000000000..f47317db0e --- /dev/null +++ b/22.02/classarmnn_1_1_neon_layer_support.xhtml @@ -0,0 +1,4680 @@ + + + + + + + + + + + + + +ArmNN: NeonLayerSupport Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  22.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Public Member Functions | +List of all members
+
+
NeonLayerSupport Class Reference
+
+
+ +

#include <NeonLayerSupport.hpp>

+
+Inheritance diagram for NeonLayerSupport:
+
+
+ + +LayerSupportBase +ILayerSupport + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 NeonLayerSupport (const IBackendInternal::IBackendSpecificModelContextPtr &modelContextPtr)
 
 NeonLayerSupport ()
 
 ~NeonLayerSupport ()
 
bool IsLayerSupported (const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo, const Optional< QuantizedLstmInputParamsInfo > &quantizedLstmParamsInfo, Optional< std::string &> reasonIfUnsupported) const override
 
bool IsActivationSupported (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsAdditionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsArgMinMaxSupported (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsBatchToSpaceNdSupported (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsCastSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsChannelShuffleSupported (const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsComparisonSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConcatSupported (const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConstantSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertBf16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToBf16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvolution3dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reason=EmptyOptional()) const override
 
bool IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFillSupported (const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFloorSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFullyConnectedSupported (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported) const override
 
bool IsInputSupported (const TensorInfo &input, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsInstanceNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsL2NormalizationSupported (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsLogicalBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported) const override
 
bool IsLogSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsMaximumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMeanSupported (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMinimumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMultiplicationSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsOutputSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPadSupported (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPermuteSupported (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPooling2dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsQuantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsQuantizedLstmSupported (const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSpaceToBatchNdSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSpaceToDepthSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSplitterSupported (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStackSupported (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStridedSliceSupported (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSubtractionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsTransposeConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
- Public Member Functions inherited from LayerSupportBase
bool IsActivationSupported (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsAdditionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsArgMinMaxSupported (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsBatchToSpaceNdSupported (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsCastSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsChannelShuffleSupported (const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsComparisonSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConcatSupported (const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConstantSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertBf16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToBf16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvolution3dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDebugSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFloorSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFullyConnectedSupported (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsInputSupported (const TensorInfo &input, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsInstanceNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsL2NormalizationSupported (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsLogicalBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsLogicalUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsLogSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsMaximumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMeanSupported (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMemCopySupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMemImportSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMergeSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMinimumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMultiplicationSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsOutputSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPadSupported (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPermuteSupported (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPooling2dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPooling3dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPreCompiledSupported (const TensorInfo &input, const PreCompiledDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported) const override
 
bool IsQuantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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=EmptyOptional()) const override
 
bool IsQuantizedLstmSupported (const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsRankSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported) const override
 
bool IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsShapeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSpaceToBatchNdSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSpaceToDepthSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSplitterSupported (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStackSupported (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStandInSupported (const std::vector< const TensorInfo *> &inputs, const std::vector< const TensorInfo *> &outputs, const StandInDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStridedSliceSupported (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSubtractionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSwitchSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsTransposeConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsUnidirectionalSequenceLstmSupported (const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &output, const Optional< TensorInfo > &hiddenStateOutput, const Optional< TensorInfo > &cellStateOutput, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
- Public Member Functions inherited from ILayerSupport
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsActivationSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsAdditionSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsArgMinMaxSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsBatchNormalizationSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsBatchToSpaceNdSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsCastSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsChannelShuffleSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsComparisonSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConvertBf16ToFp32Supported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConvertFp32ToBf16Supported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConvertFp16ToFp32Supported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConvertFp32ToFp16Supported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConvolution2dSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConvolution3dSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDebugSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDepthToSpaceSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDepthwiseConvolutionSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDequantizeSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDetectionPostProcessSupported(const TensorInfo &boxEncodings
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsDivisionSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsElementwiseUnarySupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsFakeQuantizationSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsFillSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsFloorSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsFullyConnectedSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsGatherSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsInputSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsInstanceNormalizationSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsL2NormalizationSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsLogicalBinarySupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsLogicalUnarySupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsLogSoftmaxSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsLstmSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMaximumSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMeanSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMemCopySupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMemImportSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMergeSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMinimumSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsMultiplicationSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsNormalizationSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsOutputSupported(const TensorInfo &output
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsPadSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsPermuteSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsPooling2dSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsPooling3dSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsPreCompiledSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsPreluSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsQuantizeSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsQLstmSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsQuantizedLstmSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsRankSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsReduceSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsReshapeSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsResizeSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsShapeSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSliceSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSoftmaxSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSpaceToBatchNdSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSpaceToDepthSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSplitterSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSubtractionSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsSwitchSupported(const TensorInfo &input0
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsTransposeConvolution2dSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsTransposeSupported(const TensorInfo &input
 
 ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsUnidirectionalSequenceLstmSupported(const TensorInfo &input
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Public Attributes inherited from ILayerSupport
const TensorInfo & output
 
const TensorInfo const ActivationDescriptor & descriptor
 
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo & input1
 
const TensorInfo const TensorInfo & output
 
const TensorInfo const TensorInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const ArgMinMaxDescriptor & descriptor
 
const TensorInfo const ArgMinMaxDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo & mean
 
const TensorInfo const TensorInfo const TensorInfo & var
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & beta
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & gamma
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const BatchNormalizationDescriptor & descriptor
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const BatchNormalizationDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const BatchToSpaceNdDescriptor & descriptor
 
const TensorInfo const BatchToSpaceNdDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const ChannelShuffleDescriptor & descriptor
 
const TensorInfo const ChannelShuffleDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo const ComparisonDescriptor & descriptor
 
const TensorInfo const TensorInfo const ComparisonDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsConcatSupported(const std Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const Convolution2dDescriptor & descriptor
 
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
 
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
 
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const Convolution3dDescriptor & descriptor
 
const TensorInfo const Convolution3dDescriptor const TensorInfo & weights
 
const TensorInfo const Convolution3dDescriptor const TensorInfo const Optional< TensorInfo > & biases
 
const TensorInfo const Convolution3dDescriptor const TensorInfo const Optional< TensorInfo > Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const DepthToSpaceDescriptor & descriptor
 
const TensorInfo const DepthToSpaceDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const DepthwiseConvolution2dDescriptor & descriptor
 
const TensorInfo const DepthwiseConvolution2dDescriptor const TensorInfo & weights
 
const TensorInfo const DepthwiseConvolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
 
const TensorInfo const DepthwiseConvolution2dDescriptor const TensorInfo const Optional< TensorInfo > Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo & scores
 
const TensorInfo const TensorInfo & anchors
 
const TensorInfo const TensorInfo const TensorInfo & detectionBoxes
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & detectionClasses
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & detectionScores
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & numDetections
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const DetectionPostProcessDescriptor & descriptor
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const DetectionPostProcessDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const =0
 
const TensorInfo const ElementwiseUnaryDescriptor & descriptor
 
const TensorInfo const ElementwiseUnaryDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const FakeQuantizationDescriptor & descriptor
 
const FakeQuantizationDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const FillDescriptor & descriptor
 
const TensorInfo const FillDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo & weights
 
const TensorInfo const TensorInfo const TensorInfo & biases
 
const TensorInfo const TensorInfo const TensorInfo const FullyConnectedDescriptor & descriptor
 
const TensorInfo const TensorInfo const TensorInfo const FullyConnectedDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo const GatherDescriptor & descriptor
 
const TensorInfo const TensorInfo const GatherDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const InstanceNormalizationDescriptor & descriptor
 
const TensorInfo const InstanceNormalizationDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const L2NormalizationDescriptor & descriptor
 
const TensorInfo const L2NormalizationDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo const LogicalBinaryDescriptor & descriptor
 
const TensorInfo const TensorInfo const LogicalBinaryDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const LogSoftmaxDescriptor & descriptor
 
const TensorInfo const LogSoftmaxDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo & outputStateIn
 
const TensorInfo const TensorInfo & cellStateIn
 
const TensorInfo const TensorInfo const TensorInfo & scratchBuffer
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & output
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor & descriptor
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo & paramsInfo
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const MeanDescriptor & descriptor
 
const TensorInfo const MeanDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo & ouput
 
const TensorInfo const NormalizationDescriptor & descriptor
 
const TensorInfo const NormalizationDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const PadDescriptor & descriptor
 
const TensorInfo const PadDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const PermuteDescriptor & descriptor
 
const TensorInfo const PermuteDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const Pooling2dDescriptor & descriptor
 
const TensorInfo const Pooling2dDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const Pooling3dDescriptor & descriptor
 
const TensorInfo const Pooling3dDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const PreCompiledDescriptor & descriptor
 
const PreCompiledDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo & alpha
 
const TensorInfo & previousOutputIn
 
const TensorInfo const TensorInfo & previousCellStateIn
 
const TensorInfo const TensorInfo const TensorInfo & outputStateOut
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & output
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const QLstmDescriptor & descriptor
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const QLstmDescriptor const LstmInputParamsInfo & paramsInfo
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const QLstmDescriptor const LstmInputParamsInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo & previousCellStateIn
 
const TensorInfo const TensorInfo & previousOutputIn
 
const TensorInfo const TensorInfo const TensorInfo & cellStateOut
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & output
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const QuantizedLstmInputParamsInfo & paramsInfo
 
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const QuantizedLstmInputParamsInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const ReduceDescriptor & descriptor
 
const TensorInfo const ReduceDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const ReshapeDescriptor & descriptor
 
const TensorInfo const ReshapeDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const ResizeDescriptor & descriptor
 
const TensorInfo const ResizeDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const SliceDescriptor & descriptor
 
const TensorInfo const SliceDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const SoftmaxDescriptor & descriptor
 
const TensorInfo const SoftmaxDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const SpaceToBatchNdDescriptor & descriptor
 
const TensorInfo const SpaceToBatchNdDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const SpaceToDepthDescriptor & descriptor
 
const TensorInfo const SpaceToDepthDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const std::vector< std::reference_wrapper< TensorInfo > > & outputs
 
const std::vector< std::reference_wrapper< TensorInfo > > const ViewsDescriptor & descriptor
 
const std::vector< std::reference_wrapper< TensorInfo > > const ViewsDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsStackSupported(const std ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsStandInSupported(const std const TensorInfo & output
 
ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsStackSupported(const std ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsStandInSupported(const std const TensorInfo const StridedSliceDescriptor & descriptor
 
ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsStackSupported(const std ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. " "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "22.11") virtual bool IsStandInSupported(const std const TensorInfo const StridedSliceDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo & output0
 
const TensorInfo const TensorInfo const TensorInfo & output1
 
const TensorInfo const TensorInfo const TensorInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TransposeConvolution2dDescriptor & descriptor
 
const TensorInfo const TransposeConvolution2dDescriptor const TensorInfo & weights
 
const TensorInfo const TransposeConvolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
 
const TensorInfo const TransposeConvolution2dDescriptor const TensorInfo const Optional< TensorInfo > Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TransposeDescriptor & descriptor
 
const TensorInfo const TransposeDescriptor Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
const TensorInfo const TensorInfo const TensorInfo & output
 
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > & hiddenStateOutput
 
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > & cellStateOutput
 
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > const LstmDescriptor & descriptor
 
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > const LstmDescriptor const LstmInputParamsInfo & paramsInfo
 
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > const LstmDescriptor const LstmInputParamsInfo Optional< std::string & > reasonIfUnsupported = EmptyOptional()) const
 
- Protected Member Functions inherited from ILayerSupport
 ILayerSupport ()
 
virtual ~ILayerSupport ()
 
+

Detailed Description

+
+

Definition at line 14 of file NeonLayerSupport.hpp.

+

Constructor & Destructor Documentation

+ +

◆ NeonLayerSupport() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
NeonLayerSupport (const IBackendInternal::IBackendSpecificModelContextPtr & modelContextPtr)
+ 		+explicit
+
+ +

Definition at line 138 of file NeonLayerSupport.cpp.

+
139  : m_ModelContextPtr(modelContextPtr)
140 {
141 }
+
+
+ +

◆ NeonLayerSupport() [2/2]

+ +
+
+ + + + + + + +
NeonLayerSupport ()
+
+ +

Definition at line 143 of file NeonLayerSupport.cpp.

+
144  : m_ModelContextPtr(nullptr)
145 {
146 }
+
+
+ +

◆ ~NeonLayerSupport()

+ +
+
+ + + + + +
+ + + + + + + +
~NeonLayerSupport ()
+ 		+inline
+
+ +

Definition at line 20 of file NeonLayerSupport.hpp.

+ +

References ILayerSupport::alpha, ILayerSupport::beta, ILayerSupport::biases, ILayerSupport::cellStateIn, ILayerSupport::cellStateOut, ILayerSupport::descriptor, ILayerSupport::gamma, ILayerSupport::input1, NeonLayerSupport::IsActivationSupported(), NeonLayerSupport::IsAdditionSupported(), NeonLayerSupport::IsArgMinMaxSupported(), NeonLayerSupport::IsBatchNormalizationSupported(), NeonLayerSupport::IsBatchToSpaceNdSupported(), NeonLayerSupport::IsCastSupported(), NeonLayerSupport::IsChannelShuffleSupported(), NeonLayerSupport::IsComparisonSupported(), NeonLayerSupport::IsConcatSupported(), NeonLayerSupport::IsConstantSupported(), NeonLayerSupport::IsConvertBf16ToFp32Supported(), NeonLayerSupport::IsConvertFp16ToFp32Supported(), NeonLayerSupport::IsConvertFp32ToBf16Supported(), NeonLayerSupport::IsConvertFp32ToFp16Supported(), NeonLayerSupport::IsConvolution2dSupported(), NeonLayerSupport::IsConvolution3dSupported(), NeonLayerSupport::IsDepthToSpaceSupported(), NeonLayerSupport::IsDepthwiseConvolutionSupported(), NeonLayerSupport::IsDequantizeSupported(), NeonLayerSupport::IsDilatedDepthwiseConvolutionSupported(), NeonLayerSupport::IsDivisionSupported(), NeonLayerSupport::IsElementwiseUnarySupported(), NeonLayerSupport::IsFillSupported(), NeonLayerSupport::IsFloorSupported(), NeonLayerSupport::IsFullyConnectedSupported(), NeonLayerSupport::IsGatherSupported(), NeonLayerSupport::IsInputSupported(), NeonLayerSupport::IsInstanceNormalizationSupported(), NeonLayerSupport::IsL2NormalizationSupported(), NeonLayerSupport::IsLayerSupported(), NeonLayerSupport::IsLogicalBinarySupported(), NeonLayerSupport::IsLogSoftmaxSupported(), NeonLayerSupport::IsLstmSupported(), NeonLayerSupport::IsMaximumSupported(), NeonLayerSupport::IsMeanSupported(), NeonLayerSupport::IsMinimumSupported(), NeonLayerSupport::IsMultiplicationSupported(), NeonLayerSupport::IsNormalizationSupported(), NeonLayerSupport::IsOutputSupported(), NeonLayerSupport::IsPadSupported(), NeonLayerSupport::IsPermuteSupported(), NeonLayerSupport::IsPooling2dSupported(), NeonLayerSupport::IsPreluSupported(), NeonLayerSupport::IsQLstmSupported(), NeonLayerSupport::IsQuantizedLstmSupported(), NeonLayerSupport::IsQuantizeSupported(), NeonLayerSupport::IsReduceSupported(), NeonLayerSupport::IsReshapeSupported(), NeonLayerSupport::IsResizeSupported(), NeonLayerSupport::IsSliceSupported(), NeonLayerSupport::IsSoftmaxSupported(), NeonLayerSupport::IsSpaceToBatchNdSupported(), NeonLayerSupport::IsSpaceToDepthSupported(), NeonLayerSupport::IsSplitterSupported(), NeonLayerSupport::IsStackSupported(), NeonLayerSupport::IsStridedSliceSupported(), NeonLayerSupport::IsSubtractionSupported(), NeonLayerSupport::IsTransposeConvolution2dSupported(), NeonLayerSupport::IsTransposeSupported(), ILayerSupport::mean, ILayerSupport::output, ILayerSupport::outputs, ILayerSupport::outputStateIn, ILayerSupport::outputStateOut, ILayerSupport::paramsInfo, ILayerSupport::previousCellStateIn, ILayerSupport::previousOutputIn, ILayerSupport::reasonIfUnsupported, ILayerSupport::scratchBuffer, ILayerSupport::var, and ILayerSupport::weights.

+
20 {}
+
+
+

Member Function Documentation

+ +

◆ IsActivationSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsActivationSupported (const TensorInfo & input,
const TensorInfo & output,
const ActivationDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 566 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::IgnoreUnused(), and armnn::NeonActivationWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
570 {
571  IgnoreUnused(descriptor);
572  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonActivationWorkloadValidate,
573  reasonIfUnsupported,
574  input,
575  output,
576  descriptor);
577 }
armnn::NeonActivationWorkloadValidate
arm_compute::Status NeonActivationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor)
Definition: NeonActivationWorkload.cpp:17
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsAdditionSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsAdditionSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 579 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonAdditionWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
583 {
584  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAdditionWorkloadValidate,
585  reasonIfUnsupported,
586  input0,
587  input1,
588  output,
589  nullptr);
590 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonAdditionWorkloadValidate
arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonAdditionWorkload.cpp:20
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsArgMinMaxSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsArgMinMaxSupported (const TensorInfo & input,
const TensorInfo & output,
const ArgMinMaxDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 592 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonArgMinMaxWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
596 {
597  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonArgMinMaxWorkloadValidate,
598  reasonIfUnsupported,
599  input,
600  output,
601  descriptor);
602 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonArgMinMaxWorkloadValidate
arm_compute::Status NeonArgMinMaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor)
Definition: NeonArgMinMaxWorkload.cpp:31
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsBatchNormalizationSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool 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 = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 604 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonBatchNormalizationValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
612 {
613  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchNormalizationValidate,
614  reasonIfUnsupported,
615  input,
616  output,
617  mean,
618  var,
619  beta,
620  gamma,
621  descriptor,
622  nullptr);
623 }
armnn::NeonBatchNormalizationValidate
arm_compute::Status NeonBatchNormalizationValidate(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: NeonBatchNormalizationWorkload.cpp:24
+
armnn::ILayerSupport::gamma
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & gamma
Definition: ILayerSupport.hpp:62
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::var
const TensorInfo const TensorInfo const TensorInfo & var
Definition: ILayerSupport.hpp:62
+
armnn::ILayerSupport::beta
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & beta
Definition: ILayerSupport.hpp:62
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::mean
const TensorInfo const TensorInfo & mean
Definition: ILayerSupport.hpp:62
+
+
+
+ +

◆ IsBatchToSpaceNdSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsBatchToSpaceNdSupported (const TensorInfo & input,
const TensorInfo & output,
const BatchToSpaceNdDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 625 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonBatchToSpaceNdWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
629 {
630  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchToSpaceNdWorkloadValidate,
631  reasonIfUnsupported,
632  input,
633  output,
634  descriptor);
635 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonBatchToSpaceNdWorkloadValidate
arm_compute::Status NeonBatchToSpaceNdWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor)
Definition: NeonBatchToSpaceNdWorkload.cpp:20
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsCastSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsCastSupported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 637 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonCastValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
640 {
641  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonCastValidate,
642  reasonIfUnsupported,
643  input,
644  output);
645 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonCastValidate
arm_compute::Status NeonCastValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonCastWorkload.cpp:19
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsChannelShuffleSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsChannelShuffleSupported (const TensorInfo & input,
const TensorInfo & output,
const ChannelShuffleDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 647 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonChannelShuffleValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
651 {
652  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonChannelShuffleValidate,
653  reasonIfUnsupported,
654  input,
655  output,
656  descriptor);
657 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonChannelShuffleValidate
arm_compute::Status NeonChannelShuffleValidate(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor)
Definition: NeonChannelShuffleWorkload.cpp:17
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsComparisonSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsComparisonSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
const ComparisonDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 659 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonComparisonWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
664 {
665 
666  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonComparisonWorkloadValidate,
667  reasonIfUnsupported,
668  input0,
669  input1,
670  output,
671  descriptor);
672 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonComparisonWorkloadValidate
arm_compute::Status NeonComparisonWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor)
Definition: NeonComparisonWorkload.cpp:16
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsConcatSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConcatSupported (const std::vector< const TensorInfo *> inputs,
const TensorInfo & output,
const OriginsDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 674 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, OriginsDescriptor::GetConcatAxis(), OriginsDescriptor::GetNumDimensions(), TensorInfo::IsTypeSpaceMatch(), armnn::NeonConcatWorkloadValidate(), and armnn::SetValueChecked().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
678 {
679  if (descriptor.GetNumDimensions() <= descriptor.GetConcatAxis())
680  {
681  SetValueChecked(reasonIfUnsupported, "Neon Concat: Concat axis > Number of dimensions.");
682  return false;
683  }
684 
685  unsigned int concatInnerAxis = (descriptor.GetNumDimensions() - descriptor.GetConcatAxis()) - 1;
686  if(concatInnerAxis < 3) // Width, height, or channels
687  {
688  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConcatWorkloadValidate,
689  reasonIfUnsupported,
690  inputs,
691  output,
692  descriptor);
693  }
694  else if (concatInnerAxis == 3)
695  {
696  for (auto& input : inputs)
697  {
698  if (input && !output.IsTypeSpaceMatch(*input)) // Cannot use sub-tensors if the types are not same space
699  {
700  SetValueChecked(reasonIfUnsupported, "Neon Concat: Types and quantization parameters must match.");
701  return false;
702  }
703  }
704  return true; // Sub-tensors support concat along batch
705  }
706  else // > 4 dimensions not supported.
707  {
708  SetValueChecked(reasonIfUnsupported, "Neon Concat: Maximum of 4 dimensions supported.");
709  return false;
710  }
711 }
armnn::TensorInfo::IsTypeSpaceMatch
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
Definition: Tensor.cpp:434
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonConcatWorkloadValidate
arm_compute::Status NeonConcatWorkloadValidate(const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const OriginsDescriptor &descriptor)
Definition: NeonConcatWorkload.cpp:27
+
armnn::SetValueChecked
void SetValueChecked(Optional< T &> optionalRef, V &&val)
Definition: LayerSupportCommon.hpp:17
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::TensorInfo::GetNumDimensions
unsigned int GetNumDimensions() const
Definition: Tensor.hpp:195
+
+
+
+ +

◆ IsConstantSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool IsConstantSupported (const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 713 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonConstantWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
715 {
716  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConstantWorkloadValidate,
717  reasonIfUnsupported,
718  output);
719 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonConstantWorkloadValidate
arm_compute::Status NeonConstantWorkloadValidate(const TensorInfo &output)
Definition: NeonConstantWorkload.cpp:20
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsConvertBf16ToFp32Supported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConvertBf16ToFp32Supported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 721 of file NeonLayerSupport.cpp.

+ +

References armnn::IgnoreUnused().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
724 {
725  armnn::IgnoreUnused(input);
726  armnn::IgnoreUnused(output);
727  armnn::IgnoreUnused(reasonIfUnsupported);
728  return true;
729 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
+
+
+ +

◆ IsConvertFp16ToFp32Supported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConvertFp16ToFp32Supported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 731 of file NeonLayerSupport.cpp.

+ +

References armnn::IgnoreUnused().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
734 {
735  armnn::IgnoreUnused(input);
736  armnn::IgnoreUnused(output);
737  armnn::IgnoreUnused(reasonIfUnsupported);
738  return true;
739 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
+
+
+ +

◆ IsConvertFp32ToBf16Supported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConvertFp32ToBf16Supported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 741 of file NeonLayerSupport.cpp.

+ +

References armnn::IgnoreUnused().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
744 {
745  armnn::IgnoreUnused(input);
746  armnn::IgnoreUnused(output);
747  armnn::IgnoreUnused(reasonIfUnsupported);
748  return true;
749 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
+
+
+ +

◆ IsConvertFp32ToFp16Supported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConvertFp32ToFp16Supported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 751 of file NeonLayerSupport.cpp.

+ +

References armnn::IgnoreUnused().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
754 {
755  armnn::IgnoreUnused(input);
756  armnn::IgnoreUnused(output);
757  armnn::IgnoreUnused(reasonIfUnsupported);
758  return true;
759 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
+
+
+ +

◆ IsConvolution2dSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConvolution2dSupported (const TensorInfo & input,
const TensorInfo & output,
const Convolution2dDescriptor & descriptor,
const TensorInfo & weights,
const Optional< TensorInfo > & biases,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 761 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, NeonBackendModelContext::IsFastMathEnabled(), and armnn::NeonConvolution2dWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
767 {
768  bool isFastMathEnabled = false;
769 #if defined(ARMCOMPUTENEON_ENABLED)
770  if (m_ModelContextPtr)
771  {
772  if (m_ModelContextPtr.get() != nullptr)
773  {
774  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
775  if (modelOptions)
776  {
777  isFastMathEnabled = modelOptions->IsFastMathEnabled();
778  }
779  }
780  }
781 #endif
782 
783  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvolution2dWorkloadValidate,
784  reasonIfUnsupported,
785  input,
786  output,
787  descriptor,
788  weights,
789  biases,
790  isFastMathEnabled,
791  nullptr);
792 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonConvolution2dWorkloadValidate
arm_compute::Status NeonConvolution2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: NeonConvolution2dWorkload.cpp:24
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
+
+
+
+ +

◆ IsConvolution3dSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsConvolution3dSupported (const TensorInfo & input,
const TensorInfo & output,
const Convolution3dDescriptor & descriptor,
const TensorInfo & weights,
const Optional< TensorInfo > & biases,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 794 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, NeonBackendModelContext::IsFastMathEnabled(), and armnn::NeonConvolution3dWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
800 {
801  bool isFastMathEnabled = false;
802 #if defined(ARMCOMPUTENEON_ENABLED)
803  if (m_ModelContextPtr)
804  {
805  if (m_ModelContextPtr.get() != nullptr)
806  {
807  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
808  if (modelOptions)
809  {
810  isFastMathEnabled = modelOptions->IsFastMathEnabled();
811  }
812  }
813  }
814 #endif
815 
816  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvolution3dWorkloadValidate,
817  reasonIfUnsupported,
818  input,
819  output,
820  descriptor,
821  weights,
822  biases,
823  isFastMathEnabled,
824  nullptr);
825 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonConvolution3dWorkloadValidate
arm_compute::Status NeonConvolution3dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: NeonConvolution3dWorkload.cpp:24
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
+
+
+
+ +

◆ IsDepthToSpaceSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsDepthToSpaceSupported (const TensorInfo & input,
const TensorInfo & output,
const DepthToSpaceDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 827 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthToSpaceWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
831 {
832  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthToSpaceWorkloadValidate,
833  reasonIfUnsupported,
834  input,
835  output,
836  descriptor);
837 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::NeonDepthToSpaceWorkloadValidate
arm_compute::Status NeonDepthToSpaceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor)
Definition: NeonDepthToSpaceWorkload.cpp:19
+
+
+
+ +

◆ IsDepthwiseConvolutionSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsDepthwiseConvolutionSupported (const TensorInfo & input,
const TensorInfo & output,
const DepthwiseConvolution2dDescriptor & descriptor,
const TensorInfo & weights,
const Optional< TensorInfo > & biases,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 839 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthwiseConvolutionWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), TEST_SUITE(), and NeonLayerSupport::~NeonLayerSupport().

+
845 {
846  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthwiseConvolutionWorkloadValidate,
847  reasonIfUnsupported,
848  input,
849  output,
850  descriptor,
851  weights,
852  biases,
853  nullptr);
854 }
armnn::NeonDepthwiseConvolutionWorkloadValidate
arm_compute::Status NeonDepthwiseConvolutionWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, const ActivationDescriptor *activationDescriptor)
Definition: NeonDepthwiseConvolutionWorkload.cpp:29
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
+
+
+
+ +

◆ IsDequantizeSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsDequantizeSupported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 856 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDequantizeWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
859 {
860  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDequantizeWorkloadValidate,
861  reasonIfUnsupported,
862  input,
863  output);
864 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonDequantizeWorkloadValidate
arm_compute::Status NeonDequantizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonDequantizeWorkload.cpp:22
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsDilatedDepthwiseConvolutionSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsDilatedDepthwiseConvolutionSupported (const TensorInfo & input,
const TensorInfo & output,
const DepthwiseConvolution2dDescriptor & descriptor,
const TensorInfo & weights,
const Optional< TensorInfo > & biases,
Optional< std::string &> reason = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 866 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthwiseConvolutionWorkloadValidate().

+ +

Referenced by NeonLayerSupport::~NeonLayerSupport().

+
872 {
873  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthwiseConvolutionWorkloadValidate,
874  reasonIfUnsupported,
875  input,
876  output,
877  descriptor,
878  weights,
879  biases,
880  nullptr);
881 }
armnn::NeonDepthwiseConvolutionWorkloadValidate
arm_compute::Status NeonDepthwiseConvolutionWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, const ActivationDescriptor *activationDescriptor)
Definition: NeonDepthwiseConvolutionWorkload.cpp:29
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
+
+
+
+ +

◆ IsDivisionSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsDivisionSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1120 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDivisionWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1124 {
1125  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDivisionWorkloadValidate,
1126  reasonIfUnsupported,
1127  input0,
1128  input1,
1129  output,
1130  nullptr);
1131 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonDivisionWorkloadValidate
arm_compute::Status NeonDivisionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonDivisionWorkload.cpp:18
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsElementwiseUnarySupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsElementwiseUnarySupported (const TensorInfo & input,
const TensorInfo & output,
const ElementwiseUnaryDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 883 of file NeonLayerSupport.cpp.

+ +

References armnn::Abs, armnn::Exp, FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::Log, armnn::LogicalNot, ElementwiseUnaryDescriptor::m_Operation, armnn::Neg, armnn::NeonAbsWorkloadValidate(), armnn::NeonExpWorkloadValidate(), armnn::NeonLogicalNotWorkloadValidate(), armnn::NeonLogWorkloadValidate(), armnn::NeonNegWorkloadValidate(), armnn::NeonRsqrtWorkloadValidate(), armnn::NeonSinWorkloadValidate(), armnn::Rsqrt, and armnn::Sin.

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
887 {
888  switch(descriptor.m_Operation)
889  {
890  case UnaryOperation::Abs:
891  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAbsWorkloadValidate,
892  reasonIfUnsupported,
893  input,
894  output);
895  case UnaryOperation::Exp:
896  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonExpWorkloadValidate,
897  reasonIfUnsupported,
898  input,
899  output);
900  case UnaryOperation::LogicalNot:
901  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalNotWorkloadValidate,
902  reasonIfUnsupported,
903  input,
904  output);
905  case UnaryOperation::Log:
906  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogWorkloadValidate,
907  reasonIfUnsupported,
908  input,
909  output);
910  case UnaryOperation::Neg:
911  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonNegWorkloadValidate,
912  reasonIfUnsupported,
913  input,
914  output);
915  case UnaryOperation::Rsqrt:
916  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonRsqrtWorkloadValidate,
917  reasonIfUnsupported,
918  input,
919  output);
920  case UnaryOperation::Sin:
921  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSinWorkloadValidate,
922  reasonIfUnsupported,
923  input,
924  output);
925  default:
926  return false;
927  }
928 }
armnn::NeonNegWorkloadValidate
arm_compute::Status NeonNegWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonNegWorkload.cpp:17
+ +
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+ +
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+ +
armnn::NeonLogWorkloadValidate
arm_compute::Status NeonLogWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonLogWorkload.cpp:17
+ +
armnn::NeonAbsWorkloadValidate
arm_compute::Status NeonAbsWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonAbsWorkload.cpp:17
+ +
armnn::NeonExpWorkloadValidate
arm_compute::Status NeonExpWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonExpWorkload.cpp:17
+
armnn::NeonLogicalNotWorkloadValidate
arm_compute::Status NeonLogicalNotWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonLogicalNotWorkload.cpp:19
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonRsqrtWorkloadValidate
arm_compute::Status NeonRsqrtWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonRsqrtWorkload.cpp:18
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+ + +
armnn::NeonSinWorkloadValidate
arm_compute::Status NeonSinWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonSinWorkload.cpp:17
+
+
+
+ +

◆ IsFillSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsFillSupported (const TensorInfo & input,
const TensorInfo & output,
const FillDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+overridevirtual
+
+ +

Reimplemented from LayerSupportBase.

+ +

Definition at line 930 of file NeonLayerSupport.cpp.

+ +

References armnn::IgnoreUnused().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
934 {
935  armnn::IgnoreUnused(input);
936  armnn::IgnoreUnused(output);
937  armnn::IgnoreUnused(descriptor);
938 
939  return IsNeonBackendSupported(reasonIfUnsupported);
940 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
+
+
+ +

◆ IsFloorSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsFloorSupported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 942 of file NeonLayerSupport.cpp.

+ +

References TensorInfo::GetDataType(), armnn::IgnoreUnused(), and armnn::IsSupportedForDataTypeGeneric().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
945 {
946  armnn::IgnoreUnused(output);
947  return IsNeonBackendSupported(reasonIfUnsupported) &&
948  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
949  input.GetDataType(),
950  &FalseFuncF16<>,
951  &TrueFunc<>,
952  &FalseFuncU8<>,
953  &FalseFuncI32<>,
954  &FalseFuncU8<>);
955 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::TensorInfo::GetDataType
DataType GetDataType() const
Definition: Tensor.hpp:198
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string &> reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27
+
+
+
+ +

◆ IsFullyConnectedSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsFullyConnectedSupported (const TensorInfo & input,
const TensorInfo & output,
const TensorInfo & weights,
const TensorInfo & biases,
const FullyConnectedDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 957 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonFullyConnectedWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
963 {
964  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonFullyConnectedWorkloadValidate,
965  reasonIfUnsupported,
966  input,
967  output,
968  weights,
969  biases,
970  descriptor,
971  nullptr);
972 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonFullyConnectedWorkloadValidate
arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const Optional< TensorInfo > &biases, const FullyConnectedDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: NeonFullyConnectedWorkload.cpp:24
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
+
+
+
+ +

◆ IsGatherSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsGatherSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
const GatherDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported 
) const
+ 		+override
+
+ +

Definition at line 974 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonGatherWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
979 {
980  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonGatherWorkloadValidate,
981  reasonIfUnsupported,
982  input0,
983  input1,
984  output,
985  descriptor);
986 }
armnn::NeonGatherWorkloadValidate
arm_compute::Status NeonGatherWorkloadValidate(const TensorInfo &input, const TensorInfo &indices, const TensorInfo &output, const GatherDescriptor &descriptor)
Definition: NeonGatherWorkload.cpp:13
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsInputSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool IsInputSupported (const TensorInfo & input,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 988 of file NeonLayerSupport.cpp.

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
990 {
991  return IsNeonBackendSupported(reasonIfUnsupported, input);
992 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
+
+
+ +

◆ IsInstanceNormalizationSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsInstanceNormalizationSupported (const TensorInfo & input,
const TensorInfo & output,
const InstanceNormalizationDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 994 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonInstanceNormalizationWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
998 {
999  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonInstanceNormalizationWorkloadValidate,
1000  reasonIfUnsupported,
1001  input,
1002  output,
1003  descriptor);
1004 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonInstanceNormalizationWorkloadValidate
arm_compute::Status NeonInstanceNormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor)
Definition: NeonInstanceNormalizationWorkload.cpp:19
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsL2NormalizationSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsL2NormalizationSupported (const TensorInfo & input,
const TensorInfo & output,
const L2NormalizationDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1006 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonL2NormalizationWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1010 {
1011  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonL2NormalizationWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
1012 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonL2NormalizationWorkloadValidate
arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor)
Definition: NeonL2NormalizationFloatWorkload.cpp:19
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsLayerSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsLayerSupported (const LayerType & type,
const std::vector< TensorInfo > & infos,
const BaseDescriptor & descriptor,
const Optional< LstmInputParamsInfo > & lstmParamsInfo,
const Optional< QuantizedLstmInputParamsInfo > & quantizedLstmParamsInfo,
Optional< std::string &> reasonIfUnsupported 
) const
+ 		+overridevirtual
+
+ +

Reimplemented from LayerSupportBase.

+ +

Definition at line 148 of file NeonLayerSupport.cpp.

+ +

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Cast, armnn::ChannelShuffle, armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertBf16ToFp32, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToBf16, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, ILayerSupport::descriptor, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseUnary, armnn::Fill, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::Input, armnn::InstanceNormalization, NeonLayerSupport::IsActivationSupported(), NeonLayerSupport::IsAdditionSupported(), NeonLayerSupport::IsArgMinMaxSupported(), NeonLayerSupport::IsBatchNormalizationSupported(), NeonLayerSupport::IsBatchToSpaceNdSupported(), NeonLayerSupport::IsCastSupported(), NeonLayerSupport::IsChannelShuffleSupported(), NeonLayerSupport::IsComparisonSupported(), NeonLayerSupport::IsConcatSupported(), NeonLayerSupport::IsConstantSupported(), NeonLayerSupport::IsConvertBf16ToFp32Supported(), NeonLayerSupport::IsConvertFp16ToFp32Supported(), NeonLayerSupport::IsConvertFp32ToBf16Supported(), NeonLayerSupport::IsConvertFp32ToFp16Supported(), NeonLayerSupport::IsConvolution2dSupported(), NeonLayerSupport::IsConvolution3dSupported(), NeonLayerSupport::IsDepthToSpaceSupported(), NeonLayerSupport::IsDepthwiseConvolutionSupported(), NeonLayerSupport::IsDequantizeSupported(), LayerSupportBase::IsDetectionPostProcessSupported(), NeonLayerSupport::IsDivisionSupported(), NeonLayerSupport::IsElementwiseUnarySupported(), NeonLayerSupport::IsFillSupported(), NeonLayerSupport::IsFloorSupported(), NeonLayerSupport::IsFullyConnectedSupported(), NeonLayerSupport::IsGatherSupported(), NeonLayerSupport::IsInputSupported(), NeonLayerSupport::IsInstanceNormalizationSupported(), NeonLayerSupport::IsL2NormalizationSupported(), NeonLayerSupport::IsLogicalBinarySupported(), NeonLayerSupport::IsLogSoftmaxSupported(), NeonLayerSupport::IsLstmSupported(), NeonLayerSupport::IsMaximumSupported(), NeonLayerSupport::IsMeanSupported(), LayerSupportBase::IsMemCopySupported(), LayerSupportBase::IsMemImportSupported(), LayerSupportBase::IsMergeSupported(), NeonLayerSupport::IsMinimumSupported(), NeonLayerSupport::IsMultiplicationSupported(), NeonLayerSupport::IsNormalizationSupported(), NeonLayerSupport::IsOutputSupported(), NeonLayerSupport::IsPadSupported(), NeonLayerSupport::IsPermuteSupported(), NeonLayerSupport::IsPooling2dSupported(), NeonLayerSupport::IsPreluSupported(), NeonLayerSupport::IsQLstmSupported(), NeonLayerSupport::IsQuantizedLstmSupported(), NeonLayerSupport::IsQuantizeSupported(), NeonLayerSupport::IsReduceSupported(), NeonLayerSupport::IsReshapeSupported(), NeonLayerSupport::IsResizeSupported(), LayerSupportBase::IsShapeSupported(), NeonLayerSupport::IsSliceSupported(), NeonLayerSupport::IsSoftmaxSupported(), NeonLayerSupport::IsSpaceToBatchNdSupported(), NeonLayerSupport::IsSpaceToDepthSupported(), NeonLayerSupport::IsSplitterSupported(), NeonLayerSupport::IsStackSupported(), NeonLayerSupport::IsStridedSliceSupported(), NeonLayerSupport::IsSubtractionSupported(), NeonLayerSupport::IsTransposeConvolution2dSupported(), NeonLayerSupport::IsTransposeSupported(), armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Map, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Merge, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Prelu, armnn::QLstm, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, ILayerSupport::reasonIfUnsupported, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::Shape, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StridedSlice, armnn::Subtraction, armnn::Transpose, armnn::TransposeConvolution2d, armnn::Unmap, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

+ +

Referenced by NeonLayerSupport::~NeonLayerSupport().

+
154 {
155  switch (type)
156  {
157  case LayerType::Activation:
158  return IsActivationSupported(infos[0],
159  infos[1],
160  *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
161  reasonIfUnsupported);
162  case LayerType::Addition:
163  return IsAdditionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
164  case LayerType::ArgMinMax:
165  return IsArgMinMaxSupported(infos[0],
166  infos[1],
167  *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
168  reasonIfUnsupported);
169  case LayerType::BatchNormalization:
170  return IsBatchNormalizationSupported(infos[0],
171  infos[1],
172  infos[2],
173  infos[3],
174  infos[4],
175  infos[5],
176  *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
177  (&descriptor)),
178  reasonIfUnsupported);
179  case LayerType::BatchToSpaceNd:
180  return IsBatchToSpaceNdSupported(infos[0],
181  infos[1],
182  *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
183  reasonIfUnsupported);
184  case LayerType::Comparison:
185  return IsComparisonSupported(infos[0],
186  infos[1],
187  infos[2],
188  *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
189  reasonIfUnsupported);
190  case LayerType::Concat:
191  {
192  std::vector<const TensorInfo*> inputInfos;
193  for (uint32_t i = 0; i < (infos.size() - 1); i++)
194  {
195  inputInfos.push_back(&infos[i]);
196  }
197  return IsConcatSupported(inputInfos,
198  infos[infos.size() - 1],
199  *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
200  reasonIfUnsupported);
201  }
202  case LayerType::Constant:
203  return IsConstantSupported(infos[0], reasonIfUnsupported);
204  case LayerType::ConvertBf16ToFp32:
205  return IsConvertBf16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
206  case LayerType::ConvertFp16ToFp32:
207  return IsConvertFp16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
208  case LayerType::ConvertFp32ToBf16:
209  return IsConvertFp32ToBf16Supported(infos[0], infos[1], reasonIfUnsupported);
210  case LayerType::ConvertFp32ToFp16:
211  return IsConvertFp32ToFp16Supported(infos[0], infos[1], reasonIfUnsupported);
212  case LayerType::Convolution2d:
213  {
214  if (infos.size() != 4)
215  {
216  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
217  "TensorInfos should be of format: {input, output, weights, biases}.");
218  }
219 
220  auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
221  if (infos[3] == TensorInfo())
222  {
223  return IsConvolution2dSupported(infos[0],
224  infos[1],
225  desc,
226  infos[2],
227  EmptyOptional(),
228  reasonIfUnsupported);
229  }
230  else
231  {
232  return IsConvolution2dSupported(infos[0],
233  infos[1],
234  desc,
235  infos[2],
236  infos[3],
237  reasonIfUnsupported);
238  }
239  }
240  case LayerType::DepthToSpace:
241  return IsDepthToSpaceSupported(infos[0],
242  infos[1],
243  *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
244  reasonIfUnsupported);
245  case LayerType::DepthwiseConvolution2d:
246  {
247  if (infos.size() != 4)
248  {
249  throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d TensorInfos. "
250  "TensorInfos should be of format: {input, output, weights, biases}.");
251  }
252 
253  auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
254  if (infos[3] == TensorInfo())
255  {
256  return IsDepthwiseConvolutionSupported(infos[0],
257  infos[1],
258  desc,
259  infos[2],
260  EmptyOptional(),
261  reasonIfUnsupported);
262  }
263  else
264  {
265  return IsDepthwiseConvolutionSupported(infos[0],
266  infos[1],
267  desc,
268  infos[2],
269  infos[3],
270  reasonIfUnsupported);
271  }
272  }
273  case LayerType::Dequantize:
274  return IsDequantizeSupported(infos[0], infos[1], reasonIfUnsupported);
275  case LayerType::Division:
276  return IsDivisionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
277  case LayerType::ElementwiseUnary:
278  return IsElementwiseUnarySupported(infos[0],
279  infos[1],
280  *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor)),
281  reasonIfUnsupported);
282  case LayerType::Fill:
283  return IsFillSupported(infos[0],
284  infos[1],
285  *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
286  reasonIfUnsupported);
287  case LayerType::Floor:
288  return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
289  case LayerType::FullyConnected:
290  return IsFullyConnectedSupported(infos[0],
291  infos[1],
292  infos[2],
293  infos[3],
294  *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
295  reasonIfUnsupported);
296  case LayerType::Gather:
297  return IsGatherSupported(infos[0],
298  infos[1],
299  infos[2],
300  *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
301  reasonIfUnsupported);
302  case LayerType::Input:
303  return IsInputSupported(infos[0], reasonIfUnsupported);
304  case LayerType::InstanceNormalization:
305  return IsInstanceNormalizationSupported(infos[0],
306  infos[1],
307  *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
308  (&descriptor)),
309  reasonIfUnsupported);
310  case LayerType::L2Normalization:
311  return IsL2NormalizationSupported(infos[0],
312  infos[1],
313  *(PolymorphicDowncast<const L2NormalizationDescriptor*>(&descriptor)),
314  reasonIfUnsupported);
315  case LayerType::LogicalBinary:
316  return IsLogicalBinarySupported(infos[0],
317  infos[1],
318  infos[2],
319  *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
320  reasonIfUnsupported);
321  case LayerType::LogSoftmax:
322  return IsLogSoftmaxSupported(infos[0],
323  infos[1],
324  *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
325  reasonIfUnsupported);
326  case LayerType::Lstm:
327  return IsLstmSupported(infos[0],
328  infos[1],
329  infos[2],
330  infos[3],
331  infos[4],
332  infos[5],
333  infos[6],
334  *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
335  lstmParamsInfo.value(),
336  reasonIfUnsupported);
337  case LayerType::QLstm:
338  return IsQLstmSupported(infos[0],
339  infos[1],
340  infos[2],
341  infos[3],
342  infos[4],
343  infos[5],
344  *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
345  lstmParamsInfo.value(),
346  reasonIfUnsupported);
347  case LayerType::Maximum:
348  return IsMaximumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
349  case LayerType::Mean:
350  return IsMeanSupported(infos[0],
351  infos[1],
352  *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
353  reasonIfUnsupported);
354  case LayerType::Minimum:
355  return IsMinimumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
356  case LayerType::Multiplication:
357  return IsMultiplicationSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
358  case LayerType::Normalization:
359  return IsNormalizationSupported(infos[0],
360  infos[1],
361  *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
362  reasonIfUnsupported);
363  case LayerType::Output:
364  return IsOutputSupported(infos[0], reasonIfUnsupported);
365  case LayerType::Pad:
366  return IsPadSupported(infos[0],
367  infos[1],
368  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
369  reasonIfUnsupported);
370  case LayerType::Permute:
371  return IsPermuteSupported(infos[0],
372  infos[1],
373  *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
374  reasonIfUnsupported);
375  case LayerType::Pooling2d:
376  return IsPooling2dSupported(infos[0],
377  infos[1],
378  *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
379  reasonIfUnsupported);
380  case LayerType::Prelu:
381  return IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
382  case LayerType::Quantize:
383  return IsQuantizeSupported(infos[0], infos[1], reasonIfUnsupported);
384  case LayerType::QuantizedLstm:
385  return IsQuantizedLstmSupported(infos[0],
386  infos[1],
387  infos[2],
388  infos[3],
389  infos[4],
390  quantizedLstmParamsInfo.value(),
391  reasonIfUnsupported);
392  case LayerType::Reshape:
393  return IsReshapeSupported(infos[0],
394  infos[1],
395  *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
396  reasonIfUnsupported);
397  case LayerType::Resize:
398  return IsResizeSupported(infos[0],
399  infos[1],
400  *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
401  reasonIfUnsupported);
402  case LayerType::Reduce:
403  return IsReduceSupported(infos[0],
404  infos[1],
405  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
406  reasonIfUnsupported);
407  case LayerType::Slice:
408  return IsSliceSupported(infos[0],
409  infos[1],
410  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
411  reasonIfUnsupported);
412  case LayerType::Softmax:
413  return IsSoftmaxSupported(infos[0],
414  infos[1],
415  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
416  reasonIfUnsupported);
417  case LayerType::SpaceToBatchNd:
418  return IsSpaceToBatchNdSupported(infos[0],
419  infos[1],
420  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
421  reasonIfUnsupported);
422  case LayerType::SpaceToDepth:
423  return IsSpaceToDepthSupported(infos[0],
424  infos[1],
425  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
426  reasonIfUnsupported);
427  case LayerType::Splitter:
428  {
429  std::vector<TensorInfo> outputInfos;
430  for (uint32_t i = 1; i < infos.size(); i++)
431  {
432  outputInfos.push_back(infos[i]);
433  }
434  return IsSplitterSupported(infos[0],
435  {outputInfos.begin(), outputInfos.end()},
436  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
437  reasonIfUnsupported);
438  }
439  case LayerType::Stack:
440  {
441  std::vector<const TensorInfo*> inputInfos;
442  for (uint32_t i = 0; i < infos.size() - 1; i++)
443  {
444  inputInfos.push_back(&infos[i]);
445  }
446  return IsStackSupported(inputInfos,
447  infos[infos.size() - 1],
448  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
449  reasonIfUnsupported);
450  }
451  case LayerType::StridedSlice:
452  return IsStridedSliceSupported(infos[0],
453  infos[1],
454  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
455  reasonIfUnsupported);
456  case LayerType::Subtraction:
457  return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
458  case LayerType::Transpose:
459  return IsTransposeSupported(infos[0],
460  infos[1],
461  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
462  reasonIfUnsupported);
463  case LayerType::TransposeConvolution2d:
464  {
465  if (infos.size() != 4)
466  {
467  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
468  "TensorInfos should be of format: {input, output, weights, biases}.");
469  }
470 
471  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
472  if (infos[3] == TensorInfo())
473  {
474  return IsTransposeConvolution2dSupported(infos[0],
475  infos[1],
476  desc,
477  infos[2],
478  EmptyOptional(),
479  reasonIfUnsupported);
480  }
481  else
482  {
483  return IsTransposeConvolution2dSupported(infos[0],
484  infos[1],
485  desc,
486  infos[2],
487  infos[3],
488  reasonIfUnsupported);
489  }
490  }
491  case LayerType::Cast:
492  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
493  case LayerType::ChannelShuffle:
494  return IsChannelShuffleSupported(infos[0],
495  infos[1],
496  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
497  reasonIfUnsupported);
498  case LayerType::Convolution3d:
499  {
500  if (infos.size() != 4)
501  {
502  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
503  "TensorInfos should be of format: {input, output, weights, biases}.");
504  }
505 
506  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
507  if (infos[3] == TensorInfo())
508  {
509  return IsConvolution3dSupported(infos[0],
510  infos[1],
511  desc,
512  infos[2],
513  EmptyOptional(),
514  reasonIfUnsupported);
515  }
516  else
517  {
518  return IsConvolution3dSupported(infos[0],
519  infos[1],
520  desc,
521  infos[2],
522  infos[3],
523  reasonIfUnsupported);
524  }
525  }
526  case LayerType::MemCopy:
527  return LayerSupportBase::IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
528  case LayerType::MemImport:
529  return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
530  case LayerType::DetectionPostProcess:
531  {
532  auto desc = *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>(&descriptor));
533  return LayerSupportBase::IsDetectionPostProcessSupported(infos[0],
534  infos[1],
535  infos[2],
536  infos[3],
537  infos[4],
538  infos[5],
539  infos[6],
540  desc,
541  reasonIfUnsupported);
542  }
543  case LayerType::Map:
544  return true;
545  case LayerType::Unmap:
546  return true;
547  case LayerType::Merge:
548  return LayerSupportBase::IsMergeSupported(infos[0],
549  infos[1],
550  infos[2],
551  reasonIfUnsupported);
552  case LayerType::Rank:
553  return true;
554  case LayerType::Shape:
555  return LayerSupportBase::IsShapeSupported(infos[0],
556  infos[1],
557  reasonIfUnsupported);
558  default:
559  // layers not supported in neon by default:
560  // debug, fakequantization, precompiled, standin,
561  // switch, unidirectionalsequencelstm, pooling3d
562  return false;
563  }
564 }
+ + +
armnn::NeonLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:674
+
armnn::NeonLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1286
+
armnn::NeonLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1298
+ +
armnn::NeonLayerSupport::IsConvolution2dSupported
bool IsConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:761
+
armnn::NeonLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:751
+ + +
armnn::NeonLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported) const override
Definition: NeonLayerSupport.cpp:974
+
armnn::LayerSupportBase::IsDetectionPostProcessSupported
bool 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=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:248
+
armnn::LayerSupportBase::IsMemImportSupported
bool IsMemImportSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:412
+
armnn::NeonLayerSupport::IsQuantizedLstmSupported
bool IsQuantizedLstmSupported(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1232
+ +
armnn::NeonLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:827
+
armnn::NeonLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1006
+
armnn::NeonLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:637
+
armnn::NeonLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1375
+
armnn::NeonLayerSupport::IsConvertFp32ToBf16Supported
bool IsConvertFp32ToBf16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:741
+
armnn::NeonLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:579
+ + + + + +
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+ +
armnn::LayerSupportBase::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:566
+ + + + +
armnn::NeonLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:713
+
armnn::NeonLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1151
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+ + + +
armnn::NeonLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1171
+
armnn::NeonLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:566
+ +
armnn::NeonLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1107
+ + + +
armnn::NeonLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:659
+ + +
armnn::NeonLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported) const override
Definition: NeonLayerSupport.cpp:1014
+ +
armnn::NeonLayerSupport::IsConvolution3dSupported
bool IsConvolution3dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:794
+ + +
armnn::NeonLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:930
+
armnn::NeonLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:988
+
armnn::NeonLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1363
+
armnn::NeonLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1095
+
armnn::NeonLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1179
+
armnn::NeonLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1145
+
armnn::NeonLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:994
+ + + +
armnn::NeonLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1133
+
armnn::NeonLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:883
+ + + +
armnn::NeonLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1120
+ + +
armnn::NeonLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:942
+ +
armnn::LayerSupportBase::IsMergeSupported
bool IsMergeSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:419
+ +
armnn::NeonLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1039
+ +
armnn::NeonLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1274
+ +
armnn::LayerSupportBase::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:405
+
armnn::NeonLayerSupport::IsTransposeConvolution2dSupported
bool IsTransposeConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1400
+
armnn::NeonLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1330
+ +
armnn::NeonLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1262
+ +
armnn::NeonLayerSupport::IsBatchNormalizationSupported
bool 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=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:604
+ + +
armnn::NeonLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1222
+ + + +
armnn::NeonLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:731
+ +
armnn::NeonLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1387
+
armnn::NeonLayerSupport::IsLstmSupported
bool 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=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1047
+ +
armnn::NeonLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1306
+ + + +
armnn::NeonLayerSupport::IsDepthwiseConvolutionSupported
bool IsDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:839
+ + +
armnn::NeonLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:592
+
armnn::NeonLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1318
+
armnn::NeonLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1416
+ +
armnn::NeonLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1071
+ + +
armnn::NeonLayerSupport::IsFullyConnectedSupported
bool IsFullyConnectedSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:957
+
armnn::NeonLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1083
+
armnn::NeonLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:625
+ + +
armnn::NeonLayerSupport::IsQLstmSupported
bool 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=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1187
+
armnn::NeonLayerSupport::IsConvertBf16ToFp32Supported
bool IsConvertBf16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:721
+ + + +
armnn::NeonLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1250
+
armnn::NeonLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:856
+ +
armnn::NeonLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:647
+ +
armnn::NeonLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1163
+
+
+
+ +

◆ IsLogicalBinarySupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsLogicalBinarySupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
const LogicalBinaryDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported 
) const
+ 		+override
+
+ +

Definition at line 1014 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::LogicalAnd, armnn::LogicalOr, LogicalBinaryDescriptor::m_Operation, armnn::NeonLogicalAndWorkloadValidate(), and armnn::NeonLogicalOrWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1019 {
1020  switch(descriptor.m_Operation)
1021  {
1022  case LogicalBinaryOperation::LogicalAnd:
1023  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalAndWorkloadValidate,
1024  reasonIfUnsupported,
1025  input0,
1026  input1,
1027  output);
1028  case LogicalBinaryOperation::LogicalOr:
1029  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalOrWorkloadValidate,
1030  reasonIfUnsupported,
1031  input0,
1032  input1,
1033  output);
1034  default:
1035  return false;
1036  }
1037 }
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonLogicalAndWorkloadValidate
arm_compute::Status NeonLogicalAndWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: NeonLogicalAndWorkload.cpp:18
+
armnn::NeonLogicalOrWorkloadValidate
arm_compute::Status NeonLogicalOrWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: NeonLogicalOrWorkload.cpp:18
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+ +
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsLogSoftmaxSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsLogSoftmaxSupported (const TensorInfo & input,
const TensorInfo & output,
const LogSoftmaxDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1039 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonLogSoftmaxWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1043 {
1044  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogSoftmaxWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
1045 }
armnn::NeonLogSoftmaxWorkloadValidate
arm_compute::Status NeonLogSoftmaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor)
Definition: NeonLogSoftmaxWorkload.cpp:19
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsLstmSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool 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 = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1047 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonLstmFloatWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1057 {
1058  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLstmFloatWorkloadValidate,
1059  reasonIfUnsupported,
1060  input,
1061  outputStateIn,
1062  cellStateIn,
1063  scratchBuffer,
1064  outputStateOut,
1065  cellStateOut,
1066  output,
1067  descriptor,
1068  paramsInfo);
1069 }
armnn::ILayerSupport::paramsInfo
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo & paramsInfo
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonLstmFloatWorkloadValidate
arm_compute::Status NeonLstmFloatWorkloadValidate(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)
Definition: NeonLstmFloatWorkload.cpp:280
+
armnn::ILayerSupport::outputStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::outputStateIn
const TensorInfo & outputStateIn
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::cellStateIn
const TensorInfo const TensorInfo & cellStateIn
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::scratchBuffer
const TensorInfo const TensorInfo const TensorInfo & scratchBuffer
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::cellStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
Definition: ILayerSupport.hpp:298
+
+
+
+ +

◆ IsMaximumSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsMaximumSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1071 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMaximumWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1075 {
1076  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMaximumWorkloadValidate,
1077  reasonIfUnsupported,
1078  input0,
1079  input1,
1080  output);
1081 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonMaximumWorkloadValidate
arm_compute::Status NeonMaximumWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: NeonMaximumWorkload.cpp:14
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsMeanSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsMeanSupported (const TensorInfo & input,
const TensorInfo & output,
const MeanDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1083 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMeanWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1087 {
1088  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMeanWorkloadValidate,
1089  reasonIfUnsupported,
1090  input,
1091  output,
1092  descriptor);
1093 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonMeanWorkloadValidate
arm_compute::Status NeonMeanWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor)
Definition: NeonMeanWorkload.cpp:18
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsMinimumSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsMinimumSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1095 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMinimumWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1099 {
1100  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMinimumWorkloadValidate,
1101  reasonIfUnsupported,
1102  input0,
1103  input1,
1104  output);
1105 }
armnn::NeonMinimumWorkloadValidate
arm_compute::Status NeonMinimumWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Validate function for validating the inputs and output.
Definition: NeonMinimumWorkload.cpp:15
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsMultiplicationSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsMultiplicationSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1107 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMultiplicationWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1111 {
1112  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMultiplicationWorkloadValidate,
1113  reasonIfUnsupported,
1114  input0,
1115  input1,
1116  output,
1117  nullptr);
1118 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::NeonMultiplicationWorkloadValidate
arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonMultiplicationWorkload.cpp:19
+
+
+
+ +

◆ IsNormalizationSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsNormalizationSupported (const TensorInfo & input,
const TensorInfo & output,
const NormalizationDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1133 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonNormalizationWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1137 {
1138  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonNormalizationWorkloadValidate,
1139  reasonIfUnsupported,
1140  input,
1141  output,
1142  descriptor);
1143 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonNormalizationWorkloadValidate
arm_compute::Status NeonNormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor)
Definition: NeonNormalizationFloatWorkload.cpp:49
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsOutputSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool IsOutputSupported (const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1145 of file NeonLayerSupport.cpp.

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1147 {
1148  return IsNeonBackendSupported(reasonIfUnsupported, output);
1149 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
+
+
+ +

◆ IsPadSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsPadSupported (const TensorInfo & input,
const TensorInfo & output,
const PadDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1151 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPadWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1155 {
1156  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPadWorkloadValidate,
1157  reasonIfUnsupported,
1158  input,
1159  output,
1160  descriptor);
1161 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonPadWorkloadValidate
arm_compute::Status NeonPadWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor)
Definition: NeonPadWorkload.cpp:59
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsPermuteSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsPermuteSupported (const TensorInfo & input,
const TensorInfo & output,
const PermuteDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1163 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPermuteWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1167 {
1168  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPermuteWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
1169 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonPermuteWorkloadValidate
arm_compute::Status NeonPermuteWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor)
Definition: NeonPermuteWorkload.cpp:15
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsPooling2dSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsPooling2dSupported (const TensorInfo & input,
const TensorInfo & output,
const Pooling2dDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1171 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPooling2dWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1175 {
1176  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPooling2dWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
1177 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::NeonPooling2dWorkloadValidate
arm_compute::Status NeonPooling2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor)
Definition: NeonPooling2dWorkload.cpp:22
+
+
+
+ +

◆ IsPreluSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsPreluSupported (const TensorInfo & input,
const TensorInfo & alpha,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1179 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPreluWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1183 {
1184  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPreluWorkloadValidate, reasonIfUnsupported, input, alpha, output);
1185 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::alpha
const TensorInfo & alpha
Definition: ILayerSupport.hpp:404
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonPreluWorkloadValidate
arm_compute::Status NeonPreluWorkloadValidate(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output)
Definition: NeonPreluWorkload.cpp:17
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsQLstmSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool 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 = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1187 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, TensorInfo::GetDataType(), armnn::NeonQLstmWorkloadValidate(), armnn::QAsymmS8, and armnn::QSymmS16.

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1196 {
1197  // Check required here in order to pass IsLayerSupported for datatypes tests
1198  if (input.GetDataType() == armnn::DataType::QAsymmS8 &&
1199  previousOutputIn.GetDataType() == armnn::DataType::QAsymmS8 &&
1200  previousCellStateIn.GetDataType() == armnn::DataType::QSymmS16 &&
1201  outputStateOut.GetDataType() == armnn::DataType::QAsymmS8 &&
1202  cellStateOut.GetDataType() == armnn::DataType::QSymmS16 &&
1203  output.GetDataType() == armnn::DataType::QAsymmS8)
1204  {
1205  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQLstmWorkloadValidate,
1206  reasonIfUnsupported,
1207  input,
1208  previousCellStateIn,
1209  previousOutputIn,
1210  cellStateOut,
1211  outputStateOut,
1212  output,
1213  descriptor,
1214  paramsInfo);
1215  }
1216  else
1217  {
1218  return false;
1219  }
1220 }
armnn::ILayerSupport::paramsInfo
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo & paramsInfo
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonQLstmWorkloadValidate
arm_compute::Status NeonQLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: NeonQLstmWorkload.cpp:243
+ +
armnn::ILayerSupport::outputStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
Definition: ILayerSupport.hpp:298
+ +
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::previousCellStateIn
const TensorInfo const TensorInfo & previousCellStateIn
Definition: ILayerSupport.hpp:417
+
armnn::TensorInfo::GetDataType
DataType GetDataType() const
Definition: Tensor.hpp:198
+
armnn::ILayerSupport::previousOutputIn
const TensorInfo & previousOutputIn
Definition: ILayerSupport.hpp:417
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::cellStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
Definition: ILayerSupport.hpp:298
+
+
+
+ +

◆ IsQuantizedLstmSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsQuantizedLstmSupported (const TensorInfo & input,
const TensorInfo & cellStateIn,
const TensorInfo & outputStateIn,
const TensorInfo & cellStateOut,
const TensorInfo & outputStateOut,
const QuantizedLstmInputParamsInfo & paramsInfo,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1232 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonQuantizedLstmWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1239 {
1240  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQuantizedLstmWorkloadValidate,
1241  reasonIfUnsupported,
1242  input,
1243  cellStateIn,
1244  outputStateIn,
1245  cellStateOut,
1246  outputStateOut,
1247  paramsInfo);
1248 }
armnn::ILayerSupport::paramsInfo
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo & paramsInfo
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::outputStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
Definition: ILayerSupport.hpp:298
+
armnn::ILayerSupport::outputStateIn
const TensorInfo & outputStateIn
Definition: ILayerSupport.hpp:298
+
armnn::NeonQuantizedLstmWorkloadValidate
arm_compute::Status NeonQuantizedLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const QuantizedLstmInputParamsInfo &paramsInfo)
Definition: NeonQuantizedLstmWorkload.cpp:131
+
armnn::ILayerSupport::cellStateIn
const TensorInfo const TensorInfo & cellStateIn
Definition: ILayerSupport.hpp:298
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::cellStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
Definition: ILayerSupport.hpp:298
+
+
+
+ +

◆ IsQuantizeSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool IsQuantizeSupported (const TensorInfo & input,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1222 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonQuantizeWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1225 {
1226  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQuantizeWorkloadValidate,
1227  reasonIfUnsupported,
1228  input,
1229  output);
1230 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonQuantizeWorkloadValidate
arm_compute::Status NeonQuantizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonQuantizeWorkload.cpp:18
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsReduceSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsReduceSupported (const TensorInfo & input,
const TensorInfo & output,
const ReduceDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1250 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonReduceWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1254 {
1255  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonReduceWorkloadValidate,
1256  reasonIfUnsupported,
1257  input,
1258  output,
1259  descriptor);
1260 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonReduceWorkloadValidate
arm_compute::Status NeonReduceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor)
Definition: NeonReduceWorkload.cpp:19
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsReshapeSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsReshapeSupported (const TensorInfo & input,
const TensorInfo & output,
const ReshapeDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1262 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::IgnoreUnused(), and armnn::NeonReshapeWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1266 {
1267  armnn::IgnoreUnused(descriptor);
1268  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonReshapeWorkloadValidate,
1269  reasonIfUnsupported,
1270  input,
1271  output);
1272 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonReshapeWorkloadValidate
arm_compute::Status NeonReshapeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonReshapeWorkload.cpp:17
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsResizeSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsResizeSupported (const TensorInfo & input,
const TensorInfo & output,
const ResizeDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1274 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonResizeWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1278 {
1279  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonResizeWorkloadValidate,
1280  reasonIfUnsupported,
1281  input,
1282  output,
1283  descriptor);
1284 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::NeonResizeWorkloadValidate
arm_compute::Status NeonResizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor)
Definition: NeonResizeWorkload.cpp:22
+
+
+
+ +

◆ IsSliceSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsSliceSupported (const TensorInfo & input,
const TensorInfo & output,
const SliceDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1286 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSliceWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1290 {
1291  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSliceWorkloadValidate,
1292  reasonIfUnsupported,
1293  input,
1294  output,
1295  descriptor);
1296 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonSliceWorkloadValidate
arm_compute::Status NeonSliceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor)
Definition: NeonSliceWorkload.cpp:21
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsSoftmaxSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsSoftmaxSupported (const TensorInfo & input,
const TensorInfo & output,
const SoftmaxDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1298 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSoftmaxWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1302 {
1303  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSoftmaxWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
1304 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonSoftmaxWorkloadValidate
arm_compute::Status NeonSoftmaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor)
Definition: NeonSoftmaxWorkload.cpp:19
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsSpaceToBatchNdSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsSpaceToBatchNdSupported (const TensorInfo & input,
const TensorInfo & output,
const SpaceToBatchNdDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1306 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSpaceToBatchNdWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1310 {
1311  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSpaceToBatchNdWorkloadValidate,
1312  reasonIfUnsupported,
1313  input,
1314  output,
1315  descriptor);
1316 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonSpaceToBatchNdWorkloadValidate
arm_compute::Status NeonSpaceToBatchNdWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor)
Definition: NeonSpaceToBatchNdWorkload.cpp:20
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsSpaceToDepthSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsSpaceToDepthSupported (const TensorInfo & input,
const TensorInfo & output,
const SpaceToDepthDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1318 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSpaceToDepthWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1322 {
1323  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSpaceToDepthWorkloadValidate,
1324  reasonIfUnsupported,
1325  input,
1326  output,
1327  descriptor);
1328 }
armnn::NeonSpaceToDepthWorkloadValidate
arm_compute::Status NeonSpaceToDepthWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor)
Definition: NeonSpaceToDepthWorkload.cpp:19
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsSplitterSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsSplitterSupported (const TensorInfo & input,
const std::vector< std::reference_wrapper< TensorInfo >> & outputs,
const ViewsDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1330 of file NeonLayerSupport.cpp.

+ +

References armnn::ComputeSplitAxis(), FORWARD_WORKLOAD_VALIDATE_FUNC, ViewsDescriptor::GetNumDimensions(), TensorInfo::GetShape(), armnn::IgnoreUnused(), TensorInfo::IsTypeSpaceMatch(), armnn::NeonSplitterWorkloadValidate(), ILayerSupport::output, ILayerSupport::outputs, and armnn::SetValueChecked().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1334 {
1335 #if defined(ARMCOMPUTENEON_ENABLED)
1336  // Split along the last dimension, cannot use sub-tensors
1337  // as width and height of the sub-tensors do not match
1338  // the width and height of the parent tensor
1339  // in case of input with more than 2D.
1340  std::set<unsigned int> splitAxis = ComputeSplitAxis(descriptor, input.GetShape());
1341  if (descriptor.GetNumDimensions() > 2 && splitAxis.size() == 1 &&
1342  *splitAxis.begin() == descriptor.GetNumDimensions() - 1 )
1343  {
1344  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSplitterWorkloadValidate,
1345  reasonIfUnsupported,
1346  input,
1347  outputs,
1348  *splitAxis.begin());
1349  }
1350 #endif
1351  IgnoreUnused(descriptor);
1352  for (auto output : outputs)
1353  {
1354  if (!input.IsTypeSpaceMatch(output)) // Cannot use sub-tensors if the types are not same space
1355  {
1356  SetValueChecked(reasonIfUnsupported, "Neon Splitter: Types and quantization parameters must match.");
1357  return false;
1358  }
1359  }
1360  return true;
1361 }
armnn::NeonSplitterWorkloadValidate
arm_compute::Status NeonSplitterWorkloadValidate(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, unsigned int splitAxis)
Definition: NeonSplitterWorkload.cpp:32
+
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:191
+
armnn::ILayerSupport::outputs
const std::vector< std::reference_wrapper< TensorInfo > > & outputs
Definition: ILayerSupport.hpp:500
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ComputeSplitAxis
std::set< unsigned int > ComputeSplitAxis(const armnn::SplitterDescriptor &desc, const TensorShape &input)
Definition: ArmComputeUtils.hpp:220
+
armnn::SetValueChecked
void SetValueChecked(Optional< T &> optionalRef, V &&val)
Definition: LayerSupportCommon.hpp:17
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::TensorInfo::GetNumDimensions
unsigned int GetNumDimensions() const
Definition: Tensor.hpp:195
+
+
+
+ +

◆ IsStackSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsStackSupported (const std::vector< const TensorInfo *> & inputs,
const TensorInfo & output,
const StackDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1363 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonStackWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1367 {
1368  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonStackWorkloadValidate,
1369  reasonIfUnsupported,
1370  inputs,
1371  output,
1372  descriptor);
1373 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::NeonStackWorkloadValidate
arm_compute::Status NeonStackWorkloadValidate(const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor)
Definition: NeonStackWorkload.cpp:27
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsStridedSliceSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsStridedSliceSupported (const TensorInfo & input,
const TensorInfo & output,
const StridedSliceDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1375 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonStridedSliceWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1379 {
1380  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonStridedSliceWorkloadValidate,
1381  reasonIfUnsupported,
1382  input,
1383  output,
1384  descriptor);
1385 }
armnn::NeonStridedSliceWorkloadValidate
arm_compute::Status NeonStridedSliceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor)
Definition: NeonStridedSliceWorkload.cpp:19
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsSubtractionSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsSubtractionSupported (const TensorInfo & input0,
const TensorInfo & input1,
const TensorInfo & output,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1387 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSubtractionWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1391 {
1392  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSubtractionWorkloadValidate,
1393  reasonIfUnsupported,
1394  input0,
1395  input1,
1396  output,
1397  nullptr);
1398 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonSubtractionWorkloadValidate
arm_compute::Status NeonSubtractionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonSubtractionWorkload.cpp:22
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+ +

◆ IsTransposeConvolution2dSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsTransposeConvolution2dSupported (const TensorInfo & input,
const TensorInfo & output,
const TransposeConvolution2dDescriptor & descriptor,
const TensorInfo & weights,
const Optional< TensorInfo > & biases,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1400 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonTransposeConvolution2dWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1406 {
1407  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeConvolution2dWorkloadValidate,
1408  reasonIfUnsupported,
1409  input,
1410  output,
1411  descriptor,
1412  weights,
1413  biases);
1414 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::NeonTransposeConvolution2dWorkloadValidate
arm_compute::Status NeonTransposeConvolution2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases)
Definition: NeonTransposeConvolution2dWorkload.cpp:25
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
+
+
+
+ +

◆ IsTransposeSupported()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool IsTransposeSupported (const TensorInfo & input,
const TensorInfo & output,
const TransposeDescriptor & descriptor,
Optional< std::string &> reasonIfUnsupported = EmptyOptional() 
) const
+ 		+override
+
+ +

Definition at line 1416 of file NeonLayerSupport.cpp.

+ +

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonTransposeWorkloadValidate().

+ +

Referenced by NeonLayerSupport::IsLayerSupported(), and NeonLayerSupport::~NeonLayerSupport().

+
1420 {
1421  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
1422 }
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+
armnn::NeonTransposeWorkloadValidate
arm_compute::Status NeonTransposeWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor)
Definition: NeonTransposeWorkload.cpp:15
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:130
+
+
+
+
The documentation for this class was generated from the following files: +
+
+ + + + -- cgit v1.2.1