ArmNN
 23.02
Public Member Functions | List of all members
LayerSupportHandle Class Reference

#include <BackendHelper.hpp>

Public Member Functions

 LayerSupportHandle (std::shared_ptr< ILayerSupport > layerSupport)
 
 LayerSupportHandle (std::shared_ptr< ILayerSupport > layerSupport, const BackendId &backendId)
 
bool IsBackendRegistered () const
 
bool IsActivationSupported (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsAdditionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsArgMinMaxSupported (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsBatchMatMulSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
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())
 
bool IsBatchToSpaceNdSupported (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsCastSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsChannelShuffleSupported (const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsComparisonSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsConcatSupported (const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsConstantSupported (const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsConvertFp16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsConvertFp32ToFp16Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsConvolution3dSupported (const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsDebugSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsDepthToSpaceSupported (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsDequantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
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())
 
bool IsDilatedDepthwiseConvolutionSupported (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsDivisionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsElementwiseUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsFakeQuantizationSupported (const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsFillSupported (const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsFloorSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsFullyConnectedSupported (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsGatherSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsGatherNdSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsInputSupported (const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsInstanceNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsL2NormalizationSupported (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsLogicalBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsLogicalUnarySupported (const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsLogSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
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())
 
bool IsMaximumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsMeanSupported (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsMemCopySupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsMemImportSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsMergeSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsMinimumSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsMultiplicationSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsNormalizationSupported (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsOutputSupported (const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsPadSupported (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsPermuteSupported (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsPooling2dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsPooling3dSupported (const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsPreCompiledSupported (const TensorInfo &input, const PreCompiledDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsPreluSupported (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsQuantizeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
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())
 
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())
 
bool IsRankSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsReduceSupported (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsReshapeSupported (const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsResizeSupported (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsShapeSupported (const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSliceSupported (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSoftmaxSupported (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSpaceToBatchNdSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSpaceToDepthSupported (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSplitterSupported (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsStackSupported (const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsStandInSupported (const std::vector< const TensorInfo * > &inputs, const std::vector< const TensorInfo * > &outputs, const StandInDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsStridedSliceSupported (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSubtractionSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsSwitchSupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsTransposeConvolution2dSupported (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsTransposeSupported (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 
bool IsUnidirectionalSequenceLstmSupported (const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional())
 

Detailed Description

Definition at line 29 of file BackendHelper.hpp.

Constructor & Destructor Documentation

◆ LayerSupportHandle() [1/2]

LayerSupportHandle ( std::shared_ptr< ILayerSupport >  layerSupport)
inlineexplicit

Definition at line 32 of file BackendHelper.hpp.

33  : m_LayerSupport(std::move(layerSupport)), m_BackendId(Compute::Undefined) {};

References armnn::Undefined.

◆ LayerSupportHandle() [2/2]

LayerSupportHandle ( std::shared_ptr< ILayerSupport >  layerSupport,
const BackendId &  backendId 
)
inlineexplicit

Definition at line 35 of file BackendHelper.hpp.

36  : m_LayerSupport(std::move(layerSupport)), m_BackendId(backendId) {};

Member Function Documentation

◆ IsActivationSupported()

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

Definition at line 144 of file BackendHelper.cpp.

148 {
149  TensorInfos infos{input, output};
150 
151  return m_LayerSupport->IsLayerSupported(LayerType::Activation,
152  infos,
153  descriptor,
154  EmptyOptional(),
155  EmptyOptional(),
156  reasonIfUnsupported);
157 }

References armnn::Activation.

◆ IsAdditionSupported()

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

Definition at line 159 of file BackendHelper.cpp.

163 {
164  TensorInfos infos{input0, input1, output};
165 
166  return m_LayerSupport->IsLayerSupported(LayerType::Addition,
167  infos,
168  BaseDescriptor(),
169  EmptyOptional(),
170  EmptyOptional(),
171  reasonIfUnsupported);
172 }

References armnn::Addition.

◆ IsArgMinMaxSupported()

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

Definition at line 174 of file BackendHelper.cpp.

178 {
179  TensorInfos infos{input, output};
180 
181  return m_LayerSupport->IsLayerSupported(LayerType::ArgMinMax,
182  infos,
183  descriptor,
184  EmptyOptional(),
185  EmptyOptional(),
186  reasonIfUnsupported);
187 }

References armnn::ArgMinMax.

◆ IsBackendRegistered()

bool IsBackendRegistered ( ) const

Definition at line 132 of file BackendHelper.cpp.

133 {
134  if (m_LayerSupport)
135  {
136  return true;
137  }
138 
139  return false;
140 }

◆ IsBatchMatMulSupported()

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

Definition at line 189 of file BackendHelper.cpp.

194 {
195  TensorInfos infos{input0, input1, output};
196 
197  return m_LayerSupport->IsLayerSupported(LayerType::BatchMatMul,
198  infos,
199  descriptor,
200  EmptyOptional(),
201  EmptyOptional(),
202  reasonIfUnsupported);
203 }

References armnn::BatchMatMul.

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

Definition at line 205 of file BackendHelper.cpp.

213 {
214  TensorInfos infos{input, output, mean, var, beta, gamma};
215 
216  return m_LayerSupport->IsLayerSupported(LayerType::BatchNormalization,
217  infos,
218  descriptor,
219  EmptyOptional(),
220  EmptyOptional(),
221  reasonIfUnsupported);
222 }

References armnn::BatchNormalization.

◆ IsBatchToSpaceNdSupported()

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

Definition at line 224 of file BackendHelper.cpp.

228 {
229  TensorInfos infos{input, output};
230 
231  return m_LayerSupport->IsLayerSupported(LayerType::BatchToSpaceNd,
232  infos,
233  descriptor,
234  EmptyOptional(),
235  EmptyOptional(),
236  reasonIfUnsupported);
237 }

References armnn::BatchToSpaceNd.

◆ IsCastSupported()

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

Definition at line 239 of file BackendHelper.cpp.

242 {
243  TensorInfos infos{input, output};
244 
245  return m_LayerSupport->IsLayerSupported(LayerType::Cast,
246  infos,
247  BaseDescriptor(),
248  EmptyOptional(),
249  EmptyOptional(),
250  reasonIfUnsupported);
251 }

References armnn::Cast.

◆ IsChannelShuffleSupported()

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

Definition at line 253 of file BackendHelper.cpp.

257 {
258  TensorInfos infos{input, output};
259 
260  return m_LayerSupport->IsLayerSupported(LayerType::ChannelShuffle,
261  infos,
262  descriptor,
263  EmptyOptional(),
264  EmptyOptional(),
265  reasonIfUnsupported);
266 }

References armnn::ChannelShuffle.

◆ IsComparisonSupported()

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

Definition at line 268 of file BackendHelper.cpp.

273 {
274  TensorInfos infos{input0, input1, output};
275 
276  return m_LayerSupport->IsLayerSupported(LayerType::Comparison,
277  infos,
278  descriptor,
279  EmptyOptional(),
280  EmptyOptional(),
281  reasonIfUnsupported);
282 }

References armnn::Comparison.

◆ IsConcatSupported()

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

Definition at line 284 of file BackendHelper.cpp.

288 {
289  TensorInfos infos;
290  for (const TensorInfo* inputInfo : inputs)
291  {
292  infos.push_back(*inputInfo);
293  }
294  infos.push_back(output);
295 
296  return m_LayerSupport->IsLayerSupported(LayerType::Concat,
297  infos,
298  descriptor,
299  EmptyOptional(),
300  EmptyOptional(),
301  reasonIfUnsupported);
302 }

References armnn::Concat.

◆ IsConstantSupported()

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

Definition at line 304 of file BackendHelper.cpp.

306 {
307  TensorInfos infos{output};
308 
309  return m_LayerSupport->IsLayerSupported(LayerType::Constant,
310  infos,
311  BaseDescriptor(),
312  EmptyOptional(),
313  EmptyOptional(),
314  reasonIfUnsupported);
315 }

References armnn::Constant.

◆ IsConvertFp16ToFp32Supported()

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

Definition at line 317 of file BackendHelper.cpp.

320 {
321  TensorInfos infos{input, output};
322 
323  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp16ToFp32,
324  infos,
325  BaseDescriptor(),
326  EmptyOptional(),
327  EmptyOptional(),
328  reasonIfUnsupported);
329 }

References armnn::ConvertFp16ToFp32.

◆ IsConvertFp32ToFp16Supported()

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

Definition at line 331 of file BackendHelper.cpp.

334 {
335  TensorInfos infos{input, output};
336 
337  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp32ToFp16,
338  infos,
339  BaseDescriptor(),
340  EmptyOptional(),
341  EmptyOptional(),
342  reasonIfUnsupported);
343 }

References armnn::ConvertFp32ToFp16.

◆ IsConvolution2dSupported()

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

Definition at line 345 of file BackendHelper.cpp.

351 {
352  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
353  TensorInfos infos{input, output, weights, biasesVal};
354 
355  Optional<const BackendOptions::BackendOption> capability ;
356  if (!m_BackendId.IsUndefined())
357  {
358  capability = GetCapability("NonConstWeights", m_BackendId);
359  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
360  {
361  if (!weights.IsConstant())
362  {
363  if (reasonIfUnsupported.has_value())
364  {
365  reasonIfUnsupported.value() =
366  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
367  "Convolution2d weights are set as dynamic (non constant). ";
368  }
369  return false;
370  }
371  if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
372  {
373  if (reasonIfUnsupported.has_value())
374  {
375  reasonIfUnsupported.value() =
376  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
377  "Convolution2d biases are set as dynamic (non constant). ";
378  }
379  return false;
380  }
381 
382  // At the first stage we will only print a warning. this is to give
383  // backend developers a chance to adopt and read weights from input slots.
384  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
385  "If you are a backend developer please find more information in our "
386  "doxygen documentation on github https://github.com/ARM-software/armnn "
387  "under the keyword 'ConstTensorsAsInputs'.";
388  }
389  }
390 
391  return m_LayerSupport->IsLayerSupported(LayerType::Convolution2d,
392  infos,
393  descriptor,
394  EmptyOptional(),
395  EmptyOptional(),
396  reasonIfUnsupported);
397 }

References ARMNN_LOG, armnn::Convolution2d, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), Convolution2dDescriptor::m_BiasEnabled, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), OptionalReferenceSwitch< IsReference, T >::value(), and armnn::warning.

◆ IsConvolution3dSupported()

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

Definition at line 399 of file BackendHelper.cpp.

405 {
406  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
407  TensorInfos infos{input, output, weights, biasesVal};
408 
409  return m_LayerSupport->IsLayerSupported(LayerType::Convolution3d,
410  infos,
411  descriptor,
412  EmptyOptional(),
413  EmptyOptional(),
414  reasonIfUnsupported);
415 }

References armnn::Convolution3d, OptionalBase::has_value(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

◆ IsDebugSupported()

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

Definition at line 417 of file BackendHelper.cpp.

420 {
421  TensorInfos infos{input, output};
422 
423  return m_LayerSupport->IsLayerSupported(LayerType::Debug,
424  infos,
425  BaseDescriptor(),
426  EmptyOptional(),
427  EmptyOptional(),
428  reasonIfUnsupported);
429 }

References armnn::Debug.

◆ IsDepthToSpaceSupported()

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

Definition at line 431 of file BackendHelper.cpp.

435 {
436  TensorInfos infos{input, output};
437 
438  return m_LayerSupport->IsLayerSupported(LayerType::DepthToSpace,
439  infos,
440  descriptor,
441  EmptyOptional(),
442  EmptyOptional(),
443  reasonIfUnsupported);
444 }

References armnn::DepthToSpace.

◆ IsDepthwiseConvolutionSupported()

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

Definition at line 446 of file BackendHelper.cpp.

453 {
454  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
455  TensorInfos infos{input, output, weights, biasesVal};
456 
457  Optional<const BackendOptions::BackendOption> capability ;
458  if (!m_BackendId.IsUndefined())
459  {
460  capability = GetCapability("NonConstWeights", m_BackendId);
461  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
462  {
463  if (!weights.IsConstant())
464  {
465  if (reasonIfUnsupported.has_value())
466  {
467  reasonIfUnsupported.value() =
468  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
469  "DepthwiseConvolution2d weights are set as dynamic (non constant). ";
470  }
471  return false;
472  }
473  if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
474  {
475  if (reasonIfUnsupported.has_value())
476  {
477  reasonIfUnsupported.value() =
478  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
479  "DepthwiseConvolution2d biases are set as dynamic (non constant). ";
480  }
481  return false;
482  }
483  // At the first stage we will only print a warning. this is to give
484  // backend developers a chance to adopt and read weights from input slots.
485  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
486  "If you are a backend developer please find more information in our "
487  "doxygen documentation on github https://github.com/ARM-software/armnn "
488  "under the keyword 'ConstTensorsAsInputs'.";
489  }
490  }
491 
492  return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
493  infos,
494  descriptor,
495  EmptyOptional(),
496  EmptyOptional(),
497  reasonIfUnsupported);
498 }

References ARMNN_LOG, armnn::DepthwiseConvolution2d, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), DepthwiseConvolution2dDescriptor::m_BiasEnabled, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), OptionalReferenceSwitch< IsReference, T >::value(), and armnn::warning.

◆ IsDequantizeSupported()

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

Definition at line 500 of file BackendHelper.cpp.

503 {
504  TensorInfos infos{input, output};
505 
506  return m_LayerSupport->IsLayerSupported(LayerType::Dequantize,
507  infos,
508  BaseDescriptor(),
509  EmptyOptional(),
510  EmptyOptional(),
511  reasonIfUnsupported);
512 }

References armnn::Dequantize.

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

Definition at line 514 of file BackendHelper.cpp.

523 {
524  TensorInfos infos{boxEncodings, scores, anchors, detectionBoxes, detectionClasses, detectionScores, numDetections};
525 
526  return m_LayerSupport->IsLayerSupported(LayerType::DetectionPostProcess,
527  infos,
528  descriptor,
529  EmptyOptional(),
530  EmptyOptional(),
531  reasonIfUnsupported);
532 }

References armnn::DetectionPostProcess.

◆ IsDilatedDepthwiseConvolutionSupported()

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

Definition at line 534 of file BackendHelper.cpp.

541 {
542  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
543  TensorInfos infos{input, output, weights, biasesVal};
544 
545  Optional<const BackendOptions::BackendOption> capability ;
546  if (!m_BackendId.IsUndefined())
547  {
548  capability = GetCapability("NonConstWeights", m_BackendId);
549  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
550  {
551  if (!weights.IsConstant())
552  {
553  if (reasonIfUnsupported.has_value())
554  {
555  reasonIfUnsupported.value() =
556  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
557  "DilatedDepthwiseConvolution2d weights are set as dynamic (non constant). ";
558  }
559  return false;
560  }
561  if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
562  {
563  if (reasonIfUnsupported.has_value())
564  {
565  reasonIfUnsupported.value() =
566  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
567  "DilatedDepthwiseConvolution2d biases are set as dynamic (non constant). ";
568  }
569  return false;
570  }
571  // At the first stage we will only print a warning. this is to give
572  // backend developers a chance to adopt and read weights from input slots.
573  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
574  "If you are a backend developer please find more information in our "
575  "doxygen documentation on github https://github.com/ARM-software/armnn "
576  "under the keyword 'ConstTensorsAsInputs'.";
577  }
578  }
579 
580  return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
581  infos,
582  descriptor,
583  EmptyOptional(),
584  EmptyOptional(),
585  reasonIfUnsupported);
586 }

References ARMNN_LOG, armnn::DepthwiseConvolution2d, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), DepthwiseConvolution2dDescriptor::m_BiasEnabled, OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), OptionalReferenceSwitch< IsReference, T >::value(), and armnn::warning.

◆ IsDivisionSupported()

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

Definition at line 588 of file BackendHelper.cpp.

592 {
593  TensorInfos infos{input0, input1, output};
594 
595  return m_LayerSupport->IsLayerSupported(LayerType::Division,
596  infos,
597  BaseDescriptor(),
598  EmptyOptional(),
599  EmptyOptional(),
600  reasonIfUnsupported);
601 }

References armnn::Division.

◆ IsElementwiseUnarySupported()

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

Definition at line 603 of file BackendHelper.cpp.

607 {
608  TensorInfos infos{input, output};
609 
610  return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseUnary,
611  infos,
612  descriptor,
613  EmptyOptional(),
614  EmptyOptional(),
615  reasonIfUnsupported);
616 }

References armnn::ElementwiseUnary.

◆ IsFakeQuantizationSupported()

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

Definition at line 618 of file BackendHelper.cpp.

621 {
622  TensorInfos infos{input};
623 
624  return m_LayerSupport->IsLayerSupported(LayerType::FakeQuantization,
625  infos,
626  descriptor,
627  EmptyOptional(),
628  EmptyOptional(),
629  reasonIfUnsupported);
630 }

References armnn::FakeQuantization.

◆ IsFillSupported()

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

Definition at line 632 of file BackendHelper.cpp.

636 {
637  TensorInfos infos{input, output};
638 
639  return m_LayerSupport->IsLayerSupported(LayerType::Fill,
640  infos,
641  descriptor,
642  EmptyOptional(),
643  EmptyOptional(),
644  reasonIfUnsupported);
645 }

References armnn::Fill.

◆ IsFloorSupported()

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

Definition at line 647 of file BackendHelper.cpp.

650 {
651  TensorInfos infos{input, output};
652 
653  return m_LayerSupport->IsLayerSupported(LayerType::Floor,
654  infos,
655  BaseDescriptor(),
656  EmptyOptional(),
657  EmptyOptional(),
658  reasonIfUnsupported);
659 }

References armnn::Floor.

◆ IsFullyConnectedSupported()

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

Definition at line 661 of file BackendHelper.cpp.

667 {
668  TensorInfos infos{input, output, weights, biases};
669 
670  Optional<const BackendOptions::BackendOption> capability;
671  if (!m_BackendId.IsUndefined())
672  {
673  capability = GetCapability("NonConstWeights", m_BackendId);
674  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
675  {
676  if (!descriptor.m_ConstantWeights)
677  {
678  if (reasonIfUnsupported.has_value())
679  {
680  reasonIfUnsupported.value() =
681  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
682  "FullyConnected descriptor indicates that weights are dynamic (non constant). ";
683  }
684  return false;
685  }
686  if (!weights.IsConstant())
687  {
688  if (reasonIfUnsupported.has_value())
689  {
690  reasonIfUnsupported.value() =
691  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
692  "FullyConnected weights are set as dynamic (non constant). ";
693  }
694 
695  return false;
696  }
697  if (descriptor.m_BiasEnabled && !biases.IsConstant())
698  {
699  if (reasonIfUnsupported.has_value())
700  {
701  reasonIfUnsupported.value() =
702  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
703  "FullyConnected biases are set as dynamic (non constant). ";
704  }
705  return false;
706  }
707 
708  // At the first stage we will only print a warning. this is to give
709  // backend developers a chance to adopt and read weights from input slots.
710  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
711  "If you are a backend developer please find more information in our "
712  "doxygen documentation on github https://github.com/ARM-software/armnn "
713  "under the keyword 'ConstTensorsAsInputs'.";
714  }
715  }
716 
717  return m_LayerSupport->IsLayerSupported(LayerType::FullyConnected,
718  infos,
719  descriptor,
720  EmptyOptional(),
721  EmptyOptional(),
722  reasonIfUnsupported);
723 }

References ARMNN_LOG, armnn::FullyConnected, armnn::GetCapability(), OptionalBase::has_value(), TensorInfo::IsConstant(), BackendId::IsUndefined(), FullyConnectedDescriptor::m_BiasEnabled, FullyConnectedDescriptor::m_ConstantWeights, OptionalReferenceSwitch< IsReference, T >::value(), OptionalReferenceSwitch< std::is_reference< T >::value, T >::value(), and armnn::warning.

◆ IsGatherNdSupported()

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

Definition at line 741 of file BackendHelper.cpp.

745 {
746  TensorInfos infos{input0, input1, output};
747 
748  return m_LayerSupport->IsLayerSupported(LayerType::GatherNd,
749  infos,
750  BaseDescriptor(),
751  EmptyOptional(),
752  EmptyOptional(),
753  reasonIfUnsupported);
754 }

References armnn::GatherNd.

◆ IsGatherSupported()

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

Definition at line 725 of file BackendHelper.cpp.

730 {
731  TensorInfos infos{input0, input1, output};
732 
733  return m_LayerSupport->IsLayerSupported(LayerType::Gather,
734  infos,
735  descriptor,
736  EmptyOptional(),
737  EmptyOptional(),
738  reasonIfUnsupported);
739 }

References armnn::Gather.

◆ IsInputSupported()

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

Definition at line 756 of file BackendHelper.cpp.

758 {
759  TensorInfos infos{input};
760 
761  return m_LayerSupport->IsLayerSupported(LayerType::Input,
762  infos,
763  BaseDescriptor(),
764  EmptyOptional(),
765  EmptyOptional(),
766  reasonIfUnsupported);
767 }

References armnn::Input.

◆ IsInstanceNormalizationSupported()

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

Definition at line 769 of file BackendHelper.cpp.

774 {
775  TensorInfos infos{input, output};
776 
777  return m_LayerSupport->IsLayerSupported(LayerType::InstanceNormalization,
778  infos,
779  descriptor,
780  EmptyOptional(),
781  EmptyOptional(),
782  reasonIfUnsupported);
783 }

References armnn::InstanceNormalization.

◆ IsL2NormalizationSupported()

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

Definition at line 785 of file BackendHelper.cpp.

789 {
790  TensorInfos infos{input, output};
791 
792  return m_LayerSupport->IsLayerSupported(LayerType::L2Normalization,
793  infos,
794  descriptor,
795  EmptyOptional(),
796  EmptyOptional(),
797  reasonIfUnsupported);
798 }

References armnn::L2Normalization.

◆ IsLogicalBinarySupported()

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

Definition at line 800 of file BackendHelper.cpp.

805 {
806  TensorInfos infos{input0, input1, output};
807 
808  return m_LayerSupport->IsLayerSupported(LayerType::LogicalBinary,
809  infos,
810  descriptor,
811  EmptyOptional(),
812  EmptyOptional(),
813  reasonIfUnsupported);
814 }

References armnn::LogicalBinary.

◆ IsLogicalUnarySupported()

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

Definition at line 816 of file BackendHelper.cpp.

820 {
821  TensorInfos infos{input, output};
822 
823  return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseUnary,
824  infos,
825  descriptor,
826  EmptyOptional(),
827  EmptyOptional(),
828  reasonIfUnsupported);
829 }

References armnn::ElementwiseUnary.

◆ IsLogSoftmaxSupported()

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

Definition at line 831 of file BackendHelper.cpp.

835 {
836  TensorInfos infos{input, output};
837 
838  return m_LayerSupport->IsLayerSupported(LayerType::LogSoftmax,
839  infos,
840  descriptor,
841  EmptyOptional(),
842  EmptyOptional(),
843  reasonIfUnsupported);
844 }

References armnn::LogSoftmax.

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

Definition at line 846 of file BackendHelper.cpp.

856 {
857  TensorInfos infos{input, outputStateIn, cellStateIn, scratchBuffer, outputStateOut, cellStateOut, output};
858 
859  return m_LayerSupport->IsLayerSupported(LayerType::Lstm,
860  infos,
861  descriptor,
862  paramsInfo,
863  EmptyOptional(),
864  reasonIfUnsupported);
865 }

References armnn::Lstm.

◆ IsMaximumSupported()

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

Definition at line 867 of file BackendHelper.cpp.

871 {
872  TensorInfos infos{input0, input1, output};
873 
874  return m_LayerSupport->IsLayerSupported(LayerType::Maximum,
875  infos,
876  BaseDescriptor(),
877  EmptyOptional(),
878  EmptyOptional(),
879  reasonIfUnsupported);
880 }

References armnn::Maximum.

◆ IsMeanSupported()

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

Definition at line 882 of file BackendHelper.cpp.

886 {
887  TensorInfos infos{input, output};
888 
889  return m_LayerSupport->IsLayerSupported(LayerType::Mean,
890  infos,
891  descriptor,
892  EmptyOptional(),
893  EmptyOptional(),
894  reasonIfUnsupported);
895 }

References armnn::Mean.

◆ IsMemCopySupported()

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

Definition at line 897 of file BackendHelper.cpp.

900 {
901  TensorInfos infos{input, output};
902 
903  return m_LayerSupport->IsLayerSupported(LayerType::MemCopy,
904  infos,
905  BaseDescriptor(),
906  EmptyOptional(),
907  EmptyOptional(),
908  reasonIfUnsupported);
909 }

References armnn::MemCopy.

◆ IsMemImportSupported()

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

Definition at line 911 of file BackendHelper.cpp.

914 {
915  TensorInfos infos{input, output};
916 
917  return m_LayerSupport->IsLayerSupported(LayerType::MemImport,
918  infos,
919  BaseDescriptor(),
920  EmptyOptional(),
921  EmptyOptional(),
922  reasonIfUnsupported);
923 }

References armnn::MemImport.

◆ IsMergeSupported()

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

Definition at line 925 of file BackendHelper.cpp.

929 {
930  TensorInfos infos{input0, input1, output};
931 
932  return m_LayerSupport->IsLayerSupported(LayerType::Merge,
933  infos,
934  BaseDescriptor(),
935  EmptyOptional(),
936  EmptyOptional(),
937  reasonIfUnsupported);
938 }

References armnn::Merge.

◆ IsMinimumSupported()

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

Definition at line 940 of file BackendHelper.cpp.

944 {
945  TensorInfos infos{input0, input1, output};
946 
947  return m_LayerSupport->IsLayerSupported(LayerType::Minimum,
948  infos,
949  BaseDescriptor(),
950  EmptyOptional(),
951  EmptyOptional(),
952  reasonIfUnsupported);
953 }

References armnn::Minimum.

◆ IsMultiplicationSupported()

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

Definition at line 955 of file BackendHelper.cpp.

959 {
960  TensorInfos infos{input0, input1, output};
961 
962  return m_LayerSupport->IsLayerSupported(LayerType::Multiplication,
963  infos,
964  BaseDescriptor(),
965  EmptyOptional(),
966  EmptyOptional(),
967  reasonIfUnsupported);
968 }

References armnn::Multiplication.

◆ IsNormalizationSupported()

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

Definition at line 970 of file BackendHelper.cpp.

974 {
975  TensorInfos infos{input, output};
976 
977  return m_LayerSupport->IsLayerSupported(LayerType::Normalization,
978  infos,
979  descriptor,
980  EmptyOptional(),
981  EmptyOptional(),
982  reasonIfUnsupported);
983 }

References armnn::Normalization.

◆ IsOutputSupported()

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

Definition at line 985 of file BackendHelper.cpp.

987 {
988  TensorInfos infos{output};
989 
990  return m_LayerSupport->IsLayerSupported(LayerType::Output,
991  infos,
992  BaseDescriptor(),
993  EmptyOptional(),
994  EmptyOptional(),
995  reasonIfUnsupported);
996 }

References armnn::Output.

◆ IsPadSupported()

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

Definition at line 998 of file BackendHelper.cpp.

1002 {
1003  TensorInfos infos{input, output};
1004 
1005  return m_LayerSupport->IsLayerSupported(LayerType::Pad,
1006  infos,
1007  descriptor,
1008  EmptyOptional(),
1009  EmptyOptional(),
1010  reasonIfUnsupported);
1011 }

References armnn::Pad.

◆ IsPermuteSupported()

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

Definition at line 1013 of file BackendHelper.cpp.

1017 {
1018  TensorInfos infos{input, output};
1019 
1020  return m_LayerSupport->IsLayerSupported(LayerType::Permute,
1021  infos,
1022  descriptor,
1023  EmptyOptional(),
1024  EmptyOptional(),
1025  reasonIfUnsupported);
1026 }

References armnn::Permute.

◆ IsPooling2dSupported()

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

Definition at line 1028 of file BackendHelper.cpp.

1032 {
1033  TensorInfos infos{input, output};
1034 
1035  return m_LayerSupport->IsLayerSupported(LayerType::Pooling2d,
1036  infos,
1037  descriptor,
1038  EmptyOptional(),
1039  EmptyOptional(),
1040  reasonIfUnsupported);
1041 }

References armnn::Pooling2d.

◆ IsPooling3dSupported()

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

Definition at line 1043 of file BackendHelper.cpp.

1047 {
1048  TensorInfos infos{input, output};
1049 
1050  return m_LayerSupport->IsLayerSupported(LayerType::Pooling3d,
1051  infos,
1052  descriptor,
1053  EmptyOptional(),
1054  EmptyOptional(),
1055  reasonIfUnsupported);
1056 }

References armnn::Pooling3d.

◆ IsPreCompiledSupported()

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

Definition at line 1058 of file BackendHelper.cpp.

1061 {
1062  TensorInfos infos{input};
1063 
1064  return m_LayerSupport->IsLayerSupported(LayerType::PreCompiled,
1065  infos,
1066  descriptor,
1067  EmptyOptional(),
1068  EmptyOptional(),
1069  reasonIfUnsupported);
1070 }

References armnn::PreCompiled.

◆ IsPreluSupported()

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

Definition at line 1072 of file BackendHelper.cpp.

1076 {
1077  TensorInfos infos{input, alpha, output};
1078 
1079  return m_LayerSupport->IsLayerSupported(LayerType::Prelu,
1080  infos,
1081  BaseDescriptor(),
1082  EmptyOptional(),
1083  EmptyOptional(),
1084  reasonIfUnsupported);
1085 }

References armnn::Prelu.

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

Definition at line 1101 of file BackendHelper.cpp.

1110 {
1111  TensorInfos infos{input, previousOutputIn, previousCellStateIn, outputStateOut, cellStateOut, output};
1112 
1113  return m_LayerSupport->IsLayerSupported(LayerType::QLstm,
1114  infos,
1115  descriptor,
1116  paramsInfo,
1117  EmptyOptional(),
1118  reasonIfUnsupported);
1119 }

References armnn::QLstm.

◆ IsQuantizedLstmSupported()

bool IsQuantizedLstmSupported ( const TensorInfo &  input,
const TensorInfo &  previousCellStateIn,
const TensorInfo &  previousOutputIn,
const TensorInfo &  cellStateOut,
const TensorInfo &  output,
const QuantizedLstmInputParamsInfo &  paramsInfo,
Optional< std::string & >  reasonIfUnsupported = EmptyOptional() 
)

Definition at line 1121 of file BackendHelper.cpp.

1128 {
1129  TensorInfos infos{input, previousCellStateIn, previousOutputIn, cellStateOut, output};
1130 
1131  return m_LayerSupport->IsLayerSupported(LayerType::QuantizedLstm,
1132  infos,
1133  BaseDescriptor(),
1134  EmptyOptional(),
1135  paramsInfo,
1136  reasonIfUnsupported);
1137 }

References armnn::QuantizedLstm.

◆ IsQuantizeSupported()

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

Definition at line 1087 of file BackendHelper.cpp.

1090 {
1091  TensorInfos infos{input, output};
1092 
1093  return m_LayerSupport->IsLayerSupported(LayerType::Quantize,
1094  infos,
1095  BaseDescriptor(),
1096  EmptyOptional(),
1097  EmptyOptional(),
1098  reasonIfUnsupported);
1099 }

References armnn::Quantize.

◆ IsRankSupported()

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

Definition at line 1139 of file BackendHelper.cpp.

1142 {
1143  TensorInfos infos{input, output};
1144 
1145  return m_LayerSupport->IsLayerSupported(LayerType::Rank,
1146  infos,
1147  BaseDescriptor(),
1148  EmptyOptional(),
1149  EmptyOptional(),
1150  reasonIfUnsupported);
1151 }

References armnn::Rank.

◆ IsReduceSupported()

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

Definition at line 1153 of file BackendHelper.cpp.

1157 {
1158  TensorInfos infos{input, output};
1159 
1160  return m_LayerSupport->IsLayerSupported(LayerType::Reduce,
1161  infos,
1162  descriptor,
1163  EmptyOptional(),
1164  EmptyOptional(),
1165  reasonIfUnsupported);
1166 }

References armnn::Reduce.

◆ IsReshapeSupported()

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

Definition at line 1168 of file BackendHelper.cpp.

1172 {
1173  TensorInfos infos{input, output};
1174 
1175  return m_LayerSupport->IsLayerSupported(LayerType::Reshape,
1176  infos,
1177  descriptor,
1178  EmptyOptional(),
1179  EmptyOptional(),
1180  reasonIfUnsupported);
1181 }

References armnn::Reshape.

◆ IsResizeSupported()

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

Definition at line 1183 of file BackendHelper.cpp.

1187 {
1188  TensorInfos infos{input, output};
1189 
1190  return m_LayerSupport->IsLayerSupported(LayerType::Resize,
1191  infos,
1192  descriptor,
1193  EmptyOptional(),
1194  EmptyOptional(),
1195  reasonIfUnsupported);
1196 }

References armnn::Resize.

◆ IsShapeSupported()

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

Definition at line 1198 of file BackendHelper.cpp.

1201 {
1202  TensorInfos infos{input, output};
1203 
1204  return m_LayerSupport->IsLayerSupported(LayerType::Shape,
1205  infos,
1206  BaseDescriptor(),
1207  EmptyOptional(),
1208  EmptyOptional(),
1209  reasonIfUnsupported);
1210 }

References armnn::Shape.

◆ IsSliceSupported()

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

Definition at line 1212 of file BackendHelper.cpp.

1216 {
1217  TensorInfos infos{input, output};
1218 
1219  return m_LayerSupport->IsLayerSupported(LayerType::Slice,
1220  infos,
1221  descriptor,
1222  EmptyOptional(),
1223  EmptyOptional(),
1224  reasonIfUnsupported);
1225 }

References armnn::Slice.

◆ IsSoftmaxSupported()

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

Definition at line 1227 of file BackendHelper.cpp.

1231 {
1232  TensorInfos infos{input, output};
1233 
1234  return m_LayerSupport->IsLayerSupported(LayerType::Softmax,
1235  infos,
1236  descriptor,
1237  EmptyOptional(),
1238  EmptyOptional(),
1239  reasonIfUnsupported);
1240 }

References armnn::Softmax.

◆ IsSpaceToBatchNdSupported()

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

Definition at line 1242 of file BackendHelper.cpp.

1246 {
1247  TensorInfos infos{input, output};
1248 
1249  return m_LayerSupport->IsLayerSupported(LayerType::SpaceToBatchNd,
1250  infos,
1251  descriptor,
1252  EmptyOptional(),
1253  EmptyOptional(),
1254  reasonIfUnsupported);
1255 }

References armnn::SpaceToBatchNd.

◆ IsSpaceToDepthSupported()

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

Definition at line 1257 of file BackendHelper.cpp.

1261 {
1262  TensorInfos infos{input, output};
1263 
1264  return m_LayerSupport->IsLayerSupported(LayerType::SpaceToDepth,
1265  infos,
1266  descriptor,
1267  EmptyOptional(),
1268  EmptyOptional(),
1269  reasonIfUnsupported);
1270 }

References armnn::SpaceToDepth.

◆ IsSplitterSupported()

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

Definition at line 1272 of file BackendHelper.cpp.

1276 {
1277  TensorInfos infos{input};
1278  for (TensorInfo outInfo : outputs)
1279  {
1280  infos.push_back(outInfo);
1281  }
1282 
1283  return m_LayerSupport->IsLayerSupported(LayerType::Splitter,
1284  infos,
1285  descriptor,
1286  EmptyOptional(),
1287  EmptyOptional(),
1288  reasonIfUnsupported);
1289 }

References armnn::Splitter.

◆ IsStackSupported()

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

Definition at line 1291 of file BackendHelper.cpp.

1295 {
1296  TensorInfos infos;
1297  for (const TensorInfo* inputInfo : inputs)
1298  {
1299  infos.push_back(*inputInfo);
1300  }
1301  infos.push_back(output);
1302 
1303  return m_LayerSupport->IsLayerSupported(LayerType::Stack,
1304  infos,
1305  descriptor,
1306  EmptyOptional(),
1307  EmptyOptional(),
1308  reasonIfUnsupported);
1309 }

References armnn::Stack.

◆ IsStandInSupported()

bool IsStandInSupported ( const std::vector< const TensorInfo * > &  inputs,
const std::vector< const TensorInfo * > &  outputs,
const StandInDescriptor &  descriptor,
Optional< std::string & >  reasonIfUnsupported = EmptyOptional() 
)

Definition at line 1311 of file BackendHelper.cpp.

1315 {
1316  TensorInfos infos;
1317  for (const TensorInfo* inputInfo : inputs)
1318  {
1319  infos.push_back(*inputInfo);
1320  }
1321  for (const TensorInfo* outputInfo : outputs)
1322  {
1323  infos.push_back(*outputInfo);
1324  }
1325 
1326  return m_LayerSupport->IsLayerSupported(LayerType::StandIn,
1327  infos,
1328  descriptor,
1329  EmptyOptional(),
1330  EmptyOptional(),
1331  reasonIfUnsupported);
1332 }

References armnn::StandIn.

◆ IsStridedSliceSupported()

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

Definition at line 1335 of file BackendHelper.cpp.

1339 {
1340  TensorInfos infos{input, output};
1341 
1342  return m_LayerSupport->IsLayerSupported(LayerType::StridedSlice,
1343  infos,
1344  descriptor,
1345  EmptyOptional(),
1346  EmptyOptional(),
1347  reasonIfUnsupported);
1348 }

References armnn::StridedSlice.

◆ IsSubtractionSupported()

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

Definition at line 1350 of file BackendHelper.cpp.

1354 {
1355  TensorInfos infos{input0, input1, output};
1356 
1357  return m_LayerSupport->IsLayerSupported(LayerType::Subtraction,
1358  infos,
1359  BaseDescriptor(),
1360  EmptyOptional(),
1361  EmptyOptional(),
1362  reasonIfUnsupported);
1363 }

References armnn::Subtraction.

◆ IsSwitchSupported()

bool IsSwitchSupported ( const TensorInfo &  input0,
const TensorInfo &  input1,
const TensorInfo &  output0,
const TensorInfo &  output1,
Optional< std::string & >  reasonIfUnsupported = EmptyOptional() 
)

Definition at line 1365 of file BackendHelper.cpp.

1370 {
1371  TensorInfos infos{input0, input1, output0, output1};
1372 
1373  return m_LayerSupport->IsLayerSupported(LayerType::Switch,
1374  infos,
1375  BaseDescriptor(),
1376  EmptyOptional(),
1377  EmptyOptional(),
1378  reasonIfUnsupported);
1379 }

References armnn::Switch.

◆ IsTransposeConvolution2dSupported()

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

Definition at line 1381 of file BackendHelper.cpp.

1388 {
1389  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
1390  TensorInfos infos{input, output, weights, biasesVal};
1391 
1392  return m_LayerSupport->IsLayerSupported(LayerType::TransposeConvolution2d,
1393  infos,
1394  descriptor,
1395  EmptyOptional(),
1396  EmptyOptional(),
1397  reasonIfUnsupported);
1398 }

References OptionalBase::has_value(), armnn::TransposeConvolution2d, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

◆ IsTransposeSupported()

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

Definition at line 1400 of file BackendHelper.cpp.

1404 {
1405  TensorInfos infos{input, output};
1406 
1407  return m_LayerSupport->IsLayerSupported(LayerType::Transpose,
1408  infos,
1409  descriptor,
1410  EmptyOptional(),
1411  EmptyOptional(),
1412  reasonIfUnsupported);
1413 }

References armnn::Transpose.

◆ IsUnidirectionalSequenceLstmSupported()

bool IsUnidirectionalSequenceLstmSupported ( const TensorInfo &  input,
const TensorInfo &  outputStateIn,
const TensorInfo &  cellStateIn,
const TensorInfo &  outputStateOut,
const TensorInfo &  cellStateOut,
const TensorInfo &  output,
const LstmDescriptor &  descriptor,
const LstmInputParamsInfo &  paramsInfo,
Optional< std::string & >  reasonIfUnsupported = EmptyOptional() 
)

Definition at line 1415 of file BackendHelper.cpp.

1424 {
1425  TensorInfos infos{input, outputStateIn, cellStateIn, outputStateOut, cellStateOut, output};
1426 
1427  return m_LayerSupport->IsLayerSupported(LayerType::UnidirectionalSequenceLstm,
1428  infos,
1429  descriptor,
1430  paramsInfo,
1431  EmptyOptional(),
1432  reasonIfUnsupported);
1433 }

References armnn::UnidirectionalSequenceLstm.

The documentation for this class was generated from the following files:
armnn::LayerType::Floor
@ Floor
armnn::LayerType::MemCopy
@ MemCopy
armnn::LayerType::Softmax
@ Softmax
armnn::LayerType::Pooling3d
@ Pooling3d
armnn::LayerType::FullyConnected
@ FullyConnected
armnn::LayerType::Transpose
@ Transpose
armnn::LayerType::ChannelShuffle
@ ChannelShuffle
armnn::LayerType::ConvertFp32ToFp16
@ ConvertFp32ToFp16
armnn::LayerType::L2Normalization
@ L2Normalization
armnn::LayerType::TransposeConvolution2d
@ TransposeConvolution2d
armnn::LayerType::Input
@ Input
armnn::LayerType::Slice
@ Slice
armnn::LayerType::Maximum
@ Maximum
armnn::LayerType::Quantize
@ Quantize
armnn::LayerType::ArgMinMax
@ ArgMinMax
armnn::GetCapability
Optional< const BackendOptions::BackendOption > GetCapability(const std::string &backendCapabilityName, const BackendCapabilities &capabilities)
Returns a BackendCapability if the backend lists the capability The BackendCapability must then be in...
Definition: BackendHelper.cpp:37
armnn::LayerType::Subtraction
@ Subtraction
armnn::LayerType::SpaceToBatchNd
@ SpaceToBatchNd
armnn::LayerType::Convolution2d
@ Convolution2d
armnn::LayerType::Shape
@ Shape
armnn::LayerType::Merge
@ Merge
armnn::LayerType::Permute
@ Permute
armnn::LayerType::ConvertFp16ToFp32
@ ConvertFp16ToFp32
armnn::LayerType::QLstm
@ QLstm
armnn::LayerType::Pad
@ Pad
armnn::LayerType::Addition
@ Addition
armnn::LayerType::QuantizedLstm
@ QuantizedLstm
armnn::LayerType::BatchNormalization
@ BatchNormalization
armnn::LayerType::Reduce
@ Reduce
ARMNN_LOG
#define ARMNN_LOG(severity)
Definition: Logging.hpp:212
armnn::LayerType::Division
@ Division
armnn::BackendId::IsUndefined
bool IsUndefined() const
Definition: BackendId.hpp:141
armnn::LayerType::Debug
@ Debug
armnn::LayerType::InstanceNormalization
@ InstanceNormalization
armnn::LayerType::Activation
@ Activation
armnn::LayerType::Normalization
@ Normalization
armnn::LayerType::Comparison
@ Comparison
armnn::LayerType::Stack
@ Stack
armnn::LayerType::Reshape
@ Reshape
armnn::LayerType::Gather
@ Gather
armnn::LayerType::DepthwiseConvolution2d
@ DepthwiseConvolution2d
armnn::LayerType::Fill
@ Fill
armnn::LayerType::Resize
@ Resize
armnn::LayerType::Rank
@ Rank
armnn::LayerType::LogicalBinary
@ LogicalBinary
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::LayerType::Pooling2d
@ Pooling2d
armnn::LayerType::GatherNd
@ GatherNd
armnn::LayerType::Minimum
@ Minimum
armnn::LayerType::Constant
@ Constant
armnn::LayerType::Lstm
@ Lstm
armnn::LayerType::ElementwiseUnary
@ ElementwiseUnary
armnn::LayerType::SpaceToDepth
@ SpaceToDepth
armnn::LayerType::FakeQuantization
@ FakeQuantization
armnn::Compute::Undefined
@ Undefined
armnn::LayerType::StandIn
@ StandIn
armnn::LayerType::StridedSlice
@ StridedSlice
armnn::LayerType::DetectionPostProcess
@ DetectionPostProcess
armnn::LayerType::Mean
@ Mean
armnn::LayerType::BatchToSpaceNd
@ BatchToSpaceNd
armnn::LayerType::DepthToSpace
@ DepthToSpace
armnn::LayerType::Switch
@ Switch
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:142
armnn::LayerType::Concat
@ Concat
armnn::LayerType::Cast
@ Cast
armnn::LayerType::BatchMatMul
@ BatchMatMul
armnn::LayerType::Convolution3d
@ Convolution3d
armnn::LayerType::Splitter
@ Splitter
armnn::LayerType::LogSoftmax
@ LogSoftmax
armnn::LayerType::Output
@ Output
armnn::LayerType::Multiplication
@ Multiplication
armnn::LayerType::MemImport
@ MemImport
armnn::LayerType::Prelu
@ Prelu
armnn::LayerType::Dequantize
@ Dequantize
armnn::LayerType::PreCompiled
@ PreCompiled