ClLayerSupport Class Reference

#include <ClLayerSupport.hpp>

Inheritance diagram for ClLayerSupport:

Collaboration diagram for ClLayerSupport:

Public Member Functions
	ClLayerSupport (const IBackendInternal::IBackendSpecificModelContextPtr &modelContextPtr)
	ClLayerSupport ()
	~ClLayerSupport ()
bool	IsLayerSupported (const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo, const Optional< QuantizedLstmInputParamsInfo > &quantizedLstmParamsInfo, Optional< std::string & > reasonIfUnsupported) const
	Default implementation of the ILayerSupport interface, Backends should implement this as a switch statement for each of their LayerTypes calling their specific backend implementation of IsXXXLayerSupported.
bool	IsActivationSupported (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsAdditionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsArgMinMaxSupported (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsBatchMatMulSupported (const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
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
bool	IsBatchToSpaceNdSupported (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsCastSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsChannelShuffleSupported (const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsComparisonSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &ouput, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsConcatSupported (const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsConstantSupported (const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsConvolution3dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reason=EmptyOptional()) const
bool	IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsFillSupported (const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsFloorSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsFullyConnectedSupported (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsGatherNdSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported) const
bool	IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
bool	IsInputSupported (const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsInstanceNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsL2NormalizationSupported (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsLogicalBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
bool	IsLogSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
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
bool	IsMaximumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsMeanSupported (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsMinimumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsMultiplicationSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsOutputSupported (const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsPadSupported (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsPermuteSupported (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsPooling2dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsPooling3dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
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
bool	IsQuantizedLstmSupported (const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsQuantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsReverseV2Supported (const TensorInfo &input, const TensorInfo &axis, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported) const
bool	IsScatterNdSupported (const TensorInfo &input, const TensorInfo &indices, const TensorInfo &updates, const TensorInfo &output, const ScatterNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsSpaceToBatchNdSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsSpaceToDepthSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsSplitterSupported (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo > > &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsStackSupported (const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsStridedSliceSupported (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsSubtractionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsTransposeConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsTileSupported (const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsUnidirectionalSequenceLstmSupported (const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported) const
Public Member Functions inherited from LayerSupportBase
bool	IsLayerSupported (const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo=EmptyOptional(), const Optional< QuantizedLstmInputParamsInfo > &quantizedLstmParamsInfo=EmptyOptional(), Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
	Default implementation of the ILayerSupport interface, Backends should implement this as a switch statement for each of their LayerTypes calling their specific backend implementation of IsXXXLayerSupported.
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
bool	IsMemCopySupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsMemImportSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsMergeSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsQuantizedLstmSupported (const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsShapeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
bool	IsStandInSupported (const std::vector< const TensorInfo * > &inputs, const std::vector< const TensorInfo * > &outputs, const StandInDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const

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

Detailed Description

Definition at line 14 of file ClLayerSupport.hpp.

Constructor & Destructor Documentation

ClLayerSupport() [1/2]

ClLayerSupport ( const IBackendInternal::IBackendSpecificModelContextPtr & modelContextPtr )

explicit

Definition at line 180 of file ClLayerSupport.cpp.

    : m_ModelContextPtr(modelContextPtr)
{
}

ClLayerSupport() [2/2]

ClLayerSupport

(

)

Definition at line 185 of file ClLayerSupport.cpp.

    : m_ModelContextPtr(nullptr)
{
}

~ClLayerSupport()

~ClLayerSupport ( )

inline

Definition at line 19 of file ClLayerSupport.hpp.

{}

Member Function Documentation

IsActivationSupported()

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

Definition at line 713 of file ClLayerSupport.cpp.

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

References armnn::ClActivationWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsAdditionSupported()

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

Definition at line 725 of file ClLayerSupport.cpp.

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

References armnn::ClAdditionValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsArgMinMaxSupported()

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

Definition at line 738 of file ClLayerSupport.cpp.

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

References armnn::ClArgMinMaxWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsBatchMatMulSupported()

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

Definition at line 751 of file ClLayerSupport.cpp.

{
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchMatMulValidate,
                                   reasonIfUnsupported,
                                   inputX,
                                   inputY,
                                   output,
                                   descriptor,
                                   nullptr);
}

References armnn::ClBatchMatMulValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 766 of file ClLayerSupport.cpp.

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

References armnn::ClBatchNormalizationValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsBatchToSpaceNdSupported()

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

Definition at line 787 of file ClLayerSupport.cpp.

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

References armnn::ClBatchToSpaceNdWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsCastSupported()

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

Definition at line 799 of file ClLayerSupport.cpp.

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

References armnn::ClCastValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsChannelShuffleSupported()

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

Definition at line 809 of file ClLayerSupport.cpp.

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

References armnn::ClChannelShuffleValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsComparisonSupported()

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

Definition at line 821 of file ClLayerSupport.cpp.

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

References armnn::ClComparisonWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsConcatSupported()

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

Definition at line 835 of file ClLayerSupport.cpp.

{
    if (descriptor.GetNumDimensions() <= descriptor.GetConcatAxis())
    {
        SetValueChecked(reasonIfUnsupported, "Cl 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(ClConcatWorkloadValidate,
                                       reasonIfUnsupported,
                                       inputs,
                                       output,
                                       descriptor);
    }
    else if (concatInnerAxis == 3)
    {
        // We rely on the sub-tensor optimization to handle the batch dimension for 4D tensors. If we can't use
        // sub-tensors for this then we can't support it. Here is where we check that the sub-tensors will work.
        for (auto& input : inputs)
        {
            if (input && !output.IsTypeSpaceMatch(*input)) // Cannot use sub-tensors if the types are not same space
            {
                SetValueChecked(reasonIfUnsupported, "Cl Concat: Types and quantization parameters must match.");
                return false;
            }
        }
        return true; // Sub-tensors support concat along batch
    }
    else // > 4 dimensions not supported.
    {
        SetValueChecked(reasonIfUnsupported, "Cl Concat: Maximum of 4 dimensions supported.");
        return false;
    }
}

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

Referenced by ClLayerSupport::IsLayerSupported().

IsConstantSupported()

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

Definition at line 876 of file ClLayerSupport.cpp.

{
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClConstantWorkloadValidate,
                                   reasonIfUnsupported,
                                   output);
}

References armnn::ClConstantWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsConvertFp16ToFp32Supported()

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

Definition at line 884 of file ClLayerSupport.cpp.

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

References armnn::ClConvertFp16ToFp32WorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsConvertFp32ToFp16Supported()

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

Definition at line 894 of file ClLayerSupport.cpp.

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

References armnn::ClConvertFp32ToFp16WorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 904 of file ClLayerSupport.cpp.

{
    bool isFastMathEnabled = false;
#if defined(ARMCOMPUTECL_ENABLED)
    if (m_ModelContextPtr)
    {
        if (m_ModelContextPtr.get() != nullptr)
        {
            auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
            if (modelOptions)
            {
                isFastMathEnabled = modelOptions->IsFastMathEnabled();
            }
        }
    }
#endif
 
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvolution2dWorkloadValidate,
                                   reasonIfUnsupported,
                                   input,
                                   output,
                                   descriptor,
                                   weights,
                                   biases,
                                   isFastMathEnabled,
                                   nullptr);
}

References armnn::ClConvolution2dWorkloadValidate(), FORWARD_WORKLOAD_VALIDATE_FUNC, and ClBackendModelContext::IsFastMathEnabled().

Referenced by ClLayerSupport::IsLayerSupported().

IsConvolution3dSupported()

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

Definition at line 937 of file ClLayerSupport.cpp.

{
    bool isFastMathEnabled = false;
#if defined(ARMCOMPUTECL_ENABLED)
    if (m_ModelContextPtr)
{
    if (m_ModelContextPtr.get() != nullptr)
    {
        auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
        if (modelOptions)
        {
            isFastMathEnabled = modelOptions->IsFastMathEnabled();
        }
    }
}
#endif
 
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvolution3dWorkloadValidate,
                                   reasonIfUnsupported,
                                   input,
                                   output,
                                   descriptor,
                                   weights,
                                   biases,
                                   isFastMathEnabled,
                                   nullptr);
}

References armnn::ClConvolution3dWorkloadValidate(), FORWARD_WORKLOAD_VALIDATE_FUNC, and ClBackendModelContext::IsFastMathEnabled().

Referenced by ClLayerSupport::IsLayerSupported().

IsDepthToSpaceSupported()

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

Definition at line 980 of file ClLayerSupport.cpp.

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

References armnn::ClDepthToSpaceWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 992 of file ClLayerSupport.cpp.

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

References armnn::ClDepthwiseConvolutionWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsDequantizeSupported()

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

Definition at line 970 of file ClLayerSupport.cpp.

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

References armnn::ClDequantizeWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 1009 of file ClLayerSupport.cpp.

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

References armnn::ClDepthwiseConvolutionWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

IsDivisionSupported()

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

Definition at line 1027 of file ClLayerSupport.cpp.

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

References armnn::ClDivisionWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsElementwiseUnarySupported()

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

Definition at line 1040 of file ClLayerSupport.cpp.

{
    switch(descriptor.m_Operation)
    {
        case UnaryOperation::Abs:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClAbsWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::Exp:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClExpWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::Log:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::LogicalNot:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogicalNotWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::Neg:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClNegWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::Rsqrt:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClRsqrtWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::Sin:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClSinWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        case UnaryOperation::Sqrt:
            FORWARD_WORKLOAD_VALIDATE_FUNC(ClSqrtWorkloadValidate,
                                           reasonIfUnsupported,
                                           input,
                                           output);
        default:
            return false;
    }
}

References armnn::Abs, armnn::ClAbsWorkloadValidate(), armnn::ClExpWorkloadValidate(), armnn::ClLogicalNotWorkloadValidate(), armnn::ClLogWorkloadValidate(), armnn::ClNegWorkloadValidate(), armnn::ClRsqrtWorkloadValidate(), armnn::ClSinWorkloadValidate(), armnn::ClSqrtWorkloadValidate(), armnn::Exp, FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::Log, armnn::LogicalNot, ElementwiseUnaryDescriptor::m_Operation, armnn::Neg, armnn::Rsqrt, armnn::Sin, and armnn::Sqrt.

Referenced by ClLayerSupport::IsLayerSupported().

IsFillSupported()

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

Definition at line 1092 of file ClLayerSupport.cpp.

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

References armnn::IgnoreUnused().

Referenced by ClLayerSupport::IsLayerSupported().

IsFloorSupported()

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

Definition at line 1104 of file ClLayerSupport.cpp.

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

References armnn::ClFloorWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsFullyConnectedSupported()

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

Definition at line 1114 of file ClLayerSupport.cpp.

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

References armnn::ClFullyConnectedWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsGatherNdSupported()

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

Definition at line 1145 of file ClLayerSupport.cpp.

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

References armnn::ClGatherNdWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsGatherSupported()

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

Definition at line 1131 of file ClLayerSupport.cpp.

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

References armnn::ClGatherWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsInputSupported()

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

Definition at line 1157 of file ClLayerSupport.cpp.

{
    return IsClBackendSupported(reasonIfUnsupported, input);
}

Referenced by ClLayerSupport::IsLayerSupported().

IsInstanceNormalizationSupported()

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

Definition at line 1163 of file ClLayerSupport.cpp.

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

References armnn::ClInstanceNormalizationWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsL2NormalizationSupported()

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

Definition at line 1175 of file ClLayerSupport.cpp.

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

References armnn::ClL2NormalizationWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsLayerSupported()

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

virtual

Default implementation of the ILayerSupport interface, Backends should implement this as a switch statement for each of their LayerTypes calling their specific backend implementation of IsXXXLayerSupported.

Reimplemented from ILayerSupport.

Definition at line 190 of file ClLayerSupport.cpp.

{
    switch (type)
    {
        case LayerType::Activation:
            return IsActivationSupported(infos[0],
                                         infos[1],
                                         *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
        case LayerType::Addition:
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return IsAdditionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
            ARMNN_NO_DEPRECATE_WARN_END
        case LayerType::ArgMinMax:
            return IsArgMinMaxSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::BatchMatMul:
            return IsBatchMatMulSupported(infos[0],
                                          infos[1],
                                          infos[2],
                                          *(PolymorphicDowncast<const BatchMatMulDescriptor*>(&descriptor)),
                                          reasonIfUnsupported);
        case LayerType::BatchNormalization:
            return IsBatchNormalizationSupported(infos[0],
                                                 infos[1],
                                                 infos[2],
                                                 infos[3],
                                                 infos[4],
                                                 infos[5],
                                                 *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
                                                     (&descriptor)),
                                                 reasonIfUnsupported);
        case LayerType::BatchToSpaceNd:
            return IsBatchToSpaceNdSupported(infos[0],
                                             infos[1],
                                             *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::Cast:
            return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::ChannelShuffle:
            return IsChannelShuffleSupported(infos[0],
                                             infos[1],
                                             *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::Comparison:
            return IsComparisonSupported(infos[0],
                                         infos[1],
                                         infos[2],
                                         *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
        case LayerType::Concat:
        {
            std::vector<const TensorInfo*> inputInfos;
            for (uint32_t i = 0; i < (infos.size() - 1); i++)
            {
                inputInfos.push_back(&infos[i]);
            }
            return IsConcatSupported(inputInfos,
                                     infos[infos.size() - 1],
                                     *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        }
        case LayerType::Constant:
            return IsConstantSupported(infos[0], reasonIfUnsupported);
        case LayerType::ConvertFp16ToFp32:
            return IsConvertFp16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::ConvertFp32ToFp16:
            return IsConvertFp32ToFp16Supported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::Convolution2d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of Convolution2d TensorInfos. "
                                               "TensorInfos should be of format: {input, output, weights, biases}.");
            }
 
            auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsConvolution2dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                EmptyOptional(),
                                                reasonIfUnsupported);
            }
            else
            {
                return IsConvolution2dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                infos[3],
                                                reasonIfUnsupported);
            }
        }
        case LayerType::Convolution3d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
                                               "TensorInfos should be of format: {input, output, weights, biases}.");
            }
 
            auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsConvolution3dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                EmptyOptional(),
                                                reasonIfUnsupported);
            }
            else
            {
                return IsConvolution3dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                infos[3],
                                                reasonIfUnsupported);
            }
        }
        case LayerType::DepthToSpace:
            return IsDepthToSpaceSupported(infos[0],
                                           infos[1],
                                           *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
                                           reasonIfUnsupported);
        case LayerType::DepthwiseConvolution2d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d TensorInfos. "
                                               "TensorInfos should be of format: {input, output, weights, biases}.");
            }
 
            auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsDepthwiseConvolutionSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                EmptyOptional(),
                                                reasonIfUnsupported);
            }
            else
            {
                return IsDepthwiseConvolutionSupported(infos[0],
                                                         infos[1],
                                                         desc,
                                                         infos[2],
                                                         infos[3],
                                                         reasonIfUnsupported);
            }
        }
        case LayerType::Dequantize:
            return IsDequantizeSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::Division:
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return IsDivisionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
            ARMNN_NO_DEPRECATE_WARN_END
        case LayerType::ElementwiseBinary:
        {
            auto desc = *(PolymorphicDowncast<const ElementwiseBinaryDescriptor *>(&descriptor));
 
            switch (desc.m_Operation)
            {
                case BinaryOperation::Add:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClAdditionValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   nullptr);
                case BinaryOperation::Div:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClDivisionWorkloadValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   nullptr);
                case BinaryOperation::FloorDiv:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClFloorDivWorkloadValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   nullptr);
                case BinaryOperation::Minimum:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClMinimumWorkloadValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2]);
                case BinaryOperation::Maximum:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClMaximumWorkloadValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2]);
                case BinaryOperation::Mul:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClMultiplicationWorkloadValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   nullptr);
                case BinaryOperation::Power:
                case BinaryOperation::SqDiff:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClElementwiseBinaryValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   desc,
                                                   nullptr);
                case BinaryOperation::Sub:
                    FORWARD_WORKLOAD_VALIDATE_FUNC(ClSubtractionValidate,
                                                   reasonIfUnsupported,
                                                   infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   nullptr);
                default:
                    return false;
            }
        }
        case LayerType::ElementwiseUnary:
            return IsElementwiseUnarySupported(infos[0],
                                               infos[1],
                                               *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor)),
                                               reasonIfUnsupported);
        case LayerType::Fill:
            return IsFillSupported(infos[0],
                                   infos[1],
                                   *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
                                   reasonIfUnsupported);
        case LayerType::Floor:
            return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::FullyConnected:
            return IsFullyConnectedSupported(infos[0],
                                             infos[1],
                                             infos[2],
                                             infos[3],
                                             *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::Gather:
            return IsGatherSupported(infos[0],
                                     infos[1],
                                     infos[2],
                                     *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        case LayerType::GatherNd:
            return IsGatherNdSupported(infos[0],
                                       infos[1],
                                       infos[2],
                                       reasonIfUnsupported);
        case LayerType::Input:
            return IsInputSupported(infos[0], reasonIfUnsupported);
        case LayerType::InstanceNormalization:
            return IsInstanceNormalizationSupported(infos[0],
                                                    infos[1],
                                                    *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
                                                        (&descriptor)),
                                                    reasonIfUnsupported);
        case LayerType::L2Normalization:
            return IsL2NormalizationSupported(infos[0],
                                              infos[1],
                                              *(PolymorphicDowncast<const L2NormalizationDescriptor*>(&descriptor)),
                                              reasonIfUnsupported);
        case LayerType::LogicalBinary:
            return IsLogicalBinarySupported(infos[0],
                                            infos[1],
                                            infos[2],
                                            *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
                                            reasonIfUnsupported);
        case LayerType::LogSoftmax:
            return IsLogSoftmaxSupported(infos[0],
                                         infos[1],
                                         *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
        case LayerType::Lstm:
            return IsLstmSupported(infos[0],
                                   infos[1],
                                   infos[2],
                                   infos[3],
                                   infos[4],
                                   infos[5],
                                   infos[6],
                                   *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
                                   lstmParamsInfo.value(),
                                   reasonIfUnsupported);
        case LayerType::Map:
            return true;
        case LayerType::MemCopy:
            return LayerSupportBase::IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::MemImport:
            return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::Merge:
            return LayerSupportBase::IsMergeSupported(infos[0],
                                                      infos[1],
                                                      infos[2],
                                                      reasonIfUnsupported);
        case LayerType::Maximum:
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return IsMaximumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
            ARMNN_NO_DEPRECATE_WARN_END
        case LayerType::Mean:
            return IsMeanSupported(infos[0],
                                   infos[1],
                                   *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
                                   reasonIfUnsupported);
        case LayerType::Minimum:
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return IsMinimumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
            ARMNN_NO_DEPRECATE_WARN_END
        case LayerType::Multiplication:
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return IsMultiplicationSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
            ARMNN_NO_DEPRECATE_WARN_END
        case LayerType::Normalization:
            return IsNormalizationSupported(infos[0],
                                            infos[1],
                                            *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
                                            reasonIfUnsupported);
        case LayerType::Output:
            return IsOutputSupported(infos[0], reasonIfUnsupported);
        case LayerType::Pad:
            return IsPadSupported(infos[0],
                                  infos[1],
                                  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
                                  reasonIfUnsupported);
        case LayerType::Permute:
            return IsPermuteSupported(infos[0],
                                      infos[1],
                                      *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
                                      reasonIfUnsupported);
        case LayerType::Pooling2d:
            return IsPooling2dSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::Pooling3d:
            return IsPooling3dSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::Prelu:
            return IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
        case LayerType::QLstm:
            return IsQLstmSupported(infos[0],
                                    infos[1],
                                    infos[2],
                                    infos[3],
                                    infos[4],
                                    infos[5],
                                    *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
                                    lstmParamsInfo.value(),
                                    reasonIfUnsupported);
        case LayerType::Quantize:
            return IsQuantizeSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::QuantizedLstm:
            return IsQuantizedLstmSupported(infos[0],
                                            infos[1],
                                            infos[2],
                                            infos[3],
                                            infos[4],
                                            quantizedLstmParamsInfo.value(),
                                            reasonIfUnsupported);
        case LayerType::Rank:
            return true;
        case LayerType::Reduce:
            return IsReduceSupported(infos[0],
                                     infos[1],
                                     *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        case LayerType::Reshape:
            return IsReshapeSupported(infos[0],
                                      infos[1],
                                      *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
                                      reasonIfUnsupported);
        case LayerType::Resize:
            return IsResizeSupported(infos[0],
                                     infos[1],
                                     *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        case LayerType::ReverseV2:
            return IsReverseV2Supported(infos[0],
                                        infos[1],
                                        infos[2],
                                        reasonIfUnsupported);
        case LayerType::ScatterNd:
            return IsScatterNdSupported(infos[0], // input/shape
                                        infos[1], // indices
                                        infos[2], // updates
                                        infos[3], // output
                                        *(PolymorphicDowncast<const ScatterNdDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::Shape:
            return LayerSupportBase::IsShapeSupported(infos[0],
                                                      infos[1],
                                                      reasonIfUnsupported);
        case LayerType::Slice:
            return IsSliceSupported(infos[0],
                                    infos[1],
                                    *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
                                    reasonIfUnsupported);
        case LayerType::Softmax:
            return IsSoftmaxSupported(infos[0],
                                      infos[1],
                                      *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
                                      reasonIfUnsupported);
        case LayerType::SpaceToBatchNd:
            return IsSpaceToBatchNdSupported(infos[0],
                                             infos[1],
                                             *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::SpaceToDepth:
            return IsSpaceToDepthSupported(infos[0],
                                           infos[1],
                                           *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
                                           reasonIfUnsupported);
        case LayerType::Splitter:
        {
            std::vector<TensorInfo> outputInfos;
            for (uint32_t i = 1; i < infos.size(); i++)
            {
                outputInfos.push_back(infos[i]);
            }
            return IsSplitterSupported(infos[0],
                                       {outputInfos.begin(), outputInfos.end()},
                                       *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
                                       reasonIfUnsupported);
        }
        case LayerType::Stack:
        {
            std::vector<const TensorInfo*> inputInfos;
            for (uint32_t i = 0; i < infos.size() - 1; i++)
            {
                inputInfos.push_back(&infos[i]);
            }
            return IsStackSupported(inputInfos,
                                    infos[infos.size() - 1],
                                    *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
                                    reasonIfUnsupported);
        }
        case LayerType::StridedSlice:
            return IsStridedSliceSupported(infos[0],
                                           infos[1],
                                           *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
                                           reasonIfUnsupported);
        case LayerType::Subtraction:
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
            ARMNN_NO_DEPRECATE_WARN_END
        case LayerType::Tile:
            return IsTileSupported(infos[0],
                                   infos[1],
                                   *(PolymorphicDowncast<const TileDescriptor*>(&descriptor)),
                                   reasonIfUnsupported);
        case LayerType::Transpose:
            return IsTransposeSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::TransposeConvolution2d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
                                               "TensorInfos should be of format: {input, output, weights, biases}.");
            }
 
            auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsTransposeConvolution2dSupported(infos[0],
                                                         infos[1],
                                                         desc,
                                                         infos[2],
                                                         EmptyOptional(),
                                                         reasonIfUnsupported);
            }
            else
            {
                return IsTransposeConvolution2dSupported(infos[0],
                                                         infos[1],
                                                         desc,
                                                         infos[2],
                                                         infos[3],
                                                         reasonIfUnsupported);
            }
        }
        case LayerType::UnidirectionalSequenceLstm:
            return IsUnidirectionalSequenceLstmSupported(infos[0],
                                                         infos[1],
                                                         infos[2],
                                                         infos[3],
                                                         infos[4],
                                                         infos[5],
                                                         *(PolymorphicDowncast<const
                                                            UnidirectionalSequenceLstmDescriptor*>(&descriptor)),
                                                         lstmParamsInfo.value(),
                                                         reasonIfUnsupported);
        case LayerType::Unmap:
            return true;
        default:
            // layers not supported in cl by default:
            // debug, detectionpostprocess, fakequantization,
            // precompiled, standin, switch, pooling3d, fused
            return false;
    }
}

References armnn::Activation, armnn::Add, armnn::Addition, armnn::ArgMinMax, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Cast, armnn::ChannelShuffle, armnn::ClAdditionValidate(), armnn::ClDivisionWorkloadValidate(), armnn::ClElementwiseBinaryValidate(), armnn::ClFloorDivWorkloadValidate(), armnn::ClMaximumWorkloadValidate(), armnn::ClMinimumWorkloadValidate(), armnn::ClMultiplicationWorkloadValidate(), armnn::ClSubtractionValidate(), armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::Div, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::Fill, armnn::Floor, armnn::FloorDiv, FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, armnn::Input, armnn::InstanceNormalization, ClLayerSupport::IsActivationSupported(), ClLayerSupport::IsAdditionSupported(), ClLayerSupport::IsArgMinMaxSupported(), ClLayerSupport::IsBatchMatMulSupported(), ClLayerSupport::IsBatchNormalizationSupported(), ClLayerSupport::IsBatchToSpaceNdSupported(), ClLayerSupport::IsCastSupported(), ClLayerSupport::IsChannelShuffleSupported(), ClLayerSupport::IsComparisonSupported(), ClLayerSupport::IsConcatSupported(), ClLayerSupport::IsConstantSupported(), ClLayerSupport::IsConvertFp16ToFp32Supported(), ClLayerSupport::IsConvertFp32ToFp16Supported(), ClLayerSupport::IsConvolution2dSupported(), ClLayerSupport::IsConvolution3dSupported(), ClLayerSupport::IsDepthToSpaceSupported(), ClLayerSupport::IsDepthwiseConvolutionSupported(), ClLayerSupport::IsDequantizeSupported(), ClLayerSupport::IsDivisionSupported(), ClLayerSupport::IsElementwiseUnarySupported(), ClLayerSupport::IsFillSupported(), ClLayerSupport::IsFloorSupported(), ClLayerSupport::IsFullyConnectedSupported(), ClLayerSupport::IsGatherNdSupported(), ClLayerSupport::IsGatherSupported(), ClLayerSupport::IsInputSupported(), ClLayerSupport::IsInstanceNormalizationSupported(), ClLayerSupport::IsL2NormalizationSupported(), ClLayerSupport::IsLogicalBinarySupported(), ClLayerSupport::IsLogSoftmaxSupported(), ClLayerSupport::IsLstmSupported(), ClLayerSupport::IsMaximumSupported(), ClLayerSupport::IsMeanSupported(), LayerSupportBase::IsMemCopySupported(), LayerSupportBase::IsMemImportSupported(), LayerSupportBase::IsMergeSupported(), ClLayerSupport::IsMinimumSupported(), ClLayerSupport::IsMultiplicationSupported(), ClLayerSupport::IsNormalizationSupported(), ClLayerSupport::IsOutputSupported(), ClLayerSupport::IsPadSupported(), ClLayerSupport::IsPermuteSupported(), ClLayerSupport::IsPooling2dSupported(), ClLayerSupport::IsPooling3dSupported(), ClLayerSupport::IsPreluSupported(), ClLayerSupport::IsQLstmSupported(), ClLayerSupport::IsQuantizedLstmSupported(), ClLayerSupport::IsQuantizeSupported(), ClLayerSupport::IsReduceSupported(), ClLayerSupport::IsReshapeSupported(), ClLayerSupport::IsResizeSupported(), ClLayerSupport::IsReverseV2Supported(), ClLayerSupport::IsScatterNdSupported(), LayerSupportBase::IsShapeSupported(), ClLayerSupport::IsSliceSupported(), ClLayerSupport::IsSoftmaxSupported(), ClLayerSupport::IsSpaceToBatchNdSupported(), ClLayerSupport::IsSpaceToDepthSupported(), ClLayerSupport::IsSplitterSupported(), ClLayerSupport::IsStackSupported(), ClLayerSupport::IsStridedSliceSupported(), ClLayerSupport::IsSubtractionSupported(), ClLayerSupport::IsTileSupported(), ClLayerSupport::IsTransposeConvolution2dSupported(), ClLayerSupport::IsTransposeSupported(), ClLayerSupport::IsUnidirectionalSequenceLstmSupported(), armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Map, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Merge, armnn::Minimum, armnn::Mul, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::PolymorphicDowncast(), armnn::Pooling2d, armnn::Pooling3d, armnn::Power, armnn::Prelu, armnn::QLstm, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::ReverseV2, armnn::ScatterNd, armnn::Shape, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::SqDiff, armnn::Stack, armnn::StridedSlice, armnn::Sub, armnn::Subtraction, armnn::Tile, armnn::Transpose, armnn::TransposeConvolution2d, armnn::UnidirectionalSequenceLstm, armnn::Unmap, and OptionalReferenceSwitch< IsReference, T >::value().

IsLogicalBinarySupported()

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

Definition at line 1187 of file ClLayerSupport.cpp.

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

References armnn::ClLogicalAndWorkloadValidate(), armnn::ClLogicalOrWorkloadValidate(), FORWARD_WORKLOAD_VALIDATE_FUNC, armnn::IgnoreUnused(), armnn::LogicalAnd, armnn::LogicalOr, and LogicalBinaryDescriptor::m_Operation.

Referenced by ClLayerSupport::IsLayerSupported().

IsLogSoftmaxSupported()

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

Definition at line 1215 of file ClLayerSupport.cpp.

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

References armnn::ClLogSoftmaxWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 1227 of file ClLayerSupport.cpp.

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

References armnn::ClLstmFloatWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsMaximumSupported()

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

Definition at line 1251 of file ClLayerSupport.cpp.

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

References armnn::ClMaximumWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsMeanSupported()

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

Definition at line 1263 of file ClLayerSupport.cpp.

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

References armnn::ClMeanValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsMinimumSupported()

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

Definition at line 1275 of file ClLayerSupport.cpp.

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

References armnn::ClMinimumWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsMultiplicationSupported()

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

Definition at line 1287 of file ClLayerSupport.cpp.

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

References armnn::ClMultiplicationWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsNormalizationSupported()

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

Definition at line 1300 of file ClLayerSupport.cpp.

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

References armnn::ClNormalizationWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsOutputSupported()

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

Definition at line 1308 of file ClLayerSupport.cpp.

{
    return IsClBackendSupported(reasonIfUnsupported, output);
}

Referenced by ClLayerSupport::IsLayerSupported().

IsPadSupported()

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

Definition at line 1314 of file ClLayerSupport.cpp.

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

References armnn::ClPadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsPermuteSupported()

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

Definition at line 1326 of file ClLayerSupport.cpp.

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

References armnn::ClPermuteWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsPooling2dSupported()

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

Definition at line 1334 of file ClLayerSupport.cpp.

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

References armnn::ClPooling2dWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsPooling3dSupported()

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

Definition at line 1342 of file ClLayerSupport.cpp.

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

References armnn::ClPooling3dWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsPreluSupported()

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

Definition at line 1350 of file ClLayerSupport.cpp.

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

References armnn::ClPreluWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 1358 of file ClLayerSupport.cpp.

{
    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(ClQLstmWorkloadValidate,
                                       reasonIfUnsupported,
                                       input,
                                       previousCellStateIn,
                                       previousOutputIn,
                                       cellStateOut,
                                       outputStateOut,
                                       output,
                                       descriptor,
                                       paramsInfo);
    }
    else
    {
        return false;
    }
}

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

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 1392 of file ClLayerSupport.cpp.

{
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClQuantizedLstmWorkloadValidate,
                                   reasonIfUnsupported,
                                   input,
                                   previousCellStateIn,
                                   previousOutputIn,
                                   cellStateOut,
                                   output,
                                   paramsInfo);
}

References armnn::ClQuantizedLstmWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsQuantizeSupported()

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

Definition at line 1410 of file ClLayerSupport.cpp.

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

References armnn::ClQuantizeWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsReduceSupported()

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

Definition at line 1420 of file ClLayerSupport.cpp.

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

References armnn::ClReduceWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsReshapeSupported()

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

Definition at line 1432 of file ClLayerSupport.cpp.

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

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

Referenced by ClLayerSupport::IsLayerSupported().

IsResizeSupported()

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

Definition at line 1441 of file ClLayerSupport.cpp.

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

References armnn::ClResizeWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsReverseV2Supported()

bool IsReverseV2Supported	(	const TensorInfo &	input,
		const TensorInfo &	axis,
		const TensorInfo &	output,
		Optional< std::string & >	reasonIfUnsupported ) const

Definition at line 1449 of file ClLayerSupport.cpp.

{
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClReverseV2WorkloadValidate,
                                   reasonIfUnsupported,
                                   input,
                                   axis,
                                   output);
}

References armnn::ClReverseV2WorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsScatterNdSupported()

bool IsScatterNdSupported	(	const TensorInfo &	input,
		const TensorInfo &	indices,
		const TensorInfo &	updates,
		const TensorInfo &	output,
		const ScatterNdDescriptor &	descriptor,
		Optional< std::string & >	reasonIfUnsupported = EmptyOptional() ) const

Definition at line 1461 of file ClLayerSupport.cpp.

{
    FORWARD_WORKLOAD_VALIDATE_FUNC(ClScatterNdWorkloadValidate,
                                   reasonIfUnsupported,
                                   input,
                                   indices,
                                   updates,
                                   output,
                                   descriptor);
}

References armnn::ClScatterNdWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsSliceSupported()

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

Definition at line 1477 of file ClLayerSupport.cpp.

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

References armnn::ClSliceWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsSoftmaxSupported()

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

Definition at line 1485 of file ClLayerSupport.cpp.

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

References armnn::ClSoftmaxWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsSpaceToBatchNdSupported()

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

Definition at line 1493 of file ClLayerSupport.cpp.

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

References armnn::ClSpaceToBatchNdWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsSpaceToDepthSupported()

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

Definition at line 1505 of file ClLayerSupport.cpp.

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

References armnn::ClSpaceToDepthWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsSplitterSupported()

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

Definition at line 1517 of file ClLayerSupport.cpp.

{
#if defined(ARMCOMPUTECL_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(ClSplitterWorkloadValidate,
                                       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, "Cl Splitter: Types and quantization parameters must match.");
            return false;
        }
    }
    return true;
}

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

Referenced by ClLayerSupport::IsLayerSupported().

IsStackSupported()

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

Definition at line 1550 of file ClLayerSupport.cpp.

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

References armnn::ClStackWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsStridedSliceSupported()

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

Definition at line 1562 of file ClLayerSupport.cpp.

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

References armnn::ClStridedSliceWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsSubtractionSupported()

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

Definition at line 1574 of file ClLayerSupport.cpp.

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

References armnn::ClSubtractionValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsTileSupported()

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

Definition at line 1587 of file ClLayerSupport.cpp.

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

References armnn::ClTileWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

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

Definition at line 1599 of file ClLayerSupport.cpp.

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

References armnn::ClTransposeConvolution2dWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsTransposeSupported()

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

Definition at line 1615 of file ClLayerSupport.cpp.

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

References armnn::ClTransposeWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

IsUnidirectionalSequenceLstmSupported()

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

Definition at line 1623 of file ClLayerSupport.cpp.

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

References armnn::ClUnidirectionalSequenceLstmFloatWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

---

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

• src/backends/cl/ClLayerSupport.hpp
• src/backends/cl/ClLayerSupport.cpp