ArmNN
 23.08
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 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 176 of file ClLayerSupport.cpp.

177  : m_ModelContextPtr(modelContextPtr)
178 {
179 }

◆ ClLayerSupport() [2/2]

ClLayerSupport ( )

Definition at line 181 of file ClLayerSupport.cpp.

182  : m_ModelContextPtr(nullptr)
183 {
184 }

◆ ~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 690 of file ClLayerSupport.cpp.

694 {
695  FORWARD_WORKLOAD_VALIDATE_FUNC(ClActivationWorkloadValidate,
696  reasonIfUnsupported,
697  input,
698  output,
699  descriptor);
700 }

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

706 {
707  FORWARD_WORKLOAD_VALIDATE_FUNC(ClAdditionValidate,
708  reasonIfUnsupported,
709  input0,
710  input1,
711  output,
712  nullptr);
713 }

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

719 {
720 
721  FORWARD_WORKLOAD_VALIDATE_FUNC(ClArgMinMaxWorkloadValidate,
722  reasonIfUnsupported,
723  input,
724  output,
725  descriptor);
726 }

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

733 {
734  FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchMatMulValidate,
735  reasonIfUnsupported,
736  inputX,
737  inputY,
738  output,
739  descriptor,
740  nullptr);
741 }

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

751 {
752  FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchNormalizationValidate,
753  reasonIfUnsupported,
754  input,
755  output,
756  mean,
757  var,
758  beta,
759  gamma,
760  descriptor,
761  nullptr);
762 }

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

768 {
769  FORWARD_WORKLOAD_VALIDATE_FUNC(ClBatchToSpaceNdWorkloadValidate,
770  reasonIfUnsupported,
771  input,
772  output,
773  descriptor);
774 }

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

779 {
780  FORWARD_WORKLOAD_VALIDATE_FUNC(ClCastValidate,
781  reasonIfUnsupported,
782  input,
783  output);
784 }

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

790 {
791  FORWARD_WORKLOAD_VALIDATE_FUNC(ClChannelShuffleValidate,
792  reasonIfUnsupported,
793  input,
794  output,
795  descriptor);
796 }

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

803 {
804  FORWARD_WORKLOAD_VALIDATE_FUNC(ClComparisonWorkloadValidate,
805  reasonIfUnsupported,
806  input0,
807  input1,
808  output,
809  descriptor);
810 }

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

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

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

855 {
856  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConstantWorkloadValidate,
857  reasonIfUnsupported,
858  output);
859 }

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

864 {
865  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvertFp16ToFp32WorkloadValidate,
866  reasonIfUnsupported,
867  input,
868  output);
869 }

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

874 {
875  FORWARD_WORKLOAD_VALIDATE_FUNC(ClConvertFp32ToFp16WorkloadValidate,
876  reasonIfUnsupported,
877  input,
878  output);
879 }

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

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

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

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

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

961 {
962  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDepthToSpaceWorkloadValidate,
963  reasonIfUnsupported,
964  input,
965  output,
966  descriptor);
967 }

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

975 {
976  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDepthwiseConvolutionWorkloadValidate,
977  reasonIfUnsupported,
978  input,
979  output,
980  descriptor,
981  weights,
982  biases,
983  nullptr);
984 }

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

950 {
951  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDequantizeWorkloadValidate,
952  reasonIfUnsupported,
953  input,
954  output);
955 }

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

992 {
993  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDepthwiseConvolutionWorkloadValidate,
994  reasonIfUnsupported,
995  input,
996  output,
997  descriptor,
998  weights,
999  biases,
1000  nullptr);
1001 }

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

1008 {
1009  FORWARD_WORKLOAD_VALIDATE_FUNC(ClDivisionWorkloadValidate,
1010  reasonIfUnsupported,
1011  input0,
1012  input1,
1013  output,
1014  nullptr);
1015 }

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

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

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

1073 {
1074  armnn::IgnoreUnused(input);
1075  armnn::IgnoreUnused(output);
1076  armnn::IgnoreUnused(descriptor);
1077 
1078  return IsClBackendSupported(reasonIfUnsupported);
1079 }

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

1084 {
1085  FORWARD_WORKLOAD_VALIDATE_FUNC(ClFloorWorkloadValidate,
1086  reasonIfUnsupported,
1087  input,
1088  output);
1089 }

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

1097 {
1098  FORWARD_WORKLOAD_VALIDATE_FUNC(ClFullyConnectedWorkloadValidate,
1099  reasonIfUnsupported,
1100  input,
1101  output,
1102  weights,
1103  biases,
1104  descriptor,
1105  nullptr);
1106 }

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

1126 {
1127  FORWARD_WORKLOAD_VALIDATE_FUNC(ClGatherNdWorkloadValidate,
1128  reasonIfUnsupported,
1129  input0,
1130  input1,
1131  output);
1132 }

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

1113 {
1114  FORWARD_WORKLOAD_VALIDATE_FUNC(ClGatherWorkloadValidate,
1115  reasonIfUnsupported,
1116  input0,
1117  input1,
1118  output,
1119  descriptor);
1120 }

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

1136 {
1137  return IsClBackendSupported(reasonIfUnsupported, input);
1138 }

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

1144 {
1145  FORWARD_WORKLOAD_VALIDATE_FUNC(ClInstanceNormalizationWorkloadValidate,
1146  reasonIfUnsupported,
1147  input,
1148  output,
1149  descriptor);
1150 }

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

1156 {
1157  FORWARD_WORKLOAD_VALIDATE_FUNC(ClL2NormalizationWorkloadValidate,
1158  reasonIfUnsupported,
1159  input,
1160  output,
1161  descriptor);
1162 }

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

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

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(), 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::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 1164 of file ClLayerSupport.cpp.

1169 {
1170  IgnoreUnused(output);
1171 
1172  switch(descriptor.m_Operation)
1173  {
1174  case LogicalBinaryOperation::LogicalAnd:
1175  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogicalAndWorkloadValidate,
1176  reasonIfUnsupported,
1177  input0,
1178  input1,
1179  output);
1180  case LogicalBinaryOperation::LogicalOr:
1181  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogicalOrWorkloadValidate,
1182  reasonIfUnsupported,
1183  input0,
1184  input1,
1185  output);
1186  default:
1187  return false;
1188  }
1189 }

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

1196 {
1197  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLogSoftmaxWorkloadValidate,
1198  reasonIfUnsupported,
1199  input,
1200  output,
1201  descriptor);
1202 }

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

1214 {
1215  FORWARD_WORKLOAD_VALIDATE_FUNC(ClLstmFloatWorkloadValidate,
1216  reasonIfUnsupported,
1217  input,
1218  outputStateIn,
1219  cellStateIn,
1220  scratchBuffer,
1221  outputStateOut,
1222  cellStateOut,
1223  output,
1224  descriptor,
1225  paramsInfo);
1226 }

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

1232 {
1233  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMaximumWorkloadValidate,
1234  reasonIfUnsupported,
1235  input0,
1236  input1,
1237  output);
1238 }

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

1244 {
1245  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMeanValidate,
1246  reasonIfUnsupported,
1247  input,
1248  output,
1249  descriptor);
1250 }

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

1256 {
1257  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMinimumWorkloadValidate,
1258  reasonIfUnsupported,
1259  input0,
1260  input1,
1261  output);
1262 }

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

1268 {
1269  FORWARD_WORKLOAD_VALIDATE_FUNC(ClMultiplicationWorkloadValidate,
1270  reasonIfUnsupported,
1271  input0,
1272  input1,
1273  output,
1274  nullptr);
1275 }

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

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

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

1287 {
1288  return IsClBackendSupported(reasonIfUnsupported, output);
1289 }

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

1295 {
1296  FORWARD_WORKLOAD_VALIDATE_FUNC(ClPadValidate,
1297  reasonIfUnsupported,
1298  input,
1299  output,
1300  descriptor);
1301 }

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

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

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

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

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

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

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

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

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

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

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

1376 {
1377  FORWARD_WORKLOAD_VALIDATE_FUNC(ClQuantizedLstmWorkloadValidate,
1378  reasonIfUnsupported,
1379  input,
1380  previousCellStateIn,
1381  previousOutputIn,
1382  cellStateOut,
1383  output,
1384  paramsInfo);
1385 }

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

1390 {
1391  FORWARD_WORKLOAD_VALIDATE_FUNC(ClQuantizeWorkloadValidate,
1392  reasonIfUnsupported,
1393  input,
1394  output);
1395 }

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

1401 {
1402  FORWARD_WORKLOAD_VALIDATE_FUNC(ClReduceWorkloadValidate,
1403  reasonIfUnsupported,
1404  input,
1405  output,
1406  descriptor);
1407 }

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

1413 {
1414  IgnoreUnused(descriptor);
1415  FORWARD_WORKLOAD_VALIDATE_FUNC(ClReshapeWorkloadValidate, reasonIfUnsupported, input, output);
1416 }

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

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

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

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

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

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

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

1446 {
1447  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSpaceToBatchNdWorkloadValidate,
1448  reasonIfUnsupported,
1449  input,
1450  output,
1451  descriptor);
1452 }

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

1458 {
1459  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSpaceToDepthWorkloadValidate,
1460  reasonIfUnsupported,
1461  input,
1462  output,
1463  descriptor);
1464 }

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

1470 {
1471 #if defined(ARMCOMPUTECL_ENABLED)
1472  // Split along the last dimension, cannot use sub-tensors
1473  // as width and height of the sub-tensors do not match
1474  // the width and height of the parent tensor
1475  // in case of input with more than 2D.
1476  std::set<unsigned int> splitAxis = ComputeSplitAxis(descriptor, input.GetShape());
1477  if (descriptor.GetNumDimensions() > 2 && splitAxis.size() == 1 &&
1478  *splitAxis.begin() == descriptor.GetNumDimensions() - 1 )
1479  {
1480  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSplitterWorkloadValidate,
1481  reasonIfUnsupported,
1482  input,
1483  outputs,
1484  *splitAxis.begin());
1485  }
1486 #endif
1487  IgnoreUnused(descriptor);
1488  for (auto output : outputs)
1489  {
1490  if (!input.IsTypeSpaceMatch(output)) // Cannot use sub-tensors if the types are not same space
1491  {
1492  SetValueChecked(reasonIfUnsupported, "Cl Splitter: Types and quantization parameters must match.");
1493  return false;
1494  }
1495  }
1496  return true;
1497 }

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

1503 {
1504  FORWARD_WORKLOAD_VALIDATE_FUNC(ClStackWorkloadValidate,
1505  reasonIfUnsupported,
1506  inputs,
1507  output,
1508  descriptor);
1509 }

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

1515 {
1516  FORWARD_WORKLOAD_VALIDATE_FUNC(ClStridedSliceWorkloadValidate,
1517  reasonIfUnsupported,
1518  input,
1519  output,
1520  descriptor);
1521 }

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

1527 {
1528  FORWARD_WORKLOAD_VALIDATE_FUNC(ClSubtractionValidate,
1529  reasonIfUnsupported,
1530  input0,
1531  input1,
1532  output,
1533  nullptr);
1534 }

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

1540 {
1541  FORWARD_WORKLOAD_VALIDATE_FUNC(ClTileWorkloadValidate,
1542  reasonIfUnsupported,
1543  input,
1544  output,
1545  descriptor);
1546 }

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

1554 {
1555  FORWARD_WORKLOAD_VALIDATE_FUNC(ClTransposeConvolution2dWorkloadValidate,
1556  reasonIfUnsupported,
1557  input,
1558  output,
1559  descriptor,
1560  weights,
1561  biases);
1562 }

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

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

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

1581 {
1582  FORWARD_WORKLOAD_VALIDATE_FUNC(ClUnidirectionalSequenceLstmFloatWorkloadValidate,
1583  reasonIfUnsupported,
1584  input,
1585  outputStateIn,
1586  cellStateIn,
1587  outputStateOut,
1588  cellStateOut,
1589  output,
1590  descriptor,
1591  paramsInfo);
1592 }

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:1311
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:743
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:1252
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:1327
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:881
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:1204
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:812
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:150
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:702
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:728
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:1228
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:690
armnn::LayerType::Floor
@ Floor
armnn::UnidirectionalSequenceLstmDescriptor
LstmDescriptor UnidirectionalSequenceLstmDescriptor
Definition: Descriptors.hpp:1148
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:1285
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:969
armnn::ClLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1291
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:1091
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:1164
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:1277
armnn::ClLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1397
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:1426
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:244
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:1434
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:1240
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:786
armnn::ClLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:861
armnn::ClLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1081
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:1387
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:1264
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:1548
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:1140
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:1454
armnn::ClLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1409
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:1572
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:798
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:1319
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::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:1564
armnn::ClLayerSupport::IsTileSupported
bool IsTileSupported(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1536
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:1442
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:1152
armnn::ClLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:776
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:1004
armnn::DataType::QAsymmS8
@ QAsymmS8
armnn::ClLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1134
armnn::ClLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:957
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:715
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:764
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:1017
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:1418
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:1069
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:914
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:1369
armnn::ClLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:1523
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:1303
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:1122
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:1466
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::BinaryOperation::Minimum
@ Minimum
armnn::LayerType::Map
@ Map
armnn::ClLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: ClLayerSupport.cpp:947
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:1108
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:1511
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:1499
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:1192
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:853
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::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:871
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:1335