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

#include <RefLayerSupport.hpp>

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

Public Member Functions

bool IsLayerSupported (const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo, const Optional< QuantizedLstmInputParamsInfo > &, Optional< std::string & > reasonIfUnsupported) const override
 Default implementation of the ILayerSupport interface, Backends should implement this as a switch statement for each of their LayerTypes calling their specific backend implementation of IsXXXLayerSupported. 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 IsBroadcastToSupported (const TensorInfo &input, const TensorInfo &output, const BroadcastToDescriptor &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 &output, 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 IsDebugSupported (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 IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
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 IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=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 IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &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=EmptyOptional()) const
 
bool IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) 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) 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 IsMemCopySupported (const TensorInfo &input, const TensorInfo &output, 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 IsQuantizeSupported (const TensorInfo &input, 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 IsRankSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
bool IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
bool IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
bool IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
bool IsReverseV2Supported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
bool IsShapeSupported (const TensorInfo &input, const TensorInfo &output, 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 IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
 
bool IsTileSupported (const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, 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 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=EmptyOptional()) 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 12 of file RefLayerSupport.hpp.

Member Function Documentation

◆ IsActivationSupported()

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

Definition at line 553 of file RefLayerSupport.cpp.

557 {
558  bool supported = true;
559 
560  // Define supported types.
561  std::array<DataType,6> supportedTypes = {
562  DataType::Float32,
563  DataType::Float16,
564  DataType::QAsymmS8,
565  DataType::QAsymmU8,
566  DataType::QSymmS16
567  };
568 
569  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
570  "Reference activation: input type not supported.");
571 
572  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
573  "Reference activation: output type not supported.");
574 
575  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
576  "Reference activation: input and output types mismatched.");
577 
578  supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
579  "Reference activation: input and output shapes are of different rank.");
580 
581 
582  struct ActivationFunctionSupported : public Rule
583  {
584  ActivationFunctionSupported(const ActivationDescriptor& desc)
585  {
586  switch(desc.m_Function)
587  {
588  case ActivationFunction::Abs:
589  case ActivationFunction::BoundedReLu:
590  case ActivationFunction::Elu:
591  case ActivationFunction::Gelu:
592  case ActivationFunction::HardSwish:
593  case ActivationFunction::LeakyReLu:
594  case ActivationFunction::Linear:
595  case ActivationFunction::ReLu:
596  case ActivationFunction::Sigmoid:
597  case ActivationFunction::SoftReLu:
598  case ActivationFunction::Sqrt:
599  case ActivationFunction::Square:
600  case ActivationFunction::TanH:
601  {
602  m_Res = true;
603  break;
604  }
605  default:
606  {
607  m_Res = false;
608  break;
609  }
610  }
611  }
612  };
613 
614  // Function is supported
615  supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
616  "Reference activation: function not supported.");
617 
618  return supported;
619 }

References armnn::Abs, armnn::BoundedReLu, armnn::CheckSupportRule(), armnn::Elu, armnn::Float16, armnn::Float32, armnn::Gelu, armnn::HardSwish, armnn::LeakyReLu, armnn::Linear, ActivationDescriptor::m_Function, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::ReLu, armnn::Sigmoid, armnn::SoftReLu, armnn::Sqrt, armnn::Square, and armnn::TanH.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsAdditionSupported()

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

Definition at line 621 of file RefLayerSupport.cpp.

625 {
626  bool supported = true;
627 
628  std::array<DataType,7> supportedTypes = {
629  DataType::Float32,
630  DataType::Float16,
631  DataType::QAsymmS8,
632  DataType::QAsymmU8,
633  DataType::QSymmS16,
634  DataType::Signed32
635  };
636 
637  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
638  "Reference addition: input 0 is not a supported type.");
639 
640  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
641  "Reference addition: input 1 is not a supported type.");
642 
643  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
644  "Reference addition: output is not a supported type.");
645 
646  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
647  "Reference addition: input 0 and Input 1 types are mismatched");
648 
649  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
650  "Reference addition: input and output types are mismatched");
651 
652  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
653  "Reference addition: shapes are not suitable for implicit broadcast.");
654 
655  return supported;
656 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsArgMinMaxSupported()

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

Definition at line 658 of file RefLayerSupport.cpp.

661 {
662  IgnoreUnused(descriptor);
663 
664  std::array<DataType, 8> supportedInputTypes =
665  {
666  DataType::Float16,
667  DataType::Float32,
668  DataType::QAsymmS8,
669  DataType::QAsymmU8,
670  DataType::QSymmS16,
671  DataType::Signed32,
672  DataType::Signed64
673  };
674 
675  std::array<DataType,2> supportedOutputTypes = {
676  DataType::Signed32,
677  DataType::Signed64
678  };
679 
680  bool supported = true;
681 
682  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
683  "Reference ArgMinMax: input is not a supported type.");
684  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
685  "Reference ArgMinMax: output type not supported");
686 
687  return supported;
688 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::Signed32, and armnn::Signed64.

Referenced by RefLayerSupport::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 690 of file RefLayerSupport.cpp.

695 {
696  IgnoreUnused(descriptor);
697 
698  std::array<DataType, 6> supportedTypes =
699  {
700  DataType::Float16,
701  DataType::Float32,
702  DataType::QAsymmS8,
703  DataType::QAsymmU8,
704  DataType::QSymmS16
705  };
706 
707  bool supported = true;
708 
709  supported &= CheckSupportRule(TypeAnyOf(inputX, supportedTypes), reasonIfUnsupported,
710  "Reference batch matrix multiplication: input X is not a supported type");
711 
712  supported &= CheckSupportRule(TypeAnyOf(inputY, supportedTypes), reasonIfUnsupported,
713  "Reference batch matrix multiplication: input Y is not a supported type");
714 
715  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
716  "Reference batch matrix multiplication: output is not a supported type");
717 
718  supported &= CheckSupportRule(TypesAreEqual(inputX, inputY), reasonIfUnsupported,
719  "Reference batch matrix multiplication: input X and input Y types are mismatched");
720 
721  supported &= CheckSupportRule(TypesAreEqual(inputX, output), reasonIfUnsupported,
722  "Reference batch matrix multiplication: inputs and output types are mismatched");
723 
724  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputX, 2),
725  reasonIfUnsupported,
726  "Reference batch matrix multiplication: input X is not of rank 2 or greater");
727 
728  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputY, 2),
729  reasonIfUnsupported,
730  "Reference batch matrix multiplication: input Y is not of rank 2 or greater");
731 
732  return supported;
733 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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 735 of file RefLayerSupport.cpp.

743 {
744  IgnoreUnused(descriptor);
745 
746  std::array<DataType, 6> supportedTypes =
747  {
748  DataType::Float32,
749  DataType::Float16,
750  DataType::QAsymmS8,
751  DataType::QAsymmU8,
752  DataType::QSymmS16
753  };
754 
755  bool supported = true;
756 
757  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
758  "Reference batch normalization: input is not a supported type.");
759 
760  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
761  "Reference batch normalization: output is not a supported type.");
762 
763  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
764  "Reference batch normalization: input and output types are mismatched");
765 
766  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
767  "Reference batch normalization: mean is not a supported type.");
768 
769  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
770  "Reference batch normalization: variance is not a supported type.");
771 
772  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
773  "Reference batch normalization: beta is not a supported type.");
774 
775  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
776  "Reference batch normalization: gamma is not a supported type.");
777 
778  return supported;
779 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsBatchToSpaceNdSupported()

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

Definition at line 781 of file RefLayerSupport.cpp.

785 {
786  IgnoreUnused(descriptor);
787 
788  bool supported = true;
789 
790  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
791  std::string inputTensorStr = "input";
792  std::string outputTensorStr = "output";
793 
794  // Define supported types.
795  std::array<DataType,6> supportedTypes =
796  {
797  DataType::Float32,
798  DataType::Float16,
799  DataType::QAsymmS8,
800  DataType::QAsymmU8,
801  DataType::QSymmS16
802  };
803 
804  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
805  "Reference BatchToSpaceNd: input type not supported.");
806 
807  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
808  "Reference BatchToSpaceNd: output type not supported.");
809 
810  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
811  "Reference BatchToSpaceNd: input and output types mismatched.");
812 
813  return supported;
814 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsBroadcastToSupported()

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

Definition at line 816 of file RefLayerSupport.cpp.

820 {
821  IgnoreUnused(descriptor);
822 
823  bool supported = true;
824 
825  std::array<DataType, 8> supportedTypes
826  {
827  DataType::Float32,
828  DataType::Float16,
829  DataType::QAsymmS8,
830  DataType::QAsymmU8,
831  DataType::QSymmS8,
832  DataType::QSymmS16,
833  DataType::Signed32,
834  DataType::Signed64
835  };
836 
837  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
838  "BroadcastTo: input type not supported.");
839 
840  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
841  "BroadcastTo: output type not supported");
842 
843  return supported;
844 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsCastSupported()

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

Definition at line 846 of file RefLayerSupport.cpp.

849 {
850  std::array<DataType, 10> supportedInputTypes =
851  {
852  DataType::Float32,
853  DataType::Float16,
854  DataType::QSymmS8,
855  DataType::QAsymmS8,
856  DataType::QAsymmU8,
857  DataType::QSymmS16,
858  DataType::Signed32,
859  DataType::Signed64
860  };
861 
862  bool supported = true;
863  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
864  "Reference cast: input is not a supported type");
865 
866 
867  supported &= CheckSupportRule(TypeAnyOf(output, supportedInputTypes), reasonIfUnsupported,
868  "Reference cast: output is not a supported type");
869 
870  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
871  "Reference cast: input and output shapes have different number of total elements");
872 
873  return supported;
874 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsChannelShuffleSupported()

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

Definition at line 876 of file RefLayerSupport.cpp.

880 {
881  IgnoreUnused(descriptor);
882  bool supported = true;
883 
884  // Define supported output and inputs types.
885  std::array<DataType, 7> supportedTypes =
886  {
887  DataType::Float32,
888  DataType::Float16,
889  DataType::QAsymmS8,
890  DataType::QAsymmU8,
891  DataType::QSymmS8,
892  DataType::QSymmS16
893  };
894 
895  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
896  "Reference ChannelShuffle: input is not a supported type.");
897 
898  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
899  "Reference ChannelShuffle: output is not a supported type.");
900 
901  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
902  "Reference ChannelShuffle: input and output types are mismatched.");
903 
904  return supported;
905 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsComparisonSupported()

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

Definition at line 908 of file RefLayerSupport.cpp.

913 {
914  IgnoreUnused(descriptor);
915  std::array<DataType, 8> supportedInputTypes =
916  {
917  DataType::Boolean,
918  DataType::Float32,
919  DataType::Float16,
920  DataType::QAsymmS8,
921  DataType::QAsymmU8,
922  DataType::QSymmS16,
923  DataType::Signed32
924  };
925 
926  bool supported = true;
927  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
928  "Reference comparison: input 0 is not a supported type");
929 
930  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
931  "Reference comparison: input 0 and Input 1 types are mismatched");
932 
933  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
934  "Reference comparison: output is not of type Boolean");
935 
936  return supported;
937 }

References armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::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 939 of file RefLayerSupport.cpp.

943 {
944  IgnoreUnused(descriptor);
945 
946  bool supported = true;
947  std::array<DataType,7> supportedTypes =
948  {
949  DataType::Float32,
950  DataType::Float16,
951  DataType::QAsymmS8,
952  DataType::QAsymmU8,
953  DataType::QSymmS16,
954  DataType::Signed32
955  };
956 
957  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
958  "Reference concatenation: output type not supported");
959  for (const TensorInfo* input : inputs)
960  {
961  ARMNN_ASSERT(input != nullptr);
962  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
963  "Reference concatenation: input type not supported");
964 
965  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
966  "Reference concatenation: input and output types mismatched.");
967  }
968 
969  return supported;
970 }

References ARMNN_ASSERT, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsConstantSupported()

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

Definition at line 972 of file RefLayerSupport.cpp.

974 {
975  std::array<DataType,8> supportedTypes =
976  {
977  DataType::Float16,
978  DataType::Float32,
979  DataType::QAsymmS8,
980  DataType::QAsymmU8,
981  DataType::QSymmS8,
982  DataType::QSymmS16,
983  DataType::Signed32
984  };
985 
986  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
987  "Reference constant: output is not a supported type.");
988 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsConvertFp16ToFp32Supported()

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

Definition at line 990 of file RefLayerSupport.cpp.

993 {
994  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
995  input.GetDataType(),
996  &TrueFunc<>,
997  &FalseInputFuncF32<>,
998  &FalseFuncU8<>,
999  &FalseFuncI32<>,
1000  &FalseFuncU8<>) &&
1001  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
1002  output.GetDataType(),
1003  &FalseOutputFuncF16<>,
1004  &TrueFunc<>,
1005  &FalseFuncU8<>,
1006  &FalseFuncI32<>,
1007  &FalseFuncU8<>));
1008 }

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

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsConvertFp32ToFp16Supported()

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

Definition at line 1010 of file RefLayerSupport.cpp.

1013 {
1014  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
1015  input.GetDataType(),
1016  &FalseInputFuncF16<>,
1017  &TrueFunc<>,
1018  &FalseFuncU8<>,
1019  &FalseFuncI32<>,
1020  &FalseFuncU8<>) &&
1021  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
1022  output.GetDataType(),
1023  &TrueFunc<>,
1024  &FalseOutputFuncF32<>,
1025  &FalseFuncU8<>,
1026  &FalseFuncI32<>,
1027  &FalseFuncU8<>));
1028 }

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

Referenced by RefLayerSupport::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 1030 of file RefLayerSupport.cpp.

1036 {
1037  bool supported = true;
1038 
1039  // Define supported types.
1040  std::array<DataType,7> supportedTypes =
1041  {
1042  DataType::Float32,
1043  DataType::Float16,
1044  DataType::QAsymmS8,
1045  DataType::QAsymmU8,
1046  DataType::QSymmS8,
1047  DataType::QSymmS16
1048  };
1049 
1050  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1051  "Reference Convolution2d: input is not a supported type.");
1052 
1053  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1054  "Reference Convolution2d: output is not a supported type.");
1055 
1056  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1057  "Reference Convolution2d: input and output types mismatched.");
1058 
1059 
1060  const DataType inputType = input.GetDataType();
1061  if (IsQuantized8BitType(inputType))
1062  {
1063  std::array<DataType, 3> supportedWeightTypes =
1064  {
1065  DataType::QAsymmS8,
1066  DataType::QAsymmU8,
1067  DataType::QSymmS8
1068  };
1069 
1070  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1071  "Reference Convolution2d: weights type not supported for quantized input.");
1072  }
1073  else
1074  {
1075  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1076  "Reference Convolution2d: weights is not a supported type.");
1077 
1078  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1079  "Reference Convolution2d: input and weights types mismatched.");
1080  }
1081 
1082  if (biases.has_value())
1083  {
1084  std::array<DataType,4> biasesSupportedTypes =
1085  {
1086  DataType::Float32,
1087  DataType::Float16,
1088  DataType::Signed32
1089  };
1090 
1091  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1092  "Reference Convolution2d: biases is not a supported type.");
1093  }
1094  IgnoreUnused(descriptor);
1095 
1096  return supported;
1097 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::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 1099 of file RefLayerSupport.cpp.

1105 {
1106  bool supported = true;
1107 
1108  // Define supported types.
1109  std::array<DataType,7> supportedTypes =
1110  {
1111  DataType::Float32,
1112  DataType::Float16,
1113  DataType::QAsymmS8,
1114  DataType::QAsymmU8,
1115  DataType::QSymmS8,
1116  DataType::QSymmS16
1117  };
1118 
1119  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1120  "Reference Convolution3d: input is not a supported type.");
1121 
1122  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1123  "Reference Convolution3d: output is not a supported type.");
1124 
1125  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1126  "Reference Convolution3d: input and output types mismatched.");
1127 
1128  const DataType inputType = input.GetDataType();
1129  if (IsQuantized8BitType(inputType))
1130  {
1131  std::array<DataType, 3> supportedWeightTypes =
1132  {
1133  DataType::QAsymmS8,
1134  DataType::QAsymmU8,
1135  DataType::QSymmS8
1136  };
1137 
1138  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1139  "Reference Convolution3d: weights type not supported for quantized input.");
1140  }
1141  else
1142  {
1143  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1144  "Reference Convolution3d: weights is not a supported type.");
1145 
1146  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1147  "Reference Convolution3d: input and weights types mismatched.");
1148  }
1149 
1150  if (biases.has_value())
1151  {
1152  std::array<DataType,4> biasesSupportedTypes =
1153  {
1154  DataType::Float32,
1155  DataType::Float16,
1156  DataType::Signed32
1157  };
1158 
1159  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1160  "Reference Convolution3d: biases is not a supported type.");
1161  }
1162  IgnoreUnused(descriptor);
1163 
1164  return supported;
1165 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsDebugSupported()

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

Definition at line 1167 of file RefLayerSupport.cpp.

1170 {
1171  bool supported = true;
1172 
1173  std::array<DataType, 8> supportedTypes =
1174  {
1175  DataType::BFloat16,
1176  DataType::Float16,
1177  DataType::Float32,
1178  DataType::QAsymmS8,
1179  DataType::QAsymmU8,
1180  DataType::QSymmS8,
1181  DataType::QSymmS16,
1182  DataType::Signed32
1183  };
1184 
1185  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1186  "Reference for Debug layer: input type not supported");
1187 
1188  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1189  "Reference for Debug layer: output type not supported");
1190 
1191  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1192  "Reference for Debug layer: input and output types are mismatched");
1193 
1194  return supported;
1195 }

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsDepthToSpaceSupported()

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

Definition at line 1197 of file RefLayerSupport.cpp.

1201 {
1202  IgnoreUnused(descriptor);
1203  bool supported = true;
1204 
1205  std::array<DataType,6> supportedTypes =
1206  {
1207  DataType::Float32,
1208  DataType::Float16,
1209  DataType::QAsymmS8,
1210  DataType::QAsymmU8,
1211  DataType::QSymmS16
1212  };
1213 
1214  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1215  "Reference DepthToSpace: input type not supported");
1216 
1217  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1218  "Reference DepthToSpace: output type not supported");
1219 
1220  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1221  "Reference DepthToSpace: input and output types are mismatched");
1222 
1223  return supported;
1224 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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 1226 of file RefLayerSupport.cpp.

1232 {
1233  IgnoreUnused(descriptor);
1234  bool supported = true;
1235 
1236  // Define supported types.
1237  std::array<DataType,7> supportedTypes =
1238  {
1239  DataType::Float32,
1240  DataType::Float16,
1241  DataType::QAsymmS8,
1242  DataType::QAsymmU8,
1243  DataType::QSymmS8,
1244  DataType::QSymmS16
1245  };
1246 
1247  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1248  "Reference DepthwiseConvolution2d: input is not a supported type.");
1249 
1250  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1251  "Reference DepthwiseConvolution2d: output is not a supported type.");
1252 
1253  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1254  "Reference DepthwiseConvolution2d: input and output types mismatched.");
1255 
1256  const DataType inputType = input.GetDataType();
1257  if (IsQuantized8BitType(inputType))
1258  {
1259  std::array<DataType, 3> supportedWeightTypes =
1260  {
1261  DataType::QAsymmS8,
1262  DataType::QAsymmU8,
1263  DataType::QSymmS8,
1264  };
1265 
1266  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1267  "Reference DepthwiseConvolution2d: weights type not supported for "
1268  "quantized input.");
1269  }
1270  else
1271  {
1272  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1273  "Reference DepthwiseConvolution2d: weights is not a supported type.");
1274 
1275  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1276  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
1277  }
1278 
1279  if (biases.has_value())
1280  {
1281  std::array<DataType,4> biasesSupportedTypes =
1282  {
1283  DataType::Float32,
1284  DataType::Float16,
1285  DataType::Signed32
1286  };
1287  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1288  "Reference DepthwiseConvolution2d: biases is not a supported type.");
1289  }
1290 
1291  return supported;
1292 
1293 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(), and RefLayerSupport::IsLayerSupported().

◆ IsDequantizeSupported()

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

Definition at line 1295 of file RefLayerSupport.cpp.

1298 {
1299  bool supported = true;
1300 
1301  std::array<DataType,5> supportedInputTypes = {
1302  DataType::QAsymmS8,
1303  DataType::QAsymmU8,
1304  DataType::QSymmS8,
1305  DataType::QSymmS16,
1306  DataType::Float16
1307  };
1308 
1309  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1310  "Reference for Dequantize layer: input type not supported.");
1311 
1312  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
1313  "Reference for Dequantize layer: per-axis quantized input not supported.");
1314 
1315  std::array<DataType,3> supportedOutputTypes = {
1316  DataType::Float32,
1317  DataType::Float16
1318  };
1319 
1320  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1321  "Reference for Dequantize layer: output type not supported.");
1322 
1323  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1324  "Reference for Dequantize layer: input/output shapes have different num total "
1325  "elements.");
1326 
1327  return supported;
1328 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsDetectionPostProcessSupported()

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

Definition at line 1330 of file RefLayerSupport.cpp.

1339 {
1340  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
1341 
1342  bool supported = true;
1343 
1344  std::array<DataType,6> supportedInputTypes =
1345  {
1346  DataType::Float32,
1347  DataType::Float16,
1348  DataType::QAsymmS8,
1349  DataType::QAsymmU8,
1350  DataType::QSymmS16
1351  };
1352 
1353  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
1354  "Reference DetectionPostProcess: input 0 is not a supported type.");
1355 
1356  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
1357  "Reference DetectionPostProcess: input 1 is not a supported type.");
1358 
1359  return supported;
1360 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsDilatedDepthwiseConvolutionSupported()

bool IsDilatedDepthwiseConvolutionSupported ( 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 1362 of file RefLayerSupport.cpp.

1368 {
1369  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
1370 }

References RefLayerSupport::IsDepthwiseConvolutionSupported().

◆ IsDivisionSupported()

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

Definition at line 1372 of file RefLayerSupport.cpp.

1376 {
1377  bool supported = true;
1378 
1379  std::array<DataType,7> supportedTypes = {
1380  DataType::Float32,
1381  DataType::Float16,
1382  DataType::QAsymmS8,
1383  DataType::QAsymmU8,
1384  DataType::QSymmS16,
1385  DataType::Signed32
1386  };
1387 
1388  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1389  "Reference division: input 0 is not a supported type.");
1390 
1391  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1392  "Reference division: input 1 is not a supported type.");
1393 
1394  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1395  "Reference division: output is not a supported type.");
1396 
1397  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1398  "Reference division: input 0 and Input 1 types are mismatched");
1399 
1400  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1401  "Reference division: input and output types are mismatched");
1402 
1403  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1404  "Reference division: shapes are not suitable for implicit broadcast.");
1405 
1406  return supported;
1407 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsElementwiseUnarySupported()

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

Definition at line 1409 of file RefLayerSupport.cpp.

1413 {
1414  IgnoreUnused(descriptor);
1415 
1416  std::array<DataType, 7> supportedTypes =
1417  {
1418  DataType::Float32,
1419  DataType::Float16,
1420  DataType::QAsymmS8,
1421  DataType::QAsymmU8,
1422  DataType::QSymmS16,
1423  DataType::Signed32
1424  };
1425 
1426  std::array<DataType, 1> logicalSupportedTypes =
1427  {
1428  DataType::Boolean
1429  };
1430 
1431  bool supported = true;
1432 
1433  if (descriptor.m_Operation == UnaryOperation::LogicalNot)
1434  {
1435  supported &= CheckSupportRule(TypeAnyOf(input, logicalSupportedTypes), reasonIfUnsupported,
1436  "Reference elementwise unary: input type not supported");
1437 
1438  supported &= CheckSupportRule(TypeAnyOf(output, logicalSupportedTypes), reasonIfUnsupported,
1439  "Reference elementwise unary: output type not supported");
1440  }
1441  else
1442  {
1443  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1444  "Reference elementwise unary: input type not supported");
1445 
1446  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1447  "Reference elementwise unary: output type not supported");
1448  }
1449 
1450  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1451  "Reference elementwise unary: input and output types not matching");
1452 
1453  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1454  "Reference elementwise unary: input and output shapes"
1455  "have different number of total elements");
1456 
1457  return supported;
1458 }

References armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::LogicalNot, ElementwiseUnaryDescriptor::m_Operation, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsFakeQuantizationSupported()

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

Definition at line 1460 of file RefLayerSupport.cpp.

1463 {
1464  IgnoreUnused(descriptor);
1465  bool supported = true;
1466 
1467  std::array<DataType,1> supportedTypes =
1468  {
1469  DataType::Float32
1470  };
1471 
1472  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1473  "Reference fake quantization: input type not supported.");
1474 
1475  return supported;
1476 }

References armnn::CheckSupportRule(), armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsFillSupported()

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

Definition at line 1478 of file RefLayerSupport.cpp.

1482 {
1483  IgnoreUnused(descriptor);
1484  IgnoreUnused(output);
1485 
1486  bool supported = true;
1487 
1488  std::array<DataType,3> supportedTypes =
1489  {
1490  DataType::Float32,
1491  DataType::Float16,
1492  DataType::Signed32
1493  };
1494 
1495  supported &= CheckSupportRule(TypeIs(input, DataType::Signed32), reasonIfUnsupported,
1496  "Reference Fill: input type not supported.");
1497 
1498  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1499  "Reference Fill: output type not supported.");
1500  return supported;
1501 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsFloorSupported()

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

Definition at line 1503 of file RefLayerSupport.cpp.

1506 {
1507  IgnoreUnused(output);
1508  bool supported = true;
1509 
1510  std::array<DataType,3> supportedTypes =
1511  {
1512  DataType::Float32,
1513  DataType::Float16
1514  };
1515 
1516  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1517  "Reference Floor: input type not supported.");
1518 
1519  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1520  "Reference Floor: output type not supported.");
1521 
1522  return supported;
1523 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::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 1525 of file RefLayerSupport.cpp.

1531 {
1532  bool supported = true;
1533 
1534  // Define supported types.
1535  std::array<DataType,6> supportedTypes =
1536  {
1537  DataType::Float32,
1538  DataType::Float16,
1539  DataType::QAsymmS8,
1540  DataType::QAsymmU8,
1541  DataType::QSymmS16
1542  };
1543 
1544  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1545  "Reference Fully Connected: input type not supported.");
1546 
1547  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1548  "Reference Fully Connected: output type not supported.");
1549 
1550  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1551  "Reference Fully Connected: weights type not supported.");
1552 
1553  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1554  "Reference Fully Connected: input and output types mismatched.");
1555 
1556  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1557  "Reference Fully Connected: weights is not a supported type.");
1558 
1559  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1560  "Reference Fully Connected: input and weights types mismatched.");
1561 
1562  if (descriptor.m_BiasEnabled)
1563  {
1564  // Defined supported types for bias
1565  std::array<DataType, 5>
1566  supportedBiasTypes =
1567  {
1568  DataType::Float32,
1569  DataType::Float16,
1570  DataType::Signed32,
1571  DataType::QAsymmS8
1572  };
1573 
1574  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
1575  "Reference Fully Connected: bias type not supported.");
1576 
1577  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
1578  "Reference Fully Connected: bias and weight types mismatch.");
1579 
1580  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
1581  "Reference Fully Connected: bias type inferred from weights is incompatible.");
1582 
1583  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
1584  "Reference Fully Connected: bias must have 1 dimension.");
1585 
1586  }
1587 
1588  return supported;
1589 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, FullyConnectedDescriptor::m_BiasEnabled, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsGatherNdSupported()

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

Definition at line 1591 of file RefLayerSupport.cpp.

1595 {
1596  bool supported = true;
1597  std::array<DataType,7> supportedTypes =
1598  {
1599  DataType::Float32,
1600  DataType::Float16,
1601  DataType::QAsymmS8,
1602  DataType::QAsymmU8,
1603  DataType::QSymmS16,
1604  DataType::Signed32
1605  };
1606 
1607  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1608  "Reference GatherNd: input type not supported");
1609 
1610  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1611  "Reference GatherNd: output type not supported");
1612 
1613  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1614  "Reference GatherNd: indices (input1) type not supported");
1615 
1616  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1617  "Reference GatherNd: input and output types not matching");
1618 
1619  return supported;
1620 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsGatherSupported()

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

Definition at line 1622 of file RefLayerSupport.cpp.

1627 {
1628  bool supported = true;
1629  std::array<DataType,7> supportedTypes =
1630  {
1631  DataType::Float32,
1632  DataType::Float16,
1633  DataType::QAsymmS8,
1634  DataType::QAsymmU8,
1635  DataType::QSymmS16,
1636  DataType::Signed32
1637  };
1638 
1639  IgnoreUnused(descriptor);
1640  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1641  "Reference Gather: input type not supported");
1642 
1643  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1644  "Reference Gather: output type not supported");
1645 
1646  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1647  "Reference Gather: indices (input1) type not supported");
1648 
1649  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1650  "Reference Gather: input and output types not matching");
1651 
1652  return supported;
1653 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsInputSupported()

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

Definition at line 1655 of file RefLayerSupport.cpp.

1657 {
1658  return true;
1659 }

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsInstanceNormalizationSupported()

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

Definition at line 1661 of file RefLayerSupport.cpp.

1665 {
1666  IgnoreUnused(descriptor);
1667  // Define supported types
1668  std::array<DataType, 3> supportedTypes =
1669  {
1670  DataType::Float32,
1671  DataType::Float16
1672  };
1673 
1674  bool supported = true;
1675 
1676  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1677  "Reference Instance Normalization: input type not supported.");
1678 
1679  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1680  "Reference Instance Normalization: output type not supported.");
1681 
1682  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1683  "Reference Instance Normalization: input and output types mismatched.");
1684 
1685  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1686  "Reference Instance Normalization: input and output shapes have different "
1687  "num total elements.");
1688 
1689  return supported;
1690 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsL2NormalizationSupported()

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

Definition at line 1692 of file RefLayerSupport.cpp.

1696 {
1697  IgnoreUnused(descriptor);
1698  // Define supported types
1699  std::array<DataType, 6> supportedTypes =
1700  {
1701  DataType::Float32,
1702  DataType::Float16,
1703  DataType::QAsymmS8,
1704  DataType::QAsymmU8,
1705  DataType::QSymmS16
1706  };
1707 
1708  bool supported = true;
1709 
1710  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1711  "Reference L2normalization: input type not supported.");
1712 
1713  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1714  "Reference L2normalization: output type not supported.");
1715 
1716  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1717  "Reference L2normalization: input and output types mismatched.");
1718 
1719  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1720  "Reference L2normalization: input and output shapes have different "
1721  "num total elements.");
1722 
1723  return supported;
1724 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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
overridevirtual

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 61 of file RefLayerSupport.cpp.

67 {
68  switch (type)
69  {
70  case LayerType::Activation:
71  return IsActivationSupported(infos[0],
72  infos[1],
73  *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
74  reasonIfUnsupported);
75  case LayerType::Addition:
76  return IsAdditionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
77  case LayerType::ArgMinMax:
78  return IsArgMinMaxSupported(infos[0],
79  infos[1],
80  *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
81  reasonIfUnsupported);
82  case LayerType::BatchMatMul:
83  return IsBatchMatMulSupported(infos[0],
84  infos[1],
85  infos[2],
86  *(PolymorphicDowncast<const BatchMatMulDescriptor*>(&descriptor)),
87  reasonIfUnsupported);
88  case LayerType::BatchNormalization:
89  return IsBatchNormalizationSupported(infos[0],
90  infos[1],
91  infos[2],
92  infos[3],
93  infos[4],
94  infos[5],
95  *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
96  (&descriptor)),
97  reasonIfUnsupported);
98  case LayerType::BatchToSpaceNd:
99  return IsBatchToSpaceNdSupported(infos[0],
100  infos[1],
101  *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
102  reasonIfUnsupported);
103  case LayerType::BroadcastTo:
104  return IsBroadcastToSupported(infos[0],
105  infos[1],
106  *(PolymorphicDowncast<const BroadcastToDescriptor*>(&descriptor)),
107  reasonIfUnsupported);
108  case LayerType::Comparison:
109  return IsComparisonSupported(infos[0],
110  infos[1],
111  infos[2],
112  *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
113  reasonIfUnsupported);
114  case LayerType::Concat:
115  {
116  std::vector<const TensorInfo*> inputInfos;
117  for (uint32_t i = 0; i < (infos.size() - 1); i++)
118  {
119  inputInfos.push_back(&infos[i]);
120  }
121  return IsConcatSupported(inputInfos,
122  infos[infos.size() - 1],
123  *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
124  reasonIfUnsupported);
125  }
126  case LayerType::Constant:
127  return IsConstantSupported(infos[0], reasonIfUnsupported);
128  case LayerType::ConvertFp16ToFp32:
129  return IsConvertFp16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
130  case LayerType::ConvertFp32ToFp16:
131  return IsConvertFp32ToFp16Supported(infos[0], infos[1], reasonIfUnsupported);
132  case LayerType::Convolution2d:
133  {
134  if (infos.size() != 4)
135  {
136  throw InvalidArgumentException("Invalid number of Convolution2d TensorInfos. "
137  "TensorInfos should be of format: {input, output, weights, biases}.");
138  }
139 
140  auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
141  if (infos[3] == TensorInfo())
142  {
143  return IsConvolution2dSupported(infos[0],
144  infos[1],
145  desc,
146  infos[2],
147  EmptyOptional(),
148  reasonIfUnsupported);
149  }
150  else
151  {
152  return IsConvolution2dSupported(infos[0],
153  infos[1],
154  desc,
155  infos[2],
156  infos[3],
157  reasonIfUnsupported);
158  }
159  }
160  case LayerType::DepthToSpace:
161  return IsDepthToSpaceSupported(infos[0],
162  infos[1],
163  *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
164  reasonIfUnsupported);
165  case LayerType::DepthwiseConvolution2d:
166  {
167  if (infos.size() != 4)
168  {
169  throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d TensorInfos. "
170  "TensorInfos should be of format: {input, output, weights, biases}.");
171  }
172 
173  auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
174  if (infos[3] == TensorInfo())
175  {
176  return IsDepthwiseConvolutionSupported(infos[0],
177  infos[1],
178  desc,
179  infos[2],
180  EmptyOptional(),
181  reasonIfUnsupported);
182  }
183  else
184  {
185  return IsDepthwiseConvolutionSupported(infos[0],
186  infos[1],
187  desc,
188  infos[2],
189  infos[3],
190  reasonIfUnsupported);
191  }
192  }
193  case LayerType::Dequantize:
194  return IsDequantizeSupported(infos[0], infos[1], reasonIfUnsupported);
195  case LayerType::Division:
196  return IsDivisionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
197  case LayerType::ElementwiseBinary:
198  {
199  std::array<DataType, 7> supportedTypes =
200  {
201  DataType::Float32,
202  DataType::Float16,
203  DataType::QAsymmS8,
204  DataType::QAsymmU8,
205  DataType::QSymmS16,
206  DataType::Signed32
207  };
208 
209  bool supported = true;
210  supported &= CheckSupportRule(TypeAnyOf(infos[0], supportedTypes), reasonIfUnsupported,
211  "Reference elementwise unary: input type not supported");
212 
213  supported &= CheckSupportRule(TypeAnyOf(infos[1], supportedTypes), reasonIfUnsupported,
214  "Reference elementwise unary: input type not supported");
215 
216  supported &= CheckSupportRule(TypeAnyOf(infos[2], supportedTypes), reasonIfUnsupported,
217  "Reference elementwise unary: output type not supported");
218 
219  supported &= CheckSupportRule(TypesAreEqual(infos[0], infos[1]), reasonIfUnsupported,
220  "Reference elementwise unary: input types not matching");
221 
222  supported &= CheckSupportRule(TypesAreEqual(infos[0], infos[2]), reasonIfUnsupported,
223  "Reference elementwise unary: input and output types not matching");
224 
225  return supported;
226  }
227  case LayerType::ElementwiseUnary:
228  return IsElementwiseUnarySupported(infos[0],
229  infos[1],
230  *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor)),
231  reasonIfUnsupported);
232  case LayerType::Fill:
233  return IsFillSupported(infos[0],
234  infos[1],
235  *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
236  reasonIfUnsupported);
237  case LayerType::Floor:
238  return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
239  case LayerType::FullyConnected:
240  return IsFullyConnectedSupported(infos[0],
241  infos[1],
242  infos[2],
243  infos[3],
244  *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
245  reasonIfUnsupported);
246  case LayerType::Gather:
247  return IsGatherSupported(infos[0],
248  infos[1],
249  infos[2],
250  *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
251  reasonIfUnsupported);
252  case LayerType::GatherNd:
253  return IsGatherNdSupported(infos[0],
254  infos[1],
255  infos[2],
256  reasonIfUnsupported);
257  case LayerType::Input:
258  return IsInputSupported(infos[0], reasonIfUnsupported);
259  case LayerType::InstanceNormalization:
260  return IsInstanceNormalizationSupported(infos[0],
261  infos[1],
262  *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
263  (&descriptor)),
264  reasonIfUnsupported);
265  case LayerType::L2Normalization:
266  return IsL2NormalizationSupported(infos[0],
267  infos[1],
268  *(PolymorphicDowncast<const L2NormalizationDescriptor*>(&descriptor)),
269  reasonIfUnsupported);
270  case LayerType::LogicalBinary:
271  return IsLogicalBinarySupported(infos[0],
272  infos[1],
273  infos[2],
274  *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
275  reasonIfUnsupported);
276  case LayerType::LogSoftmax:
277  return IsLogSoftmaxSupported(infos[0],
278  infos[1],
279  *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
280  reasonIfUnsupported);
281  case LayerType::Lstm:
282  return IsLstmSupported(infos[0],
283  infos[1],
284  infos[2],
285  infos[3],
286  infos[4],
287  infos[5],
288  infos[6],
289  *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
290  lstmParamsInfo.value(),
291  reasonIfUnsupported);
292  case LayerType::QLstm:
293  return IsQLstmSupported(infos[0],
294  infos[1],
295  infos[2],
296  infos[3],
297  infos[4],
298  infos[5],
299  *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
300  lstmParamsInfo.value(),
301  reasonIfUnsupported);
302  case LayerType::Maximum:
303  return IsMaximumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
304  case LayerType::Mean:
305  return IsMeanSupported(infos[0],
306  infos[1],
307  *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
308  reasonIfUnsupported);
309  case LayerType::Minimum:
310  return IsMinimumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
311  case LayerType::Multiplication:
312  return IsMultiplicationSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
313  case LayerType::Normalization:
314  return IsNormalizationSupported(infos[0],
315  infos[1],
316  *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
317  reasonIfUnsupported);
318  case LayerType::Output:
319  return IsOutputSupported(infos[0], reasonIfUnsupported);
320  case LayerType::Pad:
321  return IsPadSupported(infos[0],
322  infos[1],
323  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
324  reasonIfUnsupported);
325  case LayerType::Permute:
326  return IsPermuteSupported(infos[0],
327  infos[1],
328  *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
329  reasonIfUnsupported);
330  case LayerType::Pooling2d:
331  return IsPooling2dSupported(infos[0],
332  infos[1],
333  *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
334  reasonIfUnsupported);
335  case LayerType::Prelu:
336  return IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
337  case LayerType::Quantize:
338  return IsQuantizeSupported(infos[0], infos[1], reasonIfUnsupported);
339  case LayerType::Reshape:
340  return IsReshapeSupported(infos[0],
341  infos[1],
342  *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
343  reasonIfUnsupported);
344  case LayerType::Resize:
345  return IsResizeSupported(infos[0],
346  infos[1],
347  *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
348  reasonIfUnsupported);
349  case LayerType::ReverseV2:
350  return IsReverseV2Supported(infos[0],
351  infos[1],
352  infos[2],
353  reasonIfUnsupported);
354  case LayerType::Reduce:
355  return IsReduceSupported(infos[0],
356  infos[1],
357  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
358  reasonIfUnsupported);
359  case LayerType::Slice:
360  return IsSliceSupported(infos[0],
361  infos[1],
362  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
363  reasonIfUnsupported);
364  case LayerType::Softmax:
365  return IsSoftmaxSupported(infos[0],
366  infos[1],
367  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
368  reasonIfUnsupported);
369  case LayerType::SpaceToBatchNd:
370  return IsSpaceToBatchNdSupported(infos[0],
371  infos[1],
372  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
373  reasonIfUnsupported);
374  case LayerType::SpaceToDepth:
375  return IsSpaceToDepthSupported(infos[0],
376  infos[1],
377  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
378  reasonIfUnsupported);
379  case LayerType::Splitter:
380  {
381  std::vector<TensorInfo> outputInfos;
382  for (uint32_t i = 1; i < infos.size(); i++)
383  {
384  outputInfos.push_back(infos[i]);
385  }
386  return IsSplitterSupported(infos[0],
387  {outputInfos.begin(), outputInfos.end()},
388  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
389  reasonIfUnsupported);
390  }
391  case LayerType::Stack:
392  {
393  std::vector<const TensorInfo*> inputInfos;
394  for (uint32_t i = 0; i < infos.size() - 1; i++)
395  {
396  inputInfos.push_back(&infos[i]);
397  }
398  return IsStackSupported(inputInfos,
399  infos[infos.size() - 1],
400  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
401  reasonIfUnsupported);
402  }
403  case LayerType::StridedSlice:
404  return IsStridedSliceSupported(infos[0],
405  infos[1],
406  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
407  reasonIfUnsupported);
408  case LayerType::Subtraction:
409  return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
410  case LayerType::Tile:
411  return IsTileSupported(infos[0],
412  infos[1],
413  *(PolymorphicDowncast<const TileDescriptor*>(&descriptor)),
414  reasonIfUnsupported);
415  case LayerType::Transpose:
416  return IsTransposeSupported(infos[0],
417  infos[1],
418  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
419  reasonIfUnsupported);
420  case LayerType::TransposeConvolution2d:
421  {
422  if (infos.size() != 4)
423  {
424  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
425  "TensorInfos should be of format: {input, output, weights, biases}.");
426  }
427 
428  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
429  if (infos[3] == TensorInfo())
430  {
431  return IsTransposeConvolution2dSupported(infos[0],
432  infos[1],
433  desc,
434  infos[2],
435  EmptyOptional(),
436  reasonIfUnsupported);
437  }
438  else
439  {
440  return IsTransposeConvolution2dSupported(infos[0],
441  infos[1],
442  desc,
443  infos[2],
444  infos[3],
445  reasonIfUnsupported);
446  }
447  }
448  case LayerType::Cast:
449  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
450  case LayerType::ChannelShuffle:
451  return IsChannelShuffleSupported(infos[0],
452  infos[1],
453  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
454  reasonIfUnsupported);
455  case LayerType::Convolution3d:
456  {
457  if (infos.size() != 4)
458  {
459  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
460  "TensorInfos should be of format: {input, output, weights, biases}.");
461  }
462 
463  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
464  if (infos[3] == TensorInfo())
465  {
466  return IsConvolution3dSupported(infos[0],
467  infos[1],
468  desc,
469  infos[2],
470  EmptyOptional(),
471  reasonIfUnsupported);
472  }
473  else
474  {
475  return IsConvolution3dSupported(infos[0],
476  infos[1],
477  desc,
478  infos[2],
479  infos[3],
480  reasonIfUnsupported);
481  }
482  }
483  case LayerType::Debug:
484  return IsDebugSupported(infos[0], infos[1], reasonIfUnsupported);
485  case LayerType::DetectionPostProcess:
486  return IsDetectionPostProcessSupported(infos[0],
487  infos[1],
488  infos[2],
489  infos[3],
490  infos[4],
491  infos[5],
492  infos[6],
493  *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
494  (&descriptor)),
495  reasonIfUnsupported);
496  case LayerType::FakeQuantization:
497  return IsFakeQuantizationSupported(infos[0],
498  *(PolymorphicDowncast<const FakeQuantizationDescriptor*>(&descriptor)),
499  reasonIfUnsupported);
500  case LayerType::MemCopy:
501  return IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
502  case LayerType::Rank:
503  return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
504  case LayerType::Shape:
505  return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
506  case LayerType::UnidirectionalSequenceLstm:
507  {
508  if (infos.size() != 6)
509  {
510  throw InvalidArgumentException("Invalid number of UnidirectionalSequenceLstm TensorInfos. TensorInfos "
511  "should be of format: {input, outputStateIn, cellStateIn, "
512  "hiddenStateOutputVal, cellStateOutputVal, output}");
513  }
514  auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
515  return IsUnidirectionalSequenceLstmSupported(infos[0],
516  infos[1],
517  infos[2],
518  infos[3],
519  infos[4],
520  infos[5],
521  desc,
522  lstmParamsInfo.value(),
523  reasonIfUnsupported);
524  }
525  case LayerType::Pooling3d:
526  return IsPooling3dSupported(infos[0],
527  infos[1],
528  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
529  reasonIfUnsupported);
530  case LayerType::Map:
531  return true;
532  case LayerType::Unmap:
533  return true;
534  case LayerType::MemImport:
535  return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
536  case LayerType::Merge:
537  return LayerSupportBase::IsMergeSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
538  case LayerType::QuantizedLstm:
539  return LayerSupportBase::IsQuantizedLstmSupported(infos[0],
540  infos[1],
541  infos[2],
542  infos[3],
543  infos[4],
544  quantizedLstmInputParamsInfo.value(),
545  reasonIfUnsupported);
546  default:
547  // layers not supported in reference by default:
548  // precompiled, standin, switch, fused
549  return false;
550  }
551 }

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::BroadcastTo, armnn::Cast, armnn::ChannelShuffle, armnn::CheckSupportRule(), armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::Debug, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::FakeQuantization, armnn::Fill, armnn::Float16, armnn::Float32, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, armnn::Input, armnn::InstanceNormalization, RefLayerSupport::IsActivationSupported(), RefLayerSupport::IsAdditionSupported(), RefLayerSupport::IsArgMinMaxSupported(), RefLayerSupport::IsBatchMatMulSupported(), RefLayerSupport::IsBatchNormalizationSupported(), RefLayerSupport::IsBatchToSpaceNdSupported(), RefLayerSupport::IsBroadcastToSupported(), RefLayerSupport::IsCastSupported(), RefLayerSupport::IsChannelShuffleSupported(), RefLayerSupport::IsComparisonSupported(), RefLayerSupport::IsConcatSupported(), RefLayerSupport::IsConstantSupported(), RefLayerSupport::IsConvertFp16ToFp32Supported(), RefLayerSupport::IsConvertFp32ToFp16Supported(), RefLayerSupport::IsConvolution2dSupported(), RefLayerSupport::IsConvolution3dSupported(), RefLayerSupport::IsDebugSupported(), RefLayerSupport::IsDepthToSpaceSupported(), RefLayerSupport::IsDepthwiseConvolutionSupported(), RefLayerSupport::IsDequantizeSupported(), RefLayerSupport::IsDetectionPostProcessSupported(), RefLayerSupport::IsDivisionSupported(), RefLayerSupport::IsElementwiseUnarySupported(), RefLayerSupport::IsFakeQuantizationSupported(), RefLayerSupport::IsFillSupported(), RefLayerSupport::IsFloorSupported(), RefLayerSupport::IsFullyConnectedSupported(), RefLayerSupport::IsGatherNdSupported(), RefLayerSupport::IsGatherSupported(), RefLayerSupport::IsInputSupported(), RefLayerSupport::IsInstanceNormalizationSupported(), RefLayerSupport::IsL2NormalizationSupported(), RefLayerSupport::IsLogicalBinarySupported(), RefLayerSupport::IsLogSoftmaxSupported(), RefLayerSupport::IsLstmSupported(), RefLayerSupport::IsMaximumSupported(), RefLayerSupport::IsMeanSupported(), RefLayerSupport::IsMemCopySupported(), LayerSupportBase::IsMemImportSupported(), LayerSupportBase::IsMergeSupported(), RefLayerSupport::IsMinimumSupported(), RefLayerSupport::IsMultiplicationSupported(), RefLayerSupport::IsNormalizationSupported(), RefLayerSupport::IsOutputSupported(), RefLayerSupport::IsPadSupported(), RefLayerSupport::IsPermuteSupported(), RefLayerSupport::IsPooling2dSupported(), RefLayerSupport::IsPooling3dSupported(), RefLayerSupport::IsPreluSupported(), RefLayerSupport::IsQLstmSupported(), LayerSupportBase::IsQuantizedLstmSupported(), RefLayerSupport::IsQuantizeSupported(), RefLayerSupport::IsRankSupported(), RefLayerSupport::IsReduceSupported(), RefLayerSupport::IsReshapeSupported(), RefLayerSupport::IsResizeSupported(), RefLayerSupport::IsReverseV2Supported(), RefLayerSupport::IsShapeSupported(), RefLayerSupport::IsSliceSupported(), RefLayerSupport::IsSoftmaxSupported(), RefLayerSupport::IsSpaceToBatchNdSupported(), RefLayerSupport::IsSpaceToDepthSupported(), RefLayerSupport::IsSplitterSupported(), RefLayerSupport::IsStackSupported(), RefLayerSupport::IsStridedSliceSupported(), RefLayerSupport::IsSubtractionSupported(), RefLayerSupport::IsTileSupported(), RefLayerSupport::IsTransposeConvolution2dSupported(), RefLayerSupport::IsTransposeSupported(), RefLayerSupport::IsUnidirectionalSequenceLstmSupported(), armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Map, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Merge, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::Prelu, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QLstm, armnn::QSymmS16, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::ReverseV2, armnn::Shape, armnn::Signed32, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StridedSlice, 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 1726 of file RefLayerSupport.cpp.

1731 {
1732  IgnoreUnused(descriptor);
1733 
1734  std::array<DataType, 1> supportedTypes =
1735  {
1736  DataType::Boolean
1737  };
1738 
1739  bool supported = true;
1740  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1741  "Reference LogicalBinary: input 0 type not supported");
1742  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1743  "Reference LogicalBinary: input 1 type not supported");
1744 
1745  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1746  "Reference LogicalBinary: input and output types do not match");
1747 
1748  return supported;
1749 }

References armnn::Boolean, armnn::CheckSupportRule(), and armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsLogSoftmaxSupported()

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

Definition at line 1751 of file RefLayerSupport.cpp.

1755 {
1756  IgnoreUnused(descriptor);
1757 
1758  std::array<DataType, 3> supportedTypes =
1759  {
1760  DataType::Float32,
1761  DataType::Float16
1762  };
1763 
1764  bool supported = true;
1765  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1766  "Reference LogSoftmax: input type not supported");
1767 
1768  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1769  "Reference LogSoftmax: output type not supported");
1770 
1771  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1772  "Reference LogSoftmax: input and output types do not match");
1773 
1774  return supported;
1775 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, and armnn::IgnoreUnused().

Referenced by RefLayerSupport::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 1777 of file RefLayerSupport.cpp.

1787 {
1788  IgnoreUnused(descriptor);
1789  IgnoreUnused(paramsInfo);
1790 
1791  bool supported = true;
1792 
1793  std::array<DataType,3> supportedTypes = {
1794  DataType::Float32,
1795  DataType::QSymmS16
1796  };
1797 
1798  // check inputs and outputs
1799  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1800  "Reference Lstm: input is not a supported type.");
1801  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1802  "Reference Lstm: input and outputStateIn types are mismatched");
1803  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1804  "Reference Lstm: input and cellStateIn types are mismatched");
1805  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1806  "Reference Lstm: input and scratchBuffer types are mismatched");
1807  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1808  "Reference Lstm: input and outputStateOut types are mismatched");
1809  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1810  "Reference Lstm: input and cellStateOut types are mismatched");
1811 
1812  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1813  "Reference Lstm: input and output types are mismatched");
1814  // check layer parameters
1815  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
1816  "Reference Lstm: input and InputToForgetWeights types are mismatched");
1817  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
1818  "Reference Lstm: input and InputToCellWeights types are mismatched");
1819  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
1820  "Reference Lstm: input and InputToOutputWeights types are mismatched");
1821  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
1822  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
1823  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
1824  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
1825  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
1826  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
1827  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
1828  "Reference Lstm: input and ForgetGateBias types are mismatched");
1829  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
1830  "Reference Lstm: input and CellBias types are mismatched");
1831  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
1832  "Reference Lstm: input and OutputGateBias types are mismatched");
1833  if (!descriptor.m_CifgEnabled)
1834  {
1835  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
1836  "Reference Lstm: input and InputToInputWeights types are mismatched");
1837  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
1838  reasonIfUnsupported,
1839  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
1840  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
1841  "Reference Lstm: input and InputGateBias types are mismatched");
1842  if (descriptor.m_PeepholeEnabled)
1843  {
1844  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
1845  reasonIfUnsupported,
1846  "Reference Lstm: input and CellToInputWeights types are mismatched");
1847  }
1848  }
1849  if (descriptor.m_PeepholeEnabled)
1850  {
1851  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
1852  "Reference Lstm: input and CellToForgetWeights types are mismatched");
1853  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
1854  "Reference Lstm: input and CellToOutputWeights types are mismatched");
1855  }
1856  if (descriptor.m_ProjectionEnabled)
1857  {
1858  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
1859  "Reference Lstm: input and mProjectionWeights types are mismatched");
1860  if (paramsInfo.m_ProjectionBias != nullptr)
1861  {
1862  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
1863  "Reference Lstm: input and ProjectionBias types are mismatched");
1864  }
1865  }
1866  if (descriptor.m_LayerNormEnabled)
1867  {
1868  if (!descriptor.m_CifgEnabled)
1869  {
1870  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
1871  reasonIfUnsupported,
1872  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1873  }
1874  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
1875  reasonIfUnsupported,
1876  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
1877  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
1878  reasonIfUnsupported,
1879  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
1880  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
1881  reasonIfUnsupported,
1882  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1883  }
1884 
1885  return supported;
1886 }

References armnn::CheckSupportRule(), armnn::Float32, LstmInputParamsInfo::GetCellBias(), LstmInputParamsInfo::GetCellLayerNormWeights(), LstmInputParamsInfo::GetCellToForgetWeights(), LstmInputParamsInfo::GetCellToInputWeights(), LstmInputParamsInfo::GetCellToOutputWeights(), LstmInputParamsInfo::GetForgetGateBias(), LstmInputParamsInfo::GetForgetLayerNormWeights(), LstmInputParamsInfo::GetInputGateBias(), LstmInputParamsInfo::GetInputLayerNormWeights(), LstmInputParamsInfo::GetInputToCellWeights(), LstmInputParamsInfo::GetInputToForgetWeights(), LstmInputParamsInfo::GetInputToInputWeights(), LstmInputParamsInfo::GetInputToOutputWeights(), LstmInputParamsInfo::GetOutputGateBias(), LstmInputParamsInfo::GetOutputLayerNormWeights(), LstmInputParamsInfo::GetProjectionBias(), LstmInputParamsInfo::GetProjectionWeights(), LstmInputParamsInfo::GetRecurrentToCellWeights(), LstmInputParamsInfo::GetRecurrentToForgetWeights(), LstmInputParamsInfo::GetRecurrentToInputWeights(), LstmInputParamsInfo::GetRecurrentToOutputWeights(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsMaximumSupported()

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

Definition at line 1888 of file RefLayerSupport.cpp.

1892 {
1893  bool supported = true;
1894 
1895  std::array<DataType,7> supportedTypes = {
1896  DataType::Float32,
1897  DataType::Float16,
1898  DataType::QAsymmS8,
1899  DataType::QAsymmU8,
1900  DataType::QSymmS16,
1901  DataType::Signed32
1902  };
1903 
1904  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1905  "Reference maximum: input 0 is not a supported type.");
1906 
1907  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1908  "Reference maximum: input 1 is not a supported type.");
1909 
1910  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1911  "Reference maximum: output is not a supported type.");
1912 
1913  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1914  "Reference maximum: input 0 and Input 1 types are mismatched");
1915 
1916  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1917  "Reference maximum: input and output types are mismatched");
1918 
1919  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1920  "Reference maximum: shapes are not suitable for implicit broadcast.");
1921 
1922  return supported;
1923 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsMeanSupported()

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

Definition at line 1925 of file RefLayerSupport.cpp.

1929 {
1930  bool supported = true;
1931  std::string meanLayerStr = "Mean";
1932  std::string outputTensorStr = "output";
1933 
1934  std::array<DataType,6> supportedTypes =
1935  {
1936  DataType::Float32,
1937  DataType::Float16,
1938  DataType::QAsymmS8,
1939  DataType::QAsymmU8,
1940  DataType::QSymmS16
1941  };
1942 
1943  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1944  "Reference Mean: input type not supported.");
1945 
1946  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1947  "Reference Mean: input and output types are mismatched");
1948 
1949  if (descriptor.m_KeepDims)
1950  {
1951  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1952  reasonIfUnsupported,
1953  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1954  output.GetNumDimensions(),
1955  meanLayerStr, outputTensorStr).data());
1956  }
1957  else if (descriptor.m_Axis.empty())
1958  {
1959  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1960  reasonIfUnsupported,
1961  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1962  meanLayerStr, outputTensorStr).data());
1963  }
1964  else
1965  {
1966  auto outputDim = input.GetNumDimensions() - armnn::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1967 
1968  if (outputDim > 0)
1969  {
1970  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1971  reasonIfUnsupported,
1972  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1973  meanLayerStr, outputTensorStr).data());
1974  }
1975  else
1976  {
1977  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1978  reasonIfUnsupported,
1979  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1980  meanLayerStr, outputTensorStr).data());
1981  }
1982  }
1983 
1984  return supported;
1985 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetNumDimensions(), MeanDescriptor::m_Axis, MeanDescriptor::m_KeepDims, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsMemCopySupported()

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

Definition at line 1987 of file RefLayerSupport.cpp.

1990 {
1991  bool supported = true;
1992 
1993  std::array<DataType,7> supportedTypes =
1994  {
1995  DataType::BFloat16,
1996  DataType::Float32,
1997  DataType::Float16,
1998  DataType::QAsymmS8,
1999  DataType::QAsymmU8,
2000  DataType::QSymmS16,
2001  DataType::Boolean
2002  };
2003 
2004  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2005  "Reference MemCopy: input type not supported");
2006 
2007  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2008  "Reference MemCopy: output type not supported");
2009 
2010  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2011  "Reference MemCopy: input and output types are mismatched");
2012 
2013  return supported;
2014 }

References armnn::BFloat16, armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsMinimumSupported()

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

Definition at line 2016 of file RefLayerSupport.cpp.

2020 {
2021  bool supported = true;
2022 
2023  std::array<DataType,7> supportedTypes = {
2024  DataType::Float32,
2025  DataType::Float16,
2026  DataType::QAsymmS8,
2027  DataType::QAsymmU8,
2028  DataType::QSymmS16,
2029  DataType::Signed32
2030  };
2031 
2032  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2033  "Reference minimum: input 0 is not a supported type.");
2034 
2035  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2036  "Reference minimum: input 1 is not a supported type.");
2037 
2038  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2039  "Reference minimum: output is not a supported type.");
2040 
2041  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2042  "Reference minimum: input 0 and Input 1 types are mismatched");
2043 
2044  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2045  "Reference minimum: input and output types are mismatched");
2046 
2047  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2048  "Reference minimum: shapes are not suitable for implicit broadcast.");
2049 
2050  return supported;
2051 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsMultiplicationSupported()

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

Definition at line 2053 of file RefLayerSupport.cpp.

2057 {
2058  bool supported = true;
2059 
2060  std::array<DataType,7> supportedTypes = {
2061  DataType::Float32,
2062  DataType::Float16,
2063  DataType::QAsymmS8,
2064  DataType::QAsymmU8,
2065  DataType::QSymmS16,
2066  DataType::Signed32
2067  };
2068 
2069  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2070  "Reference multiplication: input 0 is not a supported type.");
2071 
2072  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2073  "Reference multiplication: input 1 is not a supported type.");
2074 
2075  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2076  "Reference multiplication: output is not a supported type.");
2077 
2078  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2079  "Reference multiplication: input 0 and Input 1 types are mismatched");
2080 
2081  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2082  "Reference multiplication: input and output types are mismatched");
2083 
2084  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2085  "Reference multiplication: shapes are not suitable for implicit broadcast.");
2086 
2087  return supported;
2088 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsNormalizationSupported()

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

Definition at line 2090 of file RefLayerSupport.cpp.

2094 {
2095  IgnoreUnused(descriptor);
2096 
2097  // Define supported types
2098  std::array<DataType, 6> supportedTypes =
2099  {
2100  DataType::Float16,
2101  DataType::Float32,
2102  DataType::QAsymmS8,
2103  DataType::QAsymmU8,
2104  DataType::QSymmS16
2105  };
2106 
2107  bool supported = true;
2108 
2109  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2110  "Reference normalization: input type not supported.");
2111 
2112  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2113  "Reference normalization: output type not supported.");
2114 
2115  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
2116  "Reference normalization: input and output shapes have different "
2117  "num total elements.");
2118 
2119  return supported;
2120 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsOutputSupported()

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

Definition at line 2122 of file RefLayerSupport.cpp.

2124 {
2125  return true;
2126 }

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsPadSupported()

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

Definition at line 2128 of file RefLayerSupport.cpp.

2132 {
2133  IgnoreUnused(descriptor);
2134  bool supported = true;
2135 
2136  // Define supported output and inputs types.
2137  std::array<DataType,6> supportedTypes =
2138  {
2139  DataType::Float32,
2140  DataType::Float16,
2141  DataType::QAsymmS8,
2142  DataType::QAsymmU8,
2143  DataType::QSymmS16
2144  };
2145 
2146  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2147  "Reference pad: input is not a supported type.");
2148 
2149  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2150  "Reference pad: output is not a supported type.");
2151 
2152  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2153  "Reference pad: input and output types are mismatched.");
2154 
2155  return supported;
2156 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsPermuteSupported()

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

Definition at line 2158 of file RefLayerSupport.cpp.

2162 {
2163  IgnoreUnused(descriptor);
2164  bool supported = true;
2165 
2166  // Define supported output and inputs types.
2167  std::array<DataType, 6> supportedTypes =
2168  {
2169  DataType::BFloat16,
2170  DataType::Float32,
2171  DataType::Float16,
2172  DataType::QAsymmS8,
2173  DataType::QAsymmU8,
2174  DataType::QSymmS16
2175  };
2176 
2177  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2178  "Reference permute: input is not a supported type.");
2179 
2180  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2181  "Reference permute: output is not a supported type.");
2182 
2183  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2184  "Reference permute: input and output types are mismatched.");
2185 
2186  return supported;
2187 }

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsPooling2dSupported()

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

Definition at line 2189 of file RefLayerSupport.cpp.

2193 {
2194  IgnoreUnused(descriptor);
2195  bool supported = true;
2196 
2197  // Define supported output and inputs types.
2198  std::array<DataType,6> supportedTypes =
2199  {
2200  DataType::Float32,
2201  DataType::Float16,
2202  DataType::QAsymmS8,
2203  DataType::QAsymmU8,
2204  DataType::QSymmS16
2205  };
2206 
2207  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2208  "Reference poolind2d: input is not a supported type.");
2209 
2210  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2211  "Reference poolind2d: output is not a supported type.");
2212 
2213  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2214  "Reference poolind2d: input and output types are mismatched.");
2215 
2216  return supported;
2217 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsPooling3dSupported()

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

Definition at line 2219 of file RefLayerSupport.cpp.

2223 {
2224  IgnoreUnused(descriptor);
2225  bool supported = true;
2226 
2227  // Define supported output and inputs types.
2228  std::array<DataType,6> supportedTypes =
2229  {
2230  DataType::Float32,
2231  DataType::Float16,
2232  DataType::QAsymmS8,
2233  DataType::QAsymmU8,
2234  DataType::QSymmS16
2235  };
2236 
2237  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2238  "Reference poolind3d: input is not a supported type.");
2239 
2240  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2241  "Reference poolind3d: output is not a supported type.");
2242 
2243  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2244  "Reference poolind3d: input and output types are mismatched.");
2245 
2246  return supported;
2247 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsPreluSupported()

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

Definition at line 2708 of file RefLayerSupport.cpp.

2712 {
2713  bool supported = true;
2714 
2715  std::array<DataType, 6> supportedTypes
2716  {
2717  DataType::Float32,
2718  DataType::Float16,
2719  DataType::QAsymmS8,
2720  DataType::QAsymmU8,
2721  DataType::QSymmS16
2722  };
2723 
2724  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2725  "PReLU: input is not a supported type.");
2726 
2727  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
2728  "PReLU: alpha is not a supported type.");
2729 
2730  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2731  "PReLU: output is not a supported type.");
2732 
2733  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
2734  "PReLU: input, alpha and output types are mismatched");
2735 
2736  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
2737  "PReLU: shapes are not suitable for implicit broadcast");
2738 
2739  return supported;
2740 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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 2250 of file RefLayerSupport.cpp.

2259 {
2260  IgnoreUnused(input);
2261  IgnoreUnused(previousOutputIn);
2262  IgnoreUnused(previousCellStateIn);
2263  IgnoreUnused(outputStateOut);
2264  IgnoreUnused(cellStateOut);
2265  IgnoreUnused(output);
2266  IgnoreUnused(descriptor);
2267  IgnoreUnused(paramsInfo);
2268 
2269  IgnoreUnused(reasonIfUnsupported);
2270 
2271  return true;
2272 }

References armnn::IgnoreUnused().

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsQuantizeSupported()

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

Definition at line 2274 of file RefLayerSupport.cpp.

2277 {
2278  bool supported = true;
2279 
2280  // Define supported input types.
2281  std::array<DataType,7> supportedInputTypes = {
2282  DataType::Float32,
2283  DataType::Float16,
2284  DataType::QAsymmS8,
2285  DataType::QAsymmU8,
2286  DataType::QSymmS8,
2287  DataType::QSymmS16
2288  };
2289 
2290  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
2291  "Reference quantize: input type not supported.");
2292 
2293  // Define supported output types.
2294  std::array<DataType,4> supportedOutputTypes = {
2295  DataType::QAsymmS8,
2296  DataType::QAsymmU8,
2297  DataType::QSymmS8,
2298  DataType::QSymmS16
2299  };
2300  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
2301  "Reference quantize: output type not supported.");
2302 
2303  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
2304  "Reference quantize: input and output shapes have different num total elements.");
2305 
2306  return supported;
2307 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsRankSupported()

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

Definition at line 2309 of file RefLayerSupport.cpp.

2312 {
2313  IgnoreUnused(input);
2314  // Define supported output types.
2315  std::array<DataType,1> supportedOutputTypes =
2316  {
2317  DataType::Signed32,
2318  };
2319 
2320  return CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
2321  "Reference rank: input type not supported.");
2322 }

References armnn::CheckSupportRule(), armnn::IgnoreUnused(), and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsReduceSupported()

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

Definition at line 2324 of file RefLayerSupport.cpp.

2328 {
2329  IgnoreUnused(descriptor);
2330  bool supported = true;
2331  std::array<DataType,7> supportedTypes =
2332  {
2333  DataType::Float32,
2334  DataType::Float16,
2335  DataType::QAsymmS8,
2336  DataType::QAsymmU8,
2337  DataType::QSymmS16,
2338  DataType::Signed32
2339  };
2340 
2341  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2342  "Reference Reduce: input type not supported");
2343 
2344  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2345  "Reference Reduce: output type not supported");
2346 
2347  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2348  "Reference Reduce: input and output types not matching");
2349 
2350  return supported;
2351 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsReshapeSupported()

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

Definition at line 2353 of file RefLayerSupport.cpp.

2357 {
2358  IgnoreUnused(output);
2359  IgnoreUnused(descriptor);
2360  // Define supported output types.
2361  std::array<DataType,8> supportedOutputTypes =
2362  {
2363  DataType::BFloat16,
2364  DataType::Float32,
2365  DataType::Float16,
2366  DataType::Signed32,
2367  DataType::QAsymmS8,
2368  DataType::QAsymmU8,
2369  DataType::QSymmS16,
2370  DataType::Boolean
2371  };
2372 
2373  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
2374  "Reference reshape: input type not supported.");
2375 }

References armnn::BFloat16, armnn::Boolean, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsResizeSupported()

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

Definition at line 2377 of file RefLayerSupport.cpp.

2381 {
2382  IgnoreUnused(descriptor);
2383  bool supported = true;
2384  std::array<DataType,7> supportedTypes =
2385  {
2386  DataType::BFloat16,
2387  DataType::Float32,
2388  DataType::Float16,
2389  DataType::QAsymmS8,
2390  DataType::QAsymmU8,
2391  DataType::QSymmS8,
2392  DataType::QSymmS16
2393  };
2394 
2395  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2396  "Reference Resize: input type not supported");
2397 
2398  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2399  "Reference Resize: output type not supported");
2400 
2401  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2402  "Reference Resize: input and output types not matching");
2403 
2404  return supported;
2405 }

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsReverseV2Supported()

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

Definition at line 2407 of file RefLayerSupport.cpp.

2411 {
2412  bool supported = true;
2413  // ReverseV2 is data type agnostic so it can support all the types in the Reference backend
2414  std::array<DataType,8> supportedTypes =
2415  {
2416  DataType::BFloat16,
2417  DataType::Float32,
2418  DataType::Float16,
2419  DataType::QAsymmS8,
2420  DataType::QAsymmU8,
2421  DataType::QSymmS8,
2422  DataType::QSymmS16,
2423  DataType::Signed32
2424  };
2425 
2426  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2427  "Reference ReverseV2: input0 type not supported");
2428 
2429  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2430  "Reference ReverseV2: output type not supported");
2431 
2432  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2433  "Reference ReverseV2: input0 and output types not matching");
2434 
2435  std::array<DataType,6> input2SupportedTypes =
2436  {
2437  DataType::Signed32
2438  };
2439 
2440  supported &= CheckSupportRule(TypeAnyOf(input1, input2SupportedTypes), reasonIfUnsupported,
2441  "Reference ReverseV2: input1 type not supported");
2442 
2443  return supported;
2444 }

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsShapeSupported()

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

Definition at line 2446 of file RefLayerSupport.cpp.

2449 {
2450  IgnoreUnused(input);
2451  bool supported = true;
2452 
2453  std::array<DataType, 1> supportedTypes =
2454  {
2455  DataType::Signed32
2456  };
2457 
2458  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2459  "Reference Shape: output type not supported");
2460 
2461  return supported;
2462 }

References armnn::CheckSupportRule(), armnn::IgnoreUnused(), and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsSliceSupported()

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

Definition at line 2464 of file RefLayerSupport.cpp.

2468 {
2469  IgnoreUnused(descriptor);
2470  bool supported = true;
2471 
2472  std::array<DataType, 5> supportedTypes =
2473  {
2474  DataType::Float32,
2475  DataType::QAsymmS8,
2476  DataType::QAsymmU8,
2477  DataType::QSymmS16,
2478  DataType::Signed32
2479  };
2480 
2481  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2482  "Reference Slice: input type not supported");
2483 
2484  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2485  "Reference Slice: output type not supported");
2486 
2487  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2488  "Reference Slice: input and output types are mismatched");
2489 
2490  return supported;
2491 }

References armnn::CheckSupportRule(), armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsSoftmaxSupported()

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

Definition at line 2493 of file RefLayerSupport.cpp.

2497 {
2498  IgnoreUnused(descriptor);
2499  bool supported = true;
2500  std::array<DataType,7> supportedTypes =
2501  {
2502  DataType::Float32,
2503  DataType::Float16,
2504  DataType::QSymmS8,
2505  DataType::QAsymmS8,
2506  DataType::QAsymmU8,
2507  DataType::QSymmS16
2508  };
2509 
2510  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2511  "Reference Softmax: output type not supported");
2512 
2513  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2514  "Reference Softmax: input type not supported");
2515 
2516  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2517  "Reference Softmax: input type not supported");
2518 
2519  return supported;
2520 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::QSymmS8.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsSpaceToBatchNdSupported()

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

Definition at line 2522 of file RefLayerSupport.cpp.

2526 {
2527  IgnoreUnused(descriptor);
2528  bool supported = true;
2529  std::array<DataType,6> supportedTypes =
2530  {
2531  DataType::Float32,
2532  DataType::Float16,
2533  DataType::QAsymmS8,
2534  DataType::QAsymmU8,
2535  DataType::QSymmS16
2536  };
2537 
2538  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2539  "Reference SpaceToBatchNd: input type not supported");
2540 
2541  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2542  "Reference SpaceToBatchNd: output type not supported");
2543 
2544  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2545  "Reference SpaceToBatchNd: input and output types are mismatched");
2546 
2547  return supported;
2548 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsSpaceToDepthSupported()

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

Definition at line 2550 of file RefLayerSupport.cpp.

2554 {
2555 
2556  IgnoreUnused(descriptor);
2557  bool supported = true;
2558 
2559  std::array<DataType,6> supportedTypes =
2560  {
2561  DataType::Float32,
2562  DataType::Float16,
2563  DataType::QAsymmS8,
2564  DataType::QAsymmU8,
2565  DataType::QSymmS16
2566  };
2567 
2568  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2569  "Reference SpaceToDepth: input type not supported");
2570 
2571  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2572  "Reference SpaceToDepth: output type not supported");
2573 
2574  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2575  "Reference SpaceToDepth: input and output types are mismatched");
2576 
2577  return supported;
2578 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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 2580 of file RefLayerSupport.cpp.

2584 {
2585  IgnoreUnused(descriptor);
2586  bool supported = true;
2587  std::array<DataType,6> supportedTypes =
2588  {
2589  DataType::Float32,
2590  DataType::Float16,
2591  DataType::QAsymmS8,
2592  DataType::QAsymmU8,
2593  DataType::QSymmS16
2594  };
2595 
2596  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2597  "Reference splitter: output type not supported");
2598  for (const TensorInfo& output : outputs)
2599  {
2600  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2601  "Reference splitter: input type not supported");
2602 
2603  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2604  "Reference splitter: input and output types mismatched.");
2605  }
2606 
2607  return supported;
2608 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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 2610 of file RefLayerSupport.cpp.

2614 {
2615  IgnoreUnused(descriptor);
2616 
2617  bool supported = true;
2618  std::array<DataType,7> supportedTypes =
2619  {
2620  DataType::Float32,
2621  DataType::Float16,
2622  DataType::QAsymmS8,
2623  DataType::QAsymmU8,
2624  DataType::QSymmS16,
2625  DataType::Signed32
2626  };
2627 
2628  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2629  "Reference stack: output type not supported");
2630  for (const TensorInfo* input : inputs)
2631  {
2632  ARMNN_ASSERT(input != nullptr);
2633  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
2634  "Reference stack: input type not supported");
2635 
2636  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
2637  "Reference stack: input and output types mismatched.");
2638  }
2639 
2640  return supported;
2641 }

References ARMNN_ASSERT, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsStridedSliceSupported()

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

Definition at line 2643 of file RefLayerSupport.cpp.

2647 {
2648  IgnoreUnused(descriptor);
2649  bool supported = true;
2650 
2651  std::array<DataType,5> supportedTypes =
2652  {
2653  DataType::Float32,
2654  DataType::QAsymmS8,
2655  DataType::QAsymmU8,
2656  DataType::QSymmS16
2657  };
2658 
2659  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2660  "Reference StridedSlice: input type not supported");
2661 
2662  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2663  "Reference StridedSlice: output type not supported");
2664 
2665  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2666  "Reference StridedSlice: input and output types are mismatched");
2667 
2668  return supported;
2669 }

References armnn::CheckSupportRule(), armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsSubtractionSupported()

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

Definition at line 2671 of file RefLayerSupport.cpp.

2675 {
2676  bool supported = true;
2677 
2678  std::array<DataType,7> supportedTypes = {
2679  DataType::Float32,
2680  DataType::Float16,
2681  DataType::QAsymmS8,
2682  DataType::QAsymmU8,
2683  DataType::QSymmS16,
2684  DataType::Signed32
2685  };
2686 
2687  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2688  "Reference subtraction: input 0 is not a supported type.");
2689 
2690  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2691  "Reference subtraction: input 1 is not a supported type.");
2692 
2693  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2694  "Reference subtraction: output is not a supported type.");
2695 
2696  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2697  "Reference subtraction: input 0 and Input 1 types are mismatched");
2698 
2699  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2700  "Reference subtraction: input and output types are mismatched");
2701 
2702  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2703  "Reference subtraction: shapes are not suitable for implicit broadcast.");
2704 
2705  return supported;
2706 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsTileSupported()

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

Definition at line 2742 of file RefLayerSupport.cpp.

2746 {
2747  IgnoreUnused(descriptor);
2748 
2749  bool supported = true;
2750 
2751  std::array<DataType, 7> supportedTypes
2752  {
2753  DataType::Float32,
2754  DataType::Float16,
2755  DataType::QAsymmS8,
2756  DataType::QAsymmU8,
2757  DataType::QSymmS8,
2758  DataType::QSymmS16,
2759  DataType::Signed32
2760  };
2761 
2762  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2763  "Tile: input type not supported.");
2764 
2765  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2766  "Tile: output type not supported");
2767 
2768  return supported;
2769 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::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 2771 of file RefLayerSupport.cpp.

2777 {
2778  IgnoreUnused(descriptor);
2779  bool supported = true;
2780 
2781  std::array<DataType,7> supportedTypes =
2782  {
2783  DataType::Float32,
2784  DataType::Float16,
2785  DataType::QAsymmS8,
2786  DataType::QAsymmU8,
2787  DataType::QSymmS8,
2788  DataType::QSymmS16
2789  };
2790 
2791  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2792  "Reference TransposeConvolution2d: input is not a supported type.");
2793 
2794  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2795  "Reference TransposeConvolution2d: output is not a supported type.");
2796 
2797  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2798  "Reference TransposeConvolution2d: input and output types mismatched.");
2799 
2800 
2801  const DataType inputType = input.GetDataType();
2802  if (IsQuantized8BitType(inputType))
2803  {
2804  std::array<DataType, 3> supportedWeightTypes =
2805  {
2806  DataType::QAsymmS8,
2807  DataType::QAsymmU8,
2808  DataType::QSymmS8
2809  };
2810 
2811  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
2812  "Reference TransposeConvolution2d: weights type not supported for "
2813  "quantized input.");
2814  }
2815  else
2816  {
2817  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
2818  "Reference TransposeConvolution2d: weights is not a supported type.");
2819 
2820  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
2821  "Reference TransposeConvolution2d: input and weights types mismatched.");
2822  }
2823 
2824  if (biases.has_value())
2825  {
2826  std::array<DataType,4> biasesSupportedTypes =
2827  {
2828  DataType::Float32,
2829  DataType::Float16,
2830  DataType::Signed32
2831  };
2832  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
2833  "Reference TransposeConvolution2d: biases is not a supported type.");
2834  }
2835 
2836  return supported;
2837 }

References armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IgnoreUnused(), armnn::IsQuantized8BitType(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by RefLayerSupport::IsLayerSupported().

◆ IsTransposeSupported()

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

Definition at line 2839 of file RefLayerSupport.cpp.

2843 {
2844  IgnoreUnused(descriptor);
2845  bool supported = true;
2846 
2847  // Define supported output and inputs types.
2848  std::array<DataType, 6> supportedTypes =
2849  {
2850  DataType::BFloat16,
2851  DataType::Float32,
2852  DataType::Float16,
2853  DataType::QAsymmS8,
2854  DataType::QAsymmU8,
2855  DataType::QSymmS16
2856  };
2857 
2858  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2859  "Reference transpose: input is not a supported type.");
2860 
2861  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2862  "Reference transpose: output is not a supported type.");
2863 
2864  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2865  "Reference transpose: input and output types are mismatched.");
2866 
2867  return supported;
2868 }

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, armnn::IgnoreUnused(), armnn::QAsymmS8, armnn::QAsymmU8, and armnn::QSymmS16.

Referenced by RefLayerSupport::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 = EmptyOptional() 
) const

Definition at line 2870 of file RefLayerSupport.cpp.

2880 {
2881  IgnoreUnused(descriptor);
2882  IgnoreUnused(paramsInfo);
2883  IgnoreUnused(outputStateIn);
2884  IgnoreUnused(cellStateIn);
2885  IgnoreUnused(outputStateOut);
2886  IgnoreUnused(cellStateOut);
2887  bool supported = true;
2888 
2889  std::array<DataType, 2> supportedTypes =
2890  {
2891  DataType::Float32,
2892  DataType::QAsymmS8
2893  };
2894 
2895  std::array<DataType, 2> supportedWeightTypes =
2896  {
2897  DataType::Float32,
2898  DataType::QAsymmS8
2899  };
2900 
2901  std::array<DataType, 3> supportedBiasTypes =
2902  {
2903  DataType::Float32,
2904  DataType::QAsymmS8,
2905  DataType::Signed32
2906  };
2907 
2908  // check inputs and outputs
2909  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2910  "Reference UnidirectionalSequenceLstm: input is not a supported type.");
2911  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2912  "Reference UnidirectionalSequenceLstm: output is not a supported type.");
2913 
2914  // check layer parameters
2915  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToForgetWeights(), supportedWeightTypes),
2916  reasonIfUnsupported,
2917  "Reference UnidirectionalSequenceLstm: InputToForgetWeights "
2918  "is not a supported type.");
2919  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToCellWeights(), supportedWeightTypes),
2920  reasonIfUnsupported,
2921  "Reference UnidirectionalSequenceLstm: InputToCellWeights is not a supported type.");
2922  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToOutputWeights(), supportedWeightTypes),
2923  reasonIfUnsupported,
2924  "Reference UnidirectionalSequenceLstm: InputToOutputWeights "
2925  "is not a supported type.");
2926  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToForgetWeights(), supportedWeightTypes),
2927  reasonIfUnsupported,
2928  "Reference UnidirectionalSequenceLstm: RecurrentToForgetWeights "
2929  "is not a supported type.");
2930  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToCellWeights(), supportedWeightTypes),
2931  reasonIfUnsupported,
2932  "Reference UnidirectionalSequenceLstm: RecurrentToCellWeights "
2933  "is not a supported type.");
2934  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToOutputWeights(), supportedWeightTypes),
2935  reasonIfUnsupported,
2936  "Reference UnidirectionalSequenceLstm: RecurrentToOutputWeights "
2937  "is not a supported type.");
2938 
2939  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetGateBias(), supportedBiasTypes), reasonIfUnsupported,
2940  "Reference UnidirectionalSequenceLstm: ForgetGateBias is not a supported type.");
2941  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellBias(), supportedBiasTypes), reasonIfUnsupported,
2942  "Reference UnidirectionalSequenceLstm: CellBias is not a supported type.");
2943  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputGateBias(), supportedBiasTypes), reasonIfUnsupported,
2944  "Reference UnidirectionalSequenceLstm: OutputGateBias is not a supported type.");
2945  if (!descriptor.m_CifgEnabled)
2946  {
2947  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToInputWeights(), supportedWeightTypes),
2948  reasonIfUnsupported,
2949  "Reference UnidirectionalSequenceLstm: InputToInputWeights "
2950  "is not a supported type.");
2951  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToInputWeights(), supportedWeightTypes),
2952  reasonIfUnsupported,
2953  "Reference UnidirectionalSequenceLstm: RecurrentToInputWeights "
2954  "is not a supported type.");
2955  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputGateBias(), supportedBiasTypes), reasonIfUnsupported,
2956  "Reference UnidirectionalSequenceLstm: InputGateBias is not a supported type.");
2957  if (descriptor.m_PeepholeEnabled)
2958  {
2959  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToInputWeights(), supportedWeightTypes),
2960  reasonIfUnsupported,
2961  "Reference UnidirectionalSequenceLstm: CellToInputWeights "
2962  "is not a supported type.");
2963  }
2964  }
2965  if (descriptor.m_PeepholeEnabled)
2966  {
2967  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToForgetWeights(), supportedWeightTypes),
2968  reasonIfUnsupported,
2969  "Reference UnidirectionalSequenceLstm: CellToForgetWeights "
2970  "is not a supported type.");
2971  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToOutputWeights(), supportedWeightTypes),
2972  reasonIfUnsupported,
2973  "Reference UnidirectionalSequenceLstm: CellToOutputWeights "
2974  "is not a supported type.");
2975  }
2976  if (descriptor.m_ProjectionEnabled)
2977  {
2978  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetProjectionWeights(), supportedWeightTypes),
2979  reasonIfUnsupported,
2980  "Reference UnidirectionalSequenceLstm: ProjectionWeights "
2981  "is not a supported type.");
2982  if (paramsInfo.m_ProjectionBias != nullptr)
2983  {
2984  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
2985  "Reference UnidirectionalSequenceLstm: input and ProjectionBias types "
2986  "are mismatched");
2987  }
2988  }
2989  if (descriptor.m_LayerNormEnabled)
2990  {
2991  if (!descriptor.m_CifgEnabled)
2992  {
2993  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputLayerNormWeights(), supportedWeightTypes),
2994  reasonIfUnsupported,
2995  "Reference UnidirectionalSequenceLstm: InputLayerNormWeights "
2996  "is not a supported type.");
2997  }
2998  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetLayerNormWeights(), supportedWeightTypes),
2999  reasonIfUnsupported,
3000  "Reference UnidirectionalSequenceLstm: ForgetLayerNormWeights "
3001  "is not a supported type.");
3002  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellLayerNormWeights(), supportedWeightTypes),
3003  reasonIfUnsupported,
3004  "Reference UnidirectionalSequenceLstm: CellLayerNormWeights "
3005  "is not a supported type.");
3006  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputLayerNormWeights(), supportedWeightTypes),
3007  reasonIfUnsupported,
3008  "Reference UnidirectionalSequenceLstm: OutputLayerNormWeights "
3009  "is not a supported type.");
3010  }
3011 
3012  return supported;
3013 }

References armnn::CheckSupportRule(), armnn::Float32, LstmInputParamsInfo::GetCellBias(), LstmInputParamsInfo::GetCellLayerNormWeights(), LstmInputParamsInfo::GetCellToForgetWeights(), LstmInputParamsInfo::GetCellToInputWeights(), LstmInputParamsInfo::GetCellToOutputWeights(), LstmInputParamsInfo::GetForgetGateBias(), LstmInputParamsInfo::GetForgetLayerNormWeights(), LstmInputParamsInfo::GetInputGateBias(), LstmInputParamsInfo::GetInputLayerNormWeights(), LstmInputParamsInfo::GetInputToCellWeights(), LstmInputParamsInfo::GetInputToForgetWeights(), LstmInputParamsInfo::GetInputToInputWeights(), LstmInputParamsInfo::GetInputToOutputWeights(), LstmInputParamsInfo::GetOutputGateBias(), LstmInputParamsInfo::GetOutputLayerNormWeights(), LstmInputParamsInfo::GetProjectionBias(), LstmInputParamsInfo::GetProjectionWeights(), LstmInputParamsInfo::GetRecurrentToCellWeights(), LstmInputParamsInfo::GetRecurrentToForgetWeights(), LstmInputParamsInfo::GetRecurrentToInputWeights(), LstmInputParamsInfo::GetRecurrentToOutputWeights(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, armnn::QAsymmS8, and armnn::Signed32.

Referenced by RefLayerSupport::IsLayerSupported().

The documentation for this class was generated from the following files:
armnn::RefLayerSupport::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: RefLayerSupport.cpp:1777
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::LayerType::SpaceToDepth
@ SpaceToDepth
armnn::RefLayerSupport::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: RefLayerSupport.cpp:1226
armnn::DataType::Boolean
@ Boolean
armnn::LayerType::Permute
@ Permute
armnn::RefLayerSupport::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2219
armnn::LayerType::Splitter
@ Splitter
armnn::RefLayerSupport::IsReverseV2Supported
bool IsReverseV2Supported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2407
armnn::LayerType::BatchNormalization
@ BatchNormalization
armnn::RefLayerSupport::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: RefLayerSupport.cpp:2250
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:316
armnn::ActivationFunction::LeakyReLu
@ LeakyReLu
armnn::RefLayerSupport::IsTileSupported
bool IsTileSupported(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2742
armnn::RefLayerSupport::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: RefLayerSupport.cpp:1030
armnn::RefLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1503
armnn::RefLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1295
armnn::ActivationFunction::SoftReLu
@ SoftReLu
armnn::RefLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2189
armnn::RefLayerSupport::IsDetectionPostProcessSupported
bool IsDetectionPostProcessSupported(const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1330
armnn::LayerType::InstanceNormalization
@ InstanceNormalization
armnn::LayerType::ConvertFp16ToFp32
@ ConvertFp16ToFp32
armnn::ActivationFunction::Sqrt
@ Sqrt
armnn::LayerType::Floor
@ Floor
armnn::RefLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:621
armnn::RefLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1655
armnn::LayerType::Transpose
@ Transpose
armnn::LayerType::Comparison
@ Comparison
armnn::RefLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1925
armnn::RefLayerSupport::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: RefLayerSupport.cpp:2771
armnn::LayerType::StridedSlice
@ StridedSlice
armnn::DataType::Float32
@ Float32
armnn::ActivationFunction::TanH
@ TanH
armnn::LayerType::Tile
@ Tile
armnn::RefLayerSupport::IsRankSupported
bool IsRankSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2309
armnn::DataType::QAsymmU8
@ QAsymmU8
armnn::ActivationFunction::BoundedReLu
@ BoundedReLu
min(a, max(b, input)) ReLu1 & ReLu6.
armnn::LayerType::Stack
@ Stack
armnn::DataType::QSymmS8
@ QSymmS8
armnn::LayerType::Normalization
@ Normalization
armnn::LayerType::QuantizedLstm
@ QuantizedLstm
armnn::LayerType::Reduce
@ Reduce
armnn::RefLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2580
armnn::RefLayerSupport::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: RefLayerSupport.cpp:1099
armnn::LayerType::ElementwiseUnary
@ ElementwiseUnary
armnn::RefLayerSupport::IsBatchMatMulSupported
bool IsBatchMatMulSupported(const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:690
armnn::ActivationFunction::HardSwish
@ HardSwish
armnn::DataType::QSymmS16
@ QSymmS16
armnn::ActivationFunction::Gelu
@ Gelu
armnn::RefLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2671
armnn::LayerType::GatherNd
@ GatherNd
armnn::LayerType::ElementwiseBinary
@ ElementwiseBinary
armnn::RefLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2274
armnn::DataType::BFloat16
@ BFloat16
armnn::RefLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:658
armnn::LayerType::ConvertFp32ToFp16
@ ConvertFp32ToFp16
armnn::RefLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2158
armnn::RefLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:908
armnn::RefLayerSupport::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: RefLayerSupport.cpp:735
armnn::LayerType::Slice
@ Slice
armnn::RefLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2550
armnn::RefLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:553
armnn::DataType::Float16
@ Float16
armnn::RefLayerSupport::IsFakeQuantizationSupported
bool IsFakeQuantizationSupported(const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1460
armnn::LayerType::ChannelShuffle
@ ChannelShuffle
armnn::LayerSupportBase::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: LayerSupportBase.cpp:120
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1409
armnn::RefLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:939
armnn::UnaryOperation::LogicalNot
@ LogicalNot
armnn::RefLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2324
armnn::LayerType::Subtraction
@ Subtraction
armnn::LayerType::Prelu
@ Prelu
armnn::LayerType::LogicalBinary
@ LogicalBinary
armnn::LayerType::Concat
@ Concat
armnn::RefLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2377
armnn::RefLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1197
armnn::LayerType::TransposeConvolution2d
@ TransposeConvolution2d
armnn::LayerType::Merge
@ Merge
armnn::DataType
DataType
Definition: Types.hpp:48
armnn::LayerType::Debug
@ Debug
armnn::LayerType::Softmax
@ Softmax
armnn::RefLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:781
armnn::RefLayerSupport::IsBroadcastToSupported
bool IsBroadcastToSupported(const TensorInfo &input, const TensorInfo &output, const BroadcastToDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:816
armnn::ActivationFunction::Elu
@ Elu
armnn::RefLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2522
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::RefLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1692
armnn::LayerType::Quantize
@ Quantize
armnn::RefLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1888
armnn::ActivationFunction::Linear
@ Linear
armnn::LayerSupportBase::IsMemImportSupported
bool IsMemImportSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:105
armnn::LayerType::Multiplication
@ Multiplication
armnn::LayerType::Addition
@ Addition
armnn::RefLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2353
armnn::LayerType::DepthToSpace
@ DepthToSpace
armnn::LayerType::BroadcastTo
@ BroadcastTo
armnn::RefLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:846
armnn::RefLayerSupport::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: RefLayerSupport.cpp:1525
armnn::LayerType::DetectionPostProcess
@ DetectionPostProcess
armnn::LayerType::MemImport
@ MemImport
armnn::LayerType::Pooling2d
@ Pooling2d
armnn::LayerType::Division
@ Division
armnn::DataType::Signed32
@ Signed32
armnn::LayerType::Shape
@ Shape
armnn::RefLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2122
armnn::RefLayerSupport::IsDebugSupported
bool IsDebugSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1167
armnn::ActivationFunction::Abs
@ Abs
armnn::RefLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:990
armnn::DataType::QAsymmS8
@ QAsymmS8
armnn::LayerType::FullyConnected
@ FullyConnected
armnn::LayerType::Gather
@ Gather
armnn::RefLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1726
armnn::LayerType::Pooling3d
@ Pooling3d
armnn::RefLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1372
armnn::LayerType::LogSoftmax
@ LogSoftmax
armnn::LayerType::BatchMatMul
@ BatchMatMul
armnn::LayerType::DepthwiseConvolution2d
@ DepthwiseConvolution2d
armnn::RefLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2090
armnn::LayerType::Cast
@ Cast
armnn::LayerType::BatchToSpaceNd
@ BatchToSpaceNd
armnn::RefLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2708
armnn::RefLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1478
armnn::LayerType::Reshape
@ Reshape
armnn::LayerType::SpaceToBatchNd
@ SpaceToBatchNd
armnn::LayerType::Fill
@ Fill
armnn::LayerType::L2Normalization
@ L2Normalization
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::RefLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2053
armnn::LayerType::Minimum
@ Minimum
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string & > reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::RefLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2643
armnn::LayerType::Map
@ Map
armnn::LayerType::ReverseV2
@ ReverseV2
armnn::RefLayerSupport::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1987
armnn::ActivationFunction::ReLu
@ ReLu
armnn::LayerType::MemCopy
@ MemCopy
armnn::LayerType::ArgMinMax
@ ArgMinMax
armnn::LayerType::Pad
@ Pad
armnn::RefLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:972
armnn::LayerType::Rank
@ Rank
armnn::RefLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:876
armnn::LayerType::Mean
@ Mean
armnn::RefLayerSupport::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2446
armnn::ActivationFunction::Square
@ Square
armnn::RefLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2839
armnn::LayerType::Input
@ Input
armnn::LayerType::Resize
@ Resize
armnn::RefLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1010
armnn::RefLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1622
armnn::RefLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2610
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string & > reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38
armnn::RefLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1751
armnn::DataType::Signed64
@ Signed64
armnn::LayerType::Convolution2d
@ Convolution2d
armnn::LayerType::FakeQuantization
@ FakeQuantization
armnn::LayerType::Maximum
@ Maximum
armnn::LayerType::Activation
@ Activation
armnn::LayerType::Lstm
@ Lstm
armnn::LayerType::Dequantize
@ Dequantize
armnn::LayerType::Convolution3d
@ Convolution3d
armnn::RefLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2493
armnn::RefLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2464
armnn::LayerType::Unmap
@ Unmap
armnn::RefLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2128
armnn::LayerType::QLstm
@ QLstm
armnn::RefLayerSupport::IsGatherNdSupported
bool IsGatherNdSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1591
armnn::RefLayerSupport::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=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2870
armnn::RefLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1661
armnn::RefLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2016
armnn::LayerType::Output
@ Output
armnn::LayerType::Constant
@ Constant
armnn::ActivationFunction::Sigmoid
@ Sigmoid