NeonLayerSupport Class Reference

#include <NeonLayerSupport.hpp>

Inheritance diagram for NeonLayerSupport:

Public Member Functions
	NeonLayerSupport (const IBackendInternal::IBackendSpecificModelContextPtr &modelContextPtr)
	NeonLayerSupport ()
	~NeonLayerSupport ()
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	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	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	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	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	IsLogicalUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &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	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 14 of file NeonLayerSupport.hpp.

Constructor & Destructor Documentation

NeonLayerSupport() [1/2]

NeonLayerSupport ( const IBackendInternal::IBackendSpecificModelContextPtr &  modelContextPtr )

explicit

Definition at line 134 of file NeonLayerSupport.cpp.

    : m_ModelContextPtr(modelContextPtr)
{
}

NeonLayerSupport() [2/2]

NeonLayerSupport

(

)

Definition at line 139 of file NeonLayerSupport.cpp.

    : m_ModelContextPtr(nullptr)
{
}

~NeonLayerSupport()

~NeonLayerSupport ( )

inline

Definition at line 20 of file NeonLayerSupport.hpp.

References ARMNN_DEPRECATED_MSG, NeonLayerSupport::IsAbsSupported(), NeonLayerSupport::IsActivationSupported(), NeonLayerSupport::IsAdditionSupported(), NeonLayerSupport::IsArgMinMaxSupported(), NeonLayerSupport::IsBatchNormalizationSupported(), NeonLayerSupport::IsBatchToSpaceNdSupported(), NeonLayerSupport::IsComparisonSupported(), NeonLayerSupport::IsConcatSupported(), NeonLayerSupport::IsConstantSupported(), NeonLayerSupport::IsConvertBf16ToFp32Supported(), NeonLayerSupport::IsConvertFp16ToFp32Supported(), NeonLayerSupport::IsConvertFp32ToBf16Supported(), NeonLayerSupport::IsConvertFp32ToFp16Supported(), NeonLayerSupport::IsConvolution2dSupported(), NeonLayerSupport::IsDepthToSpaceSupported(), NeonLayerSupport::IsDepthwiseConvolutionSupported(), NeonLayerSupport::IsDequantizeSupported(), NeonLayerSupport::IsDilatedDepthwiseConvolutionSupported(), NeonLayerSupport::IsDivisionSupported(), NeonLayerSupport::IsElementwiseUnarySupported(), NeonLayerSupport::IsFillSupported(), NeonLayerSupport::IsFloorSupported(), NeonLayerSupport::IsFullyConnectedSupported(), NeonLayerSupport::IsGatherSupported(), NeonLayerSupport::IsGreaterSupported(), NeonLayerSupport::IsInputSupported(), NeonLayerSupport::IsInstanceNormalizationSupported(), NeonLayerSupport::IsL2NormalizationSupported(), NeonLayerSupport::IsLogicalBinarySupported(), NeonLayerSupport::IsLogSoftmaxSupported(), NeonLayerSupport::IsLstmSupported(), NeonLayerSupport::IsMaximumSupported(), NeonLayerSupport::IsMeanSupported(), NeonLayerSupport::IsMergerSupported(), 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::IsResizeBilinearSupported(), NeonLayerSupport::IsResizeSupported(), NeonLayerSupport::IsRsqrtSupported(), NeonLayerSupport::IsSliceSupported(), NeonLayerSupport::IsSoftmaxSupported(), NeonLayerSupport::IsSpaceToBatchNdSupported(), NeonLayerSupport::IsSpaceToDepthSupported(), NeonLayerSupport::IsSplitterSupported(), NeonLayerSupport::IsStackSupported(), NeonLayerSupport::IsStridedSliceSupported(), NeonLayerSupport::IsSubtractionSupported(), NeonLayerSupport::IsTransposeConvolution2dSupported(), and NeonLayerSupport::IsTransposeSupported().

{}

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

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 152 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 165 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonAdditionWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonArgMinMaxWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 190 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonBatchNormalizationValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonBatchToSpaceNdWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 223 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonComparisonWorkloadValidate().

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

{

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

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

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

{
    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 277 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonConstantWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 285 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 295 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 305 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 315 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 325 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    bool isFastMathEnabled = false;
#if defined(ARMCOMPUTENEON_ENABLED)
    if (m_ModelContextPtr)
    {
        if (m_ModelContextPtr.get() != nullptr)
        {
            auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
            if (modelOptions)
            {
                isFastMathEnabled = modelOptions->IsFastMathEnabled();
            }
        }
    }
#endif

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthToSpaceWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 370 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthwiseConvolutionWorkloadValidate().

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

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

IsDequantizeSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 387 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDequantizeWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 397 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDepthwiseConvolutionWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonDivisionWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

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

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

{
    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);
        case UnaryOperation::LogicalNot:
            FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalNotWorkloadValidate,
                                           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 451 of file NeonLayerSupport.cpp.

References armnn::IgnoreUnused().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 463 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 478 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonFullyConnectedWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonGatherWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 509 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 518 of file NeonLayerSupport.cpp.

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 524 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonInstanceNormalizationWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 536 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonL2NormalizationWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

IsLogicalBinarySupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 544 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    switch(descriptor.m_Operation)
    {
        case LogicalBinaryOperation::LogicalAnd:
            FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalAndWorkloadValidate,
                                           reasonIfUnsupported,
                                           input0,
                                           input1,
                                           output);
        case LogicalBinaryOperation::LogicalOr:
            FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalOrWorkloadValidate,
                                           reasonIfUnsupported,
                                           input0,
                                           input1,
                                           output);
        default:
            return false;
    }
}

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonLogSoftmaxWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 577 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonLstmFloatWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 601 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMaximumWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 613 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMeanWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 625 of file NeonLayerSupport.cpp.

References NeonLayerSupport::IsConcatSupported().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
     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 633 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMinimumWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 645 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonMultiplicationWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonNormalizationWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 683 of file NeonLayerSupport.cpp.

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 689 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPadWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 701 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPermuteWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 709 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPooling2dWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 717 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonPreluWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 725 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    // 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 770 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonQuantizedLstmWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 760 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonQuantizeWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

IsReduceSupported()

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

overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 788 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonReduceWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 824 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.

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 812 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonResizeWorkloadValidate().

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

{
    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 839 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 847 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSliceWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 859 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSoftmaxWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 867 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSpaceToBatchNdWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 879 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSpaceToDepthWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 891 of file NeonLayerSupport.cpp.

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

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 902 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 935 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonStackWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 947 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonStridedSliceWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 959 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonSubtractionWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

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

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

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonTransposeConvolution2dWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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 988 of file NeonLayerSupport.cpp.

References FORWARD_WORKLOAD_VALIDATE_FUNC, and armnn::NeonTransposeWorkloadValidate().

Referenced by NeonLayerSupport::~NeonLayerSupport().

{
    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