ArmNN
 24.02
Public Member Functions | List of all members
ClLayerSupport Class Reference

#include <ClLayerSupport.hpp>

Inheritance diagram for ClLayerSupport:
[legend]
Collaboration diagram for ClLayerSupport:
[legend]

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. More...
 
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 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 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 177 of file ClLayerSupport.cpp.

178  : m_ModelContextPtr(modelContextPtr)
179 {
180 }

◆ ClLayerSupport() [2/2]

ClLayerSupport ( )

Definition at line 182 of file ClLayerSupport.cpp.

183  : m_ModelContextPtr(nullptr)
184 {
185 }

◆ ~ClLayerSupport()

~ClLayerSupport ( )
inline

Definition at line 19 of file ClLayerSupport.hpp.

19 {}

Member Function Documentation

◆ IsActivationSupported()

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

Definition at line 696 of file ClLayerSupport.cpp.

700 {
701  FORWARD_WORKLOAD_VALIDATE_FUNC(ClActivationWorkloadValidate,
702  reasonIfUnsupported,
703  input,
704  output,
705  descriptor);
706 }

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 708 of file ClLayerSupport.cpp.

712 {
713  FORWARD_WORKLOAD_VALIDATE_FUNC(ClAdditionValidate,
714  reasonIfUnsupported,
715  input0,
716  input1,
717  output,
718  nullptr);
719 }

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 721 of file ClLayerSupport.cpp.

725 {
726 
727  FORWARD_WORKLOAD_VALIDATE_FUNC(ClArgMinMaxWorkloadValidate,
728  reasonIfUnsupported,
729  input,
730  output,
731  descriptor);
732 }

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 734 of file ClLayerSupport.cpp.

739 {
740  FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchMatMulValidate,
741  reasonIfUnsupported,
742  inputX,
743  inputY,
744  output,
745  descriptor,
746  nullptr);
747 }

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 749 of file ClLayerSupport.cpp.

757 {
758  FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchNormalizationValidate,
759  reasonIfUnsupported,
760  input,
761  output,
762  mean,
763  var,
764  beta,
765  gamma,
766  descriptor,
767  nullptr);
768 }

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 770 of file ClLayerSupport.cpp.

774 {
775  FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchToSpaceNdWorkloadValidate,
776  reasonIfUnsupported,
777  input,
778  output,
779  descriptor);
780 }

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 782 of file ClLayerSupport.cpp.

785 {
786  FORWARD_WORKLOAD_VALIDATE_FUNC(ClCastValidate,
787  reasonIfUnsupported,
788  input,
789  output);
790 }

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 792 of file ClLayerSupport.cpp.

796 {
797  FORWARD_WORKLOAD_VALIDATE_FUNC(ClChannelShuffleValidate,
798  reasonIfUnsupported,
799  input,
800  output,
801  descriptor);
802 }

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 804 of file ClLayerSupport.cpp.

809 {
810  FORWARD_WORKLOAD_VALIDATE_FUNC(ClComparisonWorkloadValidate,
811  reasonIfUnsupported,
812  input0,
813  input1,
814  output,
815  descriptor);
816 }

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 818 of file ClLayerSupport.cpp.

822 {
823  if (descriptor.GetNumDimensions() <= descriptor.GetConcatAxis())
824  {
825  SetValueChecked(reasonIfUnsupported, "Cl Concat: Concat axis > Number of dimensions.");
826  return false;
827  }
828 
829  unsigned int concatInnerAxis = (descriptor.GetNumDimensions() - descriptor.GetConcatAxis()) - 1;
830  if(concatInnerAxis < 3) // Width, height, or channels
831  {
832  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConcatWorkloadValidate,
833  reasonIfUnsupported,
834  inputs,
835  output,
836  descriptor);
837  }
838  else if (concatInnerAxis == 3)
839  {
840  // We rely on the sub-tensor optimization to handle the batch dimension for 4D tensors. If we can't use
841  // sub-tensors for this then we can't support it. Here is where we check that the sub-tensors will work.
842  for (auto& input : inputs)
843  {
844  if (input && !output.IsTypeSpaceMatch(*input)) // Cannot use sub-tensors if the types are not same space
845  {
846  SetValueChecked(reasonIfUnsupported, "Cl Concat: Types and quantization parameters must match.");
847  return false;
848  }
849  }
850  return true; // Sub-tensors support concat along batch
851  }
852  else // > 4 dimensions not supported.
853  {
854  SetValueChecked(reasonIfUnsupported, "Cl Concat: Maximum of 4 dimensions supported.");
855  return false;
856  }
857 }

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

861 {
862  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConstantWorkloadValidate,
863  reasonIfUnsupported,
864  output);
865 }

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

870 {
871  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvertFp16ToFp32WorkloadValidate,
872  reasonIfUnsupported,
873  input,
874  output);
875 }

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 877 of file ClLayerSupport.cpp.

880 {
881  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvertFp32ToFp16WorkloadValidate,
882  reasonIfUnsupported,
883  input,
884  output);
885 }

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 887 of file ClLayerSupport.cpp.

893 {
894  bool isFastMathEnabled = false;
895 #if defined(ARMCOMPUTECL_ENABLED)
896  if (m_ModelContextPtr)
897  {
898  if (m_ModelContextPtr.get() != nullptr)
899  {
900  auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
901  if (modelOptions)
902  {
903  isFastMathEnabled = modelOptions->IsFastMathEnabled();
904  }
905  }
906  }
907 #endif
908 
909  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvolution2dWorkloadValidate,
910  reasonIfUnsupported,
911  input,
912  output,
913  descriptor,
914  weights,
915  biases,
916  isFastMathEnabled,
917  nullptr);
918 }

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 920 of file ClLayerSupport.cpp.

926 {
927  bool isFastMathEnabled = false;
928 #if defined(ARMCOMPUTECL_ENABLED)
929  if (m_ModelContextPtr)
930 {
931  if (m_ModelContextPtr.get() != nullptr)
932  {
933  auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
934  if (modelOptions)
935  {
936  isFastMathEnabled = modelOptions->IsFastMathEnabled();
937  }
938  }
939 }
940 #endif
941 
942  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvolution3dWorkloadValidate,
943  reasonIfUnsupported,
944  input,
945  output,
946  descriptor,
947  weights,
948  biases,
949  isFastMathEnabled,
950  nullptr);
951 }

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 963 of file ClLayerSupport.cpp.

967 {
968  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDepthToSpaceWorkloadValidate,
969  reasonIfUnsupported,
970  input,
971  output,
972  descriptor);
973 }

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 975 of file ClLayerSupport.cpp.

981 {
982  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDepthwiseConvolutionWorkloadValidate,
983  reasonIfUnsupported,
984  input,
985  output,
986  descriptor,
987  weights,
988  biases,
989  nullptr);
990 }

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 953 of file ClLayerSupport.cpp.

956 {
957  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDequantizeWorkloadValidate,
958  reasonIfUnsupported,
959  input,
960  output);
961 }

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 992 of file ClLayerSupport.cpp.

998 {
999  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDepthwiseConvolutionWorkloadValidate,
1000  reasonIfUnsupported,
1001  input,
1002  output,
1003  descriptor,
1004  weights,
1005  biases,
1006  nullptr);
1007 }

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 1010 of file ClLayerSupport.cpp.

1014 {
1015  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDivisionWorkloadValidate,
1016  reasonIfUnsupported,
1017  input0,
1018  input1,
1019  output,
1020  nullptr);
1021 }

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 1023 of file ClLayerSupport.cpp.

1027 {
1028  switch(descriptor.m_Operation)
1029  {
1030  case UnaryOperation::Abs:
1031  FORWARD_WORKLOAD_VALIDATE_FUNC(ClAbsWorkloadValidate,
1032  reasonIfUnsupported,
1033  input,
1034  output);
1035  case UnaryOperation::Exp:
1036  FORWARD_WORKLOAD_VALIDATE_FUNC(ClExpWorkloadValidate,
1037  reasonIfUnsupported,
1038  input,
1039  output);
1040  case UnaryOperation::Log:
1041  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogWorkloadValidate,
1042  reasonIfUnsupported,
1043  input,
1044  output);
1045  case UnaryOperation::LogicalNot:
1046  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogicalNotWorkloadValidate,
1047  reasonIfUnsupported,
1048  input,
1049  output);
1050  case UnaryOperation::Neg:
1051  FORWARD_WORKLOAD_VALIDATE_FUNC(ClNegWorkloadValidate,
1052  reasonIfUnsupported,
1053  input,
1054  output);
1055  case UnaryOperation::Rsqrt:
1056  FORWARD_WORKLOAD_VALIDATE_FUNC(ClRsqrtWorkloadValidate,
1057  reasonIfUnsupported,
1058  input,
1059  output);
1060  case UnaryOperation::Sin:
1061  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSinWorkloadValidate,
1062  reasonIfUnsupported,
1063  input,
1064  output);
1065  case UnaryOperation::Sqrt:
1066  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSqrtWorkloadValidate,
1067  reasonIfUnsupported,
1068  input,
1069  output);
1070  default:
1071  return false;
1072  }
1073 }

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 1075 of file ClLayerSupport.cpp.

1079 {
1080  armnn::IgnoreUnused(input);
1081  armnn::IgnoreUnused(output);
1082  armnn::IgnoreUnused(descriptor);
1083 
1084  return IsClBackendSupported(reasonIfUnsupported);
1085 }

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 1087 of file ClLayerSupport.cpp.

1090 {
1091  FORWARD_WORKLOAD_VALIDATE_FUNC(ClFloorWorkloadValidate,
1092  reasonIfUnsupported,
1093  input,
1094  output);
1095 }

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 1097 of file ClLayerSupport.cpp.

1103 {
1104  FORWARD_WORKLOAD_VALIDATE_FUNC(ClFullyConnectedWorkloadValidate,
1105  reasonIfUnsupported,
1106  input,
1107  output,
1108  weights,
1109  biases,
1110  descriptor,
1111  nullptr);
1112 }

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 1128 of file ClLayerSupport.cpp.

1132 {
1133  FORWARD_WORKLOAD_VALIDATE_FUNC(ClGatherNdWorkloadValidate,
1134  reasonIfUnsupported,
1135  input0,
1136  input1,
1137  output);
1138 }

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 1114 of file ClLayerSupport.cpp.

1119 {
1120  FORWARD_WORKLOAD_VALIDATE_FUNC(ClGatherWorkloadValidate,
1121  reasonIfUnsupported,
1122  input0,
1123  input1,
1124  output,
1125  descriptor);
1126 }

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 1140 of file ClLayerSupport.cpp.

1142 {
1143  return IsClBackendSupported(reasonIfUnsupported, input);
1144 }

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 1146 of file ClLayerSupport.cpp.

1150 {
1151  FORWARD_WORKLOAD_VALIDATE_FUNC(ClInstanceNormalizationWorkloadValidate,
1152  reasonIfUnsupported,
1153  input,
1154  output,
1155  descriptor);
1156 }

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 1158 of file ClLayerSupport.cpp.

1162 {
1163  FORWARD_WORKLOAD_VALIDATE_FUNC(ClL2NormalizationWorkloadValidate,
1164  reasonIfUnsupported,
1165  input,
1166  output,
1167  descriptor);
1168 }

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 LayerSupportBase.

Definition at line 187 of file ClLayerSupport.cpp.

193 {
194  switch (type)
195  {
196  case LayerType::Activation:
197  return IsActivationSupported(infos[0],
198  infos[1],
199  *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
200  reasonIfUnsupported);
201  case LayerType::Addition:
202  ARMNN_NO_DEPRECATE_WARN_BEGIN
203  return IsAdditionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
204  ARMNN_NO_DEPRECATE_WARN_END
205  case LayerType::ArgMinMax:
206  return IsArgMinMaxSupported(infos[0],
207  infos[1],
208  *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
209  reasonIfUnsupported);
210  case LayerType::BatchMatMul:
211  return IsBatchMatMulSupported(infos[0],
212  infos[1],
213  infos[2],
214  *(PolymorphicDowncast<const BatchMatMulDescriptor*>(&descriptor)),
215  reasonIfUnsupported);
216  case LayerType::BatchNormalization:
217  return IsBatchNormalizationSupported(infos[0],
218  infos[1],
219  infos[2],
220  infos[3],
221  infos[4],
222  infos[5],
223  *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
224  (&descriptor)),
225  reasonIfUnsupported);
226  case LayerType::BatchToSpaceNd:
227  return IsBatchToSpaceNdSupported(infos[0],
228  infos[1],
229  *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
230  reasonIfUnsupported);
231  case LayerType::Cast:
232  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
233  case LayerType::ChannelShuffle:
234  return IsChannelShuffleSupported(infos[0],
235  infos[1],
236  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
237  reasonIfUnsupported);
238  case LayerType::Comparison:
239  return IsComparisonSupported(infos[0],
240  infos[1],
241  infos[2],
242  *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
243  reasonIfUnsupported);
244  case LayerType::Concat:
245  {
246  std::vector<const TensorInfo*> inputInfos;
247  for (uint32_t i = 0; i < (infos.size() - 1); i++)
248  {
249  inputInfos.push_back(&infos[i]);
250  }
251  return IsConcatSupported(inputInfos,
252  infos[infos.size() - 1],
253  *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
254  reasonIfUnsupported);
255  }
256  case LayerType::Constant:
257  return IsConstantSupported(infos[0], reasonIfUnsupported);
258  case LayerType::ConvertFp16ToFp32:
259  return IsConvertFp16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
260  case LayerType::ConvertFp32ToFp16:
261  return IsConvertFp32ToFp16Supported(infos[0], infos[1], reasonIfUnsupported);
262  case LayerType::Convolution2d:
263  {
264  if (infos.size() != 4)
265  {
266  throw InvalidArgumentException("Invalid number of Convolution2d TensorInfos. "
267  "TensorInfos should be of format: {input, output, weights, biases}.");
268  }
269 
270  auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
271  if (infos[3] == TensorInfo())
272  {
273  return IsConvolution2dSupported(infos[0],
274  infos[1],
275  desc,
276  infos[2],
277  EmptyOptional(),
278  reasonIfUnsupported);
279  }
280  else
281  {
282  return IsConvolution2dSupported(infos[0],
283  infos[1],
284  desc,
285  infos[2],
286  infos[3],
287  reasonIfUnsupported);
288  }
289  }
290  case LayerType::Convolution3d:
291  {
292  if (infos.size() != 4)
293  {
294  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
295  "TensorInfos should be of format: {input, output, weights, biases}.");
296  }
297 
298  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
299  if (infos[3] == TensorInfo())
300  {
301  return IsConvolution3dSupported(infos[0],
302  infos[1],
303  desc,
304  infos[2],
305  EmptyOptional(),
306  reasonIfUnsupported);
307  }
308  else
309  {
310  return IsConvolution3dSupported(infos[0],
311  infos[1],
312  desc,
313  infos[2],
314  infos[3],
315  reasonIfUnsupported);
316  }
317  }
318  case LayerType::DepthToSpace:
319  return IsDepthToSpaceSupported(infos[0],
320  infos[1],
321  *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
322  reasonIfUnsupported);
323  case LayerType::DepthwiseConvolution2d:
324  {
325  if (infos.size() != 4)
326  {
327  throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d TensorInfos. "
328  "TensorInfos should be of format: {input, output, weights, biases}.");
329  }
330 
331  auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
332  if (infos[3] == TensorInfo())
333  {
334  return IsDepthwiseConvolutionSupported(infos[0],
335  infos[1],
336  desc,
337  infos[2],
338  EmptyOptional(),
339  reasonIfUnsupported);
340  }
341  else
342  {
343  return IsDepthwiseConvolutionSupported(infos[0],
344  infos[1],
345  desc,
346  infos[2],
347  infos[3],
348  reasonIfUnsupported);
349  }
350  }
351  case LayerType::Dequantize:
352  return IsDequantizeSupported(infos[0], infos[1], reasonIfUnsupported);
353  case LayerType::Division:
354  ARMNN_NO_DEPRECATE_WARN_BEGIN
355  return IsDivisionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
356  ARMNN_NO_DEPRECATE_WARN_END
357  case LayerType::ElementwiseBinary:
358  {
359  auto desc = *(PolymorphicDowncast<const ElementwiseBinaryDescriptor *>(&descriptor));
360 
361  switch (desc.m_Operation)
362  {
363  case BinaryOperation::Add:
364  FORWARD_WORKLOAD_VALIDATE_FUNC(ClAdditionValidate,
365  reasonIfUnsupported,
366  infos[0],
367  infos[1],
368  infos[2],
369  nullptr);
370  case BinaryOperation::Div:
371  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDivisionWorkloadValidate,
372  reasonIfUnsupported,
373  infos[0],
374  infos[1],
375  infos[2],
376  nullptr);
377  case BinaryOperation::Minimum:
378  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMinimumWorkloadValidate,
379  reasonIfUnsupported,
380  infos[0],
381  infos[1],
382  infos[2]);
383  case BinaryOperation::Maximum:
384  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMaximumWorkloadValidate,
385  reasonIfUnsupported,
386  infos[0],
387  infos[1],
388  infos[2]);
389  case BinaryOperation::Mul:
390  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMultiplicationWorkloadValidate,
391  reasonIfUnsupported,
392  infos[0],
393  infos[1],
394  infos[2],
395  nullptr);
396  case BinaryOperation::Power:
397  case BinaryOperation::SqDiff:
398  FORWARD_WORKLOAD_VALIDATE_FUNC(ClElementwiseBinaryValidate,
399  reasonIfUnsupported,
400  infos[0],
401  infos[1],
402  infos[2],
403  desc,
404  nullptr);
405  case BinaryOperation::Sub:
406  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSubtractionValidate,
407  reasonIfUnsupported,
408  infos[0],
409  infos[1],
410  infos[2],
411  nullptr);
412  default:
413  return false;
414  }
415  }
416  case LayerType::ElementwiseUnary:
417  return IsElementwiseUnarySupported(infos[0],
418  infos[1],
419  *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor)),
420  reasonIfUnsupported);
421  case LayerType::Fill:
422  return IsFillSupported(infos[0],
423  infos[1],
424  *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
425  reasonIfUnsupported);
426  case LayerType::Floor:
427  return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
428  case LayerType::FullyConnected:
429  return IsFullyConnectedSupported(infos[0],
430  infos[1],
431  infos[2],
432  infos[3],
433  *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
434  reasonIfUnsupported);
435  case LayerType::Gather:
436  return IsGatherSupported(infos[0],
437  infos[1],
438  infos[2],
439  *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
440  reasonIfUnsupported);
441  case LayerType::GatherNd:
442  return IsGatherNdSupported(infos[0],
443  infos[1],
444  infos[2],
445  reasonIfUnsupported);
446  case LayerType::Input:
447  return IsInputSupported(infos[0], reasonIfUnsupported);
448  case LayerType::InstanceNormalization:
449  return IsInstanceNormalizationSupported(infos[0],
450  infos[1],
451  *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
452  (&descriptor)),
453  reasonIfUnsupported);
454  case LayerType::L2Normalization:
455  return IsL2NormalizationSupported(infos[0],
456  infos[1],
457  *(PolymorphicDowncast<const L2NormalizationDescriptor*>(&descriptor)),
458  reasonIfUnsupported);
459  case LayerType::LogicalBinary:
460  return IsLogicalBinarySupported(infos[0],
461  infos[1],
462  infos[2],
463  *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
464  reasonIfUnsupported);
465  case LayerType::LogSoftmax:
466  return IsLogSoftmaxSupported(infos[0],
467  infos[1],
468  *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
469  reasonIfUnsupported);
470  case LayerType::Lstm:
471  return IsLstmSupported(infos[0],
472  infos[1],
473  infos[2],
474  infos[3],
475  infos[4],
476  infos[5],
477  infos[6],
478  *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
479  lstmParamsInfo.value(),
480  reasonIfUnsupported);
481  case LayerType::Map:
482  return true;
483  case LayerType::MemCopy:
484  return LayerSupportBase::IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
485  case LayerType::MemImport:
486  return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
487  case LayerType::Merge:
488  return LayerSupportBase::IsMergeSupported(infos[0],
489  infos[1],
490  infos[2],
491  reasonIfUnsupported);
492  case LayerType::Maximum:
493  ARMNN_NO_DEPRECATE_WARN_BEGIN
494  return IsMaximumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
495  ARMNN_NO_DEPRECATE_WARN_END
496  case LayerType::Mean:
497  return IsMeanSupported(infos[0],
498  infos[1],
499  *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
500  reasonIfUnsupported);
501  case LayerType::Minimum:
502  ARMNN_NO_DEPRECATE_WARN_BEGIN
503  return IsMinimumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
504  ARMNN_NO_DEPRECATE_WARN_END
505  case LayerType::Multiplication:
506  ARMNN_NO_DEPRECATE_WARN_BEGIN
507  return IsMultiplicationSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
508  ARMNN_NO_DEPRECATE_WARN_END
509  case LayerType::Normalization:
510  return IsNormalizationSupported(infos[0],
511  infos[1],
512  *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
513  reasonIfUnsupported);
514  case LayerType::Output:
515  return IsOutputSupported(infos[0], reasonIfUnsupported);
516  case LayerType::Pad:
517  return IsPadSupported(infos[0],
518  infos[1],
519  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
520  reasonIfUnsupported);
521  case LayerType::Permute:
522  return IsPermuteSupported(infos[0],
523  infos[1],
524  *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
525  reasonIfUnsupported);
526  case LayerType::Pooling2d:
527  return IsPooling2dSupported(infos[0],
528  infos[1],
529  *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
530  reasonIfUnsupported);
531  case LayerType::Pooling3d:
532  return IsPooling3dSupported(infos[0],
533  infos[1],
534  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
535  reasonIfUnsupported);
536  case LayerType::Prelu:
537  return IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
538  case LayerType::QLstm:
539  return IsQLstmSupported(infos[0],
540  infos[1],
541  infos[2],
542  infos[3],
543  infos[4],
544  infos[5],
545  *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
546  lstmParamsInfo.value(),
547  reasonIfUnsupported);
548  case LayerType::Quantize:
549  return IsQuantizeSupported(infos[0], infos[1], reasonIfUnsupported);
550  case LayerType::QuantizedLstm:
551  return IsQuantizedLstmSupported(infos[0],
552  infos[1],
553  infos[2],
554  infos[3],
555  infos[4],
556  quantizedLstmParamsInfo.value(),
557  reasonIfUnsupported);
558  case LayerType::Rank:
559  return true;
560  case LayerType::Reduce:
561  return IsReduceSupported(infos[0],
562  infos[1],
563  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
564  reasonIfUnsupported);
565  case LayerType::Reshape:
566  return IsReshapeSupported(infos[0],
567  infos[1],
568  *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
569  reasonIfUnsupported);
570  case LayerType::Resize:
571  return IsResizeSupported(infos[0],
572  infos[1],
573  *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
574  reasonIfUnsupported);
575  case LayerType::ReverseV2:
576  return IsReverseV2Supported(infos[0],
577  infos[1],
578  infos[2],
579  reasonIfUnsupported);
580  case LayerType::Shape:
581  return LayerSupportBase::IsShapeSupported(infos[0],
582  infos[1],
583  reasonIfUnsupported);
584  case LayerType::Slice:
585  return IsSliceSupported(infos[0],
586  infos[1],
587  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
588  reasonIfUnsupported);
589  case LayerType::Softmax:
590  return IsSoftmaxSupported(infos[0],
591  infos[1],
592  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
593  reasonIfUnsupported);
594  case LayerType::SpaceToBatchNd:
595  return IsSpaceToBatchNdSupported(infos[0],
596  infos[1],
597  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
598  reasonIfUnsupported);
599  case LayerType::SpaceToDepth:
600  return IsSpaceToDepthSupported(infos[0],
601  infos[1],
602  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
603  reasonIfUnsupported);
604  case LayerType::Splitter:
605  {
606  std::vector<TensorInfo> outputInfos;
607  for (uint32_t i = 1; i < infos.size(); i++)
608  {
609  outputInfos.push_back(infos[i]);
610  }
611  return IsSplitterSupported(infos[0],
612  {outputInfos.begin(), outputInfos.end()},
613  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
614  reasonIfUnsupported);
615  }
616  case LayerType::Stack:
617  {
618  std::vector<const TensorInfo*> inputInfos;
619  for (uint32_t i = 0; i < infos.size() - 1; i++)
620  {
621  inputInfos.push_back(&infos[i]);
622  }
623  return IsStackSupported(inputInfos,
624  infos[infos.size() - 1],
625  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
626  reasonIfUnsupported);
627  }
628  case LayerType::StridedSlice:
629  return IsStridedSliceSupported(infos[0],
630  infos[1],
631  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
632  reasonIfUnsupported);
633  case LayerType::Subtraction:
634  ARMNN_NO_DEPRECATE_WARN_BEGIN
635  return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
636  ARMNN_NO_DEPRECATE_WARN_END
637  case LayerType::Tile:
638  return IsTileSupported(infos[0],
639  infos[1],
640  *(PolymorphicDowncast<const TileDescriptor*>(&descriptor)),
641  reasonIfUnsupported);
642  case LayerType::Transpose:
643  return IsTransposeSupported(infos[0],
644  infos[1],
645  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
646  reasonIfUnsupported);
647  case LayerType::TransposeConvolution2d:
648  {
649  if (infos.size() != 4)
650  {
651  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
652  "TensorInfos should be of format: {input, output, weights, biases}.");
653  }
654 
655  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
656  if (infos[3] == TensorInfo())
657  {
658  return IsTransposeConvolution2dSupported(infos[0],
659  infos[1],
660  desc,
661  infos[2],
662  EmptyOptional(),
663  reasonIfUnsupported);
664  }
665  else
666  {
667  return IsTransposeConvolution2dSupported(infos[0],
668  infos[1],
669  desc,
670  infos[2],
671  infos[3],
672  reasonIfUnsupported);
673  }
674  }
675  case LayerType::UnidirectionalSequenceLstm:
676  return IsUnidirectionalSequenceLstmSupported(infos[0],
677  infos[1],
678  infos[2],
679  infos[3],
680  infos[4],
681  infos[5],
682  *(PolymorphicDowncast<const
683  UnidirectionalSequenceLstmDescriptor*>(&descriptor)),
684  lstmParamsInfo.value(),
685  reasonIfUnsupported);
686  case LayerType::Unmap:
687  return true;
688  default:
689  // layers not supported in cl by default:
690  // debug, detectionpostprocess, fakequantization,
691  // precompiled, standin, switch, pooling3d, fused
692  return false;
693  }
694 }

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::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, 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(), 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::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< std::is_reference< T >::value, 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 1170 of file ClLayerSupport.cpp.

1175 {
1176  IgnoreUnused(output);
1177 
1178  switch(descriptor.m_Operation)
1179  {
1180  case LogicalBinaryOperation::LogicalAnd:
1181  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogicalAndWorkloadValidate,
1182  reasonIfUnsupported,
1183  input0,
1184  input1,
1185  output);
1186  case LogicalBinaryOperation::LogicalOr:
1187  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogicalOrWorkloadValidate,
1188  reasonIfUnsupported,
1189  input0,
1190  input1,
1191  output);
1192  default:
1193  return false;
1194  }
1195 }

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 1198 of file ClLayerSupport.cpp.

1202 {
1203  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogSoftmaxWorkloadValidate,
1204  reasonIfUnsupported,
1205  input,
1206  output,
1207  descriptor);
1208 }

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 1210 of file ClLayerSupport.cpp.

1220 {
1221  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLstmFloatWorkloadValidate,
1222  reasonIfUnsupported,
1223  input,
1224  outputStateIn,
1225  cellStateIn,
1226  scratchBuffer,
1227  outputStateOut,
1228  cellStateOut,
1229  output,
1230  descriptor,
1231  paramsInfo);
1232 }

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 1234 of file ClLayerSupport.cpp.

1238 {
1239  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMaximumWorkloadValidate,
1240  reasonIfUnsupported,
1241  input0,
1242  input1,
1243  output);
1244 }

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 1246 of file ClLayerSupport.cpp.

1250 {
1251  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMeanValidate,
1252  reasonIfUnsupported,
1253  input,
1254  output,
1255  descriptor);
1256 }

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 1258 of file ClLayerSupport.cpp.

1262 {
1263  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMinimumWorkloadValidate,
1264  reasonIfUnsupported,
1265  input0,
1266  input1,
1267  output);
1268 }

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 1270 of file ClLayerSupport.cpp.

1274 {
1275  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMultiplicationWorkloadValidate,
1276  reasonIfUnsupported,
1277  input0,
1278  input1,
1279  output,
1280  nullptr);
1281 }

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 1283 of file ClLayerSupport.cpp.

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

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 1291 of file ClLayerSupport.cpp.

1293 {
1294  return IsClBackendSupported(reasonIfUnsupported, output);
1295 }

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 1297 of file ClLayerSupport.cpp.

1301 {
1302  FORWARD_WORKLOAD_VALIDATE_FUNC(ClPadValidate,
1303  reasonIfUnsupported,
1304  input,
1305  output,
1306  descriptor);
1307 }

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 1309 of file ClLayerSupport.cpp.

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

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 1317 of file ClLayerSupport.cpp.

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

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 1325 of file ClLayerSupport.cpp.

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

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 1333 of file ClLayerSupport.cpp.

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

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 1341 of file ClLayerSupport.cpp.

1350 {
1351  if (input.GetDataType() == armnn::DataType::QAsymmS8 &&
1352  previousOutputIn.GetDataType() == armnn::DataType::QAsymmS8 &&
1353  previousCellStateIn.GetDataType() == armnn::DataType::QSymmS16 &&
1354  outputStateOut.GetDataType() == armnn::DataType::QAsymmS8 &&
1355  cellStateOut.GetDataType() == armnn::DataType::QSymmS16 &&
1356  output.GetDataType() == armnn::DataType::QAsymmS8)
1357  {
1358  FORWARD_WORKLOAD_VALIDATE_FUNC(ClQLstmWorkloadValidate,
1359  reasonIfUnsupported,
1360  input,
1361  previousCellStateIn,
1362  previousOutputIn,
1363  cellStateOut,
1364  outputStateOut,
1365  output,
1366  descriptor,
1367  paramsInfo);
1368  }
1369  else
1370  {
1371  return false;
1372  }
1373 }

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 1375 of file ClLayerSupport.cpp.

1382 {
1383  FORWARD_WORKLOAD_VALIDATE_FUNC(ClQuantizedLstmWorkloadValidate,
1384  reasonIfUnsupported,
1385  input,
1386  previousCellStateIn,
1387  previousOutputIn,
1388  cellStateOut,
1389  output,
1390  paramsInfo);
1391 }

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 1393 of file ClLayerSupport.cpp.

1396 {
1397  FORWARD_WORKLOAD_VALIDATE_FUNC(ClQuantizeWorkloadValidate,
1398  reasonIfUnsupported,
1399  input,
1400  output);
1401 }

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 1403 of file ClLayerSupport.cpp.

1407 {
1408  FORWARD_WORKLOAD_VALIDATE_FUNC(ClReduceWorkloadValidate,
1409  reasonIfUnsupported,
1410  input,
1411  output,
1412  descriptor);
1413 }

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 1415 of file ClLayerSupport.cpp.

1419 {
1420  IgnoreUnused(descriptor);
1421  FORWARD_WORKLOAD_VALIDATE_FUNC(ClReshapeWorkloadValidate, reasonIfUnsupported, input, output);
1422 }

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 1424 of file ClLayerSupport.cpp.

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

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 1432 of file ClLayerSupport.cpp.

1436 {
1437  FORWARD_WORKLOAD_VALIDATE_FUNC(ClReverseV2WorkloadValidate,
1438  reasonIfUnsupported,
1439  input,
1440  axis,
1441  output);
1442 }

References armnn::ClReverseV2WorkloadValidate(), 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 1444 of file ClLayerSupport.cpp.

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

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 1452 of file ClLayerSupport.cpp.

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

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 1460 of file ClLayerSupport.cpp.

1464 {
1465  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSpaceToBatchNdWorkloadValidate,
1466  reasonIfUnsupported,
1467  input,
1468  output,
1469  descriptor);
1470 }

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 1472 of file ClLayerSupport.cpp.

1476 {
1477  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSpaceToDepthWorkloadValidate,
1478  reasonIfUnsupported,
1479  input,
1480  output,
1481  descriptor);
1482 }

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 1484 of file ClLayerSupport.cpp.

1488 {
1489 #if defined(ARMCOMPUTECL_ENABLED)
1490  // Split along the last dimension, cannot use sub-tensors
1491  // as width and height of the sub-tensors do not match
1492  // the width and height of the parent tensor
1493  // in case of input with more than 2D.
1494  std::set<unsigned int> splitAxis = ComputeSplitAxis(descriptor, input.GetShape());
1495  if (descriptor.GetNumDimensions() > 2 && splitAxis.size() == 1 &&
1496  *splitAxis.begin() == descriptor.GetNumDimensions() - 1 )
1497  {
1498  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSplitterWorkloadValidate,
1499  reasonIfUnsupported,
1500  input,
1501  outputs,
1502  *splitAxis.begin());
1503  }
1504 #endif
1505  IgnoreUnused(descriptor);
1506  for (auto output : outputs)
1507  {
1508  if (!input.IsTypeSpaceMatch(output)) // Cannot use sub-tensors if the types are not same space
1509  {
1510  SetValueChecked(reasonIfUnsupported, "Cl Splitter: Types and quantization parameters must match.");
1511  return false;
1512  }
1513  }
1514  return true;
1515 }

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 1517 of file ClLayerSupport.cpp.

1521 {
1522  FORWARD_WORKLOAD_VALIDATE_FUNC(ClStackWorkloadValidate,
1523  reasonIfUnsupported,
1524  inputs,
1525  output,
1526  descriptor);
1527 }

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 1529 of file ClLayerSupport.cpp.

1533 {
1534  FORWARD_WORKLOAD_VALIDATE_FUNC(ClStridedSliceWorkloadValidate,
1535  reasonIfUnsupported,
1536  input,
1537  output,
1538  descriptor);
1539 }

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 1541 of file ClLayerSupport.cpp.

1545 {
1546  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSubtractionValidate,
1547  reasonIfUnsupported,
1548  input0,
1549  input1,
1550  output,
1551  nullptr);
1552 }

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 1554 of file ClLayerSupport.cpp.

1558 {
1559  FORWARD_WORKLOAD_VALIDATE_FUNC(ClTileWorkloadValidate,
1560  reasonIfUnsupported,
1561  input,
1562  output,
1563  descriptor);
1564 }

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 1566 of file ClLayerSupport.cpp.

1572 {
1573  FORWARD_WORKLOAD_VALIDATE_FUNC(ClTransposeConvolution2dWorkloadValidate,
1574  reasonIfUnsupported,
1575  input,
1576  output,
1577  descriptor,
1578  weights,
1579  biases);
1580 }

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 1582 of file ClLayerSupport.cpp.

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

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 1590 of file ClLayerSupport.cpp.

1599 {
1600  FORWARD_WORKLOAD_VALIDATE_FUNC(ClUnidirectionalSequenceLstmFloatWorkloadValidate,
1601  reasonIfUnsupported,
1602  input,
1603  outputStateIn,
1604  cellStateIn,
1605  outputStateOut,
1606  cellStateOut,
1607  output,
1608  descriptor,
1609  paramsInfo);
1610 }

References armnn::ClUnidirectionalSequenceLstmFloatWorkloadValidate(), and FORWARD_WORKLOAD_VALIDATE_FUNC.

Referenced by ClLayerSupport::IsLayerSupported().

The documentation for this class was generated from the following files:
armnn::LayerType::SpaceToDepth
@ SpaceToDepth
armnn::ClLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1317
armnn::ClLayerSupport::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: ClLayerSupport.cpp:749
armnn::ClLogWorkloadValidate
arm_compute::Status ClLogWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClLogWorkload.cpp:18
armnn::BinaryOperation::Mul
@ Mul
armnn::ClRsqrtWorkloadValidate
arm_compute::Status ClRsqrtWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClRsqrtWorkload.cpp:18
armnn::LayerType::Permute
@ Permute
armnn::BinaryOperation::Add
@ Add
armnn::ClLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1258
armnn::LayerType::Splitter
@ Splitter
armnn::ClFloorWorkloadValidate
arm_compute::Status ClFloorWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClFloorFloatWorkload.cpp:14
armnn::LayerType::BatchNormalization
@ BatchNormalization
armnn::ClLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1333
armnn::ClSubtractionValidate
arm_compute::Status ClSubtractionValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: ClSubtractionWorkload.cpp:46
armnn::ClLayerSupport::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: ClLayerSupport.cpp:887
armnn::ClLayerSupport::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: ClLayerSupport.cpp:1210
armnn::ClLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:818
armnn::ClQuantizeWorkloadValidate
arm_compute::Status ClQuantizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClQuantizeWorkload.cpp:22
armnn::ClTransposeConvolution2dWorkloadValidate
arm_compute::Status ClTransposeConvolution2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases)
Definition: ClTransposeConvolution2dWorkload.cpp:26
armnn::ClCastValidate
arm_compute::Status ClCastValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClCastWorkload.cpp:20
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: ClLayerSupport.cpp:151
armnn::ClStridedSliceWorkloadValidate
arm_compute::Status ClStridedSliceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor)
Definition: ClStridedSliceWorkload.cpp:27
armnn::ClExpWorkloadValidate
arm_compute::Status ClExpWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClExpWorkload.cpp:18
armnn::ClMaximumWorkloadValidate
arm_compute::Status ClMaximumWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: ClMaximumWorkload.cpp:24
armnn::ClLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:708
armnn::ClLayerSupport::IsBatchMatMulSupported
bool IsBatchMatMulSupported(const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:734
armnn::ClMultiplicationWorkloadValidate
arm_compute::Status ClMultiplicationWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: ClMultiplicationWorkload.cpp:18
armnn::ClGatherNdWorkloadValidate
arm_compute::Status ClGatherNdWorkloadValidate(const TensorInfo &paramsInfo, const TensorInfo &indicesInfo, const TensorInfo &outputInfo)
Definition: ClGatherNdWorkload.cpp:16
armnn::ClSpaceToDepthWorkloadValidate
arm_compute::Status ClSpaceToDepthWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor)
Definition: ClSpaceToDepthWorkload.cpp:54
armnn::LayerType::InstanceNormalization
@ InstanceNormalization
armnn::LayerType::ConvertFp16ToFp32
@ ConvertFp16ToFp32
armnn::ClLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1234
armnn::ClSplitterWorkloadValidate
arm_compute::Status ClSplitterWorkloadValidate(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, unsigned int splitAxis)
Definition: ClSplitterWorkload.cpp:31
armnn::ClLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:696
armnn::LayerType::Floor
@ Floor
armnn::UnidirectionalSequenceLstmDescriptor
LstmDescriptor UnidirectionalSequenceLstmDescriptor
Definition: Descriptors.hpp:1169
armnn::ClUnidirectionalSequenceLstmFloatWorkloadValidate
arm_compute::Status ClUnidirectionalSequenceLstmFloatWorkloadValidate(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: ClUnidirectionalSequenceLstmFloatWorkload.cpp:508
armnn::ClBatchToSpaceNdWorkloadValidate
arm_compute::Status ClBatchToSpaceNdWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor)
Definition: ClBatchToSpaceNdWorkload.cpp:17
armnn::BinaryOperation::Sub
@ Sub
armnn::LayerType::Transpose
@ Transpose
armnn::ClLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1291
armnn::ClLogicalAndWorkloadValidate
arm_compute::Status ClLogicalAndWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: ClLogicalAndWorkload.cpp:20
armnn::LayerType::Comparison
@ Comparison
armnn::ClLayerSupport::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: ClLayerSupport.cpp:975
armnn::ClLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1297
armnn::ClLayerSupport::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: ClLayerSupport.cpp:1097
armnn::LayerType::StridedSlice
@ StridedSlice
armnn::ClLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: ClLayerSupport.cpp:1170
armnn::ClDepthToSpaceWorkloadValidate
arm_compute::Status ClDepthToSpaceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor)
Definition: ClDepthToSpaceWorkload.cpp:22
armnn::ClActivationWorkloadValidate
arm_compute::Status ClActivationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor)
Definition: ClActivationWorkload.cpp:17
armnn::ClMeanValidate
arm_compute::Status ClMeanValidate(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor)
Definition: ClMeanWorkload.cpp:17
armnn::ClElementwiseBinaryValidate
arm_compute::Status ClElementwiseBinaryValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ElementwiseBinaryDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: ClElementwiseBinaryWorkload.cpp:64
armnn::LogicalBinaryOperation::LogicalOr
@ LogicalOr
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::ClChannelShuffleValidate
arm_compute::Status ClChannelShuffleValidate(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor)
Definition: ClChannelShuffleWorkload.cpp:20
armnn::LayerType::Tile
@ Tile
armnn::ClLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1283
armnn::ClLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1403
armnn::LayerType::Stack
@ Stack
armnn::ClFullyConnectedWorkloadValidate
arm_compute::Status ClFullyConnectedWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const Optional< TensorInfo > &biases, const FullyConnectedDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: ClFullyConnectedWorkload.cpp:19
armnn::ClConvolution2dWorkloadValidate
arm_compute::Status ClConvolution2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: ClConvolution2dWorkload.cpp:23
armnn::LayerType::Normalization
@ Normalization
armnn::ClLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1444
armnn::LayerType::QuantizedLstm
@ QuantizedLstm
armnn::UnaryOperation::Neg
@ Neg
armnn::LayerType::Reduce
@ Reduce
armnn::LayerType::ElementwiseUnary
@ ElementwiseUnary
armnn::ComputeSplitAxis
std::set< unsigned int > ComputeSplitAxis(const armnn::SplitterDescriptor &desc, const TensorShape &input)
Definition: ArmComputeUtils.hpp:246
armnn::DataType::QSymmS16
@ QSymmS16
armnn::ClLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1452
armnn::LayerType::GatherNd
@ GatherNd
armnn::ClLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1246
armnn::LayerType::ElementwiseBinary
@ ElementwiseBinary
armnn::ClL2NormalizationWorkloadValidate
arm_compute::Status ClL2NormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor)
Definition: ClL2NormalizationFloatWorkload.cpp:17
armnn::ClLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:792
armnn::ClLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:867
armnn::ClLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1087
armnn::LayerType::ConvertFp32ToFp16
@ ConvertFp32ToFp16
armnn::ClAdditionValidate
arm_compute::Status ClAdditionValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: ClAdditionWorkload.cpp:45
armnn::ClNegWorkloadValidate
arm_compute::Status ClNegWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClNegWorkload.cpp:18
armnn::ClLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1393
armnn::ClQLstmWorkloadValidate
arm_compute::Status ClQLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: ClQLstmWorkload.cpp:247
armnn::ClReduceWorkloadValidate
arm_compute::Status ClReduceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor)
Definition: ClReduceWorkload.cpp:18
armnn::LayerType::Slice
@ Slice
armnn::ClLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1270
armnn::ClLayerSupport::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: ClLayerSupport.cpp:1566
armnn::ClConstantWorkloadValidate
arm_compute::Status ClConstantWorkloadValidate(const TensorInfo &output)
Definition: ClConstantWorkload.cpp:18
armnn::BinaryOperation::Maximum
@ Maximum
armnn::ClPermuteWorkloadValidate
arm_compute::Status ClPermuteWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor)
Definition: ClPermuteWorkload.cpp:17
armnn::ClLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1146
armnn::LayerType::ChannelShuffle
@ ChannelShuffle
armnn::BinaryOperation::SqDiff
@ SqDiff
armnn::UnaryOperation::Rsqrt
@ Rsqrt
armnn::ClLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1472
armnn::ClLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1415
armnn::UnaryOperation::Sqrt
@ Sqrt
armnn::UnaryOperation::LogicalNot
@ LogicalNot
armnn::LayerType::Subtraction
@ Subtraction
armnn::LayerType::Prelu
@ Prelu
armnn::ClResizeWorkloadValidate
arm_compute::Status ClResizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor)
Definition: ClResizeWorkload.cpp:22
armnn::LayerType::LogicalBinary
@ LogicalBinary
armnn::LayerType::Concat
@ Concat
armnn::UnaryOperation::Exp
@ Exp
armnn::ClPooling3dWorkloadValidate
arm_compute::Status ClPooling3dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor)
Definition: ClPooling3dWorkload.cpp:18
armnn::ClStackWorkloadValidate
arm_compute::Status ClStackWorkloadValidate(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor)
Definition: ClStackWorkload.cpp:29
armnn::LayerType::TransposeConvolution2d
@ TransposeConvolution2d
armnn::LayerType::Merge
@ Merge
armnn::LayerType::Softmax
@ Softmax
armnn::PolymorphicDowncast
DestType PolymorphicDowncast(SourceType *value)
Polymorphic downcast for build in pointers only.
Definition: PolymorphicDowncast.hpp:74
armnn::ClLayerSupport::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: ClLayerSupport.cpp:1590
armnn::ClComparisonWorkloadValidate
arm_compute::Status ClComparisonWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor)
Definition: ClComparisonWorkload.cpp:24
armnn::ClTileWorkloadValidate
arm_compute::Status ClTileWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor)
Definition: ClTileWorkload.cpp:16
armnn::LayerSupportBase::IsMergeSupported
bool IsMergeSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:112
armnn::ClLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &ouput, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:804
armnn::UnaryOperation::Sin
@ Sin
armnn::LayerType::Quantize
@ Quantize
armnn::ClLayerSupport::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1325
armnn::LayerSupportBase::IsMemImportSupported
bool IsMemImportSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:105
armnn::ClConvertFp32ToFp16WorkloadValidate
arm_compute::Status ClConvertFp32ToFp16WorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClConvertFp32ToFp16Workload.cpp:44
armnn::ClTransposeWorkloadValidate
arm_compute::Status ClTransposeWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor)
Definition: ClTransposeWorkload.cpp:17
armnn::LayerType::Multiplication
@ Multiplication
armnn::ClSoftmaxWorkloadValidate
arm_compute::Status ClSoftmaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor)
Definition: ClSoftmaxWorkload.cpp:17
armnn::ClReverseV2WorkloadValidate
arm_compute::Status ClReverseV2WorkloadValidate(const TensorInfo &input, const TensorInfo &axis, const TensorInfo &output)
Definition: ClReverseV2Workload.cpp:16
armnn::LayerType::Addition
@ Addition
armnn::ClPadValidate
arm_compute::Status ClPadValidate(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor)
Definition: ClPadWorkload.cpp:62
armnn::ClLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1582
armnn::ClLayerSupport::IsTileSupported
bool IsTileSupported(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1554
armnn::ClInstanceNormalizationWorkloadValidate
arm_compute::Status ClInstanceNormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor)
Definition: ClInstanceNormalizationWorkload.cpp:18
armnn::ClGatherWorkloadValidate
arm_compute::Status ClGatherWorkloadValidate(const TensorInfo &input, const TensorInfo &indices, const TensorInfo &output, const GatherDescriptor &descriptor)
Definition: ClGatherWorkload.cpp:15
armnn::ClSliceWorkloadValidate
arm_compute::Status ClSliceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor)
Definition: ClSliceWorkload.cpp:18
armnn::LayerType::DepthToSpace
@ DepthToSpace
armnn::ClBatchMatMulValidate
arm_compute::Status ClBatchMatMulValidate(const TensorInfo &inputInfoX, const TensorInfo &inputInfoY, const TensorInfo &outputInfo, const BatchMatMulDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: ClBatchMatMulWorkload.cpp:24
armnn::ClLstmFloatWorkloadValidate
arm_compute::Status ClLstmFloatWorkloadValidate(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &scratchBuffer, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: ClLstmFloatWorkload.cpp:244
armnn::BinaryOperation::Power
@ Power
armnn::ClLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1460
armnn::LayerType::MemImport
@ MemImport
armnn::LayerType::Pooling2d
@ Pooling2d
armnn::ClLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1158
armnn::ClLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:782
armnn::ClSqrtWorkloadValidate
arm_compute::Status ClSqrtWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClSqrtWorkload.cpp:19
armnn::LayerType::Division
@ Division
armnn::LayerType::Shape
@ Shape
armnn::ClNormalizationWorkloadValidate
arm_compute::Status ClNormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor)
Definition: ClNormalizationFloatWorkload.cpp:19
armnn::ClLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1010
armnn::DataType::QAsymmS8
@ QAsymmS8
armnn::ClLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1140
armnn::ClLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:963
armnn::LayerType::FullyConnected
@ FullyConnected
armnn::LayerType::Gather
@ Gather
armnn::ClLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:721
armnn::LayerType::Pooling3d
@ Pooling3d
armnn::ClLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:770
armnn::UnaryOperation::Log
@ Log
armnn::LayerType::LogSoftmax
@ LogSoftmax
armnn::LayerType::BatchMatMul
@ BatchMatMul
armnn::ClLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1023
armnn::LogicalBinaryOperation::LogicalAnd
@ LogicalAnd
armnn::LayerType::DepthwiseConvolution2d
@ DepthwiseConvolution2d
armnn::LayerType::Cast
@ Cast
armnn::ClLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1424
armnn::LayerSupportBase::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:131
armnn::LayerType::BatchToSpaceNd
@ BatchToSpaceNd
armnn::ClPooling2dWorkloadValidate
arm_compute::Status ClPooling2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor)
Definition: ClPooling2dWorkload.cpp:18
armnn::ClLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1075
armnn::ClLayerSupport::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: ClLayerSupport.cpp:920
armnn::ClMinimumWorkloadValidate
arm_compute::Status ClMinimumWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: ClMinimumWorkload.cpp:24
armnn::ClSpaceToBatchNdWorkloadValidate
arm_compute::Status ClSpaceToBatchNdWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor)
Definition: ClSpaceToBatchNdWorkload.cpp:16
armnn::ClLayerSupport::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: ClLayerSupport.cpp:1375
armnn::ClLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1541
armnn::LayerType::Reshape
@ Reshape
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::ClLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1309
armnn::LayerType::SpaceToBatchNd
@ SpaceToBatchNd
armnn::ClConvolution3dWorkloadValidate
arm_compute::Status ClConvolution3dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: ClConvolution3dWorkload.cpp:23
armnn::ClLayerSupport::IsGatherNdSupported
bool IsGatherNdSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported) const
Definition: ClLayerSupport.cpp:1128
armnn::LayerType::Fill
@ Fill
armnn::ClBatchNormalizationValidate
arm_compute::Status ClBatchNormalizationValidate(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: ClBatchNormalizationFloatWorkload.cpp:19
armnn::LayerType::L2Normalization
@ L2Normalization
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::ClQuantizedLstmWorkloadValidate
arm_compute::Status ClQuantizedLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo)
Definition: ClQuantizedLstmWorkload.cpp:18
armnn::ClLogSoftmaxWorkloadValidate
arm_compute::Status ClLogSoftmaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor)
Definition: ClLogSoftmaxWorkload.cpp:17
armnn::LayerType::Minimum
@ Minimum
armnn::ClDivisionWorkloadValidate
arm_compute::Status ClDivisionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: ClDivisionWorkload.cpp:18
armnn::ClConcatWorkloadValidate
arm_compute::Status ClConcatWorkloadValidate(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const OriginsDescriptor &descriptor)
Definition: ClConcatWorkload.cpp:27
armnn::ClLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1484
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::BinaryOperation::Minimum
@ Minimum
armnn::LayerType::Map
@ Map
armnn::LayerType::ReverseV2
@ ReverseV2
armnn::ClLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:953
armnn::LayerType::MemCopy
@ MemCopy
armnn::LayerType::ArgMinMax
@ ArgMinMax
armnn::ClPreluWorkloadValidate
arm_compute::Status ClPreluWorkloadValidate(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output)
Definition: ClPreluWorkload.cpp:16
armnn::ClLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: ClLayerSupport.cpp:1114
armnn::LayerType::Pad
@ Pad
armnn::ClSinWorkloadValidate
arm_compute::Status ClSinWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClSinWorkload.cpp:18
armnn::LayerType::Rank
@ Rank
armnn::ClAbsWorkloadValidate
arm_compute::Status ClAbsWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClAbsWorkload.cpp:19
armnn::LayerType::Mean
@ Mean
armnn::UnaryOperation::Abs
@ Abs
armnn::ClLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1529
armnn::ClLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1517
armnn::LayerType::Input
@ Input
armnn::LayerType::Resize
@ Resize
armnn::ClConvertFp16ToFp32WorkloadValidate
arm_compute::Status ClConvertFp16ToFp32WorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClConvertFp16ToFp32Workload.cpp:44
armnn::ClLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1198
armnn::SetValueChecked
void SetValueChecked(Optional< T & > optionalRef, V &&val)
Definition: LayerSupportCommon.hpp:17
armnn::BinaryOperation::Div
@ Div
armnn::ClLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:859
armnn::LayerType::Convolution2d
@ Convolution2d
armnn::LayerType::Maximum
@ Maximum
armnn::LayerType::Activation
@ Activation
armnn::ClLogicalOrWorkloadValidate
arm_compute::Status ClLogicalOrWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: ClLogicalOrWorkload.cpp:20
armnn::ClDequantizeWorkloadValidate
arm_compute::Status ClDequantizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClDequantizeWorkload.cpp:22
armnn::LayerType::Lstm
@ Lstm
armnn::LayerSupportBase::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:98
armnn::LayerType::Dequantize
@ Dequantize
armnn::LayerType::Convolution3d
@ Convolution3d
armnn::ClReshapeWorkloadValidate
arm_compute::Status ClReshapeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClReshapeWorkload.cpp:15
armnn::ClDepthwiseConvolutionWorkloadValidate
arm_compute::Status ClDepthwiseConvolutionWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, const ActivationDescriptor *activationDescriptor)
Definition: ClDepthwiseConvolutionWorkload.cpp:26
armnn::LayerType::Unmap
@ Unmap
armnn::LayerType::QLstm
@ QLstm
armnn::ClArgMinMaxWorkloadValidate
arm_compute::Status ClArgMinMaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor)
Definition: ClArgMinMaxWorkload.cpp:31
armnn::ClLayerSupport::IsReverseV2Supported
bool IsReverseV2Supported(const TensorInfo &input, const TensorInfo &axis, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported) const
Definition: ClLayerSupport.cpp:1432
armnn::ClLogicalNotWorkloadValidate
arm_compute::Status ClLogicalNotWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: ClLogicalNotWorkload.cpp:20
armnn::LayerType::Output
@ Output
armnn::LayerType::Constant
@ Constant
armnn::ClLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:877
armnn::ClLayerSupport::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: ClLayerSupport.cpp:1341