ArmNN  NotReleased
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 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 IsConvertFp16ToFp32Supported (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 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, 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 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 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 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
 
- Public Member Functions inherited from LayerSupportBase
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 65 of file RefLayerSupport.cpp.

67 {
68  return IsElementwiseUnarySupported(input,
69  output,
70  ElementwiseUnaryDescriptor(UnaryOperation::Abs),
71  reasonIfUnsupported);
72 }
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:721

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

References armnn::CheckSupportRule(), and ActivationDescriptor::m_Function.

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

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

References armnn::CheckSupportRule().

Referenced by BOOST_AUTO_TEST_CASE().

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

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

References armnn::CheckSupportRule().

178 {
179  ignore_unused(descriptor);
180 
181  std::array<DataType, 4> supportedTypes =
182  {
183  DataType::Float32,
184  DataType::QAsymmU8,
185  DataType::QSymmS16,
186  DataType::Signed32
187  };
188 
189  bool supported = true;
190 
191  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
192  "Reference ArgMinMax: input is not a supported type.");
193  supported &= CheckSupportRule(TypeIs(output, DataType::Signed32), reasonIfUnsupported,
194  "Reference ArgMinMax: output type not supported");
195 
196  return supported;
197 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

207 {
208  ignore_unused(descriptor);
209 
210  std::array<DataType, 4> supportedTypes =
211  {
212  DataType::Float32,
213  DataType::Float16,
214  DataType::QAsymmU8,
215  DataType::QSymmS16
216  };
217 
218  bool supported = true;
219 
220  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
221  "Reference batch normalization: input is not a supported type.");
222 
223  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
224  "Reference batch normalization: output is not a supported type.");
225 
226  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
227  "Reference batch normalization: input and output types are mismatched");
228 
229  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
230  "Reference batch normalization: mean is not a supported type.");
231 
232  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
233  "Reference batch normalization: variance is not a supported type.");
234 
235  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
236  "Reference batch normalization: beta is not a supported type.");
237 
238  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
239  "Reference batch normalization: gamma is not a supported type.");
240 
241  return supported;
242 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule(), and TensorInfo::GetNumDimensions().

248 {
249  ignore_unused(descriptor);
250 
251  bool supported = true;
252 
253  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
254  std::string inputTensorStr = "input";
255  std::string outputTensorStr = "output";
256 
257  // Define supported types.
258  std::array<DataType,4> supportedTypes =
259  {
260  DataType::Float32,
261  DataType::Float16,
262  DataType::QAsymmU8,
263  DataType::QSymmS16
264  };
265 
266  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
267  "Reference BatchToSpaceNd: input type not supported.");
268 
269  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
270  "Reference BatchToSpaceNd: output type not supported.");
271 
272  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
273  "Reference BatchToSpaceNd: input and output types mismatched.");
274 
275  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
276  reasonIfUnsupported,
277  CreateIncorrectDimensionsErrorMsg(4,
278  output.GetNumDimensions(),
279  batchToSpaceNdLayerStr,
280  outputTensorStr).data());
281 
282  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
283  reasonIfUnsupported,
284  CreateIncorrectDimensionsErrorMsg(4,
285  input.GetNumDimensions(),
286  batchToSpaceNdLayerStr,
287  inputTensorStr).data());
288 
289  return supported;
290 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

297 {
298  boost::ignore_unused(descriptor);
299 
300  std::array<DataType, 4> supportedInputTypes =
301  {
302  DataType::Float32,
303  DataType::Float16,
304  DataType::QAsymmU8,
305  DataType::QSymmS16
306  };
307 
308  bool supported = true;
309  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
310  "Reference comparison: input 0 is not a supported type");
311 
312  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
313  "Reference comparison: input 0 and Input 1 types are mismatched");
314 
315  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
316  "Reference comparison: output is not of type Boolean");
317 
318  return supported;
319 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

325 {
326  ignore_unused(descriptor);
327 
328  bool supported = true;
329  std::array<DataType,5> supportedTypes =
330  {
331  DataType::Float32,
332  DataType::Float16,
333  DataType::QAsymmU8,
334  DataType::QAsymmS8,
335  DataType::QSymmS16
336  };
337 
338  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
339  "Reference concatenation: output type not supported");
340  for (const TensorInfo* input : inputs)
341  {
342  BOOST_ASSERT(input != nullptr);
343  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
344  "Reference concatenation: input type not supported");
345 
346  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
347  "Reference concatenation: input and output types mismatched.");
348  }
349 
350  return supported;
351 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsConstantSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 353 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

355 {
356  std::array<DataType,6> supportedTypes =
357  {
358  DataType::Float32,
359  DataType::Signed32,
360  DataType::QAsymmU8,
361  DataType::QAsymmS8,
362  DataType::QSymmS8,
363  DataType::QSymmS16
364  };
365 
366  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
367  "Reference constant: output is not a supported type.");
368 }
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsConvertFp16ToFp32Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 370 of file RefLayerSupport.cpp.

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

373 {
374  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
375  input.GetDataType(),
376  &TrueFunc<>,
377  &FalseInputFuncF32<>,
378  &FalseFuncU8<>,
379  &FalseFuncI32<>,
380  &FalseFuncU8<>) &&
381  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
382  output.GetDataType(),
383  &FalseOutputFuncF16<>,
384  &TrueFunc<>,
385  &FalseFuncU8<>,
386  &FalseFuncI32<>,
387  &FalseFuncU8<>));
388 }
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:28

◆ IsConvertFp32ToFp16Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 390 of file RefLayerSupport.cpp.

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

393 {
394  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
395  input.GetDataType(),
396  &FalseInputFuncF16<>,
397  &TrueFunc<>,
398  &FalseFuncU8<>,
399  &FalseFuncI32<>,
400  &FalseFuncU8<>) &&
401  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
402  output.GetDataType(),
403  &TrueFunc<>,
404  &FalseOutputFuncF32<>,
405  &FalseFuncU8<>,
406  &FalseFuncI32<>,
407  &FalseFuncU8<>));
408 }
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:28

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

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::CheckSupportRule(), TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IsQuantized8BitType(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

416 {
417  bool supported = true;
418 
419  // Define supported types.
420  std::array<DataType,6> supportedTypes =
421  {
422  DataType::Float32,
423  DataType::Float16,
424  DataType::QAsymmU8,
425  DataType::QAsymmS8,
426  DataType::QSymmS8,
427  DataType::QSymmS16
428  };
429 
430  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
431  "Reference Convolution2d: input is not a supported type.");
432 
433  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
434  "Reference Convolution2d: output is not a supported type.");
435 
436  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
437  "Reference Convolution2d: input and output types mismatched.");
438 
439  const DataType inputType = input.GetDataType();
440  if (IsQuantized8BitType(inputType))
441  {
442  ARMNN_NO_DEPRECATE_WARN_BEGIN
443  std::array<DataType, 4> supportedWeightTypes =
444  {
445  DataType::QAsymmU8,
446  DataType::QSymmS8,
447  DataType::QAsymmS8,
448  DataType::QuantizedSymm8PerAxis // deprecated
449  };
450  ARMNN_NO_DEPRECATE_WARN_END
451 
452  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
453  "Reference Convolution2d: weights type not supported for quantized input.");
454  }
455  else
456  {
457  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
458  "Reference Convolution2d: weights is not a supported type.");
459 
460  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
461  "Reference Convolution2d: input and weights types mismatched.");
462  }
463 
464  if (biases.has_value())
465  {
466  std::array<DataType,3> biasesSupportedTypes =
467  {
468  DataType::Float32,
469  DataType::Float16,
470  DataType::Signed32
471  };
472 
473  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
474  "Reference Convolution2d: biases is not a supported type.");
475  }
476  ignore_unused(descriptor);
477 
478  return supported;
479 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
armnn::DataType
DataType
Definition: Types.hpp:32
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:237
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34

◆ IsDebugSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 481 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

484 {
485  bool supported = true;
486 
487  std::array<DataType, 7> supportedTypes =
488  {
489  DataType::Float16,
490  DataType::Float32,
491  DataType::QAsymmU8,
492  DataType::QAsymmS8,
493  DataType::QSymmS8,
494  DataType::QSymmS16,
495  DataType::Signed32
496  };
497 
498  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
499  "Reference for Debug layer: input type not supported");
500 
501  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
502  "Reference for Debug layer: output type not supported");
503 
504  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
505  "Reference for Debug layer: input and output types are mismatched");
506 
507  return supported;
508 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

514 {
515  ignore_unused(descriptor);
516  bool supported = true;
517 
518  std::array<DataType,4> supportedTypes =
519  {
520  DataType::Float32,
521  DataType::Float16,
522  DataType::QAsymmU8,
523  DataType::QSymmS16
524  };
525 
526  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
527  "Reference DepthToSpace: input type not supported");
528 
529  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
530  "Reference DepthToSpace: output type not supported");
531 
532  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
533  "Reference DepthToSpace: input and output types are mismatched");
534 
535  return supported;
536 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::CheckSupportRule(), TensorInfo::GetDataType(), OptionalBase::has_value(), armnn::IsQuantized8BitType(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

544 {
545  bool supported = true;
546 
547  // Define supported types.
548  std::array<DataType,6> supportedTypes =
549  {
550  DataType::Float32,
551  DataType::Float16,
552  DataType::QSymmS8,
553  DataType::QAsymmS8,
554  DataType::QAsymmU8,
555  DataType::QSymmS16
556  };
557 
558  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
559  "Reference DepthwiseConvolution2d: input is not a supported type.");
560 
561  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
562  "Reference DepthwiseConvolution2d: output is not a supported type.");
563 
564  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
565  "Reference DepthwiseConvolution2d: input and output types mismatched.");
566 
567  ARMNN_NO_DEPRECATE_WARN_BEGIN
568  std::array<DataType, 3> supportedWeightTypes =
569  {
570  DataType::QAsymmU8,
571  DataType::QSymmS8,
572  DataType::QuantizedSymm8PerAxis // deprecated
573  };
574  ARMNN_NO_DEPRECATE_WARN_END
575 
576  const DataType inputType = input.GetDataType();
577  if (IsQuantized8BitType(inputType))
578  {
579 
580  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
581  "Reference convolution2d: weights type not supported for quantized input.");
582  }
583  else
584  {
585  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
586  "Reference DepthwiseConvolution2d: weights is not a supported type.");
587 
588  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
589  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
590  }
591 
592  if (biases.has_value())
593  {
594  std::array<DataType,3> biasesSupportedTypes =
595  {
596  DataType::Float32,
597  DataType::Float16,
598  DataType::Signed32
599  };
600  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
601  "Reference DepthwiseConvolution2d: biases is not a supported type.");
602  }
603  ignore_unused(descriptor);
604 
605  return supported;
606 
607 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
armnn::DataType
DataType
Definition: Types.hpp:32
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:237
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34

◆ IsDequantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 609 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

612 {
613  bool supported = true;
614 
615  std::array<DataType,4> supportedInputTypes = {
616  DataType::QAsymmS8,
617  DataType::QAsymmU8,
618  DataType::QSymmS8,
619  DataType::QSymmS16
620  };
621 
622  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
623  "Reference for Dequantize layer: input type not supported.");
624 
625  supported &= CheckSupportRule( TypeNotPerAxisQuantized(input), reasonIfUnsupported,
626  "Reference for Dequantize layer: per-axis quantized input not support .");
627 
628  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
629  "Reference dequantize: per-axis quantized input not support .");
630 
631  std::array<DataType,2> supportedOutputTypes = {
632  DataType::Float32,
633  DataType::Float16
634  };
635 
636  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
637  "Reference for Dequantize layer: output type not supported.");
638 
639  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
640  "Reference for Dequantize layer: input/output shapes have different num total "
641  "elements.");
642 
643  return supported;
644 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

655 {
656  boost::ignore_unused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
657 
658  bool supported = true;
659 
660  std::array<DataType,3> supportedInputTypes =
661  {
662  DataType::Float32,
663  DataType::QAsymmU8,
664  DataType::QSymmS16
665  };
666 
667  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
668  "Reference DetectionPostProcess: input 0 is not a supported type.");
669 
670  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
671  "Reference DetectionPostProcess: input 1 is not a supported type.");
672 
673  return supported;
674 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
scores
std::vector< float > scores({ 0.0f, 0.9f, 0.8f, 0.0f, 0.75f, 0.72f, 0.0f, 0.6f, 0.5f, 0.0f, 0.93f, 0.95f, 0.0f, 0.5f, 0.4f, 0.0f, 0.3f, 0.2f })
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
boxEncodings
std::vector< float > boxEncodings({ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f })
anchors
std::vector< float > anchors({ 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 100.5f, 1.0f, 1.0f })

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

References armnn::IsDepthwiseConvolutionSupported().

682 {
683  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
684 }
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:538

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

References armnn::CheckSupportRule().

690 {
691  bool supported = true;
692 
693  std::array<DataType,4> supportedTypes = {
694  DataType::Float32,
695  DataType::Float16,
696  DataType::QAsymmU8,
697  DataType::QSymmS16
698  };
699 
700  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
701  "Reference division: input 0 is not a supported type.");
702 
703  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
704  "Reference division: input 1 is not a supported type.");
705 
706  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
707  "Reference division: output is not a supported type.");
708 
709  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
710  "Reference division: input 0 and Input 1 types are mismatched");
711 
712  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
713  "Reference division: input and output types are mismatched");
714 
715  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
716  "Reference division: shapes are not suitable for implicit broadcast.");
717 
718  return supported;
719 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

725 {
726  boost::ignore_unused(descriptor);
727 
728  std::array<DataType, 4> supportedTypes =
729  {
730  DataType::Float32,
731  DataType::Float16,
732  DataType::QAsymmU8,
733  DataType::QSymmS16
734  };
735 
736  bool supported = true;
737 
738  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
739  "Reference elementwise unary: input type not supported");
740 
741  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
742  "Reference elementwise unary: output type not supported");
743 
744  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
745  "Reference elementwise unary: input and output types not matching");
746 
747  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
748  "Reference elementwise unary: input and output shapes"
749  "have different number of total elements");
750 
751  return supported;
752 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

758 {
759  return IsComparisonSupported(input0,
760  input1,
761  output,
762  ComparisonDescriptor(ComparisonOperation::Equal),
763  reasonIfUnsupported);
764 }
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:292

◆ IsFakeQuantizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 766 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

769 {
770  ignore_unused(descriptor);
771  bool supported = true;
772 
773  std::array<DataType,1> supportedTypes =
774  {
775  DataType::Float32
776  };
777 
778  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
779  "Reference fake quantization: input type not supported.");
780 
781  return supported;
782 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsFloorSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 784 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

787 {
788  ignore_unused(output);
789  bool supported = true;
790 
791  std::array<DataType,3> supportedTypes =
792  {
793  DataType::Float32,
794  DataType::Float16,
795  DataType::QSymmS16
796  };
797 
798  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
799  "Reference Floor: input type not supported.");
800 
801  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
802  "Reference Floor: output type not supported.");
803 
804  return supported;
805 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule(), and FullyConnectedDescriptor::m_BiasEnabled.

813 {
814  bool supported = true;
815 
816  // Define supported types.
817  std::array<DataType,4> supportedTypes =
818  {
819  DataType::Float32,
820  DataType::Float16,
821  DataType::QAsymmU8,
822  DataType::QSymmS16
823  };
824 
825  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
826  "Reference Fully Connected: input type not supported.");
827 
828  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
829  "Reference Fully Connected: output type not supported.");
830 
831  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
832  "Reference Fully Connected: input and output types mismatched.");
833 
834  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
835  "Reference Fully Connected: weights type not supported.");
836 
837  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
838  "Reference Fully Connected: input and weight types mismatched.");
839 
840  if (descriptor.m_BiasEnabled)
841  {
842  // Defined supported types for bias
843  std::array<DataType, 3>
844  supportedBiasTypes =
845  {
846  DataType::Float32,
847  DataType::Float16,
848  DataType::Signed32
849  };
850 
851  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
852  "Reference Fully Connected: bias type not supported.");
853 
854  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
855  "Reference Fully Connected: bias and weight types mismatch.");
856 
857  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
858  "Reference Fully Connected: bias type inferred from weights is incompatible.");
859 
860  }
861 
862  return supported;
863 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsGatherSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 865 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

869 {
870  bool supported = true;
871  std::array<DataType,4> supportedTypes =
872  {
873  DataType::Float32,
874  DataType::Float16,
875  DataType::QAsymmU8,
876  DataType::QSymmS16
877  };
878 
879  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
880  "Reference Gather: input type not supported");
881 
882  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
883  "Reference Gather: output type not supported");
884 
885  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
886  "Reference Gather: indices (input1) type not supported");
887 
888  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
889  "Reference Gather: input and output types not matching");
890 
891  return supported;
892 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

898 {
899  return IsComparisonSupported(input0,
900  input1,
901  output,
902  ComparisonDescriptor(ComparisonOperation::Greater),
903  reasonIfUnsupported);
904 }
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:292

◆ IsInputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 906 of file RefLayerSupport.cpp.

908 {
909  return true;
910 }

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

References armnn::CheckSupportRule().

916 {
917  ignore_unused(descriptor);
918  // Define supported types
919  std::array<DataType, 4> supportedTypes =
920  {
921  DataType::Float32,
922  DataType::Float16
923  };
924 
925  bool supported = true;
926 
927  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
928  "Reference Instance Normalization: input type not supported.");
929 
930  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
931  "Reference Instance Normalization: output type not supported.");
932 
933  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
934  "Reference Instance Normalization: input and output types mismatched.");
935 
936  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
937  "Reference Instance Normalization: input and output shapes have different "
938  "num total elements.");
939 
940  return supported;
941 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

947 {
948  ignore_unused(descriptor);
949  // Define supported types
950  std::array<DataType, 4> supportedTypes =
951  {
952  DataType::Float32,
953  DataType::Float16,
954  DataType::QAsymmU8,
955  DataType::QSymmS16
956  };
957 
958  bool supported = true;
959 
960  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
961  "Reference L2normalization: input type not supported.");
962 
963  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
964  "Reference L2normalization: output type not supported.");
965 
966  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
967  "Reference L2normalization: input and output types mismatched.");
968 
969  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
970  "Reference L2normalization: input and output shapes have different "
971  "num total elements.");
972 
973  return supported;
974 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsLogSoftmaxSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 976 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

980 {
981  ignore_unused(descriptor);
982 
983  std::array<DataType, 2> supportedTypes =
984  {
985  DataType::Float32,
986  DataType::Float16
987  };
988 
989  bool supported = true;
990  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
991  "Reference LogSoftmax: input type not supported");
992 
993  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
994  "Reference LogSoftmax: output type not supported");
995 
996  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
997  "Reference LogSoftmax: input and output types do not match");
998 
999  return supported;
1000 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule(), 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(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, and LstmDescriptor::m_ProjectionEnabled.

1012 {
1013  ignore_unused(descriptor);
1014  ignore_unused(paramsInfo);
1015 
1016  bool supported = true;
1017 
1018  std::array<DataType,2> supportedTypes = {
1019  DataType::Float32,
1020  DataType::QSymmS16
1021  };
1022 
1023  // check inputs and outputs
1024  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1025  "Reference Lstm: input is not a supported type.");
1026  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1027  "Reference Lstm: input and outputStateIn types are mismatched");
1028  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1029  "Reference Lstm: input and cellStateIn types are mismatched");
1030  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1031  "Reference Lstm: input and scratchBuffer types are mismatched");
1032  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1033  "Reference Lstm: input and outputStateOut types are mismatched");
1034  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1035  "Reference Lstm: input and cellStateOut types are mismatched");
1036  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1037  "Reference Lstm: input and output types are mismatched");
1038  // check layer parameters
1039  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
1040  "Reference Lstm: input and InputToForgetWeights types are mismatched");
1041  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
1042  "Reference Lstm: input and InputToCellWeights types are mismatched");
1043  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
1044  "Reference Lstm: input and InputToOutputWeights types are mismatched");
1045  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
1046  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
1047  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
1048  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
1049  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
1050  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
1051  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
1052  "Reference Lstm: input and ForgetGateBias types are mismatched");
1053  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
1054  "Reference Lstm: input and CellBias types are mismatched");
1055  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
1056  "Reference Lstm: input and OutputGateBias types are mismatched");
1057  if (!descriptor.m_CifgEnabled)
1058  {
1059  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
1060  "Reference Lstm: input and InputToInputWeights types are mismatched");
1061  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
1062  reasonIfUnsupported,
1063  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
1064  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
1065  "Reference Lstm: input and InputGateBias types are mismatched");
1066  if (descriptor.m_PeepholeEnabled)
1067  {
1068  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
1069  reasonIfUnsupported,
1070  "Reference Lstm: input and CellToInputWeights types are mismatched");
1071  }
1072  }
1073  if (descriptor.m_PeepholeEnabled)
1074  {
1075  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
1076  "Reference Lstm: input and CellToForgetWeights types are mismatched");
1077  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
1078  "Reference Lstm: input and CellToOutputWeights types are mismatched");
1079  }
1080  if (descriptor.m_ProjectionEnabled)
1081  {
1082  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
1083  "Reference Lstm: input and mProjectionWeights types are mismatched");
1084  if (paramsInfo.m_ProjectionBias != nullptr)
1085  {
1086  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
1087  "Reference Lstm: input and ProjectionBias types are mismatched");
1088  }
1089  }
1090  if (descriptor.m_LayerNormEnabled)
1091  {
1092  if (!descriptor.m_CifgEnabled)
1093  {
1094  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
1095  reasonIfUnsupported,
1096  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1097  }
1098  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
1099  reasonIfUnsupported,
1100  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
1101  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
1102  reasonIfUnsupported,
1103  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
1104  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
1105  reasonIfUnsupported,
1106  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1107  }
1108 
1109  return supported;
1110 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1116 {
1117  bool supported = true;
1118 
1119  std::array<DataType,5> supportedTypes = {
1120  DataType::Float32,
1121  DataType::Float16,
1122  DataType::QAsymmS8,
1123  DataType::QAsymmU8,
1124  DataType::QSymmS16
1125  };
1126 
1127  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1128  "Reference maximum: input 0 is not a supported type.");
1129 
1130  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1131  "Reference maximum: input 1 is not a supported type.");
1132 
1133  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1134  "Reference maximum: output is not a supported type.");
1135 
1136  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1137  "Reference maximum: input 0 and Input 1 types are mismatched");
1138 
1139  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1140  "Reference maximum: input and output types are mismatched");
1141 
1142  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1143  "Reference maximum: shapes are not suitable for implicit broadcast.");
1144 
1145  return supported;
1146 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule(), TensorInfo::GetNumDimensions(), MeanDescriptor::m_Axis, and MeanDescriptor::m_KeepDims.

1152 {
1153  bool supported = true;
1154  std::string meanLayerStr = "Mean";
1155  std::string outputTensorStr = "output";
1156 
1157  std::array<DataType,4> supportedTypes =
1158  {
1159  DataType::Float32,
1160  DataType::Float16,
1161  DataType::QAsymmU8,
1162  DataType::QSymmS16
1163  };
1164 
1165  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1166  "Reference Mean: input type not supported.");
1167 
1168  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1169  "Reference Mean: input and output types are mismatched");
1170 
1171  if (descriptor.m_KeepDims)
1172  {
1173  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1174  reasonIfUnsupported,
1175  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1176  output.GetNumDimensions(),
1177  meanLayerStr, outputTensorStr).data());
1178  }
1179  else if (descriptor.m_Axis.empty())
1180  {
1181  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1182  reasonIfUnsupported,
1183  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1184  meanLayerStr, outputTensorStr).data());
1185  }
1186  else
1187  {
1188  auto outputDim = input.GetNumDimensions() - boost::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1189 
1190  if (outputDim > 0)
1191  {
1192  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1193  reasonIfUnsupported,
1194  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1195  meanLayerStr, outputTensorStr).data());
1196  }
1197  else
1198  {
1199  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1200  reasonIfUnsupported,
1201  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1202  meanLayerStr, outputTensorStr).data());
1203  }
1204  }
1205 
1206  return supported;
1207 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsMemCopySupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1217 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1220 {
1221  bool supported = true;
1222 
1223  std::array<DataType,5> supportedTypes =
1224  {
1225  DataType::Float32,
1226  DataType::Float16,
1227  DataType::QAsymmU8,
1228  DataType::QSymmS16,
1229  DataType::Boolean
1230  };
1231 
1232  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1233  "Reference MemCopy: input type not supported");
1234 
1235  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1236  "Reference MemCopy: output type not supported");
1237 
1238  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1239  "Reference MemCopy: input and output types are mismatched");
1240 
1241  return supported;
1242 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::IsConcatSupported().

1213 {
1214  return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
1215 }
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:321

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

References armnn::CheckSupportRule().

1248 {
1249  bool supported = true;
1250 
1251  std::array<DataType,4> supportedTypes = {
1252  DataType::Float32,
1253  DataType::Float16,
1254  DataType::QAsymmU8,
1255  DataType::QSymmS16
1256  };
1257 
1258  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1259  "Reference minimum: input 0 is not a supported type.");
1260 
1261  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1262  "Reference minimum: input 1 is not a supported type.");
1263 
1264  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1265  "Reference minimum: output is not a supported type.");
1266 
1267  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1268  "Reference minimum: input 0 and Input 1 types are mismatched");
1269 
1270  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1271  "Reference minimum: input and output types are mismatched");
1272 
1273  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1274  "Reference minimum: shapes are not suitable for implicit broadcast.");
1275 
1276  return supported;
1277 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1283 {
1284  bool supported = true;
1285 
1286  std::array<DataType,6> supportedTypes = {
1287  DataType::Float32,
1288  DataType::Float16,
1289  DataType::QAsymmU8,
1290  DataType::QAsymmS8,
1291  DataType::QSymmS16
1292  };
1293 
1294  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1295  "Reference multiplication: input 0 is not a supported type.");
1296 
1297  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1298  "Reference multiplication: input 1 is not a supported type.");
1299 
1300  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1301  "Reference multiplication: output is not a supported type.");
1302 
1303  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1304  "Reference multiplication: input 0 and Input 1 types are mismatched");
1305 
1306  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1307  "Reference multiplication: input and output types are mismatched");
1308 
1309  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1310  "Reference multiplication: shapes are not suitable for implicit broadcast.");
1311 
1312  return supported;
1313 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1319 {
1320  ignore_unused(descriptor);
1321 
1322  // Define supported types
1323  std::array<DataType, 4> supportedTypes =
1324  {
1325  DataType::Float16,
1326  DataType::Float32,
1327  DataType::QAsymmU8,
1328  DataType::QSymmS16
1329  };
1330 
1331  bool supported = true;
1332 
1333  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1334  "Reference normalization: input type not supported.");
1335 
1336  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1337  "Reference normalization: output type not supported.");
1338 
1339  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1340  "Reference normalization: input and output shapes have different "
1341  "num total elements.");
1342 
1343  return supported;
1344 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsOutputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1346 of file RefLayerSupport.cpp.

1348 {
1349  return true;
1350 }

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

References armnn::CheckSupportRule().

1356 {
1357  ignore_unused(descriptor);
1358  bool supported = true;
1359 
1360  // Define supported output and inputs types.
1361  std::array<DataType,4> supportedTypes =
1362  {
1363  DataType::Float32,
1364  DataType::Float16,
1365  DataType::QAsymmU8,
1366  DataType::QSymmS16
1367  };
1368 
1369  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1370  "Reference pad: input is not a supported type.");
1371 
1372  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1373  "Reference pad: output is not a supported type.");
1374 
1375  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1376  "Reference pad: input and output types are mismatched.");
1377 
1378  return supported;
1379 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1385 {
1386  ignore_unused(descriptor);
1387  bool supported = true;
1388 
1389  // Define supported output and inputs types.
1390  std::array<DataType,3> supportedTypes =
1391  {
1392  DataType::Float32,
1393  DataType::QAsymmU8,
1394  DataType::QSymmS16
1395  };
1396 
1397  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1398  "Reference permute: input is not a supported type.");
1399 
1400  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1401  "Reference permute: output is not a supported type.");
1402 
1403  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1404  "Reference permute: input and output types are mismatched.");
1405 
1406  return supported;
1407 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1413 {
1414  ignore_unused(descriptor);
1415  bool supported = true;
1416 
1417  // Define supported output and inputs types.
1418  std::array<DataType,5> supportedTypes =
1419  {
1420  DataType::Float32,
1421  DataType::Float16,
1422  DataType::QAsymmS8,
1423  DataType::QAsymmU8,
1424  DataType::QSymmS16
1425  };
1426 
1427  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1428  "Reference poolind2d: input is not a supported type.");
1429 
1430  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1431  "Reference poolind2d: output is not a supported type.");
1432 
1433  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1434  "Reference poolind2d: input and output types are mismatched.");
1435 
1436  return supported;
1437 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1817 {
1818  bool supported = true;
1819 
1820  std::array<DataType, 4> supportedTypes
1821  {
1822  DataType::Float32,
1823  DataType::Float16,
1824  DataType::QAsymmU8,
1825  DataType::QSymmS16
1826  };
1827 
1828  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1829  "PReLU: input is not a supported type.");
1830 
1831  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
1832  "PReLU: alpha is not a supported type.");
1833 
1834  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1835  "PReLU: output is not a supported type.");
1836 
1837  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
1838  "PReLU: input, alpha and output types are mismatched");
1839 
1840  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
1841  "PReLU: shapes are not suitable for implicit broadcast");
1842 
1843  return supported;
1844 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsQuantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1439 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1442 {
1443  bool supported = true;
1444 
1445  // Define supported input types.
1446  std::array<DataType,6> supportedInputTypes = {
1447  DataType::Float32,
1448  DataType::Float16,
1449  DataType::QAsymmS8,
1450  DataType::QAsymmU8,
1451  DataType::QSymmS8,
1452  DataType::QSymmS16
1453  };
1454 
1455  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1456  "Reference quantize: input type not supported.");
1457 
1458  // Define supported output types.
1459  std::array<DataType,4> supportedOutputTypes = {
1460  DataType::QAsymmU8,
1461  DataType::QAsymmS8,
1462  DataType::QSymmS8,
1463  DataType::QSymmS16
1464  };
1465  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1466  "Reference quantize: output type not supported.");
1467 
1468  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1469  "Reference quantize: input and output shapes have different num total elements.");
1470 
1471  return supported;
1472 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1478 {
1479  ignore_unused(output);
1480  ignore_unused(descriptor);
1481  // Define supported output types.
1482  std::array<DataType,7> supportedOutputTypes =
1483  {
1484  DataType::Float32,
1485  DataType::Float16,
1486  DataType::Signed32,
1487  DataType::QAsymmS8,
1488  DataType::QAsymmU8,
1489  DataType::QSymmS16
1490  };
1491 
1492  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1493  "Reference reshape: input type not supported.");
1494 }
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsResizeBilinearSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1496 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1499 {
1500  bool supported = true;
1501  std::array<DataType,4> supportedTypes =
1502  {
1503  DataType::Float32,
1504  DataType::Float16,
1505  DataType::QAsymmU8,
1506  DataType::QSymmS16
1507  };
1508 
1509  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1510  "Reference ResizeBilinear: input type not supported");
1511 
1512  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1513  "Reference ResizeBilinear: output type not supported");
1514 
1515  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1516  "Reference ResizeBilinear: input and output types not matching");
1517 
1518  return supported;
1519 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1525 {
1526  boost::ignore_unused(descriptor);
1527  bool supported = true;
1528  std::array<DataType,5> supportedTypes =
1529  {
1530  DataType::Float32,
1531  DataType::Float16,
1532  DataType::QAsymmU8,
1533  DataType::QAsymmS8,
1534  DataType::QSymmS16
1535  };
1536 
1537  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1538  "Reference Resize: input type not supported");
1539 
1540  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1541  "Reference Resize: output type not supported");
1542 
1543  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1544  "Reference Resize: input and output types not matching");
1545 
1546  return supported;
1547 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsRsqrtSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1549 of file RefLayerSupport.cpp.

1552 {
1553  return IsElementwiseUnarySupported(input,
1554  output,
1555  ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt),
1556  reasonIfUnsupported);
1557 }
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:721

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

References armnn::CheckSupportRule().

1563 {
1564  boost::ignore_unused(descriptor);
1565  bool supported = true;
1566 
1567  std::array<DataType, 3> supportedTypes =
1568  {
1569  DataType::Float32,
1570  DataType::QAsymmU8,
1571  DataType::QSymmS16
1572  };
1573 
1574  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1575  "Reference Slice: input type not supported");
1576 
1577  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1578  "Reference Slice: output type not supported");
1579 
1580  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1581  "Reference Slice: input and output types are mismatched");
1582 
1583  return supported;
1584 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1590 {
1591  boost::ignore_unused(descriptor);
1592  bool supported = true;
1593  std::array<DataType,6> supportedTypes =
1594  {
1595  DataType::Float32,
1596  DataType::Float16,
1597  DataType::QSymmS8,
1598  DataType::QAsymmS8,
1599  DataType::QAsymmU8,
1600  DataType::QSymmS16
1601  };
1602 
1603  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1604  "Reference Softmax: output type not supported");
1605 
1606  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1607  "Reference Softmax: input type not supported");
1608 
1609  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1610  "Reference Softmax: input type not supported");
1611 
1612  return supported;
1613 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1619 {
1620  boost::ignore_unused(descriptor);
1621  bool supported = true;
1622  std::array<DataType,4> supportedTypes =
1623  {
1624  DataType::Float32,
1625  DataType::Float16,
1626  DataType::QAsymmU8,
1627  DataType::QSymmS16
1628  };
1629 
1630  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1631  "Reference SpaceToBatchNd: input type not supported");
1632 
1633  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1634  "Reference SpaceToBatchNd: output type not supported");
1635 
1636  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1637  "Reference SpaceToBatchNd: input and output types are mismatched");
1638 
1639  return supported;
1640 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1646 {
1647 
1648  ignore_unused(descriptor);
1649  bool supported = true;
1650 
1651  std::array<DataType,4> supportedTypes =
1652  {
1653  DataType::Float32,
1654  DataType::Float16,
1655  DataType::QAsymmU8,
1656  DataType::QSymmS16
1657  };
1658 
1659  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1660  "Reference SpaceToDepth: input type not supported");
1661 
1662  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1663  "Reference SpaceToDepth: output type not supported");
1664 
1665  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1666  "Reference SpaceToDepth: input and output types are mismatched");
1667 
1668  return supported;
1669 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsSplitterSupported() [1/2]

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

Reimplemented from LayerSupportBase.

Definition at line 1671 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1674 {
1675  ignore_unused(descriptor);
1676  bool supported = true;
1677  std::array<DataType,4> supportedTypes =
1678  {
1679  DataType::Float32,
1680  DataType::Float16,
1681  DataType::QAsymmU8,
1682  DataType::QSymmS16
1683  };
1684 
1685  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1686  "Reference splitter: input type not supported");
1687 
1688  return supported;
1689 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1695 {
1696  ignore_unused(descriptor);
1697  bool supported = true;
1698  std::array<DataType,4> supportedTypes =
1699  {
1700  DataType::Float32,
1701  DataType::Float16,
1702  DataType::QAsymmU8,
1703  DataType::QSymmS16
1704  };
1705 
1706  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1707  "Reference splitter: output type not supported");
1708  for (const TensorInfo output : outputs)
1709  {
1710  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1711  "Reference splitter: input type not supported");
1712 
1713  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1714  "Reference splitter: input and output types mismatched.");
1715  }
1716 
1717  return supported;
1718 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1724 {
1725  ignore_unused(descriptor);
1726 
1727  bool supported = true;
1728  std::array<DataType,4> supportedTypes =
1729  {
1730  DataType::Float32,
1731  DataType::Float16,
1732  DataType::QAsymmU8,
1733  DataType::QSymmS16
1734  };
1735 
1736  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1737  "Reference stack: output type not supported");
1738  for (const TensorInfo* input : inputs)
1739  {
1740  BOOST_ASSERT(input != nullptr);
1741  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
1742  "Reference stack: input type not supported");
1743 
1744  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
1745  "Reference stack: input and output types mismatched.");
1746  }
1747 
1748  return supported;
1749 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1755 {
1756  ignore_unused(descriptor);
1757  bool supported = true;
1758 
1759  std::array<DataType,3> supportedTypes =
1760  {
1761  DataType::Float32,
1762  DataType::QAsymmU8,
1763  DataType::QSymmS16
1764  };
1765 
1766  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1767  "Reference StridedSlice: input type not supported");
1768 
1769  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1770  "Reference StridedSlice: output type not supported");
1771 
1772  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1773  "Reference StridedSlice: input and output types are mismatched");
1774 
1775  return supported;
1776 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References armnn::CheckSupportRule().

1782 {
1783  bool supported = true;
1784 
1785  std::array<DataType,4> supportedTypes = {
1786  DataType::Float32,
1787  DataType::Float16,
1788  DataType::QAsymmU8,
1789  DataType::QSymmS16
1790  };
1791 
1792  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1793  "Reference subtraction: input 0 is not a supported type.");
1794 
1795  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1796  "Reference subtraction: input 1 is not a supported type.");
1797 
1798  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1799  "Reference subtraction: output is not a supported type.");
1800 
1801  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1802  "Reference subtraction: input 0 and Input 1 types are mismatched");
1803 
1804  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1805  "Reference subtraction: input and output types are mismatched");
1806 
1807  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1808  "Reference subtraction: shapes are not suitable for implicit broadcast.");
1809 
1810  return supported;
1811 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

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

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::CheckSupportRule(), TensorInfo::GetDataType(), OptionalBase::has_value(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

1852 {
1853  boost::ignore_unused(descriptor);
1854  bool supported = true;
1855 
1856  std::array<DataType,4> supportedTypes =
1857  {
1858  DataType::Float32,
1859  DataType::Float16,
1860  DataType::QAsymmU8,
1861  DataType::QSymmS16
1862  };
1863 
1864  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1865  "Reference TransposeConvolution2d: input is not a supported type.");
1866 
1867  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1868  "Reference TransposeConvolution2d: output is not a supported type.");
1869 
1870  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1871  "Reference TransposeConvolution2d: input and output types mismatched.");
1872 
1873 
1874  const DataType inputType = input.GetDataType();
1875  if (inputType == DataType::QAsymmU8)
1876  {
1877  ARMNN_NO_DEPRECATE_WARN_BEGIN
1878  std::array<DataType, 3> supportedWeightTypes =
1879  {
1880  DataType::QAsymmU8,
1881  DataType::QSymmS8,
1882  DataType::QuantizedSymm8PerAxis //Deprecated
1883  };
1884  ARMNN_NO_DEPRECATE_WARN_END
1885 
1886  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1887  "Reference TransposeConvolution2d: weights type not supported for "
1888  "quantized input.");
1889  }
1890  else
1891  {
1892  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1893  "Reference TransposeConvolution2d: weights is not a supported type.");
1894 
1895  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1896  "Reference TransposeConvolution2d: input and weights types mismatched.");
1897  }
1898 
1899  if (biases.has_value())
1900  {
1901  std::array<DataType,3> biasesSupportedTypes =
1902  {
1903  DataType::Float32,
1904  DataType::Float16,
1905  DataType::Signed32
1906  };
1907  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1908  "Reference TransposeConvolution2d: biases is not a supported type.");
1909  }
1910 
1911  return supported;
1912 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
armnn::DataType
DataType
Definition: Types.hpp:32
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
The documentation for this class was generated from the following files: