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

#include <RefLayerSupport.hpp>

Inheritance diagram for RefLayerSupport:
LayerSupportBase ILayerSupport

Public Member Functions

bool IsAbsSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsActivationSupported (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsAdditionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsArgMinMaxSupported (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
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 override
 
bool IsBatchToSpaceNdSupported (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsCastSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsComparisonSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConcatSupported (const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const ConcatDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConstantSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertBf16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToBf16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDebugSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
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 override
 
bool IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsEqualSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFillSupported (const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFloorSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFullyConnectedSupported (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsGreaterSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsInputSupported (const TensorInfo &input, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsInstanceNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsL2NormalizationSupported (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsLogicalBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported) const override
 
bool IsLogSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported) const override
 
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 override
 
bool IsMaximumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMeanSupported (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMergerSupported (const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const MergerDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMemCopySupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMinimumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMultiplicationSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsOutputSupported (const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPadSupported (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPermuteSupported (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPooling2dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsQuantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
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 override
 
bool IsRankSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsResizeBilinearSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsRsqrtSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsShapeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSpaceToBatchNdSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSpaceToDepthSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSplitterSupported (const TensorInfo &input, const ViewsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSplitterSupported (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStackSupported (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsStridedSliceSupported (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSubtractionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsTransposeConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsUnidirectionalSequenceLstmSupported (const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &output, const Optional< TensorInfo > &hiddenStateOutput, const Optional< TensorInfo > &cellStateOutput, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
- Public Member Functions inherited from LayerSupportBase
bool IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsLogicalUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMemImportSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsMergeSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsPreCompiledSupported (const TensorInfo &input, const PreCompiledDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
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 override
 
bool IsStandInSupported (const std::vector< const TensorInfo *> &inputs, const std::vector< const TensorInfo *> &outputs, const StandInDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsSwitchSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 

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

◆ IsAbsSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 61 of file RefLayerSupport.cpp.

References armnn::Abs, and RefLayerSupport::IsElementwiseUnarySupported().

63 {
64  return IsElementwiseUnarySupported(input,
65  output,
66  ElementwiseUnaryDescriptor(UnaryOperation::Abs),
67  reasonIfUnsupported);
68 }
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:825

◆ IsActivationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 70 of file RefLayerSupport.cpp.

References armnn::Abs, armnn::BFloat16, armnn::BoundedReLu, armnn::CheckSupportRule(), armnn::Elu, armnn::Float16, armnn::Float32, 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.

74 {
75  bool supported = true;
76 
77  // Define supported types.
78  std::array<DataType,6> supportedTypes = {
79  DataType::BFloat16,
80  DataType::Float32,
81  DataType::Float16,
82  DataType::QAsymmS8,
83  DataType::QAsymmU8,
84  DataType::QSymmS16
85  };
86 
87  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
88  "Reference activation: input type not supported.");
89 
90  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
91  "Reference activation: output type not supported.");
92 
93  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
94  "Reference activation: input and output types mismatched.");
95 
96  supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
97  "Reference activation: input and output shapes are of different rank.");
98 
99 
100  struct ActivationFunctionSupported : public Rule
101  {
102  ActivationFunctionSupported(const ActivationDescriptor& desc)
103  {
104  switch(desc.m_Function)
105  {
106  case ActivationFunction::Abs:
107  case ActivationFunction::BoundedReLu:
108  case ActivationFunction::Elu:
109  case ActivationFunction::HardSwish:
110  case ActivationFunction::LeakyReLu:
111  case ActivationFunction::Linear:
112  case ActivationFunction::ReLu:
113  case ActivationFunction::Sigmoid:
114  case ActivationFunction::SoftReLu:
115  case ActivationFunction::Sqrt:
116  case ActivationFunction::Square:
117  case ActivationFunction::TanH:
118  {
119  m_Res = true;
120  break;
121  }
122  default:
123  {
124  m_Res = false;
125  break;
126  }
127  }
128  }
129  };
130 
131  // Function is supported
132  supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
133  "Reference activation: function not supported.");
134 
135  return supported;
136 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::ActivationFunction::BoundedReLu
min(a, max(b, input)) ReLu1 & ReLu6.
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsAdditionSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 138 of file RefLayerSupport.cpp.

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

Referenced by TEST_SUITE().

142 {
143  bool supported = true;
144 
145  std::array<DataType,7> supportedTypes = {
146  DataType::BFloat16,
147  DataType::Float32,
148  DataType::Float16,
149  DataType::QAsymmS8,
150  DataType::QAsymmU8,
151  DataType::QSymmS16,
152  DataType::Signed32
153  };
154 
155  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
156  "Reference addition: input 0 is not a supported type.");
157 
158  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
159  "Reference addition: input 1 is not a supported type.");
160 
161  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
162  "Reference addition: output is not a supported type.");
163 
164  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
165  "Reference addition: input 0 and Input 1 types are mismatched");
166 
167  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
168  "Reference addition: input and output types are mismatched");
169 
170  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
171  "Reference addition: shapes are not suitable for implicit broadcast.");
172 
173  return supported;
174 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsArgMinMaxSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 176 of file RefLayerSupport.cpp.

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

179 {
180  IgnoreUnused(descriptor);
181 
182  std::array<DataType, 8> supportedInputTypes =
183  {
184  DataType::BFloat16,
185  DataType::Float16,
186  DataType::Float32,
187  DataType::QAsymmS8,
188  DataType::QAsymmU8,
189  DataType::QSymmS16,
190  DataType::Signed32,
191  DataType::Signed64
192  };
193 
194  std::array<DataType,2> supportedOutputTypes = {
195  DataType::Signed32,
196  DataType::Signed64
197  };
198 
199  bool supported = true;
200 
201  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
202  "Reference ArgMinMax: input is not a supported type.");
203  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
204  "Reference ArgMinMax: output type not supported");
205 
206  return supported;
207 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 209 of file RefLayerSupport.cpp.

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

217 {
218  IgnoreUnused(descriptor);
219 
220  std::array<DataType, 6> supportedTypes =
221  {
222  DataType::BFloat16,
223  DataType::Float32,
224  DataType::Float16,
225  DataType::QAsymmS8,
226  DataType::QAsymmU8,
227  DataType::QSymmS16
228  };
229 
230  bool supported = true;
231 
232  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
233  "Reference batch normalization: input is not a supported type.");
234 
235  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
236  "Reference batch normalization: output is not a supported type.");
237 
238  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
239  "Reference batch normalization: input and output types are mismatched");
240 
241  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
242  "Reference batch normalization: mean is not a supported type.");
243 
244  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
245  "Reference batch normalization: variance is not a supported type.");
246 
247  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
248  "Reference batch normalization: beta is not a supported type.");
249 
250  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
251  "Reference batch normalization: gamma is not a supported type.");
252 
253  return supported;
254 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsBatchToSpaceNdSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 256 of file RefLayerSupport.cpp.

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

260 {
261  IgnoreUnused(descriptor);
262 
263  bool supported = true;
264 
265  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
266  std::string inputTensorStr = "input";
267  std::string outputTensorStr = "output";
268 
269  // Define supported types.
270  std::array<DataType,6> supportedTypes =
271  {
272  DataType::BFloat16,
273  DataType::Float32,
274  DataType::Float16,
275  DataType::QAsymmS8,
276  DataType::QAsymmU8,
277  DataType::QSymmS16
278  };
279 
280  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
281  "Reference BatchToSpaceNd: input type not supported.");
282 
283  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
284  "Reference BatchToSpaceNd: output type not supported.");
285 
286  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
287  "Reference BatchToSpaceNd: input and output types mismatched.");
288 
289  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
290  reasonIfUnsupported,
291  CreateIncorrectDimensionsErrorMsg(4,
292  output.GetNumDimensions(),
293  batchToSpaceNdLayerStr,
294  outputTensorStr).data());
295 
296  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
297  reasonIfUnsupported,
298  CreateIncorrectDimensionsErrorMsg(4,
299  input.GetNumDimensions(),
300  batchToSpaceNdLayerStr,
301  inputTensorStr).data());
302 
303  return supported;
304 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsCastSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 306 of file RefLayerSupport.cpp.

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

309 {
310  std::array<DataType, 9> supportedInputTypes =
311  {
312  DataType::BFloat16,
313  DataType::Float32,
314  DataType::Float16,
315  DataType::QSymmS8,
316  DataType::QAsymmS8,
317  DataType::QAsymmU8,
318  DataType::QSymmS16,
319  DataType::Signed32
320  };
321 
322  bool supported = true;
323  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
324  "Reference cast: input is not a supported type");
325 
326 
327  supported &= CheckSupportRule(TypeAnyOf(output, supportedInputTypes), reasonIfUnsupported,
328  "Reference cast: output is not a supported type");
329 
330  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
331  "Reference cast: input and output shapes have different number of total elements");
332 
333  return supported;
334 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsComparisonSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 336 of file RefLayerSupport.cpp.

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::IsEqualSupported(), and RefLayerSupport::IsGreaterSupported().

341 {
342  IgnoreUnused(descriptor);
343  std::array<DataType, 8> supportedInputTypes =
344  {
345  DataType::Boolean,
346  DataType::BFloat16,
347  DataType::Float32,
348  DataType::Float16,
349  DataType::QAsymmS8,
350  DataType::QAsymmU8,
351  DataType::QSymmS16,
352  DataType::Signed32
353  };
354 
355  bool supported = true;
356  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
357  "Reference comparison: input 0 is not a supported type");
358 
359  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
360  "Reference comparison: input 0 and Input 1 types are mismatched");
361 
362  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
363  "Reference comparison: output is not of type Boolean");
364 
365  return supported;
366 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsConcatSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 368 of file RefLayerSupport.cpp.

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

Referenced by RefLayerSupport::IsMergerSupported().

372 {
373  IgnoreUnused(descriptor);
374 
375  bool supported = true;
376  std::array<DataType,6> supportedTypes =
377  {
378  DataType::BFloat16,
379  DataType::Float32,
380  DataType::Float16,
381  DataType::QAsymmS8,
382  DataType::QAsymmU8,
383  DataType::QSymmS16
384  };
385 
386  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
387  "Reference concatenation: output type not supported");
388  for (const TensorInfo* input : inputs)
389  {
390  ARMNN_ASSERT(input != nullptr);
391  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
392  "Reference concatenation: input type not supported");
393 
394  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
395  "Reference concatenation: input and output types mismatched.");
396  }
397 
398  return supported;
399 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsConstantSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 401 of file RefLayerSupport.cpp.

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

403 {
404  std::array<DataType,8> supportedTypes =
405  {
406  DataType::BFloat16,
407  DataType::Float16,
408  DataType::Float32,
409  DataType::QAsymmS8,
410  DataType::QAsymmU8,
411  DataType::QSymmS8,
412  DataType::QSymmS16,
413  DataType::Signed32
414  };
415 
416  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
417  "Reference constant: output is not a supported type.");
418 }
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsConvertBf16ToFp32Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 420 of file RefLayerSupport.cpp.

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

423 {
424  bool supported = true;
425 
426  supported &= CheckSupportRule(TypeIs(input, DataType::BFloat16), reasonIfUnsupported,
427  "Reference for ConvertBf16ToFp32 layer: input type not supported");
428 
429  supported &= CheckSupportRule(TypeIs(output, DataType::Float32), reasonIfUnsupported,
430  "Reference for ConvertBf16ToFp32 layer: output type not supported");
431 
432  return supported;
433 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsConvertFp16ToFp32Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 435 of file RefLayerSupport.cpp.

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

438 {
439  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
440  input.GetDataType(),
441  &TrueFunc<>,
442  &FalseInputFuncF32<>,
443  &FalseFuncU8<>,
444  &FalseFuncI32<>,
445  &FalseFuncU8<>) &&
446  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
447  output.GetDataType(),
448  &FalseOutputFuncF16<>,
449  &TrueFunc<>,
450  &FalseFuncU8<>,
451  &FalseFuncI32<>,
452  &FalseFuncU8<>));
453 }
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

◆ IsConvertFp32ToBf16Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 455 of file RefLayerSupport.cpp.

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

458 {
459  bool supported = true;
460 
461  supported &= CheckSupportRule(TypeIs(input, DataType::Float32), reasonIfUnsupported,
462  "Reference for ConvertFp32ToBf16 layer: input type not supported");
463 
464  supported &= CheckSupportRule(TypeIs(output, DataType::BFloat16), reasonIfUnsupported,
465  "Reference for ConvertFp32ToBf16 layer: output type not supported");
466 
467  return supported;
468 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsConvertFp32ToFp16Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 470 of file RefLayerSupport.cpp.

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

473 {
474  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
475  input.GetDataType(),
476  &FalseInputFuncF16<>,
477  &TrueFunc<>,
478  &FalseFuncU8<>,
479  &FalseFuncI32<>,
480  &FalseFuncU8<>) &&
481  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
482  output.GetDataType(),
483  &TrueFunc<>,
484  &FalseOutputFuncF32<>,
485  &FalseFuncU8<>,
486  &FalseFuncI32<>,
487  &FalseFuncU8<>));
488 }
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

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 490 of file RefLayerSupport.cpp.

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

496 {
497  bool supported = true;
498 
499  // Define supported types.
500  std::array<DataType,7> supportedTypes =
501  {
502  DataType::BFloat16,
503  DataType::Float32,
504  DataType::Float16,
505  DataType::QAsymmS8,
506  DataType::QAsymmU8,
507  DataType::QSymmS8,
508  DataType::QSymmS16
509  };
510 
511  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
512  "Reference Convolution2d: input is not a supported type.");
513 
514  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
515  "Reference Convolution2d: output is not a supported type.");
516 
517  // For Convolution2d, we allow to have BFloat16 input with Float32 output for optimization.
518  if (input.GetDataType() == DataType::BFloat16)
519  {
520  if (output.GetDataType() != DataType::BFloat16 && output.GetDataType() != DataType::Float32)
521  {
522  reasonIfUnsupported.value() += "Output tensor type must be BFloat16 or Float32 for BFloat16 input.\n";
523  supported = false;
524  }
525  }
526  else
527  {
528  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
529  "Reference Convolution2d: input and output types mismatched.");
530  }
531 
532  const DataType inputType = input.GetDataType();
533  if (IsQuantized8BitType(inputType))
534  {
535  ARMNN_NO_DEPRECATE_WARN_BEGIN
536  std::array<DataType, 4> supportedWeightTypes =
537  {
538  DataType::QAsymmS8,
539  DataType::QAsymmU8,
540  DataType::QSymmS8,
541  DataType::QuantizedSymm8PerAxis // deprecated
542  };
543  ARMNN_NO_DEPRECATE_WARN_END
544 
545  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
546  "Reference Convolution2d: weights type not supported for quantized input.");
547  }
548  else
549  {
550  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
551  "Reference Convolution2d: weights is not a supported type.");
552 
553  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
554  "Reference Convolution2d: input and weights types mismatched.");
555  }
556 
557  if (biases.has_value())
558  {
559  std::array<DataType,4> biasesSupportedTypes =
560  {
561  DataType::BFloat16,
562  DataType::Float32,
563  DataType::Float16,
564  DataType::Signed32
565  };
566 
567  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
568  "Reference Convolution2d: biases is not a supported type.");
569  }
570  IgnoreUnused(descriptor);
571 
572  return supported;
573 }
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:267
armnn::DataType
DataType
Definition: Types.hpp:35
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsDebugSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 575 of file RefLayerSupport.cpp.

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

578 {
579  bool supported = true;
580 
581  std::array<DataType, 8> supportedTypes =
582  {
583  DataType::BFloat16,
584  DataType::Float16,
585  DataType::Float32,
586  DataType::QAsymmS8,
587  DataType::QAsymmU8,
588  DataType::QSymmS8,
589  DataType::QSymmS16,
590  DataType::Signed32
591  };
592 
593  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
594  "Reference for Debug layer: input type not supported");
595 
596  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
597  "Reference for Debug layer: output type not supported");
598 
599  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
600  "Reference for Debug layer: input and output types are mismatched");
601 
602  return supported;
603 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsDepthToSpaceSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 605 of file RefLayerSupport.cpp.

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

609 {
610  IgnoreUnused(descriptor);
611  bool supported = true;
612 
613  std::array<DataType,6> supportedTypes =
614  {
615  DataType::BFloat16,
616  DataType::Float32,
617  DataType::Float16,
618  DataType::QAsymmS8,
619  DataType::QAsymmU8,
620  DataType::QSymmS16
621  };
622 
623  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
624  "Reference DepthToSpace: input type not supported");
625 
626  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
627  "Reference DepthToSpace: output type not supported");
628 
629  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
630  "Reference DepthToSpace: input and output types are mismatched");
631 
632  return supported;
633 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 635 of file RefLayerSupport.cpp.

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

Referenced by RefLayerSupport::IsDilatedDepthwiseConvolutionSupported().

641 {
642  IgnoreUnused(descriptor);
643  bool supported = true;
644 
645  // Define supported types.
646  std::array<DataType,7> supportedTypes =
647  {
648  DataType::BFloat16,
649  DataType::Float32,
650  DataType::Float16,
651  DataType::QAsymmS8,
652  DataType::QAsymmU8,
653  DataType::QSymmS8,
654  DataType::QSymmS16
655  };
656 
657  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
658  "Reference DepthwiseConvolution2d: input is not a supported type.");
659 
660  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
661  "Reference DepthwiseConvolution2d: output is not a supported type.");
662 
663  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
664  "Reference DepthwiseConvolution2d: input and output types mismatched.");
665 
666  const DataType inputType = input.GetDataType();
667  if (IsQuantized8BitType(inputType))
668  {
669  ARMNN_NO_DEPRECATE_WARN_BEGIN
670  std::array<DataType, 4> supportedWeightTypes =
671  {
672  DataType::QAsymmS8,
673  DataType::QAsymmU8,
674  DataType::QSymmS8,
675  DataType::QuantizedSymm8PerAxis // deprecated
676  };
677  ARMNN_NO_DEPRECATE_WARN_END
678 
679  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
680  "Reference DepthwiseConvolution2d: weights type not supported for "
681  "quantized input.");
682  }
683  else
684  {
685  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
686  "Reference DepthwiseConvolution2d: weights is not a supported type.");
687 
688  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
689  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
690  }
691 
692  if (biases.has_value())
693  {
694  std::array<DataType,4> biasesSupportedTypes =
695  {
696  DataType::BFloat16,
697  DataType::Float32,
698  DataType::Float16,
699  DataType::Signed32
700  };
701  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
702  "Reference DepthwiseConvolution2d: biases is not a supported type.");
703  }
704 
705  return supported;
706 
707 }
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:267
armnn::DataType
DataType
Definition: Types.hpp:35
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsDequantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 709 of file RefLayerSupport.cpp.

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

712 {
713  bool supported = true;
714 
715  std::array<DataType,4> supportedInputTypes = {
716  DataType::QAsymmS8,
717  DataType::QAsymmU8,
718  DataType::QSymmS8,
719  DataType::QSymmS16
720  };
721 
722  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
723  "Reference for Dequantize layer: input type not supported.");
724 
725  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
726  "Reference for Dequantize layer: per-axis quantized input not supported.");
727 
728  std::array<DataType,3> supportedOutputTypes = {
729  DataType::BFloat16,
730  DataType::Float32,
731  DataType::Float16
732  };
733 
734  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
735  "Reference for Dequantize layer: output type not supported.");
736 
737  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
738  "Reference for Dequantize layer: input/output shapes have different num total "
739  "elements.");
740 
741  return supported;
742 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 744 of file RefLayerSupport.cpp.

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

753 {
754  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
755 
756  bool supported = true;
757 
758  std::array<DataType,6> supportedInputTypes =
759  {
760  DataType::BFloat16,
761  DataType::Float32,
762  DataType::Float16,
763  DataType::QAsymmS8,
764  DataType::QAsymmU8,
765  DataType::QSymmS16
766  };
767 
768  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
769  "Reference DetectionPostProcess: input 0 is not a supported type.");
770 
771  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
772  "Reference DetectionPostProcess: input 1 is not a supported type.");
773 
774  return supported;
775 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 777 of file RefLayerSupport.cpp.

References RefLayerSupport::IsDepthwiseConvolutionSupported().

783 {
784  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
785 }
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 override
Definition: RefLayerSupport.cpp:635

◆ IsDivisionSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 787 of file RefLayerSupport.cpp.

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

791 {
792  bool supported = true;
793 
794  std::array<DataType,7> supportedTypes = {
795  DataType::BFloat16,
796  DataType::Float32,
797  DataType::Float16,
798  DataType::QAsymmS8,
799  DataType::QAsymmU8,
800  DataType::QSymmS16,
801  DataType::Signed32
802  };
803 
804  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
805  "Reference division: input 0 is not a supported type.");
806 
807  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
808  "Reference division: input 1 is not a supported type.");
809 
810  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
811  "Reference division: output is not a supported type.");
812 
813  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
814  "Reference division: input 0 and Input 1 types are mismatched");
815 
816  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
817  "Reference division: input and output types are mismatched");
818 
819  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
820  "Reference division: shapes are not suitable for implicit broadcast.");
821 
822  return supported;
823 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsElementwiseUnarySupported()

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

Reimplemented from LayerSupportBase.

Definition at line 825 of file RefLayerSupport.cpp.

References armnn::BFloat16, 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::IsAbsSupported(), and RefLayerSupport::IsRsqrtSupported().

829 {
830  IgnoreUnused(descriptor);
831 
832  std::array<DataType, 7> supportedTypes =
833  {
834  DataType::BFloat16,
835  DataType::Float32,
836  DataType::Float16,
837  DataType::QAsymmS8,
838  DataType::QAsymmU8,
839  DataType::QSymmS16,
840  DataType::Signed32
841  };
842 
843  std::array<DataType, 1> logicalSupportedTypes =
844  {
845  DataType::Boolean
846  };
847 
848  bool supported = true;
849 
850  if (descriptor.m_Operation == UnaryOperation::LogicalNot)
851  {
852  supported &= CheckSupportRule(TypeAnyOf(input, logicalSupportedTypes), reasonIfUnsupported,
853  "Reference elementwise unary: input type not supported");
854 
855  supported &= CheckSupportRule(TypeAnyOf(output, logicalSupportedTypes), reasonIfUnsupported,
856  "Reference elementwise unary: output type not supported");
857  }
858  else
859  {
860  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
861  "Reference elementwise unary: input type not supported");
862 
863  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
864  "Reference elementwise unary: output type not supported");
865  }
866 
867  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
868  "Reference elementwise unary: input and output types not matching");
869 
870  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
871  "Reference elementwise unary: input and output shapes"
872  "have different number of total elements");
873 
874  return supported;
875 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsEqualSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 877 of file RefLayerSupport.cpp.

References armnn::Equal, and RefLayerSupport::IsComparisonSupported().

881 {
882  return IsComparisonSupported(input0,
883  input1,
884  output,
885  ComparisonDescriptor(ComparisonOperation::Equal),
886  reasonIfUnsupported);
887 }
armnn::RefLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:336

◆ IsFakeQuantizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 889 of file RefLayerSupport.cpp.

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

892 {
893  IgnoreUnused(descriptor);
894  bool supported = true;
895 
896  std::array<DataType,1> supportedTypes =
897  {
898  DataType::Float32
899  };
900 
901  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
902  "Reference fake quantization: input type not supported.");
903 
904  return supported;
905 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsFillSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 907 of file RefLayerSupport.cpp.

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

911 {
912  IgnoreUnused(descriptor);
913  IgnoreUnused(output);
914 
915  bool supported = true;
916 
917  std::array<DataType,3> supportedTypes =
918  {
919  DataType::Float32,
920  DataType::Float16,
921  DataType::Signed32
922  };
923 
924  supported &= CheckSupportRule(TypeIs(input, DataType::Signed32), reasonIfUnsupported,
925  "Reference Fill: input type not supported.");
926 
927  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
928  "Reference Fill: output type not supported.");
929  return supported;
930 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsFloorSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 932 of file RefLayerSupport.cpp.

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

935 {
936  IgnoreUnused(output);
937  bool supported = true;
938 
939  std::array<DataType,3> supportedTypes =
940  {
941  DataType::BFloat16,
942  DataType::Float32,
943  DataType::Float16
944  };
945 
946  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
947  "Reference Floor: input type not supported.");
948 
949  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
950  "Reference Floor: output type not supported.");
951 
952  return supported;
953 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsFullyConnectedSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 955 of file RefLayerSupport.cpp.

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, TensorInfo::GetDataType(), FullyConnectedDescriptor::m_BiasEnabled, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

961 {
962  bool supported = true;
963 
964  // Define supported types.
965  std::array<DataType,6> supportedTypes =
966  {
967  DataType::BFloat16,
968  DataType::Float32,
969  DataType::Float16,
970  DataType::QAsymmS8,
971  DataType::QAsymmU8,
972  DataType::QSymmS16
973  };
974 
975  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
976  "Reference Fully Connected: input type not supported.");
977 
978  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
979  "Reference Fully Connected: output type not supported.");
980 
981  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
982  "Reference Fully Connected: weights type not supported.");
983 
984  // For FullyConnected, we allow to have BFloat16 input with Float32 output for optimization.
985  if (input.GetDataType() == DataType::BFloat16)
986  {
987  if (output.GetDataType() != DataType::BFloat16 && output.GetDataType() != DataType::Float32)
988  {
989  reasonIfUnsupported.value() += "Output tensor type must be BFloat16 or Float32 for BFloat16 input.\n";
990  supported = false;
991  }
992  }
993  else
994  {
995  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
996  "Reference Fully Connected: input and output types mismatched.");
997  }
998 
999  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1000  "Reference Fully Connected: weights is not a supported type.");
1001 
1002  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1003  "Reference Fully Connected: input and weights types mismatched.");
1004 
1005  if (descriptor.m_BiasEnabled)
1006  {
1007  // Defined supported types for bias
1008  std::array<DataType, 5>
1009  supportedBiasTypes =
1010  {
1011  DataType::BFloat16,
1012  DataType::Float32,
1013  DataType::Float16,
1014  DataType::Signed32,
1015  DataType::QAsymmS8
1016  };
1017 
1018  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
1019  "Reference Fully Connected: bias type not supported.");
1020 
1021  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
1022  "Reference Fully Connected: bias and weight types mismatch.");
1023 
1024  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
1025  "Reference Fully Connected: bias type inferred from weights is incompatible.");
1026 
1027  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
1028  "Reference Fully Connected: bias must have 1 dimension.");
1029 
1030  }
1031 
1032  return supported;
1033 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsGatherSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1035 of file RefLayerSupport.cpp.

References armnn::BFloat16, armnn::CheckSupportRule(), armnn::Float16, armnn::Float32, GatherDescriptor::m_Axis, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

1040 {
1041  bool supported = true;
1042  std::array<DataType,7> supportedTypes =
1043  {
1044  DataType::BFloat16,
1045  DataType::Float32,
1046  DataType::Float16,
1047  DataType::QAsymmS8,
1048  DataType::QAsymmU8,
1049  DataType::QSymmS16,
1050  DataType::Signed32
1051  };
1052 
1053  if (descriptor.m_Axis != 0)
1054  {
1055  reasonIfUnsupported.value() += std::string("Reference Gather: axis not supported\n");
1056  supported &= false;
1057  }
1058  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1059  "Reference Gather: input type not supported");
1060 
1061  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1062  "Reference Gather: output type not supported");
1063 
1064  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1065  "Reference Gather: indices (input1) type not supported");
1066 
1067  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1068  "Reference Gather: input and output types not matching");
1069 
1070  return supported;
1071 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsGreaterSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1073 of file RefLayerSupport.cpp.

References armnn::Greater, and RefLayerSupport::IsComparisonSupported().

1077 {
1078  return IsComparisonSupported(input0,
1079  input1,
1080  output,
1081  ComparisonDescriptor(ComparisonOperation::Greater),
1082  reasonIfUnsupported);
1083 }
armnn::RefLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:336

◆ IsInputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1085 of file RefLayerSupport.cpp.

1087 {
1088  return true;
1089 }

◆ IsInstanceNormalizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1091 of file RefLayerSupport.cpp.

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

1095 {
1096  IgnoreUnused(descriptor);
1097  // Define supported types
1098  std::array<DataType, 3> supportedTypes =
1099  {
1100  DataType::BFloat16,
1101  DataType::Float32,
1102  DataType::Float16
1103  };
1104 
1105  bool supported = true;
1106 
1107  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1108  "Reference Instance Normalization: input type not supported.");
1109 
1110  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1111  "Reference Instance Normalization: output type not supported.");
1112 
1113  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1114  "Reference Instance Normalization: input and output types mismatched.");
1115 
1116  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1117  "Reference Instance Normalization: input and output shapes have different "
1118  "num total elements.");
1119 
1120  return supported;
1121 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsL2NormalizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1123 of file RefLayerSupport.cpp.

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

1127 {
1128  IgnoreUnused(descriptor);
1129  // Define supported types
1130  std::array<DataType, 6> supportedTypes =
1131  {
1132  DataType::BFloat16,
1133  DataType::Float32,
1134  DataType::Float16,
1135  DataType::QAsymmS8,
1136  DataType::QAsymmU8,
1137  DataType::QSymmS16
1138  };
1139 
1140  bool supported = true;
1141 
1142  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1143  "Reference L2normalization: input type not supported.");
1144 
1145  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1146  "Reference L2normalization: output type not supported.");
1147 
1148  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1149  "Reference L2normalization: input and output types mismatched.");
1150 
1151  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1152  "Reference L2normalization: input and output shapes have different "
1153  "num total elements.");
1154 
1155  return supported;
1156 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsLogicalBinarySupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1158 of file RefLayerSupport.cpp.

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

1163 {
1164  IgnoreUnused(descriptor);
1165 
1166  std::array<DataType, 1> supportedTypes =
1167  {
1168  DataType::Boolean
1169  };
1170 
1171  bool supported = true;
1172  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1173  "Reference LogicalBinary: input 0 type not supported");
1174  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1175  "Reference LogicalBinary: input 1 type not supported");
1176 
1177  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1178  "Reference LogicalBinary: input and output types do not match");
1179 
1180  return supported;
1181 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsLogSoftmaxSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1183 of file RefLayerSupport.cpp.

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

1187 {
1188  IgnoreUnused(descriptor);
1189 
1190  std::array<DataType, 3> supportedTypes =
1191  {
1192  DataType::BFloat16,
1193  DataType::Float32,
1194  DataType::Float16
1195  };
1196 
1197  bool supported = true;
1198  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1199  "Reference LogSoftmax: input type not supported");
1200 
1201  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1202  "Reference LogSoftmax: output type not supported");
1203 
1204  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1205  "Reference LogSoftmax: input and output types do not match");
1206 
1207  return supported;
1208 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 1210 of file RefLayerSupport.cpp.

References armnn::BFloat16, 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.

1220 {
1221  IgnoreUnused(descriptor);
1222  IgnoreUnused(paramsInfo);
1223 
1224  bool supported = true;
1225 
1226  std::array<DataType,3> supportedTypes = {
1227  DataType::BFloat16,
1228  DataType::Float32,
1229  DataType::QSymmS16
1230  };
1231 
1232  // check inputs and outputs
1233  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1234  "Reference Lstm: input is not a supported type.");
1235  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1236  "Reference Lstm: input and outputStateIn types are mismatched");
1237  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1238  "Reference Lstm: input and cellStateIn types are mismatched");
1239  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1240  "Reference Lstm: input and scratchBuffer types are mismatched");
1241  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1242  "Reference Lstm: input and outputStateOut types are mismatched");
1243  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1244  "Reference Lstm: input and cellStateOut types are mismatched");
1245 
1246  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1247  "Reference Lstm: input and output types are mismatched");
1248  // check layer parameters
1249  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
1250  "Reference Lstm: input and InputToForgetWeights types are mismatched");
1251  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
1252  "Reference Lstm: input and InputToCellWeights types are mismatched");
1253  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
1254  "Reference Lstm: input and InputToOutputWeights types are mismatched");
1255  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
1256  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
1257  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
1258  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
1259  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
1260  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
1261  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
1262  "Reference Lstm: input and ForgetGateBias types are mismatched");
1263  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
1264  "Reference Lstm: input and CellBias types are mismatched");
1265  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
1266  "Reference Lstm: input and OutputGateBias types are mismatched");
1267  if (!descriptor.m_CifgEnabled)
1268  {
1269  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
1270  "Reference Lstm: input and InputToInputWeights types are mismatched");
1271  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
1272  reasonIfUnsupported,
1273  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
1274  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
1275  "Reference Lstm: input and InputGateBias types are mismatched");
1276  if (descriptor.m_PeepholeEnabled)
1277  {
1278  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
1279  reasonIfUnsupported,
1280  "Reference Lstm: input and CellToInputWeights types are mismatched");
1281  }
1282  }
1283  if (descriptor.m_PeepholeEnabled)
1284  {
1285  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
1286  "Reference Lstm: input and CellToForgetWeights types are mismatched");
1287  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
1288  "Reference Lstm: input and CellToOutputWeights types are mismatched");
1289  }
1290  if (descriptor.m_ProjectionEnabled)
1291  {
1292  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
1293  "Reference Lstm: input and mProjectionWeights types are mismatched");
1294  if (paramsInfo.m_ProjectionBias != nullptr)
1295  {
1296  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
1297  "Reference Lstm: input and ProjectionBias types are mismatched");
1298  }
1299  }
1300  if (descriptor.m_LayerNormEnabled)
1301  {
1302  if (!descriptor.m_CifgEnabled)
1303  {
1304  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
1305  reasonIfUnsupported,
1306  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1307  }
1308  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
1309  reasonIfUnsupported,
1310  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
1311  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
1312  reasonIfUnsupported,
1313  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
1314  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
1315  reasonIfUnsupported,
1316  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1317  }
1318 
1319  return supported;
1320 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsMaximumSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1322 of file RefLayerSupport.cpp.

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

1326 {
1327  bool supported = true;
1328 
1329  std::array<DataType,7> supportedTypes = {
1330  DataType::BFloat16,
1331  DataType::Float32,
1332  DataType::Float16,
1333  DataType::QAsymmS8,
1334  DataType::QAsymmU8,
1335  DataType::QSymmS16,
1336  DataType::Signed32
1337  };
1338 
1339  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1340  "Reference maximum: input 0 is not a supported type.");
1341 
1342  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1343  "Reference maximum: input 1 is not a supported type.");
1344 
1345  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1346  "Reference maximum: output is not a supported type.");
1347 
1348  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1349  "Reference maximum: input 0 and Input 1 types are mismatched");
1350 
1351  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1352  "Reference maximum: input and output types are mismatched");
1353 
1354  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1355  "Reference maximum: shapes are not suitable for implicit broadcast.");
1356 
1357  return supported;
1358 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsMeanSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1360 of file RefLayerSupport.cpp.

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

1364 {
1365  bool supported = true;
1366  std::string meanLayerStr = "Mean";
1367  std::string outputTensorStr = "output";
1368 
1369  std::array<DataType,6> supportedTypes =
1370  {
1371  DataType::BFloat16,
1372  DataType::Float32,
1373  DataType::Float16,
1374  DataType::QAsymmS8,
1375  DataType::QAsymmU8,
1376  DataType::QSymmS16
1377  };
1378 
1379  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1380  "Reference Mean: input type not supported.");
1381 
1382  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1383  "Reference Mean: input and output types are mismatched");
1384 
1385  if (descriptor.m_KeepDims)
1386  {
1387  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1388  reasonIfUnsupported,
1389  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1390  output.GetNumDimensions(),
1391  meanLayerStr, outputTensorStr).data());
1392  }
1393  else if (descriptor.m_Axis.empty())
1394  {
1395  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1396  reasonIfUnsupported,
1397  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1398  meanLayerStr, outputTensorStr).data());
1399  }
1400  else
1401  {
1402  auto outputDim = input.GetNumDimensions() - armnn::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1403 
1404  if (outputDim > 0)
1405  {
1406  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1407  reasonIfUnsupported,
1408  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1409  meanLayerStr, outputTensorStr).data());
1410  }
1411  else
1412  {
1413  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1414  reasonIfUnsupported,
1415  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1416  meanLayerStr, outputTensorStr).data());
1417  }
1418  }
1419 
1420  return supported;
1421 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:35
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsMemCopySupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1431 of file RefLayerSupport.cpp.

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

1434 {
1435  bool supported = true;
1436 
1437  std::array<DataType,7> supportedTypes =
1438  {
1439  DataType::BFloat16,
1440  DataType::Float32,
1441  DataType::Float16,
1442  DataType::QAsymmS8,
1443  DataType::QAsymmU8,
1444  DataType::QSymmS16,
1445  DataType::Boolean
1446  };
1447 
1448  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1449  "Reference MemCopy: input type not supported");
1450 
1451  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1452  "Reference MemCopy: output type not supported");
1453 
1454  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1455  "Reference MemCopy: input and output types are mismatched");
1456 
1457  return supported;
1458 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsMergerSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1423 of file RefLayerSupport.cpp.

References RefLayerSupport::IsConcatSupported().

1427 {
1428  return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
1429 }
armnn::RefLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const ConcatDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:368

◆ IsMinimumSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1460 of file RefLayerSupport.cpp.

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

1464 {
1465  bool supported = true;
1466 
1467  std::array<DataType,7> supportedTypes = {
1468  DataType::BFloat16,
1469  DataType::Float32,
1470  DataType::Float16,
1471  DataType::QAsymmS8,
1472  DataType::QAsymmU8,
1473  DataType::QSymmS16,
1474  DataType::Signed32
1475  };
1476 
1477  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1478  "Reference minimum: input 0 is not a supported type.");
1479 
1480  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1481  "Reference minimum: input 1 is not a supported type.");
1482 
1483  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1484  "Reference minimum: output is not a supported type.");
1485 
1486  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1487  "Reference minimum: input 0 and Input 1 types are mismatched");
1488 
1489  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1490  "Reference minimum: input and output types are mismatched");
1491 
1492  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1493  "Reference minimum: shapes are not suitable for implicit broadcast.");
1494 
1495  return supported;
1496 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsMultiplicationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1498 of file RefLayerSupport.cpp.

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

1502 {
1503  bool supported = true;
1504 
1505  std::array<DataType,7> supportedTypes = {
1506  DataType::BFloat16,
1507  DataType::Float32,
1508  DataType::Float16,
1509  DataType::QAsymmS8,
1510  DataType::QAsymmU8,
1511  DataType::QSymmS16,
1512  DataType::Signed32
1513  };
1514 
1515  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1516  "Reference multiplication: input 0 is not a supported type.");
1517 
1518  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1519  "Reference multiplication: input 1 is not a supported type.");
1520 
1521  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1522  "Reference multiplication: output is not a supported type.");
1523 
1524  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1525  "Reference multiplication: input 0 and Input 1 types are mismatched");
1526 
1527  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1528  "Reference multiplication: input and output types are mismatched");
1529 
1530  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1531  "Reference multiplication: shapes are not suitable for implicit broadcast.");
1532 
1533  return supported;
1534 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsNormalizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1536 of file RefLayerSupport.cpp.

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

1540 {
1541  IgnoreUnused(descriptor);
1542 
1543  // Define supported types
1544  std::array<DataType, 6> supportedTypes =
1545  {
1546  DataType::BFloat16,
1547  DataType::Float16,
1548  DataType::Float32,
1549  DataType::QAsymmS8,
1550  DataType::QAsymmU8,
1551  DataType::QSymmS16
1552  };
1553 
1554  bool supported = true;
1555 
1556  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1557  "Reference normalization: input type not supported.");
1558 
1559  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1560  "Reference normalization: output type not supported.");
1561 
1562  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1563  "Reference normalization: input and output shapes have different "
1564  "num total elements.");
1565 
1566  return supported;
1567 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsOutputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1569 of file RefLayerSupport.cpp.

1571 {
1572  return true;
1573 }

◆ IsPadSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1575 of file RefLayerSupport.cpp.

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

1579 {
1580  IgnoreUnused(descriptor);
1581  bool supported = true;
1582 
1583  // Define supported output and inputs types.
1584  std::array<DataType,6> supportedTypes =
1585  {
1586  DataType::BFloat16,
1587  DataType::Float32,
1588  DataType::Float16,
1589  DataType::QAsymmS8,
1590  DataType::QAsymmU8,
1591  DataType::QSymmS16
1592  };
1593 
1594  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1595  "Reference pad: input is not a supported type.");
1596 
1597  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1598  "Reference pad: output is not a supported type.");
1599 
1600  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1601  "Reference pad: input and output types are mismatched.");
1602 
1603  return supported;
1604 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsPermuteSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1606 of file RefLayerSupport.cpp.

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

1610 {
1611  IgnoreUnused(descriptor);
1612  bool supported = true;
1613 
1614  // Define supported output and inputs types.
1615  std::array<DataType, 6> supportedTypes =
1616  {
1617  DataType::BFloat16,
1618  DataType::Float32,
1619  DataType::Float16,
1620  DataType::QAsymmS8,
1621  DataType::QAsymmU8,
1622  DataType::QSymmS16
1623  };
1624 
1625  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1626  "Reference permute: input is not a supported type.");
1627 
1628  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1629  "Reference permute: output is not a supported type.");
1630 
1631  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1632  "Reference permute: input and output types are mismatched.");
1633 
1634  return supported;
1635 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsPooling2dSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1637 of file RefLayerSupport.cpp.

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

1641 {
1642  IgnoreUnused(descriptor);
1643  bool supported = true;
1644 
1645  // Define supported output and inputs types.
1646  std::array<DataType,6> supportedTypes =
1647  {
1648  DataType::BFloat16,
1649  DataType::Float32,
1650  DataType::Float16,
1651  DataType::QAsymmS8,
1652  DataType::QAsymmU8,
1653  DataType::QSymmS16
1654  };
1655 
1656  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1657  "Reference poolind2d: input is not a supported type.");
1658 
1659  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1660  "Reference poolind2d: output is not a supported type.");
1661 
1662  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1663  "Reference poolind2d: input and output types are mismatched.");
1664 
1665  return supported;
1666 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsPreluSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 2153 of file RefLayerSupport.cpp.

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

2157 {
2158  bool supported = true;
2159 
2160  std::array<DataType, 6> supportedTypes
2161  {
2162  DataType::BFloat16,
2163  DataType::Float32,
2164  DataType::Float16,
2165  DataType::QAsymmS8,
2166  DataType::QAsymmU8,
2167  DataType::QSymmS16
2168  };
2169 
2170  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2171  "PReLU: input is not a supported type.");
2172 
2173  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
2174  "PReLU: alpha is not a supported type.");
2175 
2176  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2177  "PReLU: output is not a supported type.");
2178 
2179  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
2180  "PReLU: input, alpha and output types are mismatched");
2181 
2182  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
2183  "PReLU: shapes are not suitable for implicit broadcast");
2184 
2185  return supported;
2186 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 1668 of file RefLayerSupport.cpp.

References armnn::IgnoreUnused().

1677 {
1678  IgnoreUnused(input);
1679  IgnoreUnused(previousOutputIn);
1680  IgnoreUnused(previousCellStateIn);
1681  IgnoreUnused(outputStateOut);
1682  IgnoreUnused(cellStateOut);
1683  IgnoreUnused(output);
1684  IgnoreUnused(descriptor);
1685  IgnoreUnused(paramsInfo);
1686 
1687  IgnoreUnused(reasonIfUnsupported);
1688 
1689  return true;
1690 }
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14

◆ IsQuantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1692 of file RefLayerSupport.cpp.

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

1695 {
1696  bool supported = true;
1697 
1698  // Define supported input types.
1699  std::array<DataType,7> supportedInputTypes = {
1700  DataType::BFloat16,
1701  DataType::Float32,
1702  DataType::Float16,
1703  DataType::QAsymmS8,
1704  DataType::QAsymmU8,
1705  DataType::QSymmS8,
1706  DataType::QSymmS16
1707  };
1708 
1709  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1710  "Reference quantize: input type not supported.");
1711 
1712  // Define supported output types.
1713  std::array<DataType,4> supportedOutputTypes = {
1714  DataType::QAsymmS8,
1715  DataType::QAsymmU8,
1716  DataType::QSymmS8,
1717  DataType::QSymmS16
1718  };
1719  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1720  "Reference quantize: output type not supported.");
1721 
1722  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1723  "Reference quantize: input and output shapes have different num total elements.");
1724 
1725  return supported;
1726 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsRankSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1728 of file RefLayerSupport.cpp.

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

1731 {
1732  IgnoreUnused(input);
1733  // Define supported output types.
1734  std::array<DataType,1> supportedOutputTypes =
1735  {
1736  DataType::Signed32,
1737  };
1738 
1739  return CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1740  "Reference rank: input type not supported.");
1741 }
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsReduceSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1743 of file RefLayerSupport.cpp.

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

1747 {
1748  IgnoreUnused(descriptor);
1749  bool supported = true;
1750  std::array<DataType,7> supportedTypes =
1751  {
1752  DataType::BFloat16,
1753  DataType::Float32,
1754  DataType::Float16,
1755  DataType::QAsymmS8,
1756  DataType::QAsymmU8,
1757  DataType::QSymmS16,
1758  DataType::Signed32
1759  };
1760 
1761  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1762  "Reference Reduce: input type not supported");
1763 
1764  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1765  "Reference Reduce: output type not supported");
1766 
1767  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1768  "Reference Reduce: input and output types not matching");
1769 
1770  return supported;
1771 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsReshapeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1773 of file RefLayerSupport.cpp.

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

1777 {
1778  IgnoreUnused(output);
1779  IgnoreUnused(descriptor);
1780  // Define supported output types.
1781  std::array<DataType,8> supportedOutputTypes =
1782  {
1783  DataType::BFloat16,
1784  DataType::Float32,
1785  DataType::Float16,
1786  DataType::Signed32,
1787  DataType::QAsymmS8,
1788  DataType::QAsymmU8,
1789  DataType::QSymmS16,
1790  DataType::Boolean
1791  };
1792 
1793  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1794  "Reference reshape: input type not supported.");
1795 }
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsResizeBilinearSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1797 of file RefLayerSupport.cpp.

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

1800 {
1801  bool supported = true;
1802  std::array<DataType,6> supportedTypes =
1803  {
1804  DataType::BFloat16,
1805  DataType::Float32,
1806  DataType::Float16,
1807  DataType::QAsymmS8,
1808  DataType::QAsymmU8,
1809  DataType::QSymmS16
1810  };
1811 
1812  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1813  "Reference ResizeBilinear: input type not supported");
1814 
1815  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1816  "Reference ResizeBilinear: output type not supported");
1817 
1818  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1819  "Reference ResizeBilinear: input and output types not matching");
1820 
1821  return supported;
1822 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsResizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1824 of file RefLayerSupport.cpp.

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

1828 {
1829  IgnoreUnused(descriptor);
1830  bool supported = true;
1831  std::array<DataType,6> supportedTypes =
1832  {
1833  DataType::BFloat16,
1834  DataType::Float32,
1835  DataType::Float16,
1836  DataType::QAsymmS8,
1837  DataType::QAsymmU8,
1838  DataType::QSymmS16
1839  };
1840 
1841  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1842  "Reference Resize: input type not supported");
1843 
1844  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1845  "Reference Resize: output type not supported");
1846 
1847  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1848  "Reference Resize: input and output types not matching");
1849 
1850  return supported;
1851 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsRsqrtSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1853 of file RefLayerSupport.cpp.

References RefLayerSupport::IsElementwiseUnarySupported(), and armnn::Rsqrt.

1856 {
1857  return IsElementwiseUnarySupported(input,
1858  output,
1859  ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt),
1860  reasonIfUnsupported);
1861 }
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:825

◆ IsShapeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1863 of file RefLayerSupport.cpp.

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

1866 {
1867  IgnoreUnused(input);
1868  bool supported = true;
1869 
1870  std::array<DataType, 1> supportedTypes =
1871  {
1872  DataType::Signed32
1873  };
1874 
1875  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1876  "Reference Shape: output type not supported");
1877 
1878  return supported;
1879 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSliceSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1881 of file RefLayerSupport.cpp.

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

1885 {
1886  IgnoreUnused(descriptor);
1887  bool supported = true;
1888 
1889  std::array<DataType, 5> supportedTypes =
1890  {
1891  DataType::BFloat16,
1892  DataType::Float32,
1893  DataType::QAsymmS8,
1894  DataType::QAsymmU8,
1895  DataType::QSymmS16
1896  };
1897 
1898  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1899  "Reference Slice: input type not supported");
1900 
1901  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1902  "Reference Slice: output type not supported");
1903 
1904  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1905  "Reference Slice: input and output types are mismatched");
1906 
1907  return supported;
1908 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSoftmaxSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1910 of file RefLayerSupport.cpp.

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

1914 {
1915  IgnoreUnused(descriptor);
1916  bool supported = true;
1917  std::array<DataType,7> supportedTypes =
1918  {
1919  DataType::BFloat16,
1920  DataType::Float32,
1921  DataType::Float16,
1922  DataType::QSymmS8,
1923  DataType::QAsymmS8,
1924  DataType::QAsymmU8,
1925  DataType::QSymmS16
1926  };
1927 
1928  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1929  "Reference Softmax: output type not supported");
1930 
1931  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1932  "Reference Softmax: input type not supported");
1933 
1934  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1935  "Reference Softmax: input type not supported");
1936 
1937  return supported;
1938 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSpaceToBatchNdSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1940 of file RefLayerSupport.cpp.

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

1944 {
1945  IgnoreUnused(descriptor);
1946  bool supported = true;
1947  std::array<DataType,6> supportedTypes =
1948  {
1949  DataType::BFloat16,
1950  DataType::Float32,
1951  DataType::Float16,
1952  DataType::QAsymmS8,
1953  DataType::QAsymmU8,
1954  DataType::QSymmS16
1955  };
1956 
1957  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1958  "Reference SpaceToBatchNd: input type not supported");
1959 
1960  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1961  "Reference SpaceToBatchNd: output type not supported");
1962 
1963  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1964  "Reference SpaceToBatchNd: input and output types are mismatched");
1965 
1966  return supported;
1967 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSpaceToDepthSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1969 of file RefLayerSupport.cpp.

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

1973 {
1974 
1975  IgnoreUnused(descriptor);
1976  bool supported = true;
1977 
1978  std::array<DataType,6> supportedTypes =
1979  {
1980  DataType::BFloat16,
1981  DataType::Float32,
1982  DataType::Float16,
1983  DataType::QAsymmS8,
1984  DataType::QAsymmU8,
1985  DataType::QSymmS16
1986  };
1987 
1988  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1989  "Reference SpaceToDepth: input type not supported");
1990 
1991  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1992  "Reference SpaceToDepth: output type not supported");
1993 
1994  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1995  "Reference SpaceToDepth: input and output types are mismatched");
1996 
1997  return supported;
1998 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSplitterSupported() [1/2]

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

Reimplemented from LayerSupportBase.

Definition at line 2000 of file RefLayerSupport.cpp.

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

2003 {
2004  IgnoreUnused(descriptor);
2005  bool supported = true;
2006  std::array<DataType,6> supportedTypes =
2007  {
2008  DataType::BFloat16,
2009  DataType::Float32,
2010  DataType::Float16,
2011  DataType::QAsymmS8,
2012  DataType::QAsymmU8,
2013  DataType::QSymmS16
2014  };
2015 
2016  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2017  "Reference splitter: input type not supported");
2018 
2019  return supported;
2020 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSplitterSupported() [2/2]

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

Reimplemented from LayerSupportBase.

Definition at line 2022 of file RefLayerSupport.cpp.

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

2026 {
2027  IgnoreUnused(descriptor);
2028  bool supported = true;
2029  std::array<DataType,6> supportedTypes =
2030  {
2031  DataType::BFloat16,
2032  DataType::Float32,
2033  DataType::Float16,
2034  DataType::QAsymmS8,
2035  DataType::QAsymmU8,
2036  DataType::QSymmS16
2037  };
2038 
2039  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2040  "Reference splitter: output type not supported");
2041  for (const TensorInfo& output : outputs)
2042  {
2043  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2044  "Reference splitter: input type not supported");
2045 
2046  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2047  "Reference splitter: input and output types mismatched.");
2048  }
2049 
2050  return supported;
2051 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsStackSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 2053 of file RefLayerSupport.cpp.

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

2057 {
2058  IgnoreUnused(descriptor);
2059 
2060  bool supported = true;
2061  std::array<DataType,6> supportedTypes =
2062  {
2063  DataType::BFloat16,
2064  DataType::Float32,
2065  DataType::Float16,
2066  DataType::QAsymmS8,
2067  DataType::QAsymmU8,
2068  DataType::QSymmS16
2069  };
2070 
2071  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2072  "Reference stack: output type not supported");
2073  for (const TensorInfo* input : inputs)
2074  {
2075  ARMNN_ASSERT(input != nullptr);
2076  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
2077  "Reference stack: input type not supported");
2078 
2079  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
2080  "Reference stack: input and output types mismatched.");
2081  }
2082 
2083  return supported;
2084 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsStridedSliceSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 2086 of file RefLayerSupport.cpp.

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

2090 {
2091  IgnoreUnused(descriptor);
2092  bool supported = true;
2093 
2094  std::array<DataType,5> supportedTypes =
2095  {
2096  DataType::BFloat16,
2097  DataType::Float32,
2098  DataType::QAsymmS8,
2099  DataType::QAsymmU8,
2100  DataType::QSymmS16
2101  };
2102 
2103  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2104  "Reference StridedSlice: input type not supported");
2105 
2106  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2107  "Reference StridedSlice: output type not supported");
2108 
2109  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2110  "Reference StridedSlice: input and output types are mismatched");
2111 
2112  return supported;
2113 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsSubtractionSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 2115 of file RefLayerSupport.cpp.

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

2119 {
2120  bool supported = true;
2121 
2122  std::array<DataType,7> supportedTypes = {
2123  DataType::BFloat16,
2124  DataType::Float32,
2125  DataType::Float16,
2126  DataType::QAsymmS8,
2127  DataType::QAsymmU8,
2128  DataType::QSymmS16,
2129  DataType::Signed32
2130  };
2131 
2132  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2133  "Reference subtraction: input 0 is not a supported type.");
2134 
2135  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2136  "Reference subtraction: input 1 is not a supported type.");
2137 
2138  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2139  "Reference subtraction: output is not a supported type.");
2140 
2141  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2142  "Reference subtraction: input 0 and Input 1 types are mismatched");
2143 
2144  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2145  "Reference subtraction: input and output types are mismatched");
2146 
2147  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2148  "Reference subtraction: shapes are not suitable for implicit broadcast.");
2149 
2150  return supported;
2151 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ 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
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 2188 of file RefLayerSupport.cpp.

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

2194 {
2195  IgnoreUnused(descriptor);
2196  bool supported = true;
2197 
2198  std::array<DataType,7> supportedTypes =
2199  {
2200  DataType::BFloat16,
2201  DataType::Float32,
2202  DataType::Float16,
2203  DataType::QAsymmS8,
2204  DataType::QAsymmU8,
2205  DataType::QSymmS8,
2206  DataType::QSymmS16
2207  };
2208 
2209  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2210  "Reference TransposeConvolution2d: input is not a supported type.");
2211 
2212  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2213  "Reference TransposeConvolution2d: output is not a supported type.");
2214 
2215  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2216  "Reference TransposeConvolution2d: input and output types mismatched.");
2217 
2218 
2219  const DataType inputType = input.GetDataType();
2220  if (IsQuantized8BitType(inputType))
2221  {
2222  ARMNN_NO_DEPRECATE_WARN_BEGIN
2223  std::array<DataType, 4> supportedWeightTypes =
2224  {
2225  DataType::QAsymmS8,
2226  DataType::QAsymmU8,
2227  DataType::QSymmS8,
2228  DataType::QuantizedSymm8PerAxis //Deprecated
2229  };
2230  ARMNN_NO_DEPRECATE_WARN_END
2231 
2232  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
2233  "Reference TransposeConvolution2d: weights type not supported for "
2234  "quantized input.");
2235  }
2236  else
2237  {
2238  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
2239  "Reference TransposeConvolution2d: weights is not a supported type.");
2240 
2241  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
2242  "Reference TransposeConvolution2d: input and weights types mismatched.");
2243  }
2244 
2245  if (biases.has_value())
2246  {
2247  std::array<DataType,4> biasesSupportedTypes =
2248  {
2249  DataType::BFloat16,
2250  DataType::Float32,
2251  DataType::Float16,
2252  DataType::Signed32
2253  };
2254  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
2255  "Reference TransposeConvolution2d: biases is not a supported type.");
2256  }
2257 
2258  return supported;
2259 }
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:267
armnn::DataType
DataType
Definition: Types.hpp:35
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsTransposeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 2261 of file RefLayerSupport.cpp.

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

2265 {
2266  IgnoreUnused(descriptor);
2267  bool supported = true;
2268 
2269  // Define supported output and inputs types.
2270  std::array<DataType, 6> supportedTypes =
2271  {
2272  DataType::BFloat16,
2273  DataType::Float32,
2274  DataType::Float16,
2275  DataType::QAsymmS8,
2276  DataType::QAsymmU8,
2277  DataType::QSymmS16
2278  };
2279 
2280  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2281  "Reference transpose: input is not a supported type.");
2282 
2283  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2284  "Reference transpose: output is not a supported type.");
2285 
2286  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2287  "Reference transpose: input and output types are mismatched.");
2288 
2289  return supported;
2290 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38

◆ IsUnidirectionalSequenceLstmSupported()

bool IsUnidirectionalSequenceLstmSupported ( const TensorInfo &  input,
const TensorInfo &  outputStateIn,
const TensorInfo &  cellStateIn,
const TensorInfo &  output,
const Optional< TensorInfo > &  hiddenStateOutput,
const Optional< TensorInfo > &  cellStateOutput,
const UnidirectionalSequenceLstmDescriptor &  descriptor,
const LstmInputParamsInfo &  paramsInfo,
Optional< std::string &>  reasonIfUnsupported = EmptyOptional() 
) const
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 2292 of file RefLayerSupport.cpp.

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(), OptionalBase::has_value(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

2302 {
2303  IgnoreUnused(descriptor);
2304  IgnoreUnused(paramsInfo);
2305  IgnoreUnused(outputStateIn);
2306  IgnoreUnused(cellStateIn);
2307  bool supported = true;
2308 
2309  if (hiddenStateOutput.has_value() || cellStateOutput.has_value())
2310  {
2311  reasonIfUnsupported.value() += "Reference UnidirectionalSequenceLstm: hidden state output "
2312  "and cell state output are not supported at the moment.";
2313  }
2314 
2315  std::array<DataType, 1> supportedTypes =
2316  {
2317  DataType::Float32
2318  };
2319 
2320  std::array<DataType, 1> supportedWeightTypes =
2321  {
2322  DataType::Float32
2323  };
2324 
2325  // check inputs and outputs
2326  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2327  "Reference UnidirectionalSequenceLstm: input is not a supported type.");
2328  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
2329  "Reference UnidirectionalSequenceLstm: input and outputStateIn types are mismatched");
2330  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
2331  "Reference UnidirectionalSequenceLstm: input and cellStateIn types are mismatched");
2332 
2333  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2334  "Reference UnidirectionalSequenceLstm: input and output types are mismatched");
2335  // check layer parameters
2336  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToForgetWeights(), supportedWeightTypes),
2337  reasonIfUnsupported,
2338  "Reference UnidirectionalSequenceLstm: InputToForgetWeights "
2339  "is not a supported type.");
2340  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToCellWeights(), supportedWeightTypes),
2341  reasonIfUnsupported,
2342  "Reference UnidirectionalSequenceLstm: InputToCellWeights is not a supported type.");
2343  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToOutputWeights(), supportedWeightTypes),
2344  reasonIfUnsupported,
2345  "Reference UnidirectionalSequenceLstm: InputToOutputWeights "
2346  "is not a supported type.");
2347  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToForgetWeights(), supportedWeightTypes),
2348  reasonIfUnsupported,
2349  "Reference UnidirectionalSequenceLstm: RecurrentToForgetWeights "
2350  "is not a supported type.");
2351  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToCellWeights(), supportedWeightTypes),
2352  reasonIfUnsupported,
2353  "Reference UnidirectionalSequenceLstm: RecurrentToCellWeights "
2354  "is not a supported type.");
2355  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToOutputWeights(), supportedWeightTypes),
2356  reasonIfUnsupported,
2357  "Reference UnidirectionalSequenceLstm: RecurrentToOutputWeights "
2358  "is not a supported type.");
2359  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
2360  "Reference UnidirectionalSequenceLstm: input and ForgetGateBias types "
2361  "are mismatched");
2362  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
2363  "Reference UnidirectionalSequenceLstm: input and CellBias types are mismatched");
2364  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
2365  "Reference UnidirectionalSequenceLstm: input and OutputGateBias types "
2366  "are mismatched");
2367  if (!descriptor.m_CifgEnabled)
2368  {
2369  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToInputWeights(), supportedWeightTypes),
2370  reasonIfUnsupported,
2371  "Reference UnidirectionalSequenceLstm: InputToInputWeights "
2372  "is not a supported type.");
2373  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToInputWeights(), supportedWeightTypes),
2374  reasonIfUnsupported,
2375  "Reference UnidirectionalSequenceLstm: RecurrentToInputWeights "
2376  "is not a supported type.");
2377  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
2378  "Reference UnidirectionalSequenceLstm: input and InputGateBias types "
2379  "are mismatched");
2380  if (descriptor.m_PeepholeEnabled)
2381  {
2382  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToInputWeights(), supportedWeightTypes),
2383  reasonIfUnsupported,
2384  "Reference UnidirectionalSequenceLstm: CellToInputWeights "
2385  "is not a supported type.");
2386  }
2387  }
2388  if (descriptor.m_PeepholeEnabled)
2389  {
2390  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToForgetWeights(), supportedWeightTypes),
2391  reasonIfUnsupported,
2392  "Reference UnidirectionalSequenceLstm: CellToForgetWeights "
2393  "is not a supported type.");
2394  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToOutputWeights(), supportedWeightTypes),
2395  reasonIfUnsupported,
2396  "Reference UnidirectionalSequenceLstm: CellToOutputWeights "
2397  "is not a supported type.");
2398  }
2399  if (descriptor.m_ProjectionEnabled)
2400  {
2401  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetProjectionWeights(), supportedWeightTypes),
2402  reasonIfUnsupported,
2403  "Reference UnidirectionalSequenceLstm: ProjectionWeights "
2404  "is not a supported type.");
2405  if (paramsInfo.m_ProjectionBias != nullptr)
2406  {
2407  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
2408  "Reference UnidirectionalSequenceLstm: input and ProjectionBias types "
2409  "are mismatched");
2410  }
2411  }
2412  if (descriptor.m_LayerNormEnabled)
2413  {
2414  if (!descriptor.m_CifgEnabled)
2415  {
2416  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputLayerNormWeights(), supportedWeightTypes),
2417  reasonIfUnsupported,
2418  "Reference UnidirectionalSequenceLstm: InputLayerNormWeights "
2419  "is not a supported type.");
2420  }
2421  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetLayerNormWeights(), supportedWeightTypes),
2422  reasonIfUnsupported,
2423  "Reference UnidirectionalSequenceLstm: ForgetLayerNormWeights "
2424  "is not a supported type.");
2425  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellLayerNormWeights(), supportedWeightTypes),
2426  reasonIfUnsupported,
2427  "Reference UnidirectionalSequenceLstm: CellLayerNormWeights "
2428  "is not a supported type.");
2429  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputLayerNormWeights(), supportedWeightTypes),
2430  reasonIfUnsupported,
2431  "Reference UnidirectionalSequenceLstm: OutputLayerNormWeights "
2432  "is not a supported type.");
2433  }
2434 
2435  return supported;
2436 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38
The documentation for this class was generated from the following files: