LayerSupportHandle Class Reference

#include <BackendHelper.hpp>

Public Member Functions
	LayerSupportHandle (std::shared_ptr< ILayerSupport > layerSupport)
	LayerSupportHandle (std::shared_ptr< ILayerSupport > layerSupport, const BackendId &backendId)
bool	IsBackendRegistered () const
bool	IsActivationSupported (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsAdditionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsArgMinMaxSupported (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsBatchMatMulSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
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())
bool	IsBatchToSpaceNdSupported (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsCastSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsChannelShuffleSupported (const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsComparisonSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConcatSupported (const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConstantSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConvertBf16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConvertFp32ToBf16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsConvolution3dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsDebugSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
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())
bool	IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsFillSupported (const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsFloorSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsFullyConnectedSupported (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsGatherNdSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsInputSupported (const TensorInfo &input, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsInstanceNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsL2NormalizationSupported (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsLogicalBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsLogicalUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsLogSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
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())
bool	IsMaximumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsMeanSupported (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsMemCopySupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsMemImportSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsMergeSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsMinimumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsMultiplicationSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsOutputSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsPadSupported (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsPermuteSupported (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsPooling2dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsPooling3dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsPreCompiledSupported (const TensorInfo &input, const PreCompiledDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsQuantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
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())
bool	IsQuantizedLstmSupported (const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsRankSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsShapeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSpaceToBatchNdSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSpaceToDepthSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSplitterSupported (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsStackSupported (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsStandInSupported (const std::vector< const TensorInfo *> &inputs, const std::vector< const TensorInfo *> &outputs, const StandInDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsStridedSliceSupported (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSubtractionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsSwitchSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsTransposeConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
bool	IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
	ARMNN_DEPRECATED_MSG_REMOVAL_DATE ("This function has been deprecated, please use function without " "Optional TensorInfos", "23.02") bool IsUnidirectionalSequenceLstmSupported(const TensorInfo &input
bool	IsUnidirectionalSequenceLstmSupported (const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional())

Public Attributes
const TensorInfo &	outputStateIn
const TensorInfo const TensorInfo &	cellStateIn
const TensorInfo const TensorInfo const TensorInfo &	output
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > &	hiddenStateOutput
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > &	cellStateOutput
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > const LstmDescriptor &	descriptor
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > const LstmDescriptor const LstmInputParamsInfo &	paramsInfo
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > const LstmDescriptor const LstmInputParamsInfo Optional< std::string & >	reasonIfUnsupported = EmptyOptional())

Detailed Description

Definition at line 20 of file BackendHelper.hpp.

Constructor & Destructor Documentation

LayerSupportHandle() [1/2]

LayerSupportHandle ( std::shared_ptr< ILayerSupport >  layerSupport )

inlineexplicit

Definition at line 23 of file BackendHelper.hpp.

        : m_LayerSupport(std::move(layerSupport)), m_BackendId(Compute::Undefined) {};

LayerSupportHandle() [2/2]

LayerSupportHandle ( std::shared_ptr< ILayerSupport >  layerSupport, const BackendId &  backendId  )

inlineexplicit

Definition at line 26 of file BackendHelper.hpp.

References LayerSupportHandle::ARMNN_DEPRECATED_MSG_REMOVAL_DATE(), LayerSupportHandle::cellStateIn, LayerSupportHandle::descriptor, LayerSupportHandle::IsActivationSupported(), LayerSupportHandle::IsAdditionSupported(), LayerSupportHandle::IsArgMinMaxSupported(), LayerSupportHandle::IsBackendRegistered(), LayerSupportHandle::IsBatchMatMulSupported(), LayerSupportHandle::IsBatchNormalizationSupported(), LayerSupportHandle::IsBatchToSpaceNdSupported(), LayerSupportHandle::IsCastSupported(), LayerSupportHandle::IsChannelShuffleSupported(), LayerSupportHandle::IsComparisonSupported(), LayerSupportHandle::IsConcatSupported(), LayerSupportHandle::IsConstantSupported(), LayerSupportHandle::IsConvertBf16ToFp32Supported(), LayerSupportHandle::IsConvertFp16ToFp32Supported(), LayerSupportHandle::IsConvertFp32ToBf16Supported(), LayerSupportHandle::IsConvertFp32ToFp16Supported(), LayerSupportHandle::IsConvolution2dSupported(), LayerSupportHandle::IsConvolution3dSupported(), LayerSupportHandle::IsDebugSupported(), LayerSupportHandle::IsDepthToSpaceSupported(), LayerSupportHandle::IsDepthwiseConvolutionSupported(), LayerSupportHandle::IsDequantizeSupported(), LayerSupportHandle::IsDetectionPostProcessSupported(), LayerSupportHandle::IsDilatedDepthwiseConvolutionSupported(), LayerSupportHandle::IsDivisionSupported(), LayerSupportHandle::IsElementwiseUnarySupported(), LayerSupportHandle::IsFakeQuantizationSupported(), LayerSupportHandle::IsFillSupported(), LayerSupportHandle::IsFloorSupported(), LayerSupportHandle::IsFullyConnectedSupported(), LayerSupportHandle::IsGatherNdSupported(), LayerSupportHandle::IsGatherSupported(), LayerSupportHandle::IsInputSupported(), LayerSupportHandle::IsInstanceNormalizationSupported(), LayerSupportHandle::IsL2NormalizationSupported(), LayerSupportHandle::IsLogicalBinarySupported(), LayerSupportHandle::IsLogicalUnarySupported(), LayerSupportHandle::IsLogSoftmaxSupported(), LayerSupportHandle::IsLstmSupported(), LayerSupportHandle::IsMaximumSupported(), LayerSupportHandle::IsMeanSupported(), LayerSupportHandle::IsMemCopySupported(), LayerSupportHandle::IsMemImportSupported(), LayerSupportHandle::IsMergeSupported(), LayerSupportHandle::IsMinimumSupported(), LayerSupportHandle::IsMultiplicationSupported(), LayerSupportHandle::IsNormalizationSupported(), LayerSupportHandle::IsOutputSupported(), LayerSupportHandle::IsPadSupported(), LayerSupportHandle::IsPermuteSupported(), LayerSupportHandle::IsPooling2dSupported(), LayerSupportHandle::IsPooling3dSupported(), LayerSupportHandle::IsPreCompiledSupported(), LayerSupportHandle::IsPreluSupported(), LayerSupportHandle::IsQLstmSupported(), LayerSupportHandle::IsQuantizedLstmSupported(), LayerSupportHandle::IsQuantizeSupported(), LayerSupportHandle::IsRankSupported(), LayerSupportHandle::IsReduceSupported(), LayerSupportHandle::IsReshapeSupported(), LayerSupportHandle::IsResizeSupported(), LayerSupportHandle::IsShapeSupported(), LayerSupportHandle::IsSliceSupported(), LayerSupportHandle::IsSoftmaxSupported(), LayerSupportHandle::IsSpaceToBatchNdSupported(), LayerSupportHandle::IsSpaceToDepthSupported(), LayerSupportHandle::IsSplitterSupported(), LayerSupportHandle::IsStackSupported(), LayerSupportHandle::IsStandInSupported(), LayerSupportHandle::IsStridedSliceSupported(), LayerSupportHandle::IsSubtractionSupported(), LayerSupportHandle::IsSwitchSupported(), LayerSupportHandle::IsTransposeConvolution2dSupported(), LayerSupportHandle::IsTransposeSupported(), LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), LayerSupportHandle::output, LayerSupportHandle::outputStateIn, LayerSupportHandle::paramsInfo, and LayerSupportHandle::reasonIfUnsupported.

        : m_LayerSupport(std::move(layerSupport)), m_BackendId(backendId) {};

Member Function Documentation

ARMNN_DEPRECATED_MSG_REMOVAL_DATE()

ARMNN_DEPRECATED_MSG_REMOVAL_DATE	(	"This function has been	deprecated,
		please use function without " "Optional TensorInfos"	,
		"23.02"
	)		const &

Referenced by LayerSupportHandle::LayerSupportHandle().

IsActivationSupported()

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

Definition at line 137 of file BackendHelper.cpp.

References armnn::Activation.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Activation,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsAdditionSupported()

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

Definition at line 152 of file BackendHelper.cpp.

References armnn::Addition.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Addition,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsArgMinMaxSupported()

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

Definition at line 167 of file BackendHelper.cpp.

References armnn::ArgMinMax.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ArgMinMax,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsBackendRegistered()

bool IsBackendRegistered

(

)

const

Definition at line 125 of file BackendHelper.cpp.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    if (m_LayerSupport)
    {
        return true;
    }

    return false;
}

IsBatchMatMulSupported()

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

Definition at line 182 of file BackendHelper.cpp.

References armnn::BatchMatMul.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::BatchMatMul,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

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()
	)

Definition at line 198 of file BackendHelper.cpp.

References armnn::BatchNormalization, and LayerSupportHandle::output.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output, mean, var, beta, gamma};

    return m_LayerSupport->IsLayerSupported(LayerType::BatchNormalization,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsBatchToSpaceNdSupported()

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

Definition at line 217 of file BackendHelper.cpp.

References armnn::BatchToSpaceNd.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::BatchToSpaceNd,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsCastSupported()

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

Definition at line 232 of file BackendHelper.cpp.

References armnn::Cast.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Cast,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsChannelShuffleSupported()

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

Definition at line 246 of file BackendHelper.cpp.

References armnn::ChannelShuffle.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ChannelShuffle,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsComparisonSupported()

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

Definition at line 261 of file BackendHelper.cpp.

References armnn::Comparison.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Comparison,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConcatSupported()

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

Definition at line 277 of file BackendHelper.cpp.

References armnn::Concat.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos;
    for (const TensorInfo* inputInfo : inputs)
    {
        infos.push_back(*inputInfo);
    }
    infos.push_back(output);

    return m_LayerSupport->IsLayerSupported(LayerType::Concat,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConstantSupported()

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

Definition at line 297 of file BackendHelper.cpp.

References armnn::Constant.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{output};

    return m_LayerSupport->IsLayerSupported(LayerType::Constant,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConvertBf16ToFp32Supported()

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

Definition at line 310 of file BackendHelper.cpp.

References armnn::ConvertBf16ToFp32.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ConvertBf16ToFp32,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConvertFp16ToFp32Supported()

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

Definition at line 338 of file BackendHelper.cpp.

References armnn::ConvertFp16ToFp32.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp16ToFp32,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConvertFp32ToBf16Supported()

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

Definition at line 324 of file BackendHelper.cpp.

References armnn::ConvertFp32ToBf16.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp32ToBf16,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConvertFp32ToFp16Supported()

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

Definition at line 352 of file BackendHelper.cpp.

References armnn::ConvertFp32ToFp16.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp32ToFp16,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConvolution2dSupported()

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

Definition at line 366 of file BackendHelper.cpp.

References ARMNN_LOG, armnn::Convolution2d, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), Convolution2dDescriptor::m_BiasEnabled, LayerSupportHandle::output, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), and armnn::warning.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfo biasesVal =  biases.has_value() ? biases.value() : TensorInfo();
    TensorInfos infos{input, output, weights, biasesVal};

    Optional<const BackendOptions::BackendOption> capability ;
    if (!m_BackendId.IsUndefined())
    {
        capability = GetCapability("NonConstWeights", m_BackendId);
        if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
        {
            if (!weights.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                        "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
                        "Convolution2d weights are set as dynamic (non constant). ";
                }
                return false;
            }
            if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
                            "Convolution2d biases are set as dynamic (non constant). ";
                }
                return false;
            }

            // At the first stage we will only print a warning. this is to give
            // backend developers a chance to adopt and read weights from input slots.
            ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
                                  "If you are a backend developer please find more information in our "
                                  "doxygen documentation on github https://github.com/ARM-software/armnn "
                                  "under the keyword 'ConstTensorsAsInputs'.";
        }
    }

    return m_LayerSupport->IsLayerSupported(LayerType::Convolution2d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsConvolution3dSupported()

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

Definition at line 420 of file BackendHelper.cpp.

References armnn::Convolution3d, OptionalBase::has_value(), LayerSupportHandle::output, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfo biasesVal =  biases.has_value() ? biases.value() : TensorInfo();
    TensorInfos infos{input, output, weights, biasesVal};

    return m_LayerSupport->IsLayerSupported(LayerType::Convolution3d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDebugSupported()

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

Definition at line 438 of file BackendHelper.cpp.

References armnn::Debug.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Debug,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDepthToSpaceSupported()

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

Definition at line 452 of file BackendHelper.cpp.

References armnn::DepthToSpace.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::DepthToSpace,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDepthwiseConvolutionSupported()

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

Definition at line 467 of file BackendHelper.cpp.

References ARMNN_LOG, armnn::DepthwiseConvolution2d, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), DepthwiseConvolution2dDescriptor::m_BiasEnabled, LayerSupportHandle::output, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), and armnn::warning.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfo biasesVal =  biases.has_value() ? biases.value() : TensorInfo();
    TensorInfos infos{input, output, weights, biasesVal};

    Optional<const BackendOptions::BackendOption> capability ;
    if (!m_BackendId.IsUndefined())
    {
        capability = GetCapability("NonConstWeights", m_BackendId);
        if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
        {
            if (!weights.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
                            "DepthwiseConvolution2d weights are set as dynamic (non constant). ";
                }
                return false;
            }
            if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
                            "DepthwiseConvolution2d biases are set as dynamic (non constant). ";
                }
                return false;
            }
            // At the first stage we will only print a warning. this is to give
            // backend developers a chance to adopt and read weights from input slots.
            ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
                                  "If you are a backend developer please find more information in our "
                                  "doxygen documentation on github https://github.com/ARM-software/armnn "
                                  "under the keyword 'ConstTensorsAsInputs'.";
        }
    }

    return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDequantizeSupported()

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

Definition at line 521 of file BackendHelper.cpp.

References armnn::Dequantize.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Dequantize,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDetectionPostProcessSupported()

bool IsDetectionPostProcessSupported	(	const TensorInfo &	boxEncodings,
		const TensorInfo &	scores,
		const TensorInfo &	anchors,
		const TensorInfo &	detectionBoxes,
		const TensorInfo &	detectionClasses,
		const TensorInfo &	detectionScores,
		const TensorInfo &	numDetections,
		const DetectionPostProcessDescriptor &	descriptor,
		Optional< std::string &>	reasonIfUnsupported = EmptyOptional()
	)

Definition at line 535 of file BackendHelper.cpp.

References armnn::DetectionPostProcess.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{boxEncodings, scores, anchors, detectionBoxes, detectionClasses, detectionScores, numDetections};

    return m_LayerSupport->IsLayerSupported(LayerType::DetectionPostProcess,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDilatedDepthwiseConvolutionSupported()

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

Definition at line 555 of file BackendHelper.cpp.

References ARMNN_LOG, armnn::DepthwiseConvolution2d, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), DepthwiseConvolution2dDescriptor::m_BiasEnabled, LayerSupportHandle::output, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), and armnn::warning.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfo biasesVal =  biases.has_value() ? biases.value() : TensorInfo();
    TensorInfos infos{input, output, weights, biasesVal};

    Optional<const BackendOptions::BackendOption> capability ;
    if (!m_BackendId.IsUndefined())
    {
        capability = GetCapability("NonConstWeights", m_BackendId);
        if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
        {
            if (!weights.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
                            "DilatedDepthwiseConvolution2d weights are set as dynamic (non constant). ";
                }
                return false;
            }
            if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
                            "DilatedDepthwiseConvolution2d biases are set as dynamic (non constant). ";
                }
                return false;
            }
            // At the first stage we will only print a warning. this is to give
            // backend developers a chance to adopt and read weights from input slots.
            ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
                                  "If you are a backend developer please find more information in our "
                                  "doxygen documentation on github https://github.com/ARM-software/armnn "
                                  "under the keyword 'ConstTensorsAsInputs'.";
        }
    }

    return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsDivisionSupported()

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

Definition at line 609 of file BackendHelper.cpp.

References armnn::Division.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Division,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsElementwiseUnarySupported()

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

Definition at line 624 of file BackendHelper.cpp.

References armnn::ElementwiseUnary.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseUnary,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsFakeQuantizationSupported()

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

Definition at line 639 of file BackendHelper.cpp.

References armnn::FakeQuantization.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input};

    return m_LayerSupport->IsLayerSupported(LayerType::FakeQuantization,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsFillSupported()

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

Definition at line 653 of file BackendHelper.cpp.

References armnn::Fill.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Fill,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsFloorSupported()

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

Definition at line 668 of file BackendHelper.cpp.

References armnn::Floor.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Floor,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsFullyConnectedSupported()

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

Definition at line 682 of file BackendHelper.cpp.

References ARMNN_LOG, armnn::FullyConnected, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), FullyConnectedDescriptor::m_BiasEnabled, FullyConnectedDescriptor::m_ConstantWeights, LayerSupportHandle::output, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), and armnn::warning.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output, weights, biases};

    Optional<const BackendOptions::BackendOption> capability;
    if (!m_BackendId.IsUndefined())
    {
        capability = GetCapability("NonConstWeights", m_BackendId);
        if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
        {
            if (!descriptor.m_ConstantWeights)
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
                            "FullyConnected descriptor indicates that weights are dynamic (non constant). ";
                }
                return false;
            }
            if (!weights.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
                            "FullyConnected weights are set as dynamic (non constant). ";
                }

                return false;
            }
            if (descriptor.m_BiasEnabled && !biases.IsConstant())
            {
                if (reasonIfUnsupported.has_value())
                {
                    reasonIfUnsupported.value() =
                            "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
                            "FullyConnected biases are set as dynamic (non constant). ";
                }
                return false;
            }

            // At the first stage we will only print a warning. this is to give
            // backend developers a chance to adopt and read weights from input slots.
            ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
                                  "If you are a backend developer please find more information in our "
                                  "doxygen documentation on github https://github.com/ARM-software/armnn "
                                  "under the keyword 'ConstTensorsAsInputs'.";
        }
    }

    return m_LayerSupport->IsLayerSupported(LayerType::FullyConnected,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsGatherNdSupported()

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

Definition at line 762 of file BackendHelper.cpp.

References armnn::GatherNd.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::GatherNd,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsGatherSupported()

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

Definition at line 746 of file BackendHelper.cpp.

References armnn::Gather.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Gather,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsInputSupported()

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

Definition at line 777 of file BackendHelper.cpp.

References armnn::Input.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input};

    return m_LayerSupport->IsLayerSupported(LayerType::Input,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsInstanceNormalizationSupported()

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

Definition at line 790 of file BackendHelper.cpp.

References armnn::InstanceNormalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::InstanceNormalization,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsL2NormalizationSupported()

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

Definition at line 806 of file BackendHelper.cpp.

References armnn::L2Normalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::L2Normalization,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsLogicalBinarySupported()

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

Definition at line 821 of file BackendHelper.cpp.

References armnn::LogicalBinary.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::LogicalBinary,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsLogicalUnarySupported()

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

Definition at line 837 of file BackendHelper.cpp.

References armnn::ElementwiseUnary.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseUnary,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsLogSoftmaxSupported()

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

Definition at line 852 of file BackendHelper.cpp.

References armnn::LogSoftmax.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::LogSoftmax,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

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()
	)

Definition at line 867 of file BackendHelper.cpp.

References LayerSupportHandle::cellStateIn, armnn::Lstm, and LayerSupportHandle::outputStateIn.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, outputStateIn, cellStateIn, scratchBuffer, outputStateOut, cellStateOut, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Lstm,
                                            infos,
                                            descriptor,
                                            paramsInfo,
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMaximumSupported()

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

Definition at line 888 of file BackendHelper.cpp.

References armnn::Maximum.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Maximum,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMeanSupported()

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

Definition at line 903 of file BackendHelper.cpp.

References armnn::Mean.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Mean,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMemCopySupported()

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

Definition at line 918 of file BackendHelper.cpp.

References armnn::MemCopy.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::MemCopy,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMemImportSupported()

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

Definition at line 932 of file BackendHelper.cpp.

References armnn::MemImport.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::MemImport,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMergeSupported()

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

Definition at line 946 of file BackendHelper.cpp.

References armnn::Merge.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Merge,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMinimumSupported()

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

Definition at line 961 of file BackendHelper.cpp.

References armnn::Minimum.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Minimum,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsMultiplicationSupported()

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

Definition at line 976 of file BackendHelper.cpp.

References armnn::Multiplication.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Multiplication,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsNormalizationSupported()

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

Definition at line 991 of file BackendHelper.cpp.

References armnn::Normalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Normalization,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsOutputSupported()

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

Definition at line 1006 of file BackendHelper.cpp.

References armnn::Output.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{output};

    return m_LayerSupport->IsLayerSupported(LayerType::Output,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsPadSupported()

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

Definition at line 1019 of file BackendHelper.cpp.

References armnn::Pad.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Pad,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsPermuteSupported()

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

Definition at line 1034 of file BackendHelper.cpp.

References armnn::Permute.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Permute,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsPooling2dSupported()

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

Definition at line 1049 of file BackendHelper.cpp.

References armnn::Pooling2d.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Pooling2d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsPooling3dSupported()

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

Definition at line 1064 of file BackendHelper.cpp.

References armnn::Pooling3d.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Pooling3d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsPreCompiledSupported()

bool IsPreCompiledSupported	(	const TensorInfo &	input,
		const PreCompiledDescriptor &	descriptor,
		Optional< std::string &>	reasonIfUnsupported = EmptyOptional()
	)

Definition at line 1079 of file BackendHelper.cpp.

References armnn::PreCompiled.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input};

    return m_LayerSupport->IsLayerSupported(LayerType::PreCompiled,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsPreluSupported()

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

Definition at line 1093 of file BackendHelper.cpp.

References armnn::Prelu.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, alpha, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Prelu,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

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()
	)

Definition at line 1122 of file BackendHelper.cpp.

References armnn::QLstm.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, previousOutputIn, previousCellStateIn, outputStateOut, cellStateOut, output};

    return m_LayerSupport->IsLayerSupported(LayerType::QLstm,
                                            infos,
                                            descriptor,
                                            paramsInfo,
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsQuantizedLstmSupported()

bool IsQuantizedLstmSupported	(	const TensorInfo &	input,
		const TensorInfo &	previousCellStateIn,
		const TensorInfo &	previousOutputIn,
		const TensorInfo &	cellStateOut,
		const TensorInfo &	output,
		const QuantizedLstmInputParamsInfo &	paramsInfo,
		Optional< std::string &>	reasonIfUnsupported = EmptyOptional()
	)

Definition at line 1142 of file BackendHelper.cpp.

References armnn::QuantizedLstm.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, previousCellStateIn, previousOutputIn, cellStateOut, output};

    return m_LayerSupport->IsLayerSupported(LayerType::QuantizedLstm,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            paramsInfo,
                                            reasonIfUnsupported);
}

IsQuantizeSupported()

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

Definition at line 1108 of file BackendHelper.cpp.

References armnn::Quantize.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Quantize,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsRankSupported()

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

Definition at line 1160 of file BackendHelper.cpp.

References armnn::Rank.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Rank,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsReduceSupported()

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

Definition at line 1174 of file BackendHelper.cpp.

References armnn::Reduce.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Reduce,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsReshapeSupported()

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

Definition at line 1189 of file BackendHelper.cpp.

References armnn::Reshape.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Reshape,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsResizeSupported()

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

Definition at line 1204 of file BackendHelper.cpp.

References armnn::Resize.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Resize,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsShapeSupported()

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

Definition at line 1219 of file BackendHelper.cpp.

References armnn::Shape.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Shape,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSliceSupported()

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

Definition at line 1233 of file BackendHelper.cpp.

References armnn::Slice.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Slice,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSoftmaxSupported()

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

Definition at line 1248 of file BackendHelper.cpp.

References armnn::Softmax.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Softmax,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSpaceToBatchNdSupported()

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

Definition at line 1263 of file BackendHelper.cpp.

References armnn::SpaceToBatchNd.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::SpaceToBatchNd,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSpaceToDepthSupported()

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

Definition at line 1278 of file BackendHelper.cpp.

References armnn::SpaceToDepth.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::SpaceToDepth,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSplitterSupported()

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

Definition at line 1293 of file BackendHelper.cpp.

References armnn::Splitter.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input};
    for (TensorInfo outInfo : outputs)
    {
        infos.push_back(outInfo);
    }

    return m_LayerSupport->IsLayerSupported(LayerType::Splitter,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsStackSupported()

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

Definition at line 1312 of file BackendHelper.cpp.

References armnn::Stack.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos;
    for (const TensorInfo* inputInfo : inputs)
    {
        infos.push_back(*inputInfo);
    }
    infos.push_back(output);

    return m_LayerSupport->IsLayerSupported(LayerType::Stack,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsStandInSupported()

bool IsStandInSupported	(	const std::vector< const TensorInfo *> &	inputs,
		const std::vector< const TensorInfo *> &	outputs,
		const StandInDescriptor &	descriptor,
		Optional< std::string &>	reasonIfUnsupported = EmptyOptional()
	)

Definition at line 1332 of file BackendHelper.cpp.

References armnn::StandIn.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos;
    for (const TensorInfo* inputInfo : inputs)
    {
        infos.push_back(*inputInfo);
    }
    for (const TensorInfo* outputInfo : outputs)
    {
        infos.push_back(*outputInfo);
    }

    return m_LayerSupport->IsLayerSupported(LayerType::StandIn,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsStridedSliceSupported()

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

Definition at line 1356 of file BackendHelper.cpp.

References armnn::StridedSlice.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::StridedSlice,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSubtractionSupported()

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

Definition at line 1371 of file BackendHelper.cpp.

References armnn::Subtraction.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Subtraction,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsSwitchSupported()

bool IsSwitchSupported	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output0,
		const TensorInfo &	output1,
		Optional< std::string &>	reasonIfUnsupported = EmptyOptional()
	)

Definition at line 1386 of file BackendHelper.cpp.

References armnn::Switch.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input0, input1, output0, output1};

    return m_LayerSupport->IsLayerSupported(LayerType::Switch,
                                            infos,
                                            BaseDescriptor(),
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsTransposeConvolution2dSupported()

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

Definition at line 1402 of file BackendHelper.cpp.

References OptionalBase::has_value(), LayerSupportHandle::output, armnn::TransposeConvolution2d, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfo biasesVal =  biases.has_value() ? biases.value() : TensorInfo();
    TensorInfos infos{input, output, weights, biasesVal};

    return m_LayerSupport->IsLayerSupported(LayerType::TransposeConvolution2d,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsTransposeSupported()

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

Definition at line 1421 of file BackendHelper.cpp.

References armnn::Transpose.

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfos infos{input, output};

    return m_LayerSupport->IsLayerSupported(LayerType::Transpose,
                                            infos,
                                            descriptor,
                                            EmptyOptional(),
                                            EmptyOptional(),
                                            reasonIfUnsupported);
}

IsUnidirectionalSequenceLstmSupported()

bool IsUnidirectionalSequenceLstmSupported	(	const TensorInfo &	input,
		const TensorInfo &	outputStateIn,
		const TensorInfo &	cellStateIn,
		const TensorInfo &	outputStateOut,
		const TensorInfo &	cellStateOut,
		const TensorInfo &	output,
		const LstmDescriptor &	descriptor,
		const LstmInputParamsInfo &	paramsInfo,
		Optional< std::string &>	reasonIfUnsupported = EmptyOptional()
	)

Definition at line 1437 of file BackendHelper.cpp.

References LayerSupportHandle::cellStateIn, LayerSupportHandle::descriptor, OptionalBase::has_value(), LayerSupportHandle::output, LayerSupportHandle::outputStateIn, LayerSupportHandle::paramsInfo, LayerSupportHandle::reasonIfUnsupported, armnn::UnidirectionalSequenceLstm, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by LayerSupportHandle::LayerSupportHandle().

{
    TensorInfo hiddenStateOutputVal =  hiddenStateOutput.has_value() ? hiddenStateOutput.value() : TensorInfo();
    TensorInfo cellStateOutputVal   =  cellStateOutput.has_value() ? cellStateOutput.value() : TensorInfo();
    TensorInfos infos{input, outputStateIn, cellStateIn, hiddenStateOutputVal, cellStateOutputVal, output};

    return IsUnidirectionalSequenceLstmSupported(input,
                                                 outputStateIn,
                                                 cellStateIn,
                                                 hiddenStateOutputVal,
                                                 cellStateOutputVal,
                                                 output,
                                                 descriptor,
                                                 paramsInfo,
                                                 reasonIfUnsupported);
}

Member Data Documentation

cellStateIn

const TensorInfo const TensorInfo& cellStateIn

Definition at line 424 of file BackendHelper.hpp.

Referenced by LayerSupportHandle::IsLstmSupported(), LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), and LayerSupportHandle::LayerSupportHandle().

cellStateOutput

const TensorInfo const TensorInfo const TensorInfo const Optional<TensorInfo> const Optional<TensorInfo>& cellStateOutput

Definition at line 424 of file BackendHelper.hpp.

descriptor

const TensorInfo const TensorInfo const TensorInfo const Optional<TensorInfo> const Optional<TensorInfo> const LstmDescriptor& descriptor

Definition at line 424 of file BackendHelper.hpp.

Referenced by LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), and LayerSupportHandle::LayerSupportHandle().

hiddenStateOutput

const TensorInfo const TensorInfo const TensorInfo const Optional<TensorInfo>& hiddenStateOutput

Definition at line 424 of file BackendHelper.hpp.

output

const TensorInfo const TensorInfo const TensorInfo& output

Definition at line 424 of file BackendHelper.hpp.

Referenced by LayerSupportHandle::IsBatchNormalizationSupported(), LayerSupportHandle::IsConvolution2dSupported(), LayerSupportHandle::IsConvolution3dSupported(), LayerSupportHandle::IsDepthwiseConvolutionSupported(), LayerSupportHandle::IsDilatedDepthwiseConvolutionSupported(), LayerSupportHandle::IsFullyConnectedSupported(), LayerSupportHandle::IsTransposeConvolution2dSupported(), LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), and LayerSupportHandle::LayerSupportHandle().

outputStateIn

const TensorInfo& outputStateIn

Definition at line 424 of file BackendHelper.hpp.

Referenced by LayerSupportHandle::IsLstmSupported(), LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), and LayerSupportHandle::LayerSupportHandle().

paramsInfo

const TensorInfo const TensorInfo const TensorInfo const Optional<TensorInfo> const Optional<TensorInfo> const LstmDescriptor const LstmInputParamsInfo& paramsInfo

Definition at line 424 of file BackendHelper.hpp.

Referenced by LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), and LayerSupportHandle::LayerSupportHandle().

reasonIfUnsupported

const TensorInfo const TensorInfo const TensorInfo const Optional<TensorInfo> const Optional<TensorInfo> const LstmDescriptor const LstmInputParamsInfo Optional<std::string&> reasonIfUnsupported = EmptyOptional())

Definition at line 431 of file BackendHelper.hpp.

Referenced by LayerSupportHandle::IsUnidirectionalSequenceLstmSupported(), and LayerSupportHandle::LayerSupportHandle().

---

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

• include/armnn/BackendHelper.hpp
• src/armnn/BackendHelper.cpp