#include <NeonLayerSupport.hpp>

Inheritance diagram for NeonLayerSupport:

Public Member Functions
bool	IsAbsSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) 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	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 ConcatDescriptor &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	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	IsGreaterSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, 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	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	IsMergerSupported (const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const MergerDescriptor &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	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	IsResizeBilinearSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override

bool	IsRsqrtSupported (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 ViewsDescriptor &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	IsDebugSupported (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	IsEqualSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override

bool	IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override

bool	IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, 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	IsPreCompiledSupported (const TensorInfo &input, const PreCompiledDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override

bool	IsRankSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported) 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	IsSwitchSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override

Additional Inherited Members
Protected Member Functions inherited from ILayerSupport
	ILayerSupport ()

virtual	~ILayerSupport ()

Detailed Description

Definition at line 12 of file NeonLayerSupport.hpp.

Member Function Documentation

◆ IsAbsSupported()

bool IsAbsSupported	(	const TensorInfo &	input,
		const TensorInfo &	output,
		Optional< std::string &>	reasonIfUnsupported = `EmptyOptional()`
	)		const

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 128 of file NeonLayerSupport.cpp.

References armnn::Abs, and NeonLayerSupport::IsElementwiseUnarySupported().

 {
     ElementwiseUnaryDescriptor descriptor(UnaryOperation::Abs);
     return IsElementwiseUnarySupported(input, output, descriptor, reasonIfUnsupported);
 }

◆ IsActivationSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 136 of file NeonLayerSupport.cpp.

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

 {
     IgnoreUnused(descriptor);
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonActivationWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsAdditionSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 149 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonAdditionWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAdditionWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output);
 }

◆ IsArgMinMaxSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 161 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonArgMinMaxWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonArgMinMaxWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 173 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonBatchNormalizationValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchNormalizationValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    mean,
                                    var,
                                    beta,
                                    gamma,
                                    descriptor);
 }

◆ IsBatchToSpaceNdSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 193 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonBatchToSpaceNdWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchToSpaceNdWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsComparisonSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 205 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonComparisonWorkloadValidate().

Referenced by NeonLayerSupport::IsGreaterSupported().

 {
 
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonComparisonWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output,
                                    descriptor);
 }

◆ IsConcatSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 220 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::IsMergerSupported().

 {
     if (descriptor.GetNumDimensions() <= descriptor.GetConcatAxis())
     {
         SetValueChecked(reasonIfUnsupported, "Neon Concat: Concat axis > Number of dimensions.");
         return false;
     }
 
     unsigned int concatInnerAxis = (descriptor.GetNumDimensions() - descriptor.GetConcatAxis()) - 1;
     if(concatInnerAxis < 3) // Width, height, or channels
     {
         FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConcatWorkloadValidate,
                                        reasonIfUnsupported,
                                        inputs,
                                        output,
                                        descriptor);
     }
     else if (concatInnerAxis == 3)
     {
         for (auto& input : inputs)
         {
             if (input && !output.IsTypeSpaceMatch(*input)) // Cannot use sub-tensors if the types are not same space
             {
                 SetValueChecked(reasonIfUnsupported, "Neon Concat: Types and quantization parameters must match.");
                 return false;
             }
         }
         return true; // Sub-tensors support concat along batch
     }
     else // > 4 dimensions not supported.
     {
         SetValueChecked(reasonIfUnsupported, "Neon Concat: Maximum of 4 dimensions supported.");
         return false;
     }
 }

◆ IsConstantSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 259 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonConstantWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConstantWorkloadValidate,
                                    reasonIfUnsupported,
                                    output);
 }

◆ IsConvertBf16ToFp32Supported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 267 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

 {
     armnn::IgnoreUnused(input);
     armnn::IgnoreUnused(output);
     armnn::IgnoreUnused(reasonIfUnsupported);
     return true;
 }

◆ IsConvertFp16ToFp32Supported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 277 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

 {
     armnn::IgnoreUnused(input);
     armnn::IgnoreUnused(output);
     armnn::IgnoreUnused(reasonIfUnsupported);
     return true;
 }

◆ IsConvertFp32ToBf16Supported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 287 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

 {
     armnn::IgnoreUnused(input);
     armnn::IgnoreUnused(output);
     armnn::IgnoreUnused(reasonIfUnsupported);
     return true;
 }

◆ IsConvertFp32ToFp16Supported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 297 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

 {
     armnn::IgnoreUnused(input);
     armnn::IgnoreUnused(output);
     armnn::IgnoreUnused(reasonIfUnsupported);
     return true;
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 307 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonConvolution2dWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvolution2dWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor,
                                    weights,
                                    biases);
 }

◆ IsDepthToSpaceSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 323 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthToSpaceWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthToSpaceWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 335 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthwiseConvolutionWorkloadValidate().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthwiseConvolutionWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor,
                                    weights,
                                    biases);
 }

◆ IsDequantizeSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 351 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDequantizeWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDequantizeWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output);
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 361 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthwiseConvolutionWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthwiseConvolutionWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor,
                                    weights,
                                    biases);
 }

◆ IsDivisionSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 589 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDivisionWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDivisionWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output);
 }

◆ IsElementwiseUnarySupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 377 of file NeonLayerSupport.cpp.

References armnn::Abs, armnn::Exp, FORWARD_WORKLOAD_VALIDATE_FUNC, ElementwiseUnaryDescriptor::m_Operation, armnn::Neg, armnn::NeonAbsWorkloadValidate(), armnn::NeonExpWorkloadValidate(), armnn::NeonNegWorkloadValidate(), armnn::NeonRsqrtWorkloadValidate(), and armnn::Rsqrt.

Referenced by NeonLayerSupport::IsAbsSupported(), and NeonLayerSupport::IsRsqrtSupported().

 {
     switch(descriptor.m_Operation)
     {
         case UnaryOperation::Abs:
             FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAbsWorkloadValidate,
                                            reasonIfUnsupported,
                                            input,
                                            output);
         case UnaryOperation::Exp:
             FORWARD_WORKLOAD_VALIDATE_FUNC(NeonExpWorkloadValidate,
                                            reasonIfUnsupported,
                                            input,
                                            output);
         case UnaryOperation::Neg:
             FORWARD_WORKLOAD_VALIDATE_FUNC(NeonNegWorkloadValidate,
                                            reasonIfUnsupported,
                                            input,
                                            output);
         case UnaryOperation::Rsqrt:
             FORWARD_WORKLOAD_VALIDATE_FUNC(NeonRsqrtWorkloadValidate,
                                            reasonIfUnsupported,
                                            input,
                                            output);
         default:
             return false;
     }
 }

◆ 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 409 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

 {
     armnn::IgnoreUnused(input);
     armnn::IgnoreUnused(output);
     armnn::IgnoreUnused(descriptor);
 
     return IsNeonBackendSupported(reasonIfUnsupported);
 }

◆ IsFloorSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 421 of file NeonLayerSupport.cpp.

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

 {
     armnn::IgnoreUnused(output);
     return IsNeonBackendSupported(reasonIfUnsupported) &&
            IsSupportedForDataTypeGeneric(reasonIfUnsupported,
                                          input.GetDataType(),
                                          &FalseFuncF16<>,
                                          &TrueFunc<>,
                                          &FalseFuncU8<>,
                                          &FalseFuncI32<>,
                                          &FalseFuncU8<>);
 }

◆ IsFullyConnectedSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 436 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonFullyConnectedWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonFullyConnectedWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    weights,
                                    biases,
                                    descriptor);
 }

◆ IsGatherSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 452 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonGatherWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonGatherWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output,
                                    descriptor);
 }

◆ IsGreaterSupported()

bool IsGreaterSupported	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output,
		Optional< std::string &>	reasonIfUnsupported = `EmptyOptional()`
	)		const

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 466 of file NeonLayerSupport.cpp.

References armnn::Greater, and NeonLayerSupport::IsComparisonSupported().

 {
     ComparisonDescriptor descriptor(ComparisonOperation::Greater);
     return IsComparisonSupported(input0, input1, output, descriptor, reasonIfUnsupported);
 }

◆ IsInputSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 475 of file NeonLayerSupport.cpp.

 {
     return IsNeonBackendSupported(reasonIfUnsupported, input);
 }

◆ IsInstanceNormalizationSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 481 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonInstanceNormalizationWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonInstanceNormalizationWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsL2NormalizationSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 493 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonL2NormalizationWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonL2NormalizationWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }

◆ IsLogSoftmaxSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 501 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonLogSoftmaxWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogSoftmaxWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 509 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonLstmFloatWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLstmFloatWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    outputStateIn,
                                    cellStateIn,
                                    scratchBuffer,
                                    outputStateOut,
                                    cellStateOut,
                                    output,
                                    descriptor,
                                    paramsInfo);
 }

◆ IsMaximumSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 533 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMaximumWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMaximumWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output);
 }

◆ IsMeanSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 545 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMeanWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMeanWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsMergerSupported()

bool IsMergerSupported	(	const std::vector< const TensorInfo *>	inputs,
		const TensorInfo &	output,
		const MergerDescriptor &	descriptor,
		Optional< std::string &>	reasonIfUnsupported = `EmptyOptional()`
	)		const

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 557 of file NeonLayerSupport.cpp.

References NeonLayerSupport::IsConcatSupported().

 {
      return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
 }

◆ IsMinimumSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 565 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMinimumWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMinimumWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output);
 }

◆ IsMultiplicationSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 577 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMultiplicationWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMultiplicationWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output);
 }

◆ IsNormalizationSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 601 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonNormalizationWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonNormalizationWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsOutputSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 613 of file NeonLayerSupport.cpp.

 {
     return IsNeonBackendSupported(reasonIfUnsupported, output);
 }

◆ IsPadSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 619 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPadWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPadWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsPermuteSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 631 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPermuteWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPermuteWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }

◆ IsPooling2dSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 639 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPooling2dWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPooling2dWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }

◆ IsPreluSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 647 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPreluWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPreluWorkloadValidate, reasonIfUnsupported, input, alpha, output);
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 655 of file NeonLayerSupport.cpp.

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

 {
     // Check required here in order to pass IsLayerSupported for datatypes tests
     if (input.GetDataType()               == armnn::DataType::QAsymmS8 &&
         previousOutputIn.GetDataType()    == armnn::DataType::QAsymmS8 &&
         previousCellStateIn.GetDataType() == armnn::DataType::QSymmS16 &&
         outputStateOut.GetDataType()      == armnn::DataType::QAsymmS8 &&
         cellStateOut.GetDataType()        == armnn::DataType::QSymmS16 &&
         output.GetDataType()              == armnn::DataType::QAsymmS8)
     {
         FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQLstmWorkloadValidate,
                                        reasonIfUnsupported,
                                        input,
                                        previousCellStateIn,
                                        previousOutputIn,
                                        cellStateOut,
                                        outputStateOut,
                                        output,
                                        descriptor,
                                        paramsInfo);
     }
     else
     {
         return false;
     }
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 700 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonQuantizedLstmWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQuantizedLstmWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    cellStateIn,
                                    outputStateIn,
                                    cellStateOut,
                                    outputStateOut,
                                    paramsInfo);
 }

◆ IsQuantizeSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 690 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonQuantizeWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQuantizeWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output);
 }

◆ IsReshapeSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 718 of file NeonLayerSupport.cpp.

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

 {
     armnn::IgnoreUnused(descriptor);
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonReshapeWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output);
 }

◆ IsResizeBilinearSupported()

bool IsResizeBilinearSupported	(	const TensorInfo &	input,
		const TensorInfo &	output,
		Optional< std::string &>	reasonIfUnsupported = `EmptyOptional()`
	)		const

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 742 of file NeonLayerSupport.cpp.

References armnn::Bilinear, TensorInfo::GetShape(), NeonLayerSupport::IsResizeSupported(), ResizeDescriptor::m_DataLayout, ResizeDescriptor::m_Method, ResizeDescriptor::m_TargetHeight, ResizeDescriptor::m_TargetWidth, and armnn::NCHW.

 {
     ResizeDescriptor descriptor;
     descriptor.m_Method     = ResizeMethod::Bilinear;
     descriptor.m_DataLayout = DataLayout::NCHW;
 
     const TensorShape& outputShape = output.GetShape();
     descriptor.m_TargetHeight = outputShape[2];
     descriptor.m_TargetWidth  = outputShape[3];
 
     return IsResizeSupported(input, output, descriptor, reasonIfUnsupported);
 }

◆ IsResizeSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 730 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonResizeWorkloadValidate().

Referenced by NeonLayerSupport::IsResizeBilinearSupported().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonResizeWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsRsqrtSupported()

bool IsRsqrtSupported	(	const TensorInfo &	input,
		const TensorInfo &	output,
		Optional< std::string &>	reasonIfUnsupported = `EmptyOptional()`
	)		const

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 757 of file NeonLayerSupport.cpp.

References NeonLayerSupport::IsElementwiseUnarySupported(), and armnn::Rsqrt.

 {
     ElementwiseUnaryDescriptor descriptor(UnaryOperation::Rsqrt);
     return IsElementwiseUnarySupported(input, output, descriptor, reasonIfUnsupported);
 }

◆ IsSliceSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 765 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSliceWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSliceWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsSoftmaxSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 777 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSoftmaxWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSoftmaxWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }

◆ IsSpaceToBatchNdSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 785 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSpaceToBatchNdWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSpaceToBatchNdWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsSpaceToDepthSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 797 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSpaceToDepthWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSpaceToDepthWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsSplitterSupported() [1/2]

bool IsSplitterSupported	(	const TensorInfo &	input,
		const ViewsDescriptor &	descriptor,
		Optional< std::string &>	reasonIfUnsupported = `EmptyOptional()`
	)		const

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 809 of file NeonLayerSupport.cpp.

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

 {
     armnn::IgnoreUnused(descriptor);
     return IsSupportedForDataTypeNeon(reasonIfUnsupported,
                                       input.GetDataType(),
                                       &TrueFunc<>,
                                       &TrueFunc<>);
 }

◆ IsSplitterSupported() [2/2]

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 820 of file NeonLayerSupport.cpp.

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

 {
 #if defined(ARMCOMPUTENEON_ENABLED)
     // Split along the last dimension, cannot use sub-tensors
     // as width and height of the sub-tensors do not match
     // the width and height of the parent tensor
     // in case of input with more than 2D.
     std::set<unsigned int> splitAxis = ComputeSplitAxis(descriptor, input.GetShape());
     if (descriptor.GetNumDimensions() > 2 && splitAxis.size() == 1 &&
         *splitAxis.begin() == descriptor.GetNumDimensions() - 1 )
     {
         FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSplitterWorkloadValidate,
                                        reasonIfUnsupported,
                                        input,
                                        outputs,
                                        *splitAxis.begin());
     }
 #endif
     IgnoreUnused(descriptor);
     for (auto output : outputs)
     {
         if (!input.IsTypeSpaceMatch(output)) // Cannot use sub-tensors if the types are not same space
         {
             SetValueChecked(reasonIfUnsupported, "Neon Splitter: Types and quantization parameters must match.");
             return false;
         }
     }
     return true;
 }

◆ IsStackSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 853 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonStackWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonStackWorkloadValidate,
                                    reasonIfUnsupported,
                                    inputs,
                                    output,
                                    descriptor);
 }

◆ IsStridedSliceSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 865 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonStridedSliceWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonStridedSliceWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor);
 }

◆ IsSubtractionSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 877 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSubtractionWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSubtractionWorkloadValidate,
                                    reasonIfUnsupported,
                                    input0,
                                    input1,
                                    output);
 }

◆ 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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 889 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonTransposeConvolution2dWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeConvolution2dWorkloadValidate,
                                    reasonIfUnsupported,
                                    input,
                                    output,
                                    descriptor,
                                    weights,
                                    biases);
 }

◆ IsTransposeSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 905 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonTransposeWorkloadValidate().

 {
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }

The documentation for this class was generated from the following files:

src/backends/neon/NeonLayerSupport.hpp
src/backends/neon/NeonLayerSupport.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ IsAbsSupported()

◆ IsActivationSupported()

◆ IsAdditionSupported()

◆ IsArgMinMaxSupported()

◆ IsBatchNormalizationSupported()

◆ IsBatchToSpaceNdSupported()

◆ IsComparisonSupported()

◆ IsConcatSupported()

◆ IsConstantSupported()

◆ IsConvertBf16ToFp32Supported()

◆ IsConvertFp16ToFp32Supported()

◆ IsConvertFp32ToBf16Supported()

◆ IsConvertFp32ToFp16Supported()

◆ IsConvolution2dSupported()

◆ IsDepthToSpaceSupported()

◆ IsDepthwiseConvolutionSupported()

◆ IsDequantizeSupported()

◆ IsDilatedDepthwiseConvolutionSupported()

◆ IsDivisionSupported()

◆ IsElementwiseUnarySupported()

◆ IsFillSupported()

◆ IsFloorSupported()

◆ IsFullyConnectedSupported()

◆ IsGatherSupported()

◆ IsGreaterSupported()

◆ IsInputSupported()

◆ IsInstanceNormalizationSupported()

◆ IsL2NormalizationSupported()

◆ IsLogSoftmaxSupported()

◆ IsLstmSupported()

◆ IsMaximumSupported()

◆ IsMeanSupported()

◆ IsMergerSupported()

◆ IsMinimumSupported()

◆ IsMultiplicationSupported()

◆ IsNormalizationSupported()

◆ IsOutputSupported()

◆ IsPadSupported()

◆ IsPermuteSupported()

◆ IsPooling2dSupported()

◆ IsPreluSupported()

◆ IsQLstmSupported()

◆ IsQuantizedLstmSupported()

◆ IsQuantizeSupported()

◆ IsReshapeSupported()

◆ IsResizeBilinearSupported()

◆ IsResizeSupported()

◆ IsRsqrtSupported()

◆ IsSliceSupported()

◆ IsSoftmaxSupported()

◆ IsSpaceToBatchNdSupported()

◆ IsSpaceToDepthSupported()

◆ IsSplitterSupported() [1/2]

◆ IsSplitterSupported() [2/2]

◆ IsStackSupported()

◆ IsStridedSliceSupported()

◆ IsSubtractionSupported()

◆ IsTransposeConvolution2dSupported()

◆ IsTransposeSupported()