ArmNN
 20.05
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 IsConvertBf16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToBf16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDebugSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDetectionPostProcessSupported (const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsEqualSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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 IsQLstmSupported (const TensorInfo &input, const TensorInfo &previousOutputIn, const TensorInfo &previousCellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
 
bool 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:790

◆ 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:39

◆ 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:39

◆ 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, 6> supportedTypes =
185  {
186  DataType::BFloat16,
187  DataType::Float32,
188  DataType::QAsymmS8,
189  DataType::QAsymmU8,
190  DataType::QSymmS16,
191  DataType::Signed32
192  };
193 
194  bool supported = true;
195 
196  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
197  "Reference ArgMinMax: input is not a supported type.");
198  supported &= CheckSupportRule(TypeIs(output, DataType::Signed32), reasonIfUnsupported,
199  "Reference ArgMinMax: output type not supported");
200 
201  return supported;
202 }
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:39

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

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

212 {
213  IgnoreUnused(descriptor);
214 
215  std::array<DataType, 6> supportedTypes =
216  {
217  DataType::BFloat16,
218  DataType::Float32,
219  DataType::Float16,
220  DataType::QAsymmS8,
221  DataType::QAsymmU8,
222  DataType::QSymmS16
223  };
224 
225  bool supported = true;
226 
227  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
228  "Reference batch normalization: input is not a supported type.");
229 
230  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
231  "Reference batch normalization: output is not a supported type.");
232 
233  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
234  "Reference batch normalization: input and output types are mismatched");
235 
236  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
237  "Reference batch normalization: mean is not a supported type.");
238 
239  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
240  "Reference batch normalization: variance is not a supported type.");
241 
242  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
243  "Reference batch normalization: beta is not a supported type.");
244 
245  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
246  "Reference batch normalization: gamma is not a supported type.");
247 
248  return supported;
249 }
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:39

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

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

255 {
256  IgnoreUnused(descriptor);
257 
258  bool supported = true;
259 
260  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
261  std::string inputTensorStr = "input";
262  std::string outputTensorStr = "output";
263 
264  // Define supported types.
265  std::array<DataType,6> supportedTypes =
266  {
267  DataType::BFloat16,
268  DataType::Float32,
269  DataType::Float16,
270  DataType::QAsymmS8,
271  DataType::QAsymmU8,
272  DataType::QSymmS16
273  };
274 
275  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
276  "Reference BatchToSpaceNd: input type not supported.");
277 
278  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
279  "Reference BatchToSpaceNd: output type not supported.");
280 
281  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
282  "Reference BatchToSpaceNd: input and output types mismatched.");
283 
284  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
285  reasonIfUnsupported,
286  CreateIncorrectDimensionsErrorMsg(4,
287  output.GetNumDimensions(),
288  batchToSpaceNdLayerStr,
289  outputTensorStr).data());
290 
291  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
292  reasonIfUnsupported,
293  CreateIncorrectDimensionsErrorMsg(4,
294  input.GetNumDimensions(),
295  batchToSpaceNdLayerStr,
296  inputTensorStr).data());
297 
298  return supported;
299 }
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:39

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

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

306 {
307  IgnoreUnused(descriptor);
308  std::array<DataType, 8> supportedInputTypes =
309  {
310  DataType::Boolean,
311  DataType::BFloat16,
312  DataType::Float32,
313  DataType::Float16,
314  DataType::QAsymmS8,
315  DataType::QAsymmU8,
316  DataType::QSymmS16,
317  DataType::Signed32
318  };
319 
320  bool supported = true;
321  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
322  "Reference comparison: input 0 is not a supported type");
323 
324  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
325  "Reference comparison: input 0 and Input 1 types are mismatched");
326 
327  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
328  "Reference comparison: output is not of type Boolean");
329 
330  return supported;
331 }
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:39

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

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

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

◆ IsConstantSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 366 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

368 {
369  std::array<DataType,7> supportedTypes =
370  {
371  DataType::BFloat16,
372  DataType::Float32,
373  DataType::QAsymmS8,
374  DataType::QAsymmU8,
375  DataType::QSymmS8,
376  DataType::QSymmS16,
377  DataType::Signed32
378  };
379 
380  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
381  "Reference constant: output is not a supported type.");
382 }
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

◆ IsConvertBf16ToFp32Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 384 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

387 {
388  bool supported = true;
389 
390  supported &= CheckSupportRule(TypeIs(input, DataType::BFloat16), reasonIfUnsupported,
391  "Reference for ConvertBf16ToFp32 layer: input type not supported");
392 
393  supported &= CheckSupportRule(TypeIs(output, DataType::Float32), reasonIfUnsupported,
394  "Reference for ConvertBf16ToFp32 layer: output type not supported");
395 
396  return supported;
397 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

◆ IsConvertFp16ToFp32Supported()

bool IsConvertFp16ToFp32Supported ( 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  &TrueFunc<>,
406  &FalseInputFuncF32<>,
407  &FalseFuncU8<>,
408  &FalseFuncI32<>,
409  &FalseFuncU8<>) &&
410  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
411  output.GetDataType(),
412  &FalseOutputFuncF16<>,
413  &TrueFunc<>,
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

◆ IsConvertFp32ToBf16Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 419 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

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

◆ IsConvertFp32ToFp16Supported()

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

Reimplemented from LayerSupportBase.

Definition at line 434 of file RefLayerSupport.cpp.

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

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

460 {
461  bool supported = true;
462 
463  // Define supported types.
464  std::array<DataType,7> supportedTypes =
465  {
466  DataType::BFloat16,
467  DataType::Float32,
468  DataType::Float16,
469  DataType::QAsymmS8,
470  DataType::QAsymmU8,
471  DataType::QSymmS8,
472  DataType::QSymmS16
473  };
474 
475  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
476  "Reference Convolution2d: input is not a supported type.");
477 
478  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
479  "Reference Convolution2d: output is not a supported type.");
480 
481  // For Convolution2d, we allow to have BFloat16 input with Float32 output for optimization.
482  if (input.GetDataType() == DataType::BFloat16)
483  {
484  if (output.GetDataType() != DataType::BFloat16 && output.GetDataType() != DataType::Float32)
485  {
486  reasonIfUnsupported.value() += "Output tensor type must be BFloat16 or Float32 for BFloat16 input.\n";
487  supported = false;
488  }
489  }
490  else
491  {
492  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
493  "Reference Convolution2d: input and output types mismatched.");
494  }
495 
496  const DataType inputType = input.GetDataType();
497  if (IsQuantized8BitType(inputType))
498  {
499  ARMNN_NO_DEPRECATE_WARN_BEGIN
500  std::array<DataType, 4> supportedWeightTypes =
501  {
502  DataType::QAsymmS8,
503  DataType::QAsymmU8,
504  DataType::QSymmS8,
505  DataType::QuantizedSymm8PerAxis // deprecated
506  };
507  ARMNN_NO_DEPRECATE_WARN_END
508 
509  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
510  "Reference Convolution2d: weights type not supported for quantized input.");
511  }
512  else
513  {
514  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
515  "Reference Convolution2d: weights is not a supported type.");
516 
517  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
518  "Reference Convolution2d: input and weights types mismatched.");
519  }
520 
521  if (biases.has_value())
522  {
523  std::array<DataType,4> biasesSupportedTypes =
524  {
525  DataType::BFloat16,
526  DataType::Float32,
527  DataType::Float16,
528  DataType::Signed32
529  };
530 
531  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
532  "Reference Convolution2d: biases is not a supported type.");
533  }
534  IgnoreUnused(descriptor);
535 
536  return supported;
537 }
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:39

◆ IsDebugSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 539 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

542 {
543  bool supported = true;
544 
545  std::array<DataType, 8> supportedTypes =
546  {
547  DataType::BFloat16,
548  DataType::Float16,
549  DataType::Float32,
550  DataType::QAsymmS8,
551  DataType::QAsymmU8,
552  DataType::QSymmS8,
553  DataType::QSymmS16,
554  DataType::Signed32
555  };
556 
557  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
558  "Reference for Debug layer: input type not supported");
559 
560  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
561  "Reference for Debug layer: output type not supported");
562 
563  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
564  "Reference for Debug layer: input and output types are mismatched");
565 
566  return supported;
567 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

573 {
574  IgnoreUnused(descriptor);
575  bool supported = true;
576 
577  std::array<DataType,6> supportedTypes =
578  {
579  DataType::BFloat16,
580  DataType::Float32,
581  DataType::Float16,
582  DataType::QAsymmS8,
583  DataType::QAsymmU8,
584  DataType::QSymmS16
585  };
586 
587  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
588  "Reference DepthToSpace: input type not supported");
589 
590  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
591  "Reference DepthToSpace: output type not supported");
592 
593  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
594  "Reference DepthToSpace: input and output types are mismatched");
595 
596  return supported;
597 }
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:39

◆ 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 599 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().

605 {
606  IgnoreUnused(descriptor);
607  bool supported = true;
608 
609  // Define supported types.
610  std::array<DataType,7> supportedTypes =
611  {
612  DataType::BFloat16,
613  DataType::Float32,
614  DataType::Float16,
615  DataType::QAsymmS8,
616  DataType::QAsymmU8,
617  DataType::QSymmS8,
618  DataType::QSymmS16
619  };
620 
621  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
622  "Reference DepthwiseConvolution2d: input is not a supported type.");
623 
624  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
625  "Reference DepthwiseConvolution2d: output is not a supported type.");
626 
627  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
628  "Reference DepthwiseConvolution2d: input and output types mismatched.");
629 
630  const DataType inputType = input.GetDataType();
631  if (IsQuantized8BitType(inputType))
632  {
633  ARMNN_NO_DEPRECATE_WARN_BEGIN
634  std::array<DataType, 4> supportedWeightTypes =
635  {
636  DataType::QAsymmS8,
637  DataType::QAsymmU8,
638  DataType::QSymmS8,
639  DataType::QuantizedSymm8PerAxis // deprecated
640  };
641  ARMNN_NO_DEPRECATE_WARN_END
642 
643  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
644  "Reference DepthwiseConvolution2d: weights type not supported for "
645  "quantized input.");
646  }
647  else
648  {
649  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
650  "Reference DepthwiseConvolution2d: weights is not a supported type.");
651 
652  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
653  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
654  }
655 
656  if (biases.has_value())
657  {
658  std::array<DataType,4> biasesSupportedTypes =
659  {
660  DataType::BFloat16,
661  DataType::Float32,
662  DataType::Float16,
663  DataType::Signed32
664  };
665  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
666  "Reference DepthwiseConvolution2d: biases is not a supported type.");
667  }
668 
669  return supported;
670 
671 }
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:39

◆ IsDequantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 673 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

676 {
677  bool supported = true;
678 
679  std::array<DataType,4> supportedInputTypes = {
680  DataType::QAsymmS8,
681  DataType::QAsymmU8,
682  DataType::QSymmS8,
683  DataType::QSymmS16
684  };
685 
686  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
687  "Reference for Dequantize layer: input type not supported.");
688 
689  supported &= CheckSupportRule( TypeNotPerAxisQuantized(input), reasonIfUnsupported,
690  "Reference for Dequantize layer: per-axis quantized input not support .");
691 
692  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
693  "Reference dequantize: per-axis quantized input not support .");
694 
695  std::array<DataType,3> supportedOutputTypes = {
696  DataType::BFloat16,
697  DataType::Float32,
698  DataType::Float16
699  };
700 
701  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
702  "Reference for Dequantize layer: output type not supported.");
703 
704  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
705  "Reference for Dequantize layer: input/output shapes have different num total "
706  "elements.");
707 
708  return supported;
709 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

720 {
721  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
722 
723  bool supported = true;
724 
725  std::array<DataType,5> supportedInputTypes =
726  {
727  DataType::BFloat16,
728  DataType::Float32,
729  DataType::QAsymmS8,
730  DataType::QAsymmU8,
731  DataType::QSymmS16
732  };
733 
734  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
735  "Reference DetectionPostProcess: input 0 is not a supported type.");
736 
737  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
738  "Reference DetectionPostProcess: input 1 is not a supported type.");
739 
740  return supported;
741 }
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:39
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 743 of file RefLayerSupport.cpp.

References armnn::IsDepthwiseConvolutionSupported().

749 {
750  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
751 }
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:599

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

References armnn::CheckSupportRule().

757 {
758  bool supported = true;
759 
760  std::array<DataType,6> supportedTypes = {
761  DataType::BFloat16,
762  DataType::Float32,
763  DataType::Float16,
764  DataType::QAsymmS8,
765  DataType::QAsymmU8,
766  DataType::QSymmS16
767  };
768 
769  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
770  "Reference division: input 0 is not a supported type.");
771 
772  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
773  "Reference division: input 1 is not a supported type.");
774 
775  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
776  "Reference division: output is not a supported type.");
777 
778  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
779  "Reference division: input 0 and Input 1 types are mismatched");
780 
781  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
782  "Reference division: input and output types are mismatched");
783 
784  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
785  "Reference division: shapes are not suitable for implicit broadcast.");
786 
787  return supported;
788 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

794 {
795  IgnoreUnused(descriptor);
796 
797  std::array<DataType, 7> supportedTypes =
798  {
799  DataType::BFloat16,
800  DataType::Float32,
801  DataType::Float16,
802  DataType::QAsymmS8,
803  DataType::QAsymmU8,
804  DataType::QSymmS16,
805  DataType::Signed32
806  };
807 
808  bool supported = true;
809 
810  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
811  "Reference elementwise unary: input type not supported");
812 
813  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
814  "Reference elementwise unary: output type not supported");
815 
816  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
817  "Reference elementwise unary: input and output types not matching");
818 
819  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
820  "Reference elementwise unary: input and output shapes"
821  "have different number of total elements");
822 
823  return supported;
824 }
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:39

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

830 {
831  return IsComparisonSupported(input0,
832  input1,
833  output,
834  ComparisonDescriptor(ComparisonOperation::Equal),
835  reasonIfUnsupported);
836 }
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:301

◆ IsFakeQuantizationSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 838 of file RefLayerSupport.cpp.

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

841 {
842  IgnoreUnused(descriptor);
843  bool supported = true;
844 
845  std::array<DataType,1> supportedTypes =
846  {
847  DataType::Float32
848  };
849 
850  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
851  "Reference fake quantization: input type not supported.");
852 
853  return supported;
854 }
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:39

◆ IsFloorSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 856 of file RefLayerSupport.cpp.

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

859 {
860  IgnoreUnused(output);
861  bool supported = true;
862 
863  std::array<DataType,4> supportedTypes =
864  {
865  DataType::BFloat16,
866  DataType::Float32,
867  DataType::Float16,
868  DataType::QSymmS16
869  };
870 
871  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
872  "Reference Floor: input type not supported.");
873 
874  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
875  "Reference Floor: output type not supported.");
876 
877  return supported;
878 }
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:39

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

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

886 {
887  bool supported = true;
888 
889  // Define supported types.
890  std::array<DataType,6> supportedTypes =
891  {
892  DataType::BFloat16,
893  DataType::Float32,
894  DataType::Float16,
895  DataType::QAsymmS8,
896  DataType::QAsymmU8,
897  DataType::QSymmS16
898  };
899 
900  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
901  "Reference Fully Connected: input type not supported.");
902 
903  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
904  "Reference Fully Connected: output type not supported.");
905 
906  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
907  "Reference Fully Connected: weights type not supported.");
908 
909  // For FullyConnected, we allow to have BFloat16 input with Float32 output for optimization.
910  if (input.GetDataType() == DataType::BFloat16)
911  {
912  if (output.GetDataType() != DataType::BFloat16 && output.GetDataType() != DataType::Float32)
913  {
914  reasonIfUnsupported.value() += "Output tensor type must be BFloat16 or Float32 for BFloat16 input.\n";
915  supported = false;
916  }
917  }
918  else
919  {
920  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
921  "Reference Fully Connected: input and output types mismatched.");
922  }
923 
924  ARMNN_NO_DEPRECATE_WARN_BEGIN
925  std::array<DataType, 4> supportedWeightTypes =
926  {
927  DataType::QAsymmS8,
928  DataType::QAsymmU8,
929  DataType::QSymmS8,
930  DataType::QuantizedSymm8PerAxis // deprecated
931  };
932  ARMNN_NO_DEPRECATE_WARN_END
933 
934  if (IsQuantized8BitType(input.GetDataType()))
935  {
936 
937  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
938  "Reference Fully Connected: weights type not supported for quantized input.");
939  }
940  else
941  {
942  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
943  "Reference Fully Connected: weights is not a supported type.");
944 
945  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
946  "Reference Fully Connected: input and weights types mismatched.");
947  }
948 
949  if (descriptor.m_BiasEnabled)
950  {
951  // Defined supported types for bias
952  std::array<DataType, 5>
953  supportedBiasTypes =
954  {
955  DataType::BFloat16,
956  DataType::Float32,
957  DataType::Float16,
958  DataType::Signed32,
959  DataType::QAsymmS8
960  };
961 
962  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
963  "Reference Fully Connected: bias type not supported.");
964 
965  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
966  "Reference Fully Connected: bias and weight types mismatch.");
967 
968  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
969  "Reference Fully Connected: bias type inferred from weights is incompatible.");
970 
971  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
972  "Reference Fully Connected: bias must have 1 dimension.");
973 
974  }
975 
976  return supported;
977 }
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:39

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

References armnn::CheckSupportRule().

983 {
984  bool supported = true;
985  std::array<DataType,6> supportedTypes =
986  {
987  DataType::BFloat16,
988  DataType::Float32,
989  DataType::Float16,
990  DataType::QAsymmS8,
991  DataType::QAsymmU8,
992  DataType::QSymmS16
993  };
994 
995  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
996  "Reference Gather: input type not supported");
997 
998  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
999  "Reference Gather: output type not supported");
1000 
1001  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1002  "Reference Gather: indices (input1) type not supported");
1003 
1004  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1005  "Reference Gather: input and output types not matching");
1006 
1007  return supported;
1008 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

1014 {
1015  return IsComparisonSupported(input0,
1016  input1,
1017  output,
1018  ComparisonDescriptor(ComparisonOperation::Greater),
1019  reasonIfUnsupported);
1020 }
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:301

◆ IsInputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1022 of file RefLayerSupport.cpp.

1024 {
1025  return true;
1026 }

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

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

1032 {
1033  IgnoreUnused(descriptor);
1034  // Define supported types
1035  std::array<DataType, 3> supportedTypes =
1036  {
1037  DataType::BFloat16,
1038  DataType::Float32,
1039  DataType::Float16
1040  };
1041 
1042  bool supported = true;
1043 
1044  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1045  "Reference Instance Normalization: input type not supported.");
1046 
1047  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1048  "Reference Instance Normalization: output type not supported.");
1049 
1050  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1051  "Reference Instance Normalization: input and output types mismatched.");
1052 
1053  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1054  "Reference Instance Normalization: input and output shapes have different "
1055  "num total elements.");
1056 
1057  return supported;
1058 }
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:39

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

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

1064 {
1065  IgnoreUnused(descriptor);
1066  // Define supported types
1067  std::array<DataType, 6> supportedTypes =
1068  {
1069  DataType::BFloat16,
1070  DataType::Float32,
1071  DataType::Float16,
1072  DataType::QAsymmS8,
1073  DataType::QAsymmU8,
1074  DataType::QSymmS16
1075  };
1076 
1077  bool supported = true;
1078 
1079  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1080  "Reference L2normalization: input type not supported.");
1081 
1082  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1083  "Reference L2normalization: output type not supported.");
1084 
1085  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1086  "Reference L2normalization: input and output types mismatched.");
1087 
1088  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1089  "Reference L2normalization: input and output shapes have different "
1090  "num total elements.");
1091 
1092  return supported;
1093 }
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:39

◆ IsLogSoftmaxSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1095 of file RefLayerSupport.cpp.

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

1099 {
1100  IgnoreUnused(descriptor);
1101 
1102  std::array<DataType, 3> supportedTypes =
1103  {
1104  DataType::BFloat16,
1105  DataType::Float32,
1106  DataType::Float16
1107  };
1108 
1109  bool supported = true;
1110  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1111  "Reference LogSoftmax: input type not supported");
1112 
1113  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1114  "Reference LogSoftmax: output type not supported");
1115 
1116  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1117  "Reference LogSoftmax: input and output types do not match");
1118 
1119  return supported;
1120 }
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:39

◆ 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 1122 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.

1132 {
1133  IgnoreUnused(descriptor);
1134  IgnoreUnused(paramsInfo);
1135 
1136  bool supported = true;
1137 
1138  std::array<DataType,3> supportedTypes = {
1139  DataType::BFloat16,
1140  DataType::Float32,
1141  DataType::QSymmS16
1142  };
1143 
1144  // check inputs and outputs
1145  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1146  "Reference Lstm: input is not a supported type.");
1147  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1148  "Reference Lstm: input and outputStateIn types are mismatched");
1149  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1150  "Reference Lstm: input and cellStateIn types are mismatched");
1151  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1152  "Reference Lstm: input and scratchBuffer types are mismatched");
1153  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1154  "Reference Lstm: input and outputStateOut types are mismatched");
1155  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1156  "Reference Lstm: input and cellStateOut types are mismatched");
1157  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1158  "Reference Lstm: input and output types are mismatched");
1159  // check layer parameters
1160  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
1161  "Reference Lstm: input and InputToForgetWeights types are mismatched");
1162  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
1163  "Reference Lstm: input and InputToCellWeights types are mismatched");
1164  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
1165  "Reference Lstm: input and InputToOutputWeights types are mismatched");
1166  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
1167  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
1168  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
1169  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
1170  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
1171  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
1172  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
1173  "Reference Lstm: input and ForgetGateBias types are mismatched");
1174  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
1175  "Reference Lstm: input and CellBias types are mismatched");
1176  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
1177  "Reference Lstm: input and OutputGateBias types are mismatched");
1178  if (!descriptor.m_CifgEnabled)
1179  {
1180  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
1181  "Reference Lstm: input and InputToInputWeights types are mismatched");
1182  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
1183  reasonIfUnsupported,
1184  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
1185  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
1186  "Reference Lstm: input and InputGateBias types are mismatched");
1187  if (descriptor.m_PeepholeEnabled)
1188  {
1189  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
1190  reasonIfUnsupported,
1191  "Reference Lstm: input and CellToInputWeights types are mismatched");
1192  }
1193  }
1194  if (descriptor.m_PeepholeEnabled)
1195  {
1196  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
1197  "Reference Lstm: input and CellToForgetWeights types are mismatched");
1198  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
1199  "Reference Lstm: input and CellToOutputWeights types are mismatched");
1200  }
1201  if (descriptor.m_ProjectionEnabled)
1202  {
1203  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
1204  "Reference Lstm: input and mProjectionWeights types are mismatched");
1205  if (paramsInfo.m_ProjectionBias != nullptr)
1206  {
1207  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
1208  "Reference Lstm: input and ProjectionBias types are mismatched");
1209  }
1210  }
1211  if (descriptor.m_LayerNormEnabled)
1212  {
1213  if (!descriptor.m_CifgEnabled)
1214  {
1215  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
1216  reasonIfUnsupported,
1217  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1218  }
1219  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
1220  reasonIfUnsupported,
1221  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
1222  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
1223  reasonIfUnsupported,
1224  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
1225  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
1226  reasonIfUnsupported,
1227  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1228  }
1229 
1230  return supported;
1231 }
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:39

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

References armnn::CheckSupportRule().

1237 {
1238  bool supported = true;
1239 
1240  std::array<DataType,6> supportedTypes = {
1241  DataType::BFloat16,
1242  DataType::Float32,
1243  DataType::Float16,
1244  DataType::QAsymmS8,
1245  DataType::QAsymmU8,
1246  DataType::QSymmS16
1247  };
1248 
1249  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1250  "Reference maximum: input 0 is not a supported type.");
1251 
1252  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1253  "Reference maximum: input 1 is not a supported type.");
1254 
1255  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1256  "Reference maximum: output is not a supported type.");
1257 
1258  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1259  "Reference maximum: input 0 and Input 1 types are mismatched");
1260 
1261  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1262  "Reference maximum: input and output types are mismatched");
1263 
1264  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1265  "Reference maximum: shapes are not suitable for implicit broadcast.");
1266 
1267  return supported;
1268 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

1274 {
1275  bool supported = true;
1276  std::string meanLayerStr = "Mean";
1277  std::string outputTensorStr = "output";
1278 
1279  std::array<DataType,6> supportedTypes =
1280  {
1281  DataType::BFloat16,
1282  DataType::Float32,
1283  DataType::Float16,
1284  DataType::QAsymmS8,
1285  DataType::QAsymmU8,
1286  DataType::QSymmS16
1287  };
1288 
1289  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1290  "Reference Mean: input type not supported.");
1291 
1292  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1293  "Reference Mean: input and output types are mismatched");
1294 
1295  if (descriptor.m_KeepDims)
1296  {
1297  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1298  reasonIfUnsupported,
1299  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1300  output.GetNumDimensions(),
1301  meanLayerStr, outputTensorStr).data());
1302  }
1303  else if (descriptor.m_Axis.empty())
1304  {
1305  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1306  reasonIfUnsupported,
1307  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1308  meanLayerStr, outputTensorStr).data());
1309  }
1310  else
1311  {
1312  auto outputDim = input.GetNumDimensions() - boost::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1313 
1314  if (outputDim > 0)
1315  {
1316  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1317  reasonIfUnsupported,
1318  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1319  meanLayerStr, outputTensorStr).data());
1320  }
1321  else
1322  {
1323  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1324  reasonIfUnsupported,
1325  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1326  meanLayerStr, outputTensorStr).data());
1327  }
1328  }
1329 
1330  return supported;
1331 }
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:39

◆ IsMemCopySupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1341 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1344 {
1345  bool supported = true;
1346 
1347  std::array<DataType,7> supportedTypes =
1348  {
1349  DataType::BFloat16,
1350  DataType::Float32,
1351  DataType::Float16,
1352  DataType::QAsymmS8,
1353  DataType::QAsymmU8,
1354  DataType::QSymmS16,
1355  DataType::Boolean
1356  };
1357 
1358  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1359  "Reference MemCopy: input type not supported");
1360 
1361  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1362  "Reference MemCopy: output type not supported");
1363 
1364  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1365  "Reference MemCopy: input and output types are mismatched");
1366 
1367  return supported;
1368 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

References armnn::IsConcatSupported().

1337 {
1338  return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
1339 }
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:333

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

References armnn::CheckSupportRule().

1374 {
1375  bool supported = true;
1376 
1377  std::array<DataType,6> supportedTypes = {
1378  DataType::BFloat16,
1379  DataType::Float32,
1380  DataType::Float16,
1381  DataType::QAsymmS8,
1382  DataType::QAsymmU8,
1383  DataType::QSymmS16
1384  };
1385 
1386  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1387  "Reference minimum: input 0 is not a supported type.");
1388 
1389  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1390  "Reference minimum: input 1 is not a supported type.");
1391 
1392  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1393  "Reference minimum: output is not a supported type.");
1394 
1395  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1396  "Reference minimum: input 0 and Input 1 types are mismatched");
1397 
1398  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1399  "Reference minimum: input and output types are mismatched");
1400 
1401  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1402  "Reference minimum: shapes are not suitable for implicit broadcast.");
1403 
1404  return supported;
1405 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

References armnn::CheckSupportRule().

1411 {
1412  bool supported = true;
1413 
1414  std::array<DataType,6> supportedTypes = {
1415  DataType::BFloat16,
1416  DataType::Float32,
1417  DataType::Float16,
1418  DataType::QAsymmS8,
1419  DataType::QAsymmU8,
1420  DataType::QSymmS16
1421  };
1422 
1423  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1424  "Reference multiplication: input 0 is not a supported type.");
1425 
1426  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1427  "Reference multiplication: input 1 is not a supported type.");
1428 
1429  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1430  "Reference multiplication: output is not a supported type.");
1431 
1432  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1433  "Reference multiplication: input 0 and Input 1 types are mismatched");
1434 
1435  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1436  "Reference multiplication: input and output types are mismatched");
1437 
1438  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1439  "Reference multiplication: shapes are not suitable for implicit broadcast.");
1440 
1441  return supported;
1442 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

1448 {
1449  IgnoreUnused(descriptor);
1450 
1451  // Define supported types
1452  std::array<DataType, 6> supportedTypes =
1453  {
1454  DataType::BFloat16,
1455  DataType::Float16,
1456  DataType::Float32,
1457  DataType::QAsymmS8,
1458  DataType::QAsymmU8,
1459  DataType::QSymmS16
1460  };
1461 
1462  bool supported = true;
1463 
1464  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1465  "Reference normalization: input type not supported.");
1466 
1467  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1468  "Reference normalization: output type not supported.");
1469 
1470  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1471  "Reference normalization: input and output shapes have different "
1472  "num total elements.");
1473 
1474  return supported;
1475 }
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:39

◆ IsOutputSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1477 of file RefLayerSupport.cpp.

1479 {
1480  return true;
1481 }

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

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

1487 {
1488  IgnoreUnused(descriptor);
1489  bool supported = true;
1490 
1491  // Define supported output and inputs types.
1492  std::array<DataType,6> supportedTypes =
1493  {
1494  DataType::BFloat16,
1495  DataType::Float32,
1496  DataType::Float16,
1497  DataType::QAsymmS8,
1498  DataType::QAsymmU8,
1499  DataType::QSymmS16
1500  };
1501 
1502  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1503  "Reference pad: input is not a supported type.");
1504 
1505  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1506  "Reference pad: output is not a supported type.");
1507 
1508  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1509  "Reference pad: input and output types are mismatched.");
1510 
1511  return supported;
1512 }
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:39

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

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

1518 {
1519  IgnoreUnused(descriptor);
1520  bool supported = true;
1521 
1522  // Define supported output and inputs types.
1523  std::array<DataType, 6> supportedTypes =
1524  {
1525  DataType::BFloat16,
1526  DataType::Float32,
1527  DataType::Float16,
1528  DataType::QAsymmS8,
1529  DataType::QAsymmU8,
1530  DataType::QSymmS16
1531  };
1532 
1533  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1534  "Reference permute: input is not a supported type.");
1535 
1536  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1537  "Reference permute: output is not a supported type.");
1538 
1539  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1540  "Reference permute: input and output types are mismatched.");
1541 
1542  return supported;
1543 }
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:39

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

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

1549 {
1550  IgnoreUnused(descriptor);
1551  bool supported = true;
1552 
1553  // Define supported output and inputs types.
1554  std::array<DataType,6> supportedTypes =
1555  {
1556  DataType::BFloat16,
1557  DataType::Float32,
1558  DataType::Float16,
1559  DataType::QAsymmS8,
1560  DataType::QAsymmU8,
1561  DataType::QSymmS16
1562  };
1563 
1564  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1565  "Reference poolind2d: input is not a supported type.");
1566 
1567  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1568  "Reference poolind2d: output is not a supported type.");
1569 
1570  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1571  "Reference poolind2d: input and output types are mismatched.");
1572 
1573  return supported;
1574 }
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:39

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

References armnn::CheckSupportRule().

2000 {
2001  bool supported = true;
2002 
2003  std::array<DataType, 6> supportedTypes
2004  {
2005  DataType::BFloat16,
2006  DataType::Float32,
2007  DataType::Float16,
2008  DataType::QAsymmS8,
2009  DataType::QAsymmU8,
2010  DataType::QSymmS16
2011  };
2012 
2013  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2014  "PReLU: input is not a supported type.");
2015 
2016  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
2017  "PReLU: alpha is not a supported type.");
2018 
2019  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2020  "PReLU: output is not a supported type.");
2021 
2022  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
2023  "PReLU: input, alpha and output types are mismatched");
2024 
2025  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
2026  "PReLU: shapes are not suitable for implicit broadcast");
2027 
2028  return supported;
2029 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

◆ IsQLstmSupported()

bool IsQLstmSupported ( const TensorInfo &  input,
const TensorInfo &  previousOutputIn,
const TensorInfo &  previousCellStateIn,
const TensorInfo &  outputStateOut,
const TensorInfo &  cellStateOut,
const TensorInfo &  output,
const QLstmDescriptor &  descriptor,
const LstmInputParamsInfo &  paramsInfo,
Optional< std::string &>  reasonIfUnsupported = EmptyOptional() 
) const
overridevirtual

Reimplemented from LayerSupportBase.

Definition at line 1576 of file RefLayerSupport.cpp.

References armnn::IgnoreUnused().

1585 {
1586  IgnoreUnused(input);
1587  IgnoreUnused(previousOutputIn);
1588  IgnoreUnused(previousCellStateIn);
1589  IgnoreUnused(outputStateOut);
1590  IgnoreUnused(cellStateOut);
1591  IgnoreUnused(output);
1592  IgnoreUnused(descriptor);
1593  IgnoreUnused(paramsInfo);
1594 
1595  IgnoreUnused(reasonIfUnsupported);
1596 
1597  return true;
1598 }
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14

◆ IsQuantizeSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1600 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1603 {
1604  bool supported = true;
1605 
1606  // Define supported input types.
1607  std::array<DataType,7> supportedInputTypes = {
1608  DataType::BFloat16,
1609  DataType::Float32,
1610  DataType::Float16,
1611  DataType::QAsymmS8,
1612  DataType::QAsymmU8,
1613  DataType::QSymmS8,
1614  DataType::QSymmS16
1615  };
1616 
1617  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1618  "Reference quantize: input type not supported.");
1619 
1620  // Define supported output types.
1621  std::array<DataType,4> supportedOutputTypes = {
1622  DataType::QAsymmS8,
1623  DataType::QAsymmU8,
1624  DataType::QSymmS8,
1625  DataType::QSymmS16
1626  };
1627  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1628  "Reference quantize: output type not supported.");
1629 
1630  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1631  "Reference quantize: input and output shapes have different num total elements.");
1632 
1633  return supported;
1634 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

1640 {
1641  IgnoreUnused(output);
1642  IgnoreUnused(descriptor);
1643  // Define supported output types.
1644  std::array<DataType,7> supportedOutputTypes =
1645  {
1646  DataType::BFloat16,
1647  DataType::Float32,
1648  DataType::Float16,
1649  DataType::Signed32,
1650  DataType::QAsymmS8,
1651  DataType::QAsymmU8,
1652  DataType::QSymmS16
1653  };
1654 
1655  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1656  "Reference reshape: input type not supported.");
1657 }
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:39

◆ IsResizeBilinearSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1659 of file RefLayerSupport.cpp.

References armnn::CheckSupportRule().

1662 {
1663  bool supported = true;
1664  std::array<DataType,6> supportedTypes =
1665  {
1666  DataType::BFloat16,
1667  DataType::Float32,
1668  DataType::Float16,
1669  DataType::QAsymmS8,
1670  DataType::QAsymmU8,
1671  DataType::QSymmS16
1672  };
1673 
1674  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1675  "Reference ResizeBilinear: input type not supported");
1676 
1677  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1678  "Reference ResizeBilinear: output type not supported");
1679 
1680  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1681  "Reference ResizeBilinear: input and output types not matching");
1682 
1683  return supported;
1684 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

1690 {
1691  IgnoreUnused(descriptor);
1692  bool supported = true;
1693  std::array<DataType,6> supportedTypes =
1694  {
1695  DataType::BFloat16,
1696  DataType::Float32,
1697  DataType::Float16,
1698  DataType::QAsymmS8,
1699  DataType::QAsymmU8,
1700  DataType::QSymmS16
1701  };
1702 
1703  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1704  "Reference Resize: input type not supported");
1705 
1706  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1707  "Reference Resize: output type not supported");
1708 
1709  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1710  "Reference Resize: input and output types not matching");
1711 
1712  return supported;
1713 }
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:39

◆ IsRsqrtSupported()

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

Reimplemented from LayerSupportBase.

Definition at line 1715 of file RefLayerSupport.cpp.

1718 {
1719  return IsElementwiseUnarySupported(input,
1720  output,
1721  ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt),
1722  reasonIfUnsupported);
1723 }
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const override
Definition: RefLayerSupport.cpp:790

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

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

1729 {
1730  IgnoreUnused(descriptor);
1731  bool supported = true;
1732 
1733  std::array<DataType, 5> supportedTypes =
1734  {
1735  DataType::BFloat16,
1736  DataType::Float32,
1737  DataType::QAsymmS8,
1738  DataType::QAsymmU8,
1739  DataType::QSymmS16
1740  };
1741 
1742  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1743  "Reference Slice: input type not supported");
1744 
1745  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1746  "Reference Slice: output type not supported");
1747 
1748  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1749  "Reference Slice: input and output types are mismatched");
1750 
1751  return supported;
1752 }
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:39

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

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

1758 {
1759  IgnoreUnused(descriptor);
1760  bool supported = true;
1761  std::array<DataType,7> supportedTypes =
1762  {
1763  DataType::BFloat16,
1764  DataType::Float32,
1765  DataType::Float16,
1766  DataType::QSymmS8,
1767  DataType::QAsymmS8,
1768  DataType::QAsymmU8,
1769  DataType::QSymmS16
1770  };
1771 
1772  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1773  "Reference Softmax: output type not supported");
1774 
1775  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1776  "Reference Softmax: input type not supported");
1777 
1778  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1779  "Reference Softmax: input type not supported");
1780 
1781  return supported;
1782 }
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:39

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

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

1788 {
1789  IgnoreUnused(descriptor);
1790  bool supported = true;
1791  std::array<DataType,6> supportedTypes =
1792  {
1793  DataType::BFloat16,
1794  DataType::Float32,
1795  DataType::Float16,
1796  DataType::QAsymmS8,
1797  DataType::QAsymmU8,
1798  DataType::QSymmS16
1799  };
1800 
1801  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1802  "Reference SpaceToBatchNd: input type not supported");
1803 
1804  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1805  "Reference SpaceToBatchNd: output type not supported");
1806 
1807  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1808  "Reference SpaceToBatchNd: input and output types are mismatched");
1809 
1810  return supported;
1811 }
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:39

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

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

1817 {
1818 
1819  IgnoreUnused(descriptor);
1820  bool supported = true;
1821 
1822  std::array<DataType,6> supportedTypes =
1823  {
1824  DataType::BFloat16,
1825  DataType::Float32,
1826  DataType::Float16,
1827  DataType::QAsymmS8,
1828  DataType::QAsymmU8,
1829  DataType::QSymmS16
1830  };
1831 
1832  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1833  "Reference SpaceToDepth: input type not supported");
1834 
1835  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1836  "Reference SpaceToDepth: output type not supported");
1837 
1838  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1839  "Reference SpaceToDepth: input and output types are mismatched");
1840 
1841  return supported;
1842 }
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:39

◆ IsSplitterSupported() [1/2]

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

Reimplemented from LayerSupportBase.

Definition at line 1844 of file RefLayerSupport.cpp.

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

1847 {
1848  IgnoreUnused(descriptor);
1849  bool supported = true;
1850  std::array<DataType,6> supportedTypes =
1851  {
1852  DataType::BFloat16,
1853  DataType::Float32,
1854  DataType::Float16,
1855  DataType::QAsymmS8,
1856  DataType::QAsymmU8,
1857  DataType::QSymmS16
1858  };
1859 
1860  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1861  "Reference splitter: input type not supported");
1862 
1863  return supported;
1864 }
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:39

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

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

1870 {
1871  IgnoreUnused(descriptor);
1872  bool supported = true;
1873  std::array<DataType,6> supportedTypes =
1874  {
1875  DataType::BFloat16,
1876  DataType::Float32,
1877  DataType::Float16,
1878  DataType::QAsymmS8,
1879  DataType::QAsymmU8,
1880  DataType::QSymmS16
1881  };
1882 
1883  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1884  "Reference splitter: output type not supported");
1885  for (const TensorInfo output : outputs)
1886  {
1887  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1888  "Reference splitter: input type not supported");
1889 
1890  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1891  "Reference splitter: input and output types mismatched.");
1892  }
1893 
1894  return supported;
1895 }
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:39

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

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

1901 {
1902  IgnoreUnused(descriptor);
1903 
1904  bool supported = true;
1905  std::array<DataType,6> supportedTypes =
1906  {
1907  DataType::BFloat16,
1908  DataType::Float32,
1909  DataType::Float16,
1910  DataType::QAsymmS8,
1911  DataType::QAsymmU8,
1912  DataType::QSymmS16
1913  };
1914 
1915  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1916  "Reference stack: output type not supported");
1917  for (const TensorInfo* input : inputs)
1918  {
1919  ARMNN_ASSERT(input != nullptr);
1920  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
1921  "Reference stack: input type not supported");
1922 
1923  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
1924  "Reference stack: input and output types mismatched.");
1925  }
1926 
1927  return supported;
1928 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

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

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

1934 {
1935  IgnoreUnused(descriptor);
1936  bool supported = true;
1937 
1938  std::array<DataType,5> supportedTypes =
1939  {
1940  DataType::BFloat16,
1941  DataType::Float32,
1942  DataType::QAsymmS8,
1943  DataType::QAsymmU8,
1944  DataType::QSymmS16
1945  };
1946 
1947  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1948  "Reference StridedSlice: input type not supported");
1949 
1950  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1951  "Reference StridedSlice: output type not supported");
1952 
1953  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1954  "Reference StridedSlice: input and output types are mismatched");
1955 
1956  return supported;
1957 }
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:39

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

References armnn::CheckSupportRule().

1963 {
1964  bool supported = true;
1965 
1966  std::array<DataType,6> supportedTypes = {
1967  DataType::BFloat16,
1968  DataType::Float32,
1969  DataType::Float16,
1970  DataType::QAsymmS8,
1971  DataType::QAsymmU8,
1972  DataType::QSymmS16
1973  };
1974 
1975  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1976  "Reference subtraction: input 0 is not a supported type.");
1977 
1978  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1979  "Reference subtraction: input 1 is not a supported type.");
1980 
1981  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1982  "Reference subtraction: output is not a supported type.");
1983 
1984  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1985  "Reference subtraction: input 0 and Input 1 types are mismatched");
1986 
1987  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1988  "Reference subtraction: input and output types are mismatched");
1989 
1990  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1991  "Reference subtraction: shapes are not suitable for implicit broadcast.");
1992 
1993  return supported;
1994 }
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:39

◆ 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 2031 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().

2037 {
2038  IgnoreUnused(descriptor);
2039  bool supported = true;
2040 
2041  std::array<DataType,7> supportedTypes =
2042  {
2043  DataType::BFloat16,
2044  DataType::Float32,
2045  DataType::Float16,
2046  DataType::QAsymmS8,
2047  DataType::QAsymmU8,
2048  DataType::QSymmS8,
2049  DataType::QSymmS16
2050  };
2051 
2052  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2053  "Reference TransposeConvolution2d: input is not a supported type.");
2054 
2055  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2056  "Reference TransposeConvolution2d: output is not a supported type.");
2057 
2058  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2059  "Reference TransposeConvolution2d: input and output types mismatched.");
2060 
2061 
2062  const DataType inputType = input.GetDataType();
2063  if (IsQuantized8BitType(inputType))
2064  {
2065  ARMNN_NO_DEPRECATE_WARN_BEGIN
2066  std::array<DataType, 4> supportedWeightTypes =
2067  {
2068  DataType::QAsymmS8,
2069  DataType::QAsymmU8,
2070  DataType::QSymmS8,
2071  DataType::QuantizedSymm8PerAxis //Deprecated
2072  };
2073  ARMNN_NO_DEPRECATE_WARN_END
2074 
2075  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
2076  "Reference TransposeConvolution2d: weights type not supported for "
2077  "quantized input.");
2078  }
2079  else
2080  {
2081  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
2082  "Reference TransposeConvolution2d: weights is not a supported type.");
2083 
2084  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
2085  "Reference TransposeConvolution2d: input and weights types mismatched.");
2086  }
2087 
2088  if (biases.has_value())
2089  {
2090  std::array<DataType,4> biasesSupportedTypes =
2091  {
2092  DataType::BFloat16,
2093  DataType::Float32,
2094  DataType::Float16,
2095  DataType::Signed32
2096  };
2097  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
2098  "Reference TransposeConvolution2d: biases is not a supported type.");
2099  }
2100 
2101  return supported;
2102 }
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:39

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

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

2108 {
2109  IgnoreUnused(descriptor);
2110  bool supported = true;
2111 
2112  // Define supported output and inputs types.
2113  std::array<DataType, 6> supportedTypes =
2114  {
2115  DataType::BFloat16,
2116  DataType::Float32,
2117  DataType::Float16,
2118  DataType::QAsymmS8,
2119  DataType::QAsymmU8,
2120  DataType::QSymmS16
2121  };
2122 
2123  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2124  "Reference transpose: input is not a supported type.");
2125 
2126  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2127  "Reference transpose: output is not a supported type.");
2128 
2129  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2130  "Reference transpose: input and output types are mismatched.");
2131 
2132  return supported;
2133 }
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:39
The documentation for this class was generated from the following files: