ArmNN
 20.02
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
 
bool IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, 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 64 of file RefLayerSupport.cpp.

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

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

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

77 {
78  bool supported = true;
79 
80  // Define supported types.
81  std::array<DataType,6> supportedTypes = {
82  DataType::BFloat16,
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::Elu:
112  case ActivationFunction::HardSwish:
113  case ActivationFunction::LeakyReLu:
114  case ActivationFunction::Linear:
115  case ActivationFunction::ReLu:
116  case ActivationFunction::Sigmoid:
117  case ActivationFunction::SoftReLu:
118  case ActivationFunction::Sqrt:
119  case ActivationFunction::Square:
120  case ActivationFunction::TanH:
121  {
122  m_Res = true;
123  break;
124  }
125  default:
126  {
127  m_Res = false;
128  break;
129  }
130  }
131  }
132  };
133 
134  // Function is supported
135  supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
136  "Reference activation: function not supported.");
137 
138  return supported;
139 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::ActivationFunction::BoundedReLu
min(a, max(b, input)) ReLu1 & ReLu6.
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 141 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

Referenced by BOOST_AUTO_TEST_CASE().

145 {
146  bool supported = true;
147 
148  std::array<DataType,6> supportedTypes = {
149  DataType::BFloat16,
150  DataType::Float32,
151  DataType::Float16,
152  DataType::QAsymmS8,
153  DataType::QAsymmU8,
154  DataType::QSymmS16
155  };
156 
157  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
158  "Reference addition: input 0 is not a supported type.");
159 
160  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
161  "Reference addition: input 1 is not a supported type.");
162 
163  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
164  "Reference addition: output is not a supported type.");
165 
166  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
167  "Reference addition: input 0 and Input 1 types are mismatched");
168 
169  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
170  "Reference addition: input and output types are mismatched");
171 
172  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
173  "Reference addition: shapes are not suitable for implicit broadcast.");
174 
175  return supported;
176 }
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 178 of file RefLayerSupport.cpp.

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

181 {
182  IgnoreUnused(descriptor);
183 
184  std::array<DataType, 5> supportedTypes =
185  {
186  DataType::BFloat16,
187  DataType::Float32,
188  DataType::QAsymmU8,
189  DataType::QSymmS16,
190  DataType::Signed32
191  };
192 
193  bool supported = true;
194 
195  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
196  "Reference ArgMinMax: input is not a supported type.");
197  supported &= CheckSupportRule(TypeIs(output, DataType::Signed32), reasonIfUnsupported,
198  "Reference ArgMinMax: output type not supported");
199 
200  return supported;
201 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 203 of file RefLayerSupport.cpp.

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

211 {
212  IgnoreUnused(descriptor);
213 
214  std::array<DataType, 5> supportedTypes =
215  {
216  DataType::BFloat16,
217  DataType::Float32,
218  DataType::Float16,
219  DataType::QAsymmU8,
220  DataType::QSymmS16
221  };
222 
223  bool supported = true;
224 
225  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
226  "Reference batch normalization: input is not a supported type.");
227 
228  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
229  "Reference batch normalization: output is not a supported type.");
230 
231  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
232  "Reference batch normalization: input and output types are mismatched");
233 
234  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
235  "Reference batch normalization: mean is not a supported type.");
236 
237  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
238  "Reference batch normalization: variance is not a supported type.");
239 
240  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
241  "Reference batch normalization: beta is not a supported type.");
242 
243  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
244  "Reference batch normalization: gamma is not a supported type.");
245 
246  return supported;
247 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 249 of file RefLayerSupport.cpp.

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

253 {
254  IgnoreUnused(descriptor);
255 
256  bool supported = true;
257 
258  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
259  std::string inputTensorStr = "input";
260  std::string outputTensorStr = "output";
261 
262  // Define supported types.
263  std::array<DataType,5> supportedTypes =
264  {
265  DataType::BFloat16,
266  DataType::Float32,
267  DataType::Float16,
268  DataType::QAsymmU8,
269  DataType::QSymmS16
270  };
271 
272  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
273  "Reference BatchToSpaceNd: input type not supported.");
274 
275  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
276  "Reference BatchToSpaceNd: output type not supported.");
277 
278  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
279  "Reference BatchToSpaceNd: input and output types mismatched.");
280 
281  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
282  reasonIfUnsupported,
283  CreateIncorrectDimensionsErrorMsg(4,
284  output.GetNumDimensions(),
285  batchToSpaceNdLayerStr,
286  outputTensorStr).data());
287 
288  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
289  reasonIfUnsupported,
290  CreateIncorrectDimensionsErrorMsg(4,
291  input.GetNumDimensions(),
292  batchToSpaceNdLayerStr,
293  inputTensorStr).data());
294 
295  return supported;
296 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 298 of file RefLayerSupport.cpp.

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

303 {
304  IgnoreUnused(descriptor);
305 
306  std::array<DataType, 5> supportedInputTypes =
307  {
308  DataType::BFloat16,
309  DataType::Float32,
310  DataType::Float16,
311  DataType::QAsymmU8,
312  DataType::QSymmS16
313  };
314 
315  bool supported = true;
316  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
317  "Reference comparison: input 0 is not a supported type");
318 
319  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
320  "Reference comparison: input 0 and Input 1 types are mismatched");
321 
322  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
323  "Reference comparison: output is not of type Boolean");
324 
325  return supported;
326 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 328 of file RefLayerSupport.cpp.

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

332 {
333  IgnoreUnused(descriptor);
334 
335  bool supported = true;
336  std::array<DataType,6> supportedTypes =
337  {
338  DataType::BFloat16,
339  DataType::Float32,
340  DataType::Float16,
341  DataType::QAsymmU8,
342  DataType::QAsymmS8,
343  DataType::QSymmS16
344  };
345 
346  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
347  "Reference concatenation: output type not supported");
348  for (const TensorInfo* input : inputs)
349  {
350  BOOST_ASSERT(input != nullptr);
351  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
352  "Reference concatenation: input type not supported");
353 
354  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
355  "Reference concatenation: input and output types mismatched.");
356  }
357 
358  return supported;
359 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsConstantSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 361 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

363 {
364  std::array<DataType,7> supportedTypes =
365  {
366  DataType::BFloat16,
367  DataType::Float32,
368  DataType::Signed32,
369  DataType::QAsymmU8,
370  DataType::QAsymmS8,
371  DataType::QSymmS8,
372  DataType::QSymmS16
373  };
374 
375  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
376  "Reference constant: output is not a supported type.");
377 }
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 379 of file RefLayerSupport.cpp.

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

382 {
383  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
384  input.GetDataType(),
385  &TrueFunc<>,
386  &FalseInputFuncF32<>,
387  &FalseFuncU8<>,
388  &FalseFuncI32<>,
389  &FalseFuncU8<>) &&
390  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
391  output.GetDataType(),
392  &FalseOutputFuncF16<>,
393  &TrueFunc<>,
394  &FalseFuncU8<>,
395  &FalseFuncI32<>,
396  &FalseFuncU8<>));
397 }
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string &> reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27

◆ IsConvertFp32ToFp16Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 399 of file RefLayerSupport.cpp.

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

402 {
403  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
404  input.GetDataType(),
405  &FalseInputFuncF16<>,
406  &TrueFunc<>,
407  &FalseFuncU8<>,
408  &FalseFuncI32<>,
409  &FalseFuncU8<>) &&
410  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
411  output.GetDataType(),
412  &TrueFunc<>,
413  &FalseOutputFuncF32<>,
414  &FalseFuncU8<>,
415  &FalseFuncI32<>,
416  &FalseFuncU8<>));
417 }
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string &> reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27

◆ IsConvolution2dSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 419 of file RefLayerSupport.cpp.

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

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

◆ IsDebugSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 492 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

495 {
496  bool supported = true;
497 
498  std::array<DataType, 8> supportedTypes =
499  {
500  DataType::BFloat16,
501  DataType::Float16,
502  DataType::Float32,
503  DataType::QAsymmU8,
504  DataType::QAsymmS8,
505  DataType::QSymmS8,
506  DataType::QSymmS16,
507  DataType::Signed32
508  };
509 
510  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
511  "Reference for Debug layer: input type not supported");
512 
513  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
514  "Reference for Debug layer: output type not supported");
515 
516  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
517  "Reference for Debug layer: input and output types are mismatched");
518 
519  return supported;
520 }
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 522 of file RefLayerSupport.cpp.

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

526 {
527  IgnoreUnused(descriptor);
528  bool supported = true;
529 
530  std::array<DataType,5> supportedTypes =
531  {
532  DataType::BFloat16,
533  DataType::Float32,
534  DataType::Float16,
535  DataType::QAsymmU8,
536  DataType::QSymmS16
537  };
538 
539  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
540  "Reference DepthToSpace: input type not supported");
541 
542  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
543  "Reference DepthToSpace: output type not supported");
544 
545  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
546  "Reference DepthToSpace: input and output types are mismatched");
547 
548  return supported;
549 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 551 of file RefLayerSupport.cpp.

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

557 {
558  bool supported = true;
559 
560  // Define supported types.
561  std::array<DataType,7> supportedTypes =
562  {
563  DataType::BFloat16,
564  DataType::Float32,
565  DataType::Float16,
566  DataType::QSymmS8,
567  DataType::QAsymmS8,
568  DataType::QAsymmU8,
569  DataType::QSymmS16
570  };
571 
572  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
573  "Reference DepthwiseConvolution2d: input is not a supported type.");
574 
575  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
576  "Reference DepthwiseConvolution2d: output is not a supported type.");
577 
578  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
579  "Reference DepthwiseConvolution2d: input and output types mismatched.");
580 
581  ARMNN_NO_DEPRECATE_WARN_BEGIN
582  std::array<DataType, 3> supportedWeightTypes =
583  {
584  DataType::QAsymmU8,
585  DataType::QSymmS8,
586  DataType::QuantizedSymm8PerAxis // deprecated
587  };
588  ARMNN_NO_DEPRECATE_WARN_END
589 
590  const DataType inputType = input.GetDataType();
591  if (IsQuantized8BitType(inputType))
592  {
593 
594  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
595  "Reference convolution2d: weights type not supported for quantized input.");
596  }
597  else
598  {
599  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
600  "Reference DepthwiseConvolution2d: weights is not a supported type.");
601 
602  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
603  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
604  }
605 
606  if (biases.has_value())
607  {
608  std::array<DataType,4> biasesSupportedTypes =
609  {
610  DataType::BFloat16,
611  DataType::Float32,
612  DataType::Float16,
613  DataType::Signed32
614  };
615  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
616  "Reference DepthwiseConvolution2d: biases is not a supported type.");
617  }
618  IgnoreUnused(descriptor);
619 
620  return supported;
621 
622 }
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:241
armnn::DataType
DataType
Definition: Types.hpp:32
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsDequantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 624 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

627 {
628  bool supported = true;
629 
630  std::array<DataType,4> supportedInputTypes = {
631  DataType::QAsymmS8,
632  DataType::QAsymmU8,
633  DataType::QSymmS8,
634  DataType::QSymmS16
635  };
636 
637  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
638  "Reference for Dequantize layer: input type not supported.");
639 
640  supported &= CheckSupportRule( TypeNotPerAxisQuantized(input), reasonIfUnsupported,
641  "Reference for Dequantize layer: per-axis quantized input not support .");
642 
643  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
644  "Reference dequantize: per-axis quantized input not support .");
645 
646  std::array<DataType,3> supportedOutputTypes = {
647  DataType::BFloat16,
648  DataType::Float32,
649  DataType::Float16
650  };
651 
652  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
653  "Reference for Dequantize layer: output type not supported.");
654 
655  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
656  "Reference for Dequantize layer: input/output shapes have different num total "
657  "elements.");
658 
659  return supported;
660 }
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 662 of file RefLayerSupport.cpp.

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

671 {
672  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
673 
674  bool supported = true;
675 
676  std::array<DataType,4> supportedInputTypes =
677  {
678  DataType::BFloat16,
679  DataType::Float32,
680  DataType::QAsymmU8,
681  DataType::QSymmS16
682  };
683 
684  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
685  "Reference DetectionPostProcess: input 0 is not a supported type.");
686 
687  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
688  "Reference DetectionPostProcess: input 1 is not a supported type.");
689 
690  return supported;
691 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
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 })
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
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
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 693 of file RefLayerSupport.cpp.

References armnn::IsDepthwiseConvolutionSupported().

699 {
700  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
701 }
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:551

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

References armnn::CheckSupportRule().

707 {
708  bool supported = true;
709 
710  std::array<DataType,5> supportedTypes = {
711  DataType::BFloat16,
712  DataType::Float32,
713  DataType::Float16,
714  DataType::QAsymmU8,
715  DataType::QSymmS16
716  };
717 
718  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
719  "Reference division: input 0 is not a supported type.");
720 
721  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
722  "Reference division: input 1 is not a supported type.");
723 
724  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
725  "Reference division: output is not a supported type.");
726 
727  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
728  "Reference division: input 0 and Input 1 types are mismatched");
729 
730  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
731  "Reference division: input and output types are mismatched");
732 
733  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
734  "Reference division: shapes are not suitable for implicit broadcast.");
735 
736  return supported;
737 }
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 739 of file RefLayerSupport.cpp.

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

743 {
744  IgnoreUnused(descriptor);
745 
746  std::array<DataType, 5> supportedTypes =
747  {
748  DataType::BFloat16,
749  DataType::Float32,
750  DataType::Float16,
751  DataType::QAsymmU8,
752  DataType::QSymmS16
753  };
754 
755  bool supported = true;
756 
757  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
758  "Reference elementwise unary: input type not supported");
759 
760  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
761  "Reference elementwise unary: output type not supported");
762 
763  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
764  "Reference elementwise unary: input and output types not matching");
765 
766  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
767  "Reference elementwise unary: input and output shapes"
768  "have different number of total elements");
769 
770  return supported;
771 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 773 of file RefLayerSupport.cpp.

777 {
778  return IsComparisonSupported(input0,
779  input1,
780  output,
781  ComparisonDescriptor(ComparisonOperation::Equal),
782  reasonIfUnsupported);
783 }
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:298

◆ IsFakeQuantizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 785 of file RefLayerSupport.cpp.

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

788 {
789  IgnoreUnused(descriptor);
790  bool supported = true;
791 
792  std::array<DataType,1> supportedTypes =
793  {
794  DataType::Float32
795  };
796 
797  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
798  "Reference fake quantization: input type not supported.");
799 
800  return supported;
801 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsFloorSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 803 of file RefLayerSupport.cpp.

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

806 {
807  IgnoreUnused(output);
808  bool supported = true;
809 
810  std::array<DataType,4> supportedTypes =
811  {
812  DataType::BFloat16,
813  DataType::Float32,
814  DataType::Float16,
815  DataType::QSymmS16
816  };
817 
818  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
819  "Reference Floor: input type not supported.");
820 
821  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
822  "Reference Floor: output type not supported.");
823 
824  return supported;
825 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 827 of file RefLayerSupport.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::CheckSupportRule(), TensorInfo::GetDataType(), armnn::IsQuantized8BitType(), and FullyConnectedDescriptor::m_BiasEnabled.

833 {
834  bool supported = true;
835 
836  // Define supported types.
837  std::array<DataType,6> supportedTypes =
838  {
839  DataType::BFloat16,
840  DataType::Float32,
841  DataType::Float16,
842  DataType::QAsymmU8,
843  DataType::QAsymmS8,
844  DataType::QSymmS16
845  };
846 
847  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
848  "Reference Fully Connected: input type not supported.");
849 
850  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
851  "Reference Fully Connected: output type not supported.");
852 
853  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
854  "Reference Fully Connected: input and output types mismatched.");
855 
856  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
857  "Reference Fully Connected: weights type not supported.");
858 
859  ARMNN_NO_DEPRECATE_WARN_BEGIN
860  std::array<DataType, 3> supportedWeightTypes =
861  {
862  DataType::QAsymmU8,
863  DataType::QSymmS8,
864  DataType::QuantizedSymm8PerAxis // deprecated
865  };
866  ARMNN_NO_DEPRECATE_WARN_END
867 
868  if (IsQuantized8BitType(input.GetDataType()))
869  {
870 
871  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
872  "Reference Fully Connected: weights type not supported for quantized input.");
873  }
874  else
875  {
876  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
877  "Reference Fully Connected: weights is not a supported type.");
878 
879  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
880  "Reference Fully Connected: input and weights types mismatched.");
881  }
882 
883  if (descriptor.m_BiasEnabled)
884  {
885  // Defined supported types for bias
886  std::array<DataType, 4>
887  supportedBiasTypes =
888  {
889  DataType::BFloat16,
890  DataType::Float32,
891  DataType::Float16,
892  DataType::Signed32
893  };
894 
895  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
896  "Reference Fully Connected: bias type not supported.");
897 
898  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
899  "Reference Fully Connected: bias and weight types mismatch.");
900 
901  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
902  "Reference Fully Connected: bias type inferred from weights is incompatible.");
903 
904  }
905 
906  return supported;
907 }
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:241
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 909 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

913 {
914  bool supported = true;
915  std::array<DataType,5> supportedTypes =
916  {
917  DataType::BFloat16,
918  DataType::Float32,
919  DataType::Float16,
920  DataType::QAsymmU8,
921  DataType::QSymmS16
922  };
923 
924  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
925  "Reference Gather: input type not supported");
926 
927  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
928  "Reference Gather: output type not supported");
929 
930  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
931  "Reference Gather: indices (input1) type not supported");
932 
933  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
934  "Reference Gather: input and output types not matching");
935 
936  return supported;
937 }
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 939 of file RefLayerSupport.cpp.

943 {
944  return IsComparisonSupported(input0,
945  input1,
946  output,
947  ComparisonDescriptor(ComparisonOperation::Greater),
948  reasonIfUnsupported);
949 }
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:298

◆ IsInputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 951 of file RefLayerSupport.cpp.

953 {
954  return true;
955 }

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

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

961 {
962  IgnoreUnused(descriptor);
963  // Define supported types
964  std::array<DataType, 3> supportedTypes =
965  {
966  DataType::BFloat16,
967  DataType::Float32,
968  DataType::Float16
969  };
970 
971  bool supported = true;
972 
973  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
974  "Reference Instance Normalization: input type not supported.");
975 
976  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
977  "Reference Instance Normalization: output type not supported.");
978 
979  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
980  "Reference Instance Normalization: input and output types mismatched.");
981 
982  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
983  "Reference Instance Normalization: input and output shapes have different "
984  "num total elements.");
985 
986  return supported;
987 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 989 of file RefLayerSupport.cpp.

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

993 {
994  IgnoreUnused(descriptor);
995  // Define supported types
996  std::array<DataType, 5> supportedTypes =
997  {
998  DataType::BFloat16,
999  DataType::Float32,
1000  DataType::Float16,
1001  DataType::QAsymmU8,
1002  DataType::QSymmS16
1003  };
1004 
1005  bool supported = true;
1006 
1007  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1008  "Reference L2normalization: input type not supported.");
1009 
1010  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1011  "Reference L2normalization: output type not supported.");
1012 
1013  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1014  "Reference L2normalization: input and output types mismatched.");
1015 
1016  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1017  "Reference L2normalization: input and output shapes have different "
1018  "num total elements.");
1019 
1020  return supported;
1021 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1023 of file RefLayerSupport.cpp.

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

1027 {
1028  IgnoreUnused(descriptor);
1029 
1030  std::array<DataType, 3> supportedTypes =
1031  {
1032  DataType::BFloat16,
1033  DataType::Float32,
1034  DataType::Float16
1035  };
1036 
1037  bool supported = true;
1038  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1039  "Reference LogSoftmax: input type not supported");
1040 
1041  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1042  "Reference LogSoftmax: output type not supported");
1043 
1044  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1045  "Reference LogSoftmax: input and output types do not match");
1046 
1047  return supported;
1048 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1050 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(), armnn::IgnoreUnused(), LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_LayerNormEnabled, LstmDescriptor::m_PeepholeEnabled, LstmInputParamsInfo::m_ProjectionBias, and LstmDescriptor::m_ProjectionEnabled.

1060 {
1061  IgnoreUnused(descriptor);
1062  IgnoreUnused(paramsInfo);
1063 
1064  bool supported = true;
1065 
1066  std::array<DataType,3> supportedTypes = {
1067  DataType::BFloat16,
1068  DataType::Float32,
1069  DataType::QSymmS16
1070  };
1071 
1072  // check inputs and outputs
1073  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1074  "Reference Lstm: input is not a supported type.");
1075  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1076  "Reference Lstm: input and outputStateIn types are mismatched");
1077  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1078  "Reference Lstm: input and cellStateIn types are mismatched");
1079  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1080  "Reference Lstm: input and scratchBuffer types are mismatched");
1081  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1082  "Reference Lstm: input and outputStateOut types are mismatched");
1083  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1084  "Reference Lstm: input and cellStateOut types are mismatched");
1085  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1086  "Reference Lstm: input and output types are mismatched");
1087  // check layer parameters
1088  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
1089  "Reference Lstm: input and InputToForgetWeights types are mismatched");
1090  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
1091  "Reference Lstm: input and InputToCellWeights types are mismatched");
1092  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
1093  "Reference Lstm: input and InputToOutputWeights types are mismatched");
1094  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
1095  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
1096  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
1097  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
1098  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
1099  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
1100  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
1101  "Reference Lstm: input and ForgetGateBias types are mismatched");
1102  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
1103  "Reference Lstm: input and CellBias types are mismatched");
1104  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
1105  "Reference Lstm: input and OutputGateBias types are mismatched");
1106  if (!descriptor.m_CifgEnabled)
1107  {
1108  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
1109  "Reference Lstm: input and InputToInputWeights types are mismatched");
1110  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
1111  reasonIfUnsupported,
1112  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
1113  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
1114  "Reference Lstm: input and InputGateBias types are mismatched");
1115  if (descriptor.m_PeepholeEnabled)
1116  {
1117  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
1118  reasonIfUnsupported,
1119  "Reference Lstm: input and CellToInputWeights types are mismatched");
1120  }
1121  }
1122  if (descriptor.m_PeepholeEnabled)
1123  {
1124  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
1125  "Reference Lstm: input and CellToForgetWeights types are mismatched");
1126  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
1127  "Reference Lstm: input and CellToOutputWeights types are mismatched");
1128  }
1129  if (descriptor.m_ProjectionEnabled)
1130  {
1131  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
1132  "Reference Lstm: input and mProjectionWeights types are mismatched");
1133  if (paramsInfo.m_ProjectionBias != nullptr)
1134  {
1135  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
1136  "Reference Lstm: input and ProjectionBias types are mismatched");
1137  }
1138  }
1139  if (descriptor.m_LayerNormEnabled)
1140  {
1141  if (!descriptor.m_CifgEnabled)
1142  {
1143  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
1144  reasonIfUnsupported,
1145  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1146  }
1147  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
1148  reasonIfUnsupported,
1149  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
1150  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
1151  reasonIfUnsupported,
1152  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
1153  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
1154  reasonIfUnsupported,
1155  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1156  }
1157 
1158  return supported;
1159 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1161 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1165 {
1166  bool supported = true;
1167 
1168  std::array<DataType,6> supportedTypes = {
1169  DataType::BFloat16,
1170  DataType::Float32,
1171  DataType::Float16,
1172  DataType::QAsymmS8,
1173  DataType::QAsymmU8,
1174  DataType::QSymmS16
1175  };
1176 
1177  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1178  "Reference maximum: input 0 is not a supported type.");
1179 
1180  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1181  "Reference maximum: input 1 is not a supported type.");
1182 
1183  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1184  "Reference maximum: output is not a supported type.");
1185 
1186  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1187  "Reference maximum: input 0 and Input 1 types are mismatched");
1188 
1189  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1190  "Reference maximum: input and output types are mismatched");
1191 
1192  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1193  "Reference maximum: shapes are not suitable for implicit broadcast.");
1194 
1195  return supported;
1196 }
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 1198 of file RefLayerSupport.cpp.

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

1202 {
1203  bool supported = true;
1204  std::string meanLayerStr = "Mean";
1205  std::string outputTensorStr = "output";
1206 
1207  std::array<DataType,5> supportedTypes =
1208  {
1209  DataType::BFloat16,
1210  DataType::Float32,
1211  DataType::Float16,
1212  DataType::QAsymmU8,
1213  DataType::QSymmS16
1214  };
1215 
1216  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1217  "Reference Mean: input type not supported.");
1218 
1219  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1220  "Reference Mean: input and output types are mismatched");
1221 
1222  if (descriptor.m_KeepDims)
1223  {
1224  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1225  reasonIfUnsupported,
1226  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1227  output.GetNumDimensions(),
1228  meanLayerStr, outputTensorStr).data());
1229  }
1230  else if (descriptor.m_Axis.empty())
1231  {
1232  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1233  reasonIfUnsupported,
1234  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1235  meanLayerStr, outputTensorStr).data());
1236  }
1237  else
1238  {
1239  auto outputDim = input.GetNumDimensions() - boost::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1240 
1241  if (outputDim > 0)
1242  {
1243  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1244  reasonIfUnsupported,
1245  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1246  meanLayerStr, outputTensorStr).data());
1247  }
1248  else
1249  {
1250  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1251  reasonIfUnsupported,
1252  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1253  meanLayerStr, outputTensorStr).data());
1254  }
1255  }
1256 
1257  return supported;
1258 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
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 1268 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1271 {
1272  bool supported = true;
1273 
1274  std::array<DataType,6> supportedTypes =
1275  {
1276  DataType::BFloat16,
1277  DataType::Float32,
1278  DataType::Float16,
1279  DataType::QAsymmU8,
1280  DataType::QSymmS16,
1281  DataType::Boolean
1282  };
1283 
1284  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1285  "Reference MemCopy: input type not supported");
1286 
1287  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1288  "Reference MemCopy: output type not supported");
1289 
1290  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1291  "Reference MemCopy: input and output types are mismatched");
1292 
1293  return supported;
1294 }
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 1260 of file RefLayerSupport.cpp.

References armnn::IsConcatSupported().

1264 {
1265  return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
1266 }
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:328

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

References armnn::CheckSupportRule().

1300 {
1301  bool supported = true;
1302 
1303  std::array<DataType,5> supportedTypes = {
1304  DataType::BFloat16,
1305  DataType::Float32,
1306  DataType::Float16,
1307  DataType::QAsymmU8,
1308  DataType::QSymmS16
1309  };
1310 
1311  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1312  "Reference minimum: input 0 is not a supported type.");
1313 
1314  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1315  "Reference minimum: input 1 is not a supported type.");
1316 
1317  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1318  "Reference minimum: output is not a supported type.");
1319 
1320  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1321  "Reference minimum: input 0 and Input 1 types are mismatched");
1322 
1323  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1324  "Reference minimum: input and output types are mismatched");
1325 
1326  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1327  "Reference minimum: shapes are not suitable for implicit broadcast.");
1328 
1329  return supported;
1330 }
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 1332 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1336 {
1337  bool supported = true;
1338 
1339  std::array<DataType,6> supportedTypes = {
1340  DataType::BFloat16,
1341  DataType::Float32,
1342  DataType::Float16,
1343  DataType::QAsymmU8,
1344  DataType::QAsymmS8,
1345  DataType::QSymmS16
1346  };
1347 
1348  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1349  "Reference multiplication: input 0 is not a supported type.");
1350 
1351  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1352  "Reference multiplication: input 1 is not a supported type.");
1353 
1354  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1355  "Reference multiplication: output is not a supported type.");
1356 
1357  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1358  "Reference multiplication: input 0 and Input 1 types are mismatched");
1359 
1360  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1361  "Reference multiplication: input and output types are mismatched");
1362 
1363  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1364  "Reference multiplication: shapes are not suitable for implicit broadcast.");
1365 
1366  return supported;
1367 }
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 1369 of file RefLayerSupport.cpp.

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

1373 {
1374  IgnoreUnused(descriptor);
1375 
1376  // Define supported types
1377  std::array<DataType, 5> supportedTypes =
1378  {
1379  DataType::BFloat16,
1380  DataType::Float16,
1381  DataType::Float32,
1382  DataType::QAsymmU8,
1383  DataType::QSymmS16
1384  };
1385 
1386  bool supported = true;
1387 
1388  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1389  "Reference normalization: input type not supported.");
1390 
1391  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1392  "Reference normalization: output type not supported.");
1393 
1394  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1395  "Reference normalization: input and output shapes have different "
1396  "num total elements.");
1397 
1398  return supported;
1399 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsOutputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1401 of file RefLayerSupport.cpp.

1403 {
1404  return true;
1405 }

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

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

1411 {
1412  IgnoreUnused(descriptor);
1413  bool supported = true;
1414 
1415  // Define supported output and inputs types.
1416  std::array<DataType,5> supportedTypes =
1417  {
1418  DataType::BFloat16,
1419  DataType::Float32,
1420  DataType::Float16,
1421  DataType::QAsymmU8,
1422  DataType::QSymmS16
1423  };
1424 
1425  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1426  "Reference pad: input is not a supported type.");
1427 
1428  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1429  "Reference pad: output is not a supported type.");
1430 
1431  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1432  "Reference pad: input and output types are mismatched.");
1433 
1434  return supported;
1435 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1437 of file RefLayerSupport.cpp.

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

1441 {
1442  IgnoreUnused(descriptor);
1443  bool supported = true;
1444 
1445  // Define supported output and inputs types.
1446  std::array<DataType, 5> supportedTypes =
1447  {
1448  DataType::BFloat16,
1449  DataType::Float32,
1450  DataType::Float16,
1451  DataType::QAsymmU8,
1452  DataType::QSymmS16
1453  };
1454 
1455  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1456  "Reference permute: input is not a supported type.");
1457 
1458  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1459  "Reference permute: output is not a supported type.");
1460 
1461  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1462  "Reference permute: input and output types are mismatched.");
1463 
1464  return supported;
1465 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1467 of file RefLayerSupport.cpp.

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

1471 {
1472  IgnoreUnused(descriptor);
1473  bool supported = true;
1474 
1475  // Define supported output and inputs types.
1476  std::array<DataType,6> supportedTypes =
1477  {
1478  DataType::BFloat16,
1479  DataType::Float32,
1480  DataType::Float16,
1481  DataType::QAsymmS8,
1482  DataType::QAsymmU8,
1483  DataType::QSymmS16
1484  };
1485 
1486  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1487  "Reference poolind2d: input is not a supported type.");
1488 
1489  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1490  "Reference poolind2d: output is not a supported type.");
1491 
1492  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1493  "Reference poolind2d: input and output types are mismatched.");
1494 
1495  return supported;
1496 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1885 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1889 {
1890  bool supported = true;
1891 
1892  std::array<DataType, 5> supportedTypes
1893  {
1894  DataType::BFloat16,
1895  DataType::Float32,
1896  DataType::Float16,
1897  DataType::QAsymmU8,
1898  DataType::QSymmS16
1899  };
1900 
1901  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1902  "PReLU: input is not a supported type.");
1903 
1904  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
1905  "PReLU: alpha is not a supported type.");
1906 
1907  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1908  "PReLU: output is not a supported type.");
1909 
1910  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
1911  "PReLU: input, alpha and output types are mismatched");
1912 
1913  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
1914  "PReLU: shapes are not suitable for implicit broadcast");
1915 
1916  return supported;
1917 }
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 1498 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1501 {
1502  bool supported = true;
1503 
1504  // Define supported input types.
1505  std::array<DataType,7> supportedInputTypes = {
1506  DataType::BFloat16,
1507  DataType::Float32,
1508  DataType::Float16,
1509  DataType::QAsymmS8,
1510  DataType::QAsymmU8,
1511  DataType::QSymmS8,
1512  DataType::QSymmS16
1513  };
1514 
1515  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1516  "Reference quantize: input type not supported.");
1517 
1518  // Define supported output types.
1519  std::array<DataType,4> supportedOutputTypes = {
1520  DataType::QAsymmU8,
1521  DataType::QAsymmS8,
1522  DataType::QSymmS8,
1523  DataType::QSymmS16
1524  };
1525  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1526  "Reference quantize: output type not supported.");
1527 
1528  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1529  "Reference quantize: input and output shapes have different num total elements.");
1530 
1531  return supported;
1532 }
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 1534 of file RefLayerSupport.cpp.

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

1538 {
1539  IgnoreUnused(output);
1540  IgnoreUnused(descriptor);
1541  // Define supported output types.
1542  std::array<DataType,7> supportedOutputTypes =
1543  {
1544  DataType::BFloat16,
1545  DataType::Float32,
1546  DataType::Float16,
1547  DataType::Signed32,
1548  DataType::QAsymmS8,
1549  DataType::QAsymmU8,
1550  DataType::QSymmS16
1551  };
1552 
1553  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1554  "Reference reshape: input type not supported.");
1555 }
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsResizeBilinearSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1557 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1560 {
1561  bool supported = true;
1562  std::array<DataType,5> supportedTypes =
1563  {
1564  DataType::BFloat16,
1565  DataType::Float32,
1566  DataType::Float16,
1567  DataType::QAsymmU8,
1568  DataType::QSymmS16
1569  };
1570 
1571  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1572  "Reference ResizeBilinear: input type not supported");
1573 
1574  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1575  "Reference ResizeBilinear: output type not supported");
1576 
1577  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1578  "Reference ResizeBilinear: input and output types not matching");
1579 
1580  return supported;
1581 }
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 1583 of file RefLayerSupport.cpp.

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

1587 {
1588  IgnoreUnused(descriptor);
1589  bool supported = true;
1590  std::array<DataType,6> supportedTypes =
1591  {
1592  DataType::BFloat16,
1593  DataType::Float32,
1594  DataType::Float16,
1595  DataType::QAsymmU8,
1596  DataType::QAsymmS8,
1597  DataType::QSymmS16
1598  };
1599 
1600  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1601  "Reference Resize: input type not supported");
1602 
1603  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1604  "Reference Resize: output type not supported");
1605 
1606  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1607  "Reference Resize: input and output types not matching");
1608 
1609  return supported;
1610 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsRsqrtSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1612 of file RefLayerSupport.cpp.

1615 {
1616  return IsElementwiseUnarySupported(input,
1617  output,
1618  ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt),
1619  reasonIfUnsupported);
1620 }
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:739

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

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

1626 {
1627  IgnoreUnused(descriptor);
1628  bool supported = true;
1629 
1630  std::array<DataType, 4> supportedTypes =
1631  {
1632  DataType::BFloat16,
1633  DataType::Float32,
1634  DataType::QAsymmU8,
1635  DataType::QSymmS16
1636  };
1637 
1638  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1639  "Reference Slice: input type not supported");
1640 
1641  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1642  "Reference Slice: output type not supported");
1643 
1644  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1645  "Reference Slice: input and output types are mismatched");
1646 
1647  return supported;
1648 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1650 of file RefLayerSupport.cpp.

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

1654 {
1655  IgnoreUnused(descriptor);
1656  bool supported = true;
1657  std::array<DataType,7> supportedTypes =
1658  {
1659  DataType::BFloat16,
1660  DataType::Float32,
1661  DataType::Float16,
1662  DataType::QSymmS8,
1663  DataType::QAsymmS8,
1664  DataType::QAsymmU8,
1665  DataType::QSymmS16
1666  };
1667 
1668  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1669  "Reference Softmax: output type not supported");
1670 
1671  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1672  "Reference Softmax: input type not supported");
1673 
1674  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1675  "Reference Softmax: input type not supported");
1676 
1677  return supported;
1678 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1680 of file RefLayerSupport.cpp.

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

1684 {
1685  IgnoreUnused(descriptor);
1686  bool supported = true;
1687  std::array<DataType,5> supportedTypes =
1688  {
1689  DataType::BFloat16,
1690  DataType::Float32,
1691  DataType::Float16,
1692  DataType::QAsymmU8,
1693  DataType::QSymmS16
1694  };
1695 
1696  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1697  "Reference SpaceToBatchNd: input type not supported");
1698 
1699  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1700  "Reference SpaceToBatchNd: output type not supported");
1701 
1702  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1703  "Reference SpaceToBatchNd: input and output types are mismatched");
1704 
1705  return supported;
1706 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1708 of file RefLayerSupport.cpp.

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

1712 {
1713 
1714  IgnoreUnused(descriptor);
1715  bool supported = true;
1716 
1717  std::array<DataType,5> supportedTypes =
1718  {
1719  DataType::BFloat16,
1720  DataType::Float32,
1721  DataType::Float16,
1722  DataType::QAsymmU8,
1723  DataType::QSymmS16
1724  };
1725 
1726  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1727  "Reference SpaceToDepth: input type not supported");
1728 
1729  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1730  "Reference SpaceToDepth: output type not supported");
1731 
1732  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1733  "Reference SpaceToDepth: input and output types are mismatched");
1734 
1735  return supported;
1736 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1738 of file RefLayerSupport.cpp.

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

1741 {
1742  IgnoreUnused(descriptor);
1743  bool supported = true;
1744  std::array<DataType,5> supportedTypes =
1745  {
1746  DataType::BFloat16,
1747  DataType::Float32,
1748  DataType::Float16,
1749  DataType::QAsymmU8,
1750  DataType::QSymmS16
1751  };
1752 
1753  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1754  "Reference splitter: input type not supported");
1755 
1756  return supported;
1757 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1759 of file RefLayerSupport.cpp.

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

1763 {
1764  IgnoreUnused(descriptor);
1765  bool supported = true;
1766  std::array<DataType,5> supportedTypes =
1767  {
1768  DataType::BFloat16,
1769  DataType::Float32,
1770  DataType::Float16,
1771  DataType::QAsymmU8,
1772  DataType::QSymmS16
1773  };
1774 
1775  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1776  "Reference splitter: output type not supported");
1777  for (const TensorInfo output : outputs)
1778  {
1779  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1780  "Reference splitter: input type not supported");
1781 
1782  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1783  "Reference splitter: input and output types mismatched.");
1784  }
1785 
1786  return supported;
1787 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1789 of file RefLayerSupport.cpp.

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

1793 {
1794  IgnoreUnused(descriptor);
1795 
1796  bool supported = true;
1797  std::array<DataType,5> supportedTypes =
1798  {
1799  DataType::BFloat16,
1800  DataType::Float32,
1801  DataType::Float16,
1802  DataType::QAsymmU8,
1803  DataType::QSymmS16
1804  };
1805 
1806  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1807  "Reference stack: output type not supported");
1808  for (const TensorInfo* input : inputs)
1809  {
1810  BOOST_ASSERT(input != nullptr);
1811  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
1812  "Reference stack: input type not supported");
1813 
1814  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
1815  "Reference stack: input and output types mismatched.");
1816  }
1817 
1818  return supported;
1819 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1821 of file RefLayerSupport.cpp.

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

1825 {
1826  IgnoreUnused(descriptor);
1827  bool supported = true;
1828 
1829  std::array<DataType,4> supportedTypes =
1830  {
1831  DataType::BFloat16,
1832  DataType::Float32,
1833  DataType::QAsymmU8,
1834  DataType::QSymmS16
1835  };
1836 
1837  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1838  "Reference StridedSlice: input type not supported");
1839 
1840  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1841  "Reference StridedSlice: output type not supported");
1842 
1843  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1844  "Reference StridedSlice: input and output types are mismatched");
1845 
1846  return supported;
1847 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp: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 1849 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1853 {
1854  bool supported = true;
1855 
1856  std::array<DataType,5> supportedTypes = {
1857  DataType::BFloat16,
1858  DataType::Float32,
1859  DataType::Float16,
1860  DataType::QAsymmU8,
1861  DataType::QSymmS16
1862  };
1863 
1864  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1865  "Reference subtraction: input 0 is not a supported type.");
1866 
1867  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1868  "Reference subtraction: input 1 is not a supported type.");
1869 
1870  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1871  "Reference subtraction: output is not a supported type.");
1872 
1873  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1874  "Reference subtraction: input 0 and Input 1 types are mismatched");
1875 
1876  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1877  "Reference subtraction: input and output types are mismatched");
1878 
1879  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1880  "Reference subtraction: shapes are not suitable for implicit broadcast.");
1881 
1882  return supported;
1883 }
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 1919 of file RefLayerSupport.cpp.

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

1925 {
1926  IgnoreUnused(descriptor);
1927  bool supported = true;
1928 
1929  std::array<DataType,5> supportedTypes =
1930  {
1931  DataType::BFloat16,
1932  DataType::Float32,
1933  DataType::Float16,
1934  DataType::QAsymmU8,
1935  DataType::QSymmS16
1936  };
1937 
1938  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1939  "Reference TransposeConvolution2d: input is not a supported type.");
1940 
1941  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1942  "Reference TransposeConvolution2d: output is not a supported type.");
1943 
1944  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1945  "Reference TransposeConvolution2d: input and output types mismatched.");
1946 
1947 
1948  const DataType inputType = input.GetDataType();
1949  if (inputType == DataType::QAsymmU8)
1950  {
1951  ARMNN_NO_DEPRECATE_WARN_BEGIN
1952  std::array<DataType, 3> supportedWeightTypes =
1953  {
1954  DataType::QAsymmU8,
1955  DataType::QSymmS8,
1956  DataType::QuantizedSymm8PerAxis //Deprecated
1957  };
1958  ARMNN_NO_DEPRECATE_WARN_END
1959 
1960  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1961  "Reference TransposeConvolution2d: weights type not supported for "
1962  "quantized input.");
1963  }
1964  else
1965  {
1966  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1967  "Reference TransposeConvolution2d: weights is not a supported type.");
1968 
1969  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1970  "Reference TransposeConvolution2d: input and weights types mismatched.");
1971  }
1972 
1973  if (biases.has_value())
1974  {
1975  std::array<DataType,4> biasesSupportedTypes =
1976  {
1977  DataType::BFloat16,
1978  DataType::Float32,
1979  DataType::Float16,
1980  DataType::Signed32
1981  };
1982  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1983  "Reference TransposeConvolution2d: biases is not a supported type.");
1984  }
1985 
1986  return supported;
1987 }
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::DataType
DataType
Definition: Types.hpp:32
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37

◆ IsTransposeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1989 of file RefLayerSupport.cpp.

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

1993 {
1994  IgnoreUnused(descriptor);
1995  bool supported = true;
1996 
1997  // Define supported output and inputs types.
1998  std::array<DataType, 5> supportedTypes =
1999  {
2000  DataType::BFloat16,
2001  DataType::Float32,
2002  DataType::Float16,
2003  DataType::QAsymmU8,
2004  DataType::QSymmS16
2005  };
2006 
2007  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2008  "Reference transpose: input is not a supported type.");
2009 
2010  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2011  "Reference transpose: output is not a supported type.");
2012 
2013  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2014  "Reference transpose: input and output types are mismatched.");
2015 
2016  return supported;
2017 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
The documentation for this class was generated from the following files: