ArmNN
 24.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 IsBroadcastToSupported (const TensorInfo &input, const TensorInfo &output, const BroadcastToDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported)
 
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 IsElementwiseBinarySupported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ElementwiseBinaryDescriptor &descriptor, 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 IsFusedSupported (const std::vector< std::reference_wrapper< TensorInfo >> &inputs, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const FusedDescriptor &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 IsReverseV2Supported (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, 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 IsTileSupported (const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, 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 154 of file BackendHelper.cpp.

158 {
159  TensorInfos infos{input, output};
160 
161  return m_LayerSupport->IsLayerSupported(LayerType::Activation,
162  infos,
163  descriptor,
164  EmptyOptional(),
165  EmptyOptional(),
166  reasonIfUnsupported);
167 }

References armnn::Activation.

◆ IsAdditionSupported()

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

Definition at line 169 of file BackendHelper.cpp.

173 {
174  TensorInfos infos{input0, input1, output};
175 
176  return m_LayerSupport->IsLayerSupported(LayerType::Addition,
177  infos,
178  BaseDescriptor(),
179  EmptyOptional(),
180  EmptyOptional(),
181  reasonIfUnsupported);
182 }

References armnn::Addition.

◆ IsArgMinMaxSupported()

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

Definition at line 184 of file BackendHelper.cpp.

188 {
189  TensorInfos infos{input, output};
190 
191  return m_LayerSupport->IsLayerSupported(LayerType::ArgMinMax,
192  infos,
193  descriptor,
194  EmptyOptional(),
195  EmptyOptional(),
196  reasonIfUnsupported);
197 }

References armnn::ArgMinMax.

◆ IsBackendRegistered()

bool IsBackendRegistered ( ) const

Definition at line 142 of file BackendHelper.cpp.

143 {
144  if (m_LayerSupport)
145  {
146  return true;
147  }
148 
149  return false;
150 }

◆ IsBatchMatMulSupported()

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

Definition at line 199 of file BackendHelper.cpp.

204 {
205  TensorInfos infos{input0, input1, output};
206 
207  return m_LayerSupport->IsLayerSupported(LayerType::BatchMatMul,
208  infos,
209  descriptor,
210  EmptyOptional(),
211  EmptyOptional(),
212  reasonIfUnsupported);
213 }

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 215 of file BackendHelper.cpp.

223 {
224  TensorInfos infos{input, output, mean, var, beta, gamma};
225 
226  return m_LayerSupport->IsLayerSupported(LayerType::BatchNormalization,
227  infos,
228  descriptor,
229  EmptyOptional(),
230  EmptyOptional(),
231  reasonIfUnsupported);
232 }

References armnn::BatchNormalization.

◆ IsBatchToSpaceNdSupported()

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

Definition at line 234 of file BackendHelper.cpp.

238 {
239  TensorInfos infos{input, output};
240 
241  return m_LayerSupport->IsLayerSupported(LayerType::BatchToSpaceNd,
242  infos,
243  descriptor,
244  EmptyOptional(),
245  EmptyOptional(),
246  reasonIfUnsupported);
247 }

References armnn::BatchToSpaceNd.

◆ IsBroadcastToSupported()

bool IsBroadcastToSupported ( const TensorInfo &  input,
const TensorInfo &  output,
const BroadcastToDescriptor &  descriptor,
Optional< std::string & >  reasonIfUnsupported 
)

Definition at line 250 of file BackendHelper.cpp.

254 {
255  TensorInfos infos{input, output};
256 
257  return m_LayerSupport->IsLayerSupported(LayerType::BroadcastTo,
258  infos,
259  descriptor,
260  EmptyOptional(),
261  EmptyOptional(),
262  reasonIfUnsupported.value());
263 }

References armnn::BroadcastTo, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

◆ IsCastSupported()

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

Definition at line 265 of file BackendHelper.cpp.

268 {
269  TensorInfos infos{input, output};
270 
271  return m_LayerSupport->IsLayerSupported(LayerType::Cast,
272  infos,
273  BaseDescriptor(),
274  EmptyOptional(),
275  EmptyOptional(),
276  reasonIfUnsupported);
277 }

References armnn::Cast.

◆ IsChannelShuffleSupported()

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

Definition at line 279 of file BackendHelper.cpp.

283 {
284  TensorInfos infos{input, output};
285 
286  return m_LayerSupport->IsLayerSupported(LayerType::ChannelShuffle,
287  infos,
288  descriptor,
289  EmptyOptional(),
290  EmptyOptional(),
291  reasonIfUnsupported);
292 }

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 294 of file BackendHelper.cpp.

299 {
300  TensorInfos infos{input0, input1, output};
301 
302  return m_LayerSupport->IsLayerSupported(LayerType::Comparison,
303  infos,
304  descriptor,
305  EmptyOptional(),
306  EmptyOptional(),
307  reasonIfUnsupported);
308 }

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 310 of file BackendHelper.cpp.

314 {
315  TensorInfos infos;
316  for (const TensorInfo* inputInfo : inputs)
317  {
318  infos.push_back(*inputInfo);
319  }
320  infos.push_back(output);
321 
322  return m_LayerSupport->IsLayerSupported(LayerType::Concat,
323  infos,
324  descriptor,
325  EmptyOptional(),
326  EmptyOptional(),
327  reasonIfUnsupported);
328 }

References armnn::Concat.

◆ IsConstantSupported()

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

Definition at line 330 of file BackendHelper.cpp.

332 {
333  TensorInfos infos{output};
334 
335  return m_LayerSupport->IsLayerSupported(LayerType::Constant,
336  infos,
337  BaseDescriptor(),
338  EmptyOptional(),
339  EmptyOptional(),
340  reasonIfUnsupported);
341 }

References armnn::Constant.

◆ IsConvertFp16ToFp32Supported()

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

Definition at line 343 of file BackendHelper.cpp.

346 {
347  TensorInfos infos{input, output};
348 
349  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp16ToFp32,
350  infos,
351  BaseDescriptor(),
352  EmptyOptional(),
353  EmptyOptional(),
354  reasonIfUnsupported);
355 }

References armnn::ConvertFp16ToFp32.

◆ IsConvertFp32ToFp16Supported()

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

Definition at line 357 of file BackendHelper.cpp.

360 {
361  TensorInfos infos{input, output};
362 
363  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp32ToFp16,
364  infos,
365  BaseDescriptor(),
366  EmptyOptional(),
367  EmptyOptional(),
368  reasonIfUnsupported);
369 }

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 371 of file BackendHelper.cpp.

377 {
378  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
379  TensorInfos infos{input, output, weights, biasesVal};
380 
381  Optional<const BackendOptions::BackendOption> capability ;
382  if (!m_BackendId.IsUndefined())
383  {
384  capability = GetCapability("NonConstWeights", m_BackendId);
385  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
386  {
387  if (!weights.IsConstant())
388  {
389  if (reasonIfUnsupported.has_value())
390  {
391  reasonIfUnsupported.value() =
392  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
393  "Convolution2d weights are set as dynamic (non constant). ";
394  }
395  return false;
396  }
397  if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
398  {
399  if (reasonIfUnsupported.has_value())
400  {
401  reasonIfUnsupported.value() =
402  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
403  "Convolution2d biases are set as dynamic (non constant). ";
404  }
405  return false;
406  }
407 
408  // At the first stage we will only print a warning. this is to give
409  // backend developers a chance to adopt and read weights from input slots.
410  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
411  "If you are a backend developer please find more information in our "
412  "doxygen documentation on github https://github.com/ARM-software/armnn "
413  "under the keyword 'ConstTensorsAsInputs'.";
414  }
415  }
416 
417  return m_LayerSupport->IsLayerSupported(LayerType::Convolution2d,
418  infos,
419  descriptor,
420  EmptyOptional(),
421  EmptyOptional(),
422  reasonIfUnsupported);
423 }

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(), 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 425 of file BackendHelper.cpp.

431 {
432  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
433  TensorInfos infos{input, output, weights, biasesVal};
434 
435  return m_LayerSupport->IsLayerSupported(LayerType::Convolution3d,
436  infos,
437  descriptor,
438  EmptyOptional(),
439  EmptyOptional(),
440  reasonIfUnsupported);
441 }

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 443 of file BackendHelper.cpp.

446 {
447  TensorInfos infos{input, output};
448 
449  return m_LayerSupport->IsLayerSupported(LayerType::Debug,
450  infos,
451  BaseDescriptor(),
452  EmptyOptional(),
453  EmptyOptional(),
454  reasonIfUnsupported);
455 }

References armnn::Debug.

◆ IsDepthToSpaceSupported()

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

Definition at line 457 of file BackendHelper.cpp.

461 {
462  TensorInfos infos{input, output};
463 
464  return m_LayerSupport->IsLayerSupported(LayerType::DepthToSpace,
465  infos,
466  descriptor,
467  EmptyOptional(),
468  EmptyOptional(),
469  reasonIfUnsupported);
470 }

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 472 of file BackendHelper.cpp.

479 {
480  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
481  TensorInfos infos{input, output, weights, biasesVal};
482 
483  Optional<const BackendOptions::BackendOption> capability ;
484  if (!m_BackendId.IsUndefined())
485  {
486  capability = GetCapability("NonConstWeights", m_BackendId);
487  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
488  {
489  if (!weights.IsConstant())
490  {
491  if (reasonIfUnsupported.has_value())
492  {
493  reasonIfUnsupported.value() =
494  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
495  "DepthwiseConvolution2d weights are set as dynamic (non constant). ";
496  }
497  return false;
498  }
499  if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
500  {
501  if (reasonIfUnsupported.has_value())
502  {
503  reasonIfUnsupported.value() =
504  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
505  "DepthwiseConvolution2d biases are set as dynamic (non constant). ";
506  }
507  return false;
508  }
509  // At the first stage we will only print a warning. this is to give
510  // backend developers a chance to adopt and read weights from input slots.
511  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
512  "If you are a backend developer please find more information in our "
513  "doxygen documentation on github https://github.com/ARM-software/armnn "
514  "under the keyword 'ConstTensorsAsInputs'.";
515  }
516  }
517 
518  return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
519  infos,
520  descriptor,
521  EmptyOptional(),
522  EmptyOptional(),
523  reasonIfUnsupported);
524 }

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(), and armnn::warning.

◆ IsDequantizeSupported()

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

Definition at line 526 of file BackendHelper.cpp.

529 {
530  TensorInfos infos{input, output};
531 
532  return m_LayerSupport->IsLayerSupported(LayerType::Dequantize,
533  infos,
534  BaseDescriptor(),
535  EmptyOptional(),
536  EmptyOptional(),
537  reasonIfUnsupported);
538 }

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 540 of file BackendHelper.cpp.

549 {
550  TensorInfos infos{boxEncodings, scores, anchors, detectionBoxes, detectionClasses, detectionScores, numDetections};
551 
552  return m_LayerSupport->IsLayerSupported(LayerType::DetectionPostProcess,
553  infos,
554  descriptor,
555  EmptyOptional(),
556  EmptyOptional(),
557  reasonIfUnsupported);
558 }

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 560 of file BackendHelper.cpp.

567 {
568  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
569  TensorInfos infos{input, output, weights, biasesVal};
570 
571  Optional<const BackendOptions::BackendOption> capability ;
572  if (!m_BackendId.IsUndefined())
573  {
574  capability = GetCapability("NonConstWeights", m_BackendId);
575  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
576  {
577  if (!weights.IsConstant())
578  {
579  if (reasonIfUnsupported.has_value())
580  {
581  reasonIfUnsupported.value() =
582  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
583  "DilatedDepthwiseConvolution2d weights are set as dynamic (non constant). ";
584  }
585  return false;
586  }
587  if (descriptor.m_BiasEnabled && !biasesVal.IsConstant())
588  {
589  if (reasonIfUnsupported.has_value())
590  {
591  reasonIfUnsupported.value() =
592  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
593  "DilatedDepthwiseConvolution2d biases are set as dynamic (non constant). ";
594  }
595  return false;
596  }
597  // At the first stage we will only print a warning. this is to give
598  // backend developers a chance to adopt and read weights from input slots.
599  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
600  "If you are a backend developer please find more information in our "
601  "doxygen documentation on github https://github.com/ARM-software/armnn "
602  "under the keyword 'ConstTensorsAsInputs'.";
603  }
604  }
605 
606  return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
607  infos,
608  descriptor,
609  EmptyOptional(),
610  EmptyOptional(),
611  reasonIfUnsupported);
612 }

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(), and armnn::warning.

◆ IsDivisionSupported()

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

Definition at line 614 of file BackendHelper.cpp.

618 {
619  TensorInfos infos{input0, input1, output};
620 
621  return m_LayerSupport->IsLayerSupported(LayerType::Division,
622  infos,
623  BaseDescriptor(),
624  EmptyOptional(),
625  EmptyOptional(),
626  reasonIfUnsupported);
627 }

References armnn::Division.

◆ IsElementwiseBinarySupported()

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

Definition at line 629 of file BackendHelper.cpp.

634 {
635  TensorInfos infos{input0, input1, output};
636 
637  return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseBinary,
638  infos,
639  descriptor,
640  EmptyOptional(),
641  EmptyOptional(),
642  reasonIfUnsupported);
643 }

References armnn::ElementwiseBinary.

◆ IsElementwiseUnarySupported()

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

Definition at line 645 of file BackendHelper.cpp.

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

References armnn::ElementwiseUnary.

◆ IsFakeQuantizationSupported()

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

Definition at line 660 of file BackendHelper.cpp.

663 {
664  TensorInfos infos{input};
665 
666  return m_LayerSupport->IsLayerSupported(LayerType::FakeQuantization,
667  infos,
668  descriptor,
669  EmptyOptional(),
670  EmptyOptional(),
671  reasonIfUnsupported);
672 }

References armnn::FakeQuantization.

◆ IsFillSupported()

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

Definition at line 674 of file BackendHelper.cpp.

678 {
679  TensorInfos infos{input, output};
680 
681  return m_LayerSupport->IsLayerSupported(LayerType::Fill,
682  infos,
683  descriptor,
684  EmptyOptional(),
685  EmptyOptional(),
686  reasonIfUnsupported);
687 }

References armnn::Fill.

◆ IsFloorSupported()

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

Definition at line 689 of file BackendHelper.cpp.

692 {
693  TensorInfos infos{input, output};
694 
695  return m_LayerSupport->IsLayerSupported(LayerType::Floor,
696  infos,
697  BaseDescriptor(),
698  EmptyOptional(),
699  EmptyOptional(),
700  reasonIfUnsupported);
701 }

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

709 {
710  TensorInfos infos{input, output, weights, biases};
711 
712  Optional<const BackendOptions::BackendOption> capability;
713  if (!m_BackendId.IsUndefined())
714  {
715  capability = GetCapability("NonConstWeights", m_BackendId);
716  if (!capability.has_value() || capability.value().GetValue().AsBool() == false)
717  {
718  if (!descriptor.m_ConstantWeights)
719  {
720  if (reasonIfUnsupported.has_value())
721  {
722  reasonIfUnsupported.value() =
723  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
724  "FullyConnected descriptor indicates that weights are dynamic (non constant). ";
725  }
726  return false;
727  }
728  if (!weights.IsConstant())
729  {
730  if (reasonIfUnsupported.has_value())
731  {
732  reasonIfUnsupported.value() =
733  "Backend is not capable of supporting dynamic weights (NonConstWeights) and "
734  "FullyConnected weights are set as dynamic (non constant). ";
735  }
736 
737  return false;
738  }
739  if (descriptor.m_BiasEnabled && !biases.IsConstant())
740  {
741  if (reasonIfUnsupported.has_value())
742  {
743  reasonIfUnsupported.value() =
744  "Backend is not capable of supporting dynamic biases (NonConstWeights) and "
745  "FullyConnected biases are set as dynamic (non constant). ";
746  }
747  return false;
748  }
749 
750  // At the first stage we will only print a warning. this is to give
751  // backend developers a chance to adopt and read weights from input slots.
752  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
753  "If you are a backend developer please find more information in our "
754  "doxygen documentation on github https://github.com/ARM-software/armnn "
755  "under the keyword 'ConstTensorsAsInputs'.";
756  }
757  }
758 
759  return m_LayerSupport->IsLayerSupported(LayerType::FullyConnected,
760  infos,
761  descriptor,
762  EmptyOptional(),
763  EmptyOptional(),
764  reasonIfUnsupported);
765 }

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

◆ IsFusedSupported()

bool IsFusedSupported ( const std::vector< std::reference_wrapper< TensorInfo >> &  inputs,
const std::vector< std::reference_wrapper< TensorInfo >> &  outputs,
const FusedDescriptor &  descriptor,
Optional< std::string & >  reasonIfUnsupported = EmptyOptional() 
)

Definition at line 767 of file BackendHelper.cpp.

771 {
772  TensorInfos infos;
773  infos.reserve(inputs.size() + outputs.size());
774  for (TensorInfo inInfo : inputs)
775  {
776  infos.emplace_back(inInfo);
777  }
778  for (TensorInfo outInfo : outputs)
779  {
780  infos.emplace_back(outInfo);
781  }
782 
783  return m_LayerSupport->IsLayerSupported(LayerType::Fused,
784  infos,
785  descriptor,
786  EmptyOptional(),
787  EmptyOptional(),
788  reasonIfUnsupported);
789 }

References armnn::Fused.

◆ IsGatherNdSupported()

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

Definition at line 807 of file BackendHelper.cpp.

811 {
812  TensorInfos infos{input0, input1, output};
813 
814  return m_LayerSupport->IsLayerSupported(LayerType::GatherNd,
815  infos,
816  BaseDescriptor(),
817  EmptyOptional(),
818  EmptyOptional(),
819  reasonIfUnsupported);
820 }

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 791 of file BackendHelper.cpp.

796 {
797  TensorInfos infos{input0, input1, output};
798 
799  return m_LayerSupport->IsLayerSupported(LayerType::Gather,
800  infos,
801  descriptor,
802  EmptyOptional(),
803  EmptyOptional(),
804  reasonIfUnsupported);
805 }

References armnn::Gather.

◆ IsInputSupported()

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

Definition at line 822 of file BackendHelper.cpp.

824 {
825  TensorInfos infos{input};
826 
827  return m_LayerSupport->IsLayerSupported(LayerType::Input,
828  infos,
829  BaseDescriptor(),
830  EmptyOptional(),
831  EmptyOptional(),
832  reasonIfUnsupported);
833 }

References armnn::Input.

◆ IsInstanceNormalizationSupported()

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

Definition at line 835 of file BackendHelper.cpp.

840 {
841  TensorInfos infos{input, output};
842 
843  return m_LayerSupport->IsLayerSupported(LayerType::InstanceNormalization,
844  infos,
845  descriptor,
846  EmptyOptional(),
847  EmptyOptional(),
848  reasonIfUnsupported);
849 }

References armnn::InstanceNormalization.

◆ IsL2NormalizationSupported()

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

Definition at line 851 of file BackendHelper.cpp.

855 {
856  TensorInfos infos{input, output};
857 
858  return m_LayerSupport->IsLayerSupported(LayerType::L2Normalization,
859  infos,
860  descriptor,
861  EmptyOptional(),
862  EmptyOptional(),
863  reasonIfUnsupported);
864 }

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 866 of file BackendHelper.cpp.

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

References armnn::LogicalBinary.

◆ IsLogicalUnarySupported()

bool IsLogicalUnarySupported ( const TensorInfo &  input,
const TensorInfo &  output,
const ElementwiseUnaryDescriptor &  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::ElementwiseUnary,
890  infos,
891  descriptor,
892  EmptyOptional(),
893  EmptyOptional(),
894  reasonIfUnsupported);
895 }

References armnn::ElementwiseUnary.

◆ IsLogSoftmaxSupported()

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

Definition at line 897 of file BackendHelper.cpp.

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

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

922 {
923  TensorInfos infos{input, outputStateIn, cellStateIn, scratchBuffer, outputStateOut, cellStateOut, output};
924 
925  return m_LayerSupport->IsLayerSupported(LayerType::Lstm,
926  infos,
927  descriptor,
928  paramsInfo,
929  EmptyOptional(),
930  reasonIfUnsupported);
931 }

References armnn::Lstm.

◆ IsMaximumSupported()

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

Definition at line 933 of file BackendHelper.cpp.

937 {
938  TensorInfos infos{input0, input1, output};
939 
940  return m_LayerSupport->IsLayerSupported(LayerType::Maximum,
941  infos,
942  BaseDescriptor(),
943  EmptyOptional(),
944  EmptyOptional(),
945  reasonIfUnsupported);
946 }

References armnn::Maximum.

◆ IsMeanSupported()

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

Definition at line 948 of file BackendHelper.cpp.

952 {
953  TensorInfos infos{input, output};
954 
955  return m_LayerSupport->IsLayerSupported(LayerType::Mean,
956  infos,
957  descriptor,
958  EmptyOptional(),
959  EmptyOptional(),
960  reasonIfUnsupported);
961 }

References armnn::Mean.

◆ IsMemCopySupported()

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

Definition at line 963 of file BackendHelper.cpp.

966 {
967  TensorInfos infos{input, output};
968 
969  return m_LayerSupport->IsLayerSupported(LayerType::MemCopy,
970  infos,
971  BaseDescriptor(),
972  EmptyOptional(),
973  EmptyOptional(),
974  reasonIfUnsupported);
975 }

References armnn::MemCopy.

◆ IsMemImportSupported()

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

Definition at line 977 of file BackendHelper.cpp.

980 {
981  TensorInfos infos{input, output};
982 
983  return m_LayerSupport->IsLayerSupported(LayerType::MemImport,
984  infos,
985  BaseDescriptor(),
986  EmptyOptional(),
987  EmptyOptional(),
988  reasonIfUnsupported);
989 }

References armnn::MemImport.

◆ IsMergeSupported()

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

Definition at line 991 of file BackendHelper.cpp.

995 {
996  TensorInfos infos{input0, input1, output};
997 
998  return m_LayerSupport->IsLayerSupported(LayerType::Merge,
999  infos,
1000  BaseDescriptor(),
1001  EmptyOptional(),
1002  EmptyOptional(),
1003  reasonIfUnsupported);
1004 }

References armnn::Merge.

◆ IsMinimumSupported()

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

Definition at line 1006 of file BackendHelper.cpp.

1010 {
1011  TensorInfos infos{input0, input1, output};
1012 
1013  return m_LayerSupport->IsLayerSupported(LayerType::Minimum,
1014  infos,
1015  BaseDescriptor(),
1016  EmptyOptional(),
1017  EmptyOptional(),
1018  reasonIfUnsupported);
1019 }

References armnn::Minimum.

◆ IsMultiplicationSupported()

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

Definition at line 1021 of file BackendHelper.cpp.

1025 {
1026  TensorInfos infos{input0, input1, output};
1027 
1028  return m_LayerSupport->IsLayerSupported(LayerType::Multiplication,
1029  infos,
1030  BaseDescriptor(),
1031  EmptyOptional(),
1032  EmptyOptional(),
1033  reasonIfUnsupported);
1034 }

References armnn::Multiplication.

◆ IsNormalizationSupported()

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

Definition at line 1036 of file BackendHelper.cpp.

1040 {
1041  TensorInfos infos{input, output};
1042 
1043  return m_LayerSupport->IsLayerSupported(LayerType::Normalization,
1044  infos,
1045  descriptor,
1046  EmptyOptional(),
1047  EmptyOptional(),
1048  reasonIfUnsupported);
1049 }

References armnn::Normalization.

◆ IsOutputSupported()

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

Definition at line 1051 of file BackendHelper.cpp.

1053 {
1054  TensorInfos infos{output};
1055 
1056  return m_LayerSupport->IsLayerSupported(LayerType::Output,
1057  infos,
1058  BaseDescriptor(),
1059  EmptyOptional(),
1060  EmptyOptional(),
1061  reasonIfUnsupported);
1062 }

References armnn::Output.

◆ IsPadSupported()

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

Definition at line 1064 of file BackendHelper.cpp.

1068 {
1069  TensorInfos infos{input, output};
1070 
1071  return m_LayerSupport->IsLayerSupported(LayerType::Pad,
1072  infos,
1073  descriptor,
1074  EmptyOptional(),
1075  EmptyOptional(),
1076  reasonIfUnsupported);
1077 }

References armnn::Pad.

◆ IsPermuteSupported()

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

Definition at line 1079 of file BackendHelper.cpp.

1083 {
1084  TensorInfos infos{input, output};
1085 
1086  return m_LayerSupport->IsLayerSupported(LayerType::Permute,
1087  infos,
1088  descriptor,
1089  EmptyOptional(),
1090  EmptyOptional(),
1091  reasonIfUnsupported);
1092 }

References armnn::Permute.

◆ IsPooling2dSupported()

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

Definition at line 1094 of file BackendHelper.cpp.

1098 {
1099  TensorInfos infos{input, output};
1100 
1101  return m_LayerSupport->IsLayerSupported(LayerType::Pooling2d,
1102  infos,
1103  descriptor,
1104  EmptyOptional(),
1105  EmptyOptional(),
1106  reasonIfUnsupported);
1107 }

References armnn::Pooling2d.

◆ IsPooling3dSupported()

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

Definition at line 1109 of file BackendHelper.cpp.

1113 {
1114  TensorInfos infos{input, output};
1115 
1116  return m_LayerSupport->IsLayerSupported(LayerType::Pooling3d,
1117  infos,
1118  descriptor,
1119  EmptyOptional(),
1120  EmptyOptional(),
1121  reasonIfUnsupported);
1122 }

References armnn::Pooling3d.

◆ IsPreCompiledSupported()

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

Definition at line 1124 of file BackendHelper.cpp.

1127 {
1128  TensorInfos infos{input};
1129 
1130  return m_LayerSupport->IsLayerSupported(LayerType::PreCompiled,
1131  infos,
1132  descriptor,
1133  EmptyOptional(),
1134  EmptyOptional(),
1135  reasonIfUnsupported);
1136 }

References armnn::PreCompiled.

◆ IsPreluSupported()

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

Definition at line 1138 of file BackendHelper.cpp.

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

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 1167 of file BackendHelper.cpp.

1176 {
1177  TensorInfos infos{input, previousOutputIn, previousCellStateIn, outputStateOut, cellStateOut, output};
1178 
1179  return m_LayerSupport->IsLayerSupported(LayerType::QLstm,
1180  infos,
1181  descriptor,
1182  paramsInfo,
1183  EmptyOptional(),
1184  reasonIfUnsupported);
1185 }

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 1187 of file BackendHelper.cpp.

1194 {
1195  TensorInfos infos{input, previousCellStateIn, previousOutputIn, cellStateOut, output};
1196 
1197  return m_LayerSupport->IsLayerSupported(LayerType::QuantizedLstm,
1198  infos,
1199  BaseDescriptor(),
1200  EmptyOptional(),
1201  paramsInfo,
1202  reasonIfUnsupported);
1203 }

References armnn::QuantizedLstm.

◆ IsQuantizeSupported()

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

Definition at line 1153 of file BackendHelper.cpp.

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

References armnn::Quantize.

◆ IsRankSupported()

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

Definition at line 1205 of file BackendHelper.cpp.

1208 {
1209  TensorInfos infos{input, output};
1210 
1211  return m_LayerSupport->IsLayerSupported(LayerType::Rank,
1212  infos,
1213  BaseDescriptor(),
1214  EmptyOptional(),
1215  EmptyOptional(),
1216  reasonIfUnsupported);
1217 }

References armnn::Rank.

◆ IsReduceSupported()

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

Definition at line 1219 of file BackendHelper.cpp.

1223 {
1224  TensorInfos infos{input, output};
1225 
1226  return m_LayerSupport->IsLayerSupported(LayerType::Reduce,
1227  infos,
1228  descriptor,
1229  EmptyOptional(),
1230  EmptyOptional(),
1231  reasonIfUnsupported);
1232 }

References armnn::Reduce.

◆ IsReshapeSupported()

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

Definition at line 1234 of file BackendHelper.cpp.

1238 {
1239  TensorInfos infos{input, output};
1240 
1241  return m_LayerSupport->IsLayerSupported(LayerType::Reshape,
1242  infos,
1243  descriptor,
1244  EmptyOptional(),
1245  EmptyOptional(),
1246  reasonIfUnsupported);
1247 }

References armnn::Reshape.

◆ IsResizeSupported()

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

Definition at line 1249 of file BackendHelper.cpp.

1253 {
1254  TensorInfos infos{input, output};
1255 
1256  return m_LayerSupport->IsLayerSupported(LayerType::Resize,
1257  infos,
1258  descriptor,
1259  EmptyOptional(),
1260  EmptyOptional(),
1261  reasonIfUnsupported);
1262 }

References armnn::Resize.

◆ IsReverseV2Supported()

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

Definition at line 1264 of file BackendHelper.cpp.

1268 {
1269  TensorInfos infos{input0, input1, output};
1270 
1271  return m_LayerSupport->IsLayerSupported(LayerType::ReverseV2,
1272  infos,
1273  BaseDescriptor(),
1274  EmptyOptional(),
1275  EmptyOptional(),
1276  reasonIfUnsupported);
1277 }

References armnn::ReverseV2.

◆ IsShapeSupported()

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

Definition at line 1279 of file BackendHelper.cpp.

1282 {
1283  TensorInfos infos{input, output};
1284 
1285  return m_LayerSupport->IsLayerSupported(LayerType::Shape,
1286  infos,
1287  BaseDescriptor(),
1288  EmptyOptional(),
1289  EmptyOptional(),
1290  reasonIfUnsupported);
1291 }

References armnn::Shape.

◆ IsSliceSupported()

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

Definition at line 1293 of file BackendHelper.cpp.

1297 {
1298  TensorInfos infos{input, output};
1299 
1300  return m_LayerSupport->IsLayerSupported(LayerType::Slice,
1301  infos,
1302  descriptor,
1303  EmptyOptional(),
1304  EmptyOptional(),
1305  reasonIfUnsupported);
1306 }

References armnn::Slice.

◆ IsSoftmaxSupported()

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

Definition at line 1308 of file BackendHelper.cpp.

1312 {
1313  TensorInfos infos{input, output};
1314 
1315  return m_LayerSupport->IsLayerSupported(LayerType::Softmax,
1316  infos,
1317  descriptor,
1318  EmptyOptional(),
1319  EmptyOptional(),
1320  reasonIfUnsupported);
1321 }

References armnn::Softmax.

◆ IsSpaceToBatchNdSupported()

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

Definition at line 1323 of file BackendHelper.cpp.

1327 {
1328  TensorInfos infos{input, output};
1329 
1330  return m_LayerSupport->IsLayerSupported(LayerType::SpaceToBatchNd,
1331  infos,
1332  descriptor,
1333  EmptyOptional(),
1334  EmptyOptional(),
1335  reasonIfUnsupported);
1336 }

References armnn::SpaceToBatchNd.

◆ IsSpaceToDepthSupported()

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

Definition at line 1338 of file BackendHelper.cpp.

1342 {
1343  TensorInfos infos{input, output};
1344 
1345  return m_LayerSupport->IsLayerSupported(LayerType::SpaceToDepth,
1346  infos,
1347  descriptor,
1348  EmptyOptional(),
1349  EmptyOptional(),
1350  reasonIfUnsupported);
1351 }

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 1353 of file BackendHelper.cpp.

1357 {
1358  TensorInfos infos{input};
1359  for (TensorInfo outInfo : outputs)
1360  {
1361  infos.push_back(outInfo);
1362  }
1363 
1364  return m_LayerSupport->IsLayerSupported(LayerType::Splitter,
1365  infos,
1366  descriptor,
1367  EmptyOptional(),
1368  EmptyOptional(),
1369  reasonIfUnsupported);
1370 }

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 1372 of file BackendHelper.cpp.

1376 {
1377  TensorInfos infos;
1378  for (const TensorInfo* inputInfo : inputs)
1379  {
1380  infos.push_back(*inputInfo);
1381  }
1382  infos.push_back(output);
1383 
1384  return m_LayerSupport->IsLayerSupported(LayerType::Stack,
1385  infos,
1386  descriptor,
1387  EmptyOptional(),
1388  EmptyOptional(),
1389  reasonIfUnsupported);
1390 }

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 1392 of file BackendHelper.cpp.

1396 {
1397  TensorInfos infos;
1398  for (const TensorInfo* inputInfo : inputs)
1399  {
1400  infos.push_back(*inputInfo);
1401  }
1402  for (const TensorInfo* outputInfo : outputs)
1403  {
1404  infos.push_back(*outputInfo);
1405  }
1406 
1407  return m_LayerSupport->IsLayerSupported(LayerType::StandIn,
1408  infos,
1409  descriptor,
1410  EmptyOptional(),
1411  EmptyOptional(),
1412  reasonIfUnsupported);
1413 }

References armnn::StandIn.

◆ IsStridedSliceSupported()

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

Definition at line 1416 of file BackendHelper.cpp.

1420 {
1421  TensorInfos infos{input, output};
1422 
1423  return m_LayerSupport->IsLayerSupported(LayerType::StridedSlice,
1424  infos,
1425  descriptor,
1426  EmptyOptional(),
1427  EmptyOptional(),
1428  reasonIfUnsupported);
1429 }

References armnn::StridedSlice.

◆ IsSubtractionSupported()

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

Definition at line 1431 of file BackendHelper.cpp.

1435 {
1436  TensorInfos infos{input0, input1, output};
1437 
1438  return m_LayerSupport->IsLayerSupported(LayerType::Subtraction,
1439  infos,
1440  BaseDescriptor(),
1441  EmptyOptional(),
1442  EmptyOptional(),
1443  reasonIfUnsupported);
1444 }

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 1446 of file BackendHelper.cpp.

1451 {
1452  TensorInfos infos{input0, input1, output0, output1};
1453 
1454  return m_LayerSupport->IsLayerSupported(LayerType::Switch,
1455  infos,
1456  BaseDescriptor(),
1457  EmptyOptional(),
1458  EmptyOptional(),
1459  reasonIfUnsupported);
1460 }

References armnn::Switch.

◆ IsTileSupported()

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

Definition at line 1462 of file BackendHelper.cpp.

1466 {
1467  TensorInfos infos{input, output};
1468 
1469  return m_LayerSupport->IsLayerSupported(LayerType::Tile,
1470  infos,
1471  descriptor,
1472  EmptyOptional(),
1473  EmptyOptional(),
1474  reasonIfUnsupported);
1475 }

References armnn::Tile.

◆ 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 1477 of file BackendHelper.cpp.

1484 {
1485  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
1486  TensorInfos infos{input, output, weights, biasesVal};
1487 
1488  return m_LayerSupport->IsLayerSupported(LayerType::TransposeConvolution2d,
1489  infos,
1490  descriptor,
1491  EmptyOptional(),
1492  EmptyOptional(),
1493  reasonIfUnsupported);
1494 }

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 1496 of file BackendHelper.cpp.

1500 {
1501  TensorInfos infos{input, output};
1502 
1503  return m_LayerSupport->IsLayerSupported(LayerType::Transpose,
1504  infos,
1505  descriptor,
1506  EmptyOptional(),
1507  EmptyOptional(),
1508  reasonIfUnsupported);
1509 }

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 1511 of file BackendHelper.cpp.

1520 {
1521  TensorInfos infos{input, outputStateIn, cellStateIn, outputStateOut, cellStateOut, output};
1522 
1523  return m_LayerSupport->IsLayerSupported(LayerType::UnidirectionalSequenceLstm,
1524  infos,
1525  descriptor,
1526  paramsInfo,
1527  EmptyOptional(),
1528  reasonIfUnsupported);
1529 }

References armnn::UnidirectionalSequenceLstm.

The documentation for this class was generated from the following files:
armnn::LayerType::SpaceToDepth
@ SpaceToDepth
armnn::Compute::Undefined
@ Undefined
armnn::LayerType::Permute
@ Permute
armnn::LayerType::Splitter
@ Splitter
armnn::LayerType::BatchNormalization
@ BatchNormalization
armnn::BackendId::IsUndefined
bool IsUndefined() const
Definition: BackendId.hpp:141
armnn::LayerType::InstanceNormalization
@ InstanceNormalization
armnn::LayerType::ConvertFp16ToFp32
@ ConvertFp16ToFp32
armnn::LayerType::Floor
@ Floor
armnn::LayerType::Transpose
@ Transpose
armnn::LayerType::Comparison
@ Comparison
armnn::LayerType::StridedSlice
@ StridedSlice
armnn::LayerType::Tile
@ Tile
armnn::LayerType::Stack
@ Stack
armnn::LayerType::Normalization
@ Normalization
armnn::LayerType::QuantizedLstm
@ QuantizedLstm
armnn::LayerType::Reduce
@ Reduce
armnn::LayerType::ElementwiseUnary
@ ElementwiseUnary
armnn::LayerType::GatherNd
@ GatherNd
armnn::LayerType::ElementwiseBinary
@ ElementwiseBinary
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:152
armnn::LayerType::ConvertFp32ToFp16
@ ConvertFp32ToFp16
ARMNN_LOG
#define ARMNN_LOG(severity)
Definition: Logging.hpp:212
armnn::LayerType::Slice
@ Slice
armnn::LayerType::ChannelShuffle
@ ChannelShuffle
armnn::LayerType::Subtraction
@ Subtraction
armnn::LayerType::Prelu
@ Prelu
armnn::LayerType::LogicalBinary
@ LogicalBinary
armnn::LayerType::Concat
@ Concat
armnn::LayerType::TransposeConvolution2d
@ TransposeConvolution2d
armnn::LayerType::Merge
@ Merge
armnn::LayerType::StandIn
@ StandIn
armnn::LayerType::Debug
@ Debug
armnn::LayerType::Softmax
@ Softmax
armnn::LayerType::Quantize
@ Quantize
armnn::LayerType::Multiplication
@ Multiplication
armnn::LayerType::Addition
@ Addition
armnn::LayerType::DepthToSpace
@ DepthToSpace
armnn::LayerType::BroadcastTo
@ BroadcastTo
armnn::LayerType::DetectionPostProcess
@ DetectionPostProcess
armnn::LayerType::MemImport
@ MemImport
armnn::LayerType::Pooling2d
@ Pooling2d
armnn::LayerType::Division
@ Division
armnn::LayerType::Shape
@ Shape
armnn::LayerType::FullyConnected
@ FullyConnected
armnn::LayerType::Gather
@ Gather
armnn::LayerType::Pooling3d
@ Pooling3d
armnn::LayerType::LogSoftmax
@ LogSoftmax
armnn::LayerType::BatchMatMul
@ BatchMatMul
armnn::LayerType::DepthwiseConvolution2d
@ DepthwiseConvolution2d
armnn::LayerType::Cast
@ Cast
armnn::LayerType::BatchToSpaceNd
@ BatchToSpaceNd
armnn::LayerType::Switch
@ Switch
armnn::LayerType::Reshape
@ Reshape
armnn::LayerType::SpaceToBatchNd
@ SpaceToBatchNd
armnn::LayerType::Fill
@ Fill
armnn::LayerType::L2Normalization
@ L2Normalization
armnn::LayerType::Fused
@ Fused
armnn::LayerType::Minimum
@ Minimum
armnn::LayerType::PreCompiled
@ PreCompiled
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::LayerType::ReverseV2
@ ReverseV2
armnn::LayerType::MemCopy
@ MemCopy
armnn::LayerType::ArgMinMax
@ ArgMinMax
armnn::LayerType::Pad
@ Pad
armnn::LayerType::Rank
@ Rank
armnn::LayerType::Mean
@ Mean
armnn::LayerType::Input
@ Input
armnn::LayerType::Resize
@ Resize
armnn::LayerType::Convolution2d
@ Convolution2d
armnn::LayerType::FakeQuantization
@ FakeQuantization
armnn::LayerType::Maximum
@ Maximum
armnn::LayerType::Activation
@ Activation
armnn::LayerType::Lstm
@ Lstm
armnn::LayerType::Dequantize
@ Dequantize
armnn::LayerType::Convolution3d
@ Convolution3d
armnn::LayerType::QLstm
@ QLstm
armnn::LayerType::Output
@ Output
armnn::LayerType::Constant
@ Constant
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