ArmNN
 22.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 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 IsConvertBf16ToFp32Supported (const TensorInfo &input, const TensorInfo &output, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
 
bool IsConvertFp32ToBf16Supported (const TensorInfo &input, 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 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 &output, const Optional< TensorInfo > &hiddenStateOutput, const Optional< TensorInfo > &cellStateOutput, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
 

Detailed Description

Definition at line 20 of file BackendHelper.hpp.

Constructor & Destructor Documentation

◆ LayerSupportHandle() [1/2]

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

Definition at line 23 of file BackendHelper.hpp.

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

◆ LayerSupportHandle() [2/2]

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

Definition at line 26 of file BackendHelper.hpp.

References armnn::ARMNN_DEPRECATED_MSG_REMOVAL_DATE(), armnn::GetCapability(), armnn::GetILayerSupportByBackendId(), armnn::GetNumberOfCacheFiles(), armnn::HasCapability(), LayerSupportHandle::IsActivationSupported(), LayerSupportHandle::IsAdditionSupported(), LayerSupportHandle::IsArgMinMaxSupported(), LayerSupportHandle::IsBackendRegistered(), LayerSupportHandle::IsBatchNormalizationSupported(), LayerSupportHandle::IsBatchToSpaceNdSupported(), armnn::IsCapabilitySupported(), LayerSupportHandle::IsCastSupported(), LayerSupportHandle::IsChannelShuffleSupported(), LayerSupportHandle::IsComparisonSupported(), LayerSupportHandle::IsConcatSupported(), LayerSupportHandle::IsConstantSupported(), LayerSupportHandle::IsConvertBf16ToFp32Supported(), LayerSupportHandle::IsConvertFp16ToFp32Supported(), LayerSupportHandle::IsConvertFp32ToBf16Supported(), LayerSupportHandle::IsConvertFp32ToFp16Supported(), LayerSupportHandle::IsConvolution2dSupported(), LayerSupportHandle::IsConvolution3dSupported(), LayerSupportHandle::IsDebugSupported(), LayerSupportHandle::IsDepthToSpaceSupported(), LayerSupportHandle::IsDepthwiseConvolutionSupported(), LayerSupportHandle::IsDequantizeSupported(), LayerSupportHandle::IsDetectionPostProcessSupported(), LayerSupportHandle::IsDilatedDepthwiseConvolutionSupported(), LayerSupportHandle::IsDivisionSupported(), LayerSupportHandle::IsElementwiseUnarySupported(), LayerSupportHandle::IsFakeQuantizationSupported(), LayerSupportHandle::IsFillSupported(), LayerSupportHandle::IsFloorSupported(), LayerSupportHandle::IsFullyConnectedSupported(), LayerSupportHandle::IsGatherSupported(), LayerSupportHandle::IsInputSupported(), LayerSupportHandle::IsInstanceNormalizationSupported(), LayerSupportHandle::IsL2NormalizationSupported(), LayerSupportHandle::IsLogicalBinarySupported(), LayerSupportHandle::IsLogicalUnarySupported(), LayerSupportHandle::IsLogSoftmaxSupported(), LayerSupportHandle::IsLstmSupported(), LayerSupportHandle::IsMaximumSupported(), LayerSupportHandle::IsMeanSupported(), LayerSupportHandle::IsMemCopySupported(), LayerSupportHandle::IsMemImportSupported(), LayerSupportHandle::IsMergeSupported(), LayerSupportHandle::IsMinimumSupported(), LayerSupportHandle::IsMultiplicationSupported(), LayerSupportHandle::IsNormalizationSupported(), LayerSupportHandle::IsOutputSupported(), LayerSupportHandle::IsPadSupported(), LayerSupportHandle::IsPermuteSupported(), LayerSupportHandle::IsPooling2dSupported(), LayerSupportHandle::IsPooling3dSupported(), LayerSupportHandle::IsPreCompiledSupported(), LayerSupportHandle::IsPreluSupported(), LayerSupportHandle::IsQLstmSupported(), LayerSupportHandle::IsQuantizedLstmSupported(), LayerSupportHandle::IsQuantizeSupported(), LayerSupportHandle::IsRankSupported(), LayerSupportHandle::IsReduceSupported(), LayerSupportHandle::IsReshapeSupported(), LayerSupportHandle::IsResizeSupported(), LayerSupportHandle::IsShapeSupported(), LayerSupportHandle::IsSliceSupported(), LayerSupportHandle::IsSoftmaxSupported(), LayerSupportHandle::IsSpaceToBatchNdSupported(), LayerSupportHandle::IsSpaceToDepthSupported(), LayerSupportHandle::IsSplitterSupported(), LayerSupportHandle::IsStackSupported(), LayerSupportHandle::IsStandInSupported(), LayerSupportHandle::IsStridedSliceSupported(), LayerSupportHandle::IsSubtractionSupported(), LayerSupportHandle::IsSwitchSupported(), LayerSupportHandle::IsTransposeConvolution2dSupported(), LayerSupportHandle::IsTransposeSupported(), and LayerSupportHandle::IsUnidirectionalSequenceLstmSupported().

27  : 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 153 of file BackendHelper.cpp.

References armnn::Activation.

Referenced by LayerSupportHandle::LayerSupportHandle().

157 {
158  TensorInfos infos{input, output};
159 
160  return m_LayerSupport->IsLayerSupported(LayerType::Activation,
161  infos,
162  descriptor,
163  EmptyOptional(),
164  EmptyOptional(),
165  reasonIfUnsupported);
166 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsAdditionSupported()

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

Definition at line 168 of file BackendHelper.cpp.

References armnn::Addition.

Referenced by LayerSupportHandle::LayerSupportHandle().

172 {
173  TensorInfos infos{input0, input1, output};
174 
175  return m_LayerSupport->IsLayerSupported(LayerType::Addition,
176  infos,
177  BaseDescriptor(),
178  EmptyOptional(),
179  EmptyOptional(),
180  reasonIfUnsupported);
181 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsArgMinMaxSupported()

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

Definition at line 183 of file BackendHelper.cpp.

References armnn::ArgMinMax.

Referenced by LayerSupportHandle::LayerSupportHandle().

187 {
188  TensorInfos infos{input, output};
189 
190  return m_LayerSupport->IsLayerSupported(LayerType::ArgMinMax,
191  infos,
192  descriptor,
193  EmptyOptional(),
194  EmptyOptional(),
195  reasonIfUnsupported);
196 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsBackendRegistered()

bool IsBackendRegistered ( ) const

Definition at line 141 of file BackendHelper.cpp.

Referenced by LayerSupportHandle::LayerSupportHandle().

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

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

References armnn::BatchNormalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

206 {
207  TensorInfos infos{input, output, mean, var, beta, gamma};
208 
209  return m_LayerSupport->IsLayerSupported(LayerType::BatchNormalization,
210  infos,
211  descriptor,
212  EmptyOptional(),
213  EmptyOptional(),
214  reasonIfUnsupported);
215 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsBatchToSpaceNdSupported()

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

Definition at line 217 of file BackendHelper.cpp.

References armnn::BatchToSpaceNd.

Referenced by LayerSupportHandle::LayerSupportHandle().

221 {
222  TensorInfos infos{input, output};
223 
224  return m_LayerSupport->IsLayerSupported(LayerType::BatchToSpaceNd,
225  infos,
226  descriptor,
227  EmptyOptional(),
228  EmptyOptional(),
229  reasonIfUnsupported);
230 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsCastSupported()

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

Definition at line 232 of file BackendHelper.cpp.

References armnn::Cast.

Referenced by LayerSupportHandle::LayerSupportHandle().

235 {
236  TensorInfos infos{input, output};
237 
238  return m_LayerSupport->IsLayerSupported(LayerType::Cast,
239  infos,
240  BaseDescriptor(),
241  EmptyOptional(),
242  EmptyOptional(),
243  reasonIfUnsupported);
244 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsChannelShuffleSupported()

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

Definition at line 246 of file BackendHelper.cpp.

References armnn::ChannelShuffle.

Referenced by LayerSupportHandle::LayerSupportHandle().

250 {
251  TensorInfos infos{input, output};
252 
253  return m_LayerSupport->IsLayerSupported(LayerType::ChannelShuffle,
254  infos,
255  descriptor,
256  EmptyOptional(),
257  EmptyOptional(),
258  reasonIfUnsupported);
259 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsComparisonSupported()

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

Definition at line 261 of file BackendHelper.cpp.

References armnn::Comparison.

Referenced by LayerSupportHandle::LayerSupportHandle().

266 {
267  TensorInfos infos{input0, input1, output};
268 
269  return m_LayerSupport->IsLayerSupported(LayerType::Comparison,
270  infos,
271  descriptor,
272  EmptyOptional(),
273  EmptyOptional(),
274  reasonIfUnsupported);
275 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsConcatSupported()

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

Definition at line 277 of file BackendHelper.cpp.

References armnn::Concat.

Referenced by LayerSupportHandle::LayerSupportHandle().

281 {
282  TensorInfos infos;
283  for (const TensorInfo* inputInfo : inputs)
284  {
285  infos.push_back(*inputInfo);
286  }
287  infos.push_back(output);
288 
289  return m_LayerSupport->IsLayerSupported(LayerType::Concat,
290  infos,
291  descriptor,
292  EmptyOptional(),
293  EmptyOptional(),
294  reasonIfUnsupported);
295 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsConstantSupported()

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

Definition at line 297 of file BackendHelper.cpp.

References armnn::Constant.

Referenced by LayerSupportHandle::LayerSupportHandle().

299 {
300  TensorInfos infos{output};
301 
302  return m_LayerSupport->IsLayerSupported(LayerType::Constant,
303  infos,
304  BaseDescriptor(),
305  EmptyOptional(),
306  EmptyOptional(),
307  reasonIfUnsupported);
308 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsConvertBf16ToFp32Supported()

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

Definition at line 310 of file BackendHelper.cpp.

References armnn::ConvertBf16ToFp32.

Referenced by LayerSupportHandle::LayerSupportHandle().

313 {
314  TensorInfos infos{input, output};
315 
316  return m_LayerSupport->IsLayerSupported(LayerType::ConvertBf16ToFp32,
317  infos,
318  BaseDescriptor(),
319  EmptyOptional(),
320  EmptyOptional(),
321  reasonIfUnsupported);
322 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsConvertFp16ToFp32Supported()

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

Definition at line 338 of file BackendHelper.cpp.

References armnn::ConvertFp16ToFp32.

Referenced by LayerSupportHandle::LayerSupportHandle().

341 {
342  TensorInfos infos{input, output};
343 
344  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp16ToFp32,
345  infos,
346  BaseDescriptor(),
347  EmptyOptional(),
348  EmptyOptional(),
349  reasonIfUnsupported);
350 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsConvertFp32ToBf16Supported()

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

Definition at line 324 of file BackendHelper.cpp.

References armnn::ConvertFp32ToBf16.

Referenced by LayerSupportHandle::LayerSupportHandle().

327 {
328  TensorInfos infos{input, output};
329 
330  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp32ToBf16,
331  infos,
332  BaseDescriptor(),
333  EmptyOptional(),
334  EmptyOptional(),
335  reasonIfUnsupported);
336 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsConvertFp32ToFp16Supported()

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

Definition at line 352 of file BackendHelper.cpp.

References armnn::ConvertFp32ToFp16.

Referenced by LayerSupportHandle::LayerSupportHandle().

355 {
356  TensorInfos infos{input, output};
357 
358  return m_LayerSupport->IsLayerSupported(LayerType::ConvertFp32ToFp16,
359  infos,
360  BaseDescriptor(),
361  EmptyOptional(),
362  EmptyOptional(),
363  reasonIfUnsupported);
364 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

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

Referenced by LayerSupportHandle::LayerSupportHandle().

372 {
373  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
374  TensorInfos infos{input, output, weights, biasesVal};
375 
376  return m_LayerSupport->IsLayerSupported(LayerType::Convolution2d,
377  infos,
378  descriptor,
379  EmptyOptional(),
380  EmptyOptional(),
381  reasonIfUnsupported);
382 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

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

Referenced by LayerSupportHandle::LayerSupportHandle().

390 {
391  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
392  TensorInfos infos{input, output, weights, biasesVal};
393 
394  return m_LayerSupport->IsLayerSupported(LayerType::Convolution3d,
395  infos,
396  descriptor,
397  EmptyOptional(),
398  EmptyOptional(),
399  reasonIfUnsupported);
400 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsDebugSupported()

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

Definition at line 402 of file BackendHelper.cpp.

References armnn::Debug.

Referenced by LayerSupportHandle::LayerSupportHandle().

405 {
406  TensorInfos infos{input, output};
407 
408  return m_LayerSupport->IsLayerSupported(LayerType::Debug,
409  infos,
410  BaseDescriptor(),
411  EmptyOptional(),
412  EmptyOptional(),
413  reasonIfUnsupported);
414 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsDepthToSpaceSupported()

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

Definition at line 416 of file BackendHelper.cpp.

References armnn::DepthToSpace.

Referenced by LayerSupportHandle::LayerSupportHandle().

420 {
421  TensorInfos infos{input, output};
422 
423  return m_LayerSupport->IsLayerSupported(LayerType::DepthToSpace,
424  infos,
425  descriptor,
426  EmptyOptional(),
427  EmptyOptional(),
428  reasonIfUnsupported);
429 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

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

Referenced by LayerSupportHandle::LayerSupportHandle().

438 {
439  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
440  TensorInfos infos{input, output, weights, biasesVal};
441 
442  return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
443  infos,
444  descriptor,
445  EmptyOptional(),
446  EmptyOptional(),
447  reasonIfUnsupported);
448 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsDequantizeSupported()

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

Definition at line 450 of file BackendHelper.cpp.

References armnn::Dequantize.

Referenced by LayerSupportHandle::LayerSupportHandle().

453 {
454  TensorInfos infos{input, output};
455 
456  return m_LayerSupport->IsLayerSupported(LayerType::Dequantize,
457  infos,
458  BaseDescriptor(),
459  EmptyOptional(),
460  EmptyOptional(),
461  reasonIfUnsupported);
462 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

References armnn::DetectionPostProcess.

Referenced by LayerSupportHandle::LayerSupportHandle().

473 {
474  TensorInfos infos{boxEncodings, scores, anchors, detectionBoxes, detectionClasses, detectionScores, numDetections};
475 
476  return m_LayerSupport->IsLayerSupported(LayerType::DetectionPostProcess,
477  infos,
478  descriptor,
479  EmptyOptional(),
480  EmptyOptional(),
481  reasonIfUnsupported);
482 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

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

Referenced by LayerSupportHandle::LayerSupportHandle().

491 {
492  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
493  TensorInfos infos{input, output, weights, biasesVal};
494 
495  return m_LayerSupport->IsLayerSupported(LayerType::DepthwiseConvolution2d,
496  infos,
497  descriptor,
498  EmptyOptional(),
499  EmptyOptional(),
500  reasonIfUnsupported);
501 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsDivisionSupported()

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

Definition at line 503 of file BackendHelper.cpp.

References armnn::Division.

Referenced by LayerSupportHandle::LayerSupportHandle().

507 {
508  TensorInfos infos{input0, input1, output};
509 
510  return m_LayerSupport->IsLayerSupported(LayerType::Division,
511  infos,
512  BaseDescriptor(),
513  EmptyOptional(),
514  EmptyOptional(),
515  reasonIfUnsupported);
516 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsElementwiseUnarySupported()

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

Definition at line 518 of file BackendHelper.cpp.

References armnn::ElementwiseUnary.

Referenced by LayerSupportHandle::LayerSupportHandle().

522 {
523  TensorInfos infos{input, output};
524 
525  return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseUnary,
526  infos,
527  descriptor,
528  EmptyOptional(),
529  EmptyOptional(),
530  reasonIfUnsupported);
531 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsFakeQuantizationSupported()

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

Definition at line 533 of file BackendHelper.cpp.

References armnn::FakeQuantization.

Referenced by LayerSupportHandle::LayerSupportHandle().

536 {
537  TensorInfos infos{input};
538 
539  return m_LayerSupport->IsLayerSupported(LayerType::FakeQuantization,
540  infos,
541  descriptor,
542  EmptyOptional(),
543  EmptyOptional(),
544  reasonIfUnsupported);
545 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsFillSupported()

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

Definition at line 547 of file BackendHelper.cpp.

References armnn::Fill.

Referenced by LayerSupportHandle::LayerSupportHandle().

551 {
552  TensorInfos infos{input, output};
553 
554  return m_LayerSupport->IsLayerSupported(LayerType::Fill,
555  infos,
556  descriptor,
557  EmptyOptional(),
558  EmptyOptional(),
559  reasonIfUnsupported);
560 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsFloorSupported()

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

Definition at line 562 of file BackendHelper.cpp.

References armnn::Floor.

Referenced by LayerSupportHandle::LayerSupportHandle().

565 {
566  TensorInfos infos{input, output};
567 
568  return m_LayerSupport->IsLayerSupported(LayerType::Floor,
569  infos,
570  BaseDescriptor(),
571  EmptyOptional(),
572  EmptyOptional(),
573  reasonIfUnsupported);
574 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

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.

Referenced by LayerSupportHandle::LayerSupportHandle().

582 {
583  if(!m_BackendId.IsUndefined())
584  {
585  auto capability = GetCapability("ConstantTensorsAsInputs", m_BackendId);
586  if(!capability.has_value() || capability.value().GetValue().AsBool() == false)
587  {
588  if(!weights.IsConstant())
589  {
590  if (reasonIfUnsupported.has_value())
591  {
592  reasonIfUnsupported.value() =
593  "This backend might not support non constant weights. "
594  "If weights are constant make sure to set IsConstant when creating TensorInfo";
595  }
596 
597  return false;
598  }
599  if(descriptor.m_BiasEnabled)
600  {
601  if(!biases.IsConstant())
602  {
603  if (reasonIfUnsupported.has_value())
604  {
605  reasonIfUnsupported.value() =
606  "This backend might not support non constant weights. "
607  "If weights are constant make sure to set IsConstant when creating TensorInfo";
608  }
609  return false;
610  }
611  }
612 
613  // At the first stage we will only print a warning. this is to give
614  // backend developers a chance to adopt and read weights from input slots.
615  ARMNN_LOG(warning) << "The backend makes use of a deprecated interface to read constant tensors. "
616  "If you are a backend developer please find more information in our "
617  "doxygen documentation on github https://github.com/ARM-software/armnn "
618  "under the keyword 'ConstTensorsAsInputs'.";
619  }
620 
621  if(!descriptor.m_ConstantWeights)
622  {
623  capability = GetCapability("NonConstWeights", m_BackendId);
624  if (capability.has_value() && capability.value().GetValue().AsBool() == true)
625  {
626  return true;
627  }
628  return false;
629  }
630  }
631 
632  TensorInfos infos{input, output, weights, biases};
633 
634  return m_LayerSupport->IsLayerSupported(LayerType::FullyConnected,
635  infos,
636  descriptor,
637  EmptyOptional(),
638  EmptyOptional(),
639  reasonIfUnsupported);
640 }
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:30
ARMNN_LOG
#define ARMNN_LOG(severity)
Definition: Logging.hpp:205
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151
armnn::BackendId::IsUndefined
bool IsUndefined() const
Definition: BackendId.hpp:141

◆ IsGatherSupported()

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

Definition at line 642 of file BackendHelper.cpp.

References armnn::Gather.

Referenced by LayerSupportHandle::LayerSupportHandle().

647 {
648  TensorInfos infos{input0, input1, output};
649 
650  return m_LayerSupport->IsLayerSupported(LayerType::Gather,
651  infos,
652  descriptor,
653  EmptyOptional(),
654  EmptyOptional(),
655  reasonIfUnsupported);
656 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsInputSupported()

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

Definition at line 658 of file BackendHelper.cpp.

References armnn::Input.

Referenced by LayerSupportHandle::LayerSupportHandle().

660 {
661  TensorInfos infos{input};
662 
663  return m_LayerSupport->IsLayerSupported(LayerType::Input,
664  infos,
665  BaseDescriptor(),
666  EmptyOptional(),
667  EmptyOptional(),
668  reasonIfUnsupported);
669 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsInstanceNormalizationSupported()

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

Definition at line 671 of file BackendHelper.cpp.

References armnn::InstanceNormalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

676 {
677  TensorInfos infos{input, output};
678 
679  return m_LayerSupport->IsLayerSupported(LayerType::InstanceNormalization,
680  infos,
681  descriptor,
682  EmptyOptional(),
683  EmptyOptional(),
684  reasonIfUnsupported);
685 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsL2NormalizationSupported()

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

Definition at line 687 of file BackendHelper.cpp.

References armnn::L2Normalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

691 {
692  TensorInfos infos{input, output};
693 
694  return m_LayerSupport->IsLayerSupported(LayerType::L2Normalization,
695  infos,
696  descriptor,
697  EmptyOptional(),
698  EmptyOptional(),
699  reasonIfUnsupported);
700 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsLogicalBinarySupported()

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

Definition at line 702 of file BackendHelper.cpp.

References armnn::LogicalBinary.

Referenced by LayerSupportHandle::LayerSupportHandle().

707 {
708  TensorInfos infos{input0, input1, output};
709 
710  return m_LayerSupport->IsLayerSupported(LayerType::LogicalBinary,
711  infos,
712  descriptor,
713  EmptyOptional(),
714  EmptyOptional(),
715  reasonIfUnsupported);
716 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsLogicalUnarySupported()

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

Definition at line 718 of file BackendHelper.cpp.

References armnn::ElementwiseUnary.

Referenced by LayerSupportHandle::LayerSupportHandle().

722 {
723  TensorInfos infos{input, output};
724 
725  return m_LayerSupport->IsLayerSupported(LayerType::ElementwiseUnary,
726  infos,
727  descriptor,
728  EmptyOptional(),
729  EmptyOptional(),
730  reasonIfUnsupported);
731 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsLogSoftmaxSupported()

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

Definition at line 733 of file BackendHelper.cpp.

References armnn::LogSoftmax.

Referenced by LayerSupportHandle::LayerSupportHandle().

737 {
738  TensorInfos infos{input, output};
739 
740  return m_LayerSupport->IsLayerSupported(LayerType::LogSoftmax,
741  infos,
742  descriptor,
743  EmptyOptional(),
744  EmptyOptional(),
745  reasonIfUnsupported);
746 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

References armnn::Lstm.

Referenced by LayerSupportHandle::LayerSupportHandle().

758 {
759  TensorInfos infos{input, outputStateIn, cellStateIn, scratchBuffer, outputStateOut, cellStateOut, output};
760 
761  return m_LayerSupport->IsLayerSupported(LayerType::Lstm,
762  infos,
763  descriptor,
764  paramsInfo,
765  EmptyOptional(),
766  reasonIfUnsupported);
767 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMaximumSupported()

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

Definition at line 769 of file BackendHelper.cpp.

References armnn::Maximum.

Referenced by LayerSupportHandle::LayerSupportHandle().

773 {
774  TensorInfos infos{input0, input1, output};
775 
776  return m_LayerSupport->IsLayerSupported(LayerType::Maximum,
777  infos,
778  BaseDescriptor(),
779  EmptyOptional(),
780  EmptyOptional(),
781  reasonIfUnsupported);
782 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMeanSupported()

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

Definition at line 784 of file BackendHelper.cpp.

References armnn::Mean.

Referenced by LayerSupportHandle::LayerSupportHandle().

788 {
789  TensorInfos infos{input, output};
790 
791  return m_LayerSupport->IsLayerSupported(LayerType::Mean,
792  infos,
793  descriptor,
794  EmptyOptional(),
795  EmptyOptional(),
796  reasonIfUnsupported);
797 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMemCopySupported()

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

Definition at line 799 of file BackendHelper.cpp.

References armnn::MemCopy.

Referenced by LayerSupportHandle::LayerSupportHandle().

802 {
803  TensorInfos infos{input, output};
804 
805  return m_LayerSupport->IsLayerSupported(LayerType::MemCopy,
806  infos,
807  BaseDescriptor(),
808  EmptyOptional(),
809  EmptyOptional(),
810  reasonIfUnsupported);
811 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMemImportSupported()

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

Definition at line 813 of file BackendHelper.cpp.

References armnn::MemImport.

Referenced by LayerSupportHandle::LayerSupportHandle().

816 {
817  TensorInfos infos{input, output};
818 
819  return m_LayerSupport->IsLayerSupported(LayerType::MemImport,
820  infos,
821  BaseDescriptor(),
822  EmptyOptional(),
823  EmptyOptional(),
824  reasonIfUnsupported);
825 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMergeSupported()

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

Definition at line 827 of file BackendHelper.cpp.

References armnn::Merge.

Referenced by LayerSupportHandle::LayerSupportHandle().

831 {
832  TensorInfos infos{input0, input1, output};
833 
834  return m_LayerSupport->IsLayerSupported(LayerType::Merge,
835  infos,
836  BaseDescriptor(),
837  EmptyOptional(),
838  EmptyOptional(),
839  reasonIfUnsupported);
840 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMinimumSupported()

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

Definition at line 842 of file BackendHelper.cpp.

References armnn::Minimum.

Referenced by LayerSupportHandle::LayerSupportHandle().

846 {
847  TensorInfos infos{input0, input1, output};
848 
849  return m_LayerSupport->IsLayerSupported(LayerType::Minimum,
850  infos,
851  BaseDescriptor(),
852  EmptyOptional(),
853  EmptyOptional(),
854  reasonIfUnsupported);
855 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsMultiplicationSupported()

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

Definition at line 857 of file BackendHelper.cpp.

References armnn::Multiplication.

Referenced by LayerSupportHandle::LayerSupportHandle().

861 {
862  TensorInfos infos{input0, input1, output};
863 
864  return m_LayerSupport->IsLayerSupported(LayerType::Multiplication,
865  infos,
866  BaseDescriptor(),
867  EmptyOptional(),
868  EmptyOptional(),
869  reasonIfUnsupported);
870 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsNormalizationSupported()

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

Definition at line 872 of file BackendHelper.cpp.

References armnn::Normalization.

Referenced by LayerSupportHandle::LayerSupportHandle().

876 {
877  TensorInfos infos{input, output};
878 
879  return m_LayerSupport->IsLayerSupported(LayerType::Normalization,
880  infos,
881  descriptor,
882  EmptyOptional(),
883  EmptyOptional(),
884  reasonIfUnsupported);
885 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsOutputSupported()

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

Definition at line 887 of file BackendHelper.cpp.

References armnn::Output.

Referenced by LayerSupportHandle::LayerSupportHandle().

889 {
890  TensorInfos infos{output};
891 
892  return m_LayerSupport->IsLayerSupported(LayerType::Output,
893  infos,
894  BaseDescriptor(),
895  EmptyOptional(),
896  EmptyOptional(),
897  reasonIfUnsupported);
898 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsPadSupported()

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

Definition at line 900 of file BackendHelper.cpp.

References armnn::Pad.

Referenced by LayerSupportHandle::LayerSupportHandle().

904 {
905  TensorInfos infos{input, output};
906 
907  return m_LayerSupport->IsLayerSupported(LayerType::Pad,
908  infos,
909  descriptor,
910  EmptyOptional(),
911  EmptyOptional(),
912  reasonIfUnsupported);
913 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsPermuteSupported()

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

Definition at line 915 of file BackendHelper.cpp.

References armnn::Permute.

Referenced by LayerSupportHandle::LayerSupportHandle().

919 {
920  TensorInfos infos{input, output};
921 
922  return m_LayerSupport->IsLayerSupported(LayerType::Permute,
923  infos,
924  descriptor,
925  EmptyOptional(),
926  EmptyOptional(),
927  reasonIfUnsupported);
928 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsPooling2dSupported()

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

Definition at line 930 of file BackendHelper.cpp.

References armnn::Pooling2d.

Referenced by LayerSupportHandle::LayerSupportHandle().

934 {
935  TensorInfos infos{input, output};
936 
937  return m_LayerSupport->IsLayerSupported(LayerType::Pooling2d,
938  infos,
939  descriptor,
940  EmptyOptional(),
941  EmptyOptional(),
942  reasonIfUnsupported);
943 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsPooling3dSupported()

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

Definition at line 945 of file BackendHelper.cpp.

References armnn::Pooling3d.

Referenced by LayerSupportHandle::LayerSupportHandle().

949 {
950  TensorInfos infos{input, output};
951 
952  return m_LayerSupport->IsLayerSupported(LayerType::Pooling3d,
953  infos,
954  descriptor,
955  EmptyOptional(),
956  EmptyOptional(),
957  reasonIfUnsupported);
958 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsPreCompiledSupported()

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

Definition at line 960 of file BackendHelper.cpp.

References armnn::PreCompiled.

Referenced by LayerSupportHandle::LayerSupportHandle().

963 {
964  TensorInfos infos{input};
965 
966  return m_LayerSupport->IsLayerSupported(LayerType::PreCompiled,
967  infos,
968  descriptor,
969  EmptyOptional(),
970  EmptyOptional(),
971  reasonIfUnsupported);
972 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsPreluSupported()

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

Definition at line 974 of file BackendHelper.cpp.

References armnn::Prelu.

Referenced by LayerSupportHandle::LayerSupportHandle().

978 {
979  TensorInfos infos{input, alpha, output};
980 
981  return m_LayerSupport->IsLayerSupported(LayerType::Prelu,
982  infos,
983  BaseDescriptor(),
984  EmptyOptional(),
985  EmptyOptional(),
986  reasonIfUnsupported);
987 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

References armnn::QLstm.

Referenced by LayerSupportHandle::LayerSupportHandle().

1012 {
1013  TensorInfos infos{input, previousOutputIn, previousCellStateIn, outputStateOut, cellStateOut, output};
1014 
1015  return m_LayerSupport->IsLayerSupported(LayerType::QLstm,
1016  infos,
1017  descriptor,
1018  paramsInfo,
1019  EmptyOptional(),
1020  reasonIfUnsupported);
1021 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

References armnn::QuantizedLstm.

Referenced by LayerSupportHandle::LayerSupportHandle().

1030 {
1031  TensorInfos infos{input, previousCellStateIn, previousOutputIn, cellStateOut, output};
1032 
1033  return m_LayerSupport->IsLayerSupported(LayerType::QuantizedLstm,
1034  infos,
1035  BaseDescriptor(),
1036  EmptyOptional(),
1037  paramsInfo,
1038  reasonIfUnsupported);
1039 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsQuantizeSupported()

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

Definition at line 989 of file BackendHelper.cpp.

References armnn::Quantize.

Referenced by LayerSupportHandle::LayerSupportHandle().

992 {
993  TensorInfos infos{input, output};
994 
995  return m_LayerSupport->IsLayerSupported(LayerType::Quantize,
996  infos,
997  BaseDescriptor(),
998  EmptyOptional(),
999  EmptyOptional(),
1000  reasonIfUnsupported);
1001 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsRankSupported()

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

Definition at line 1041 of file BackendHelper.cpp.

References armnn::Rank.

Referenced by LayerSupportHandle::LayerSupportHandle().

1044 {
1045  TensorInfos infos{input, output};
1046 
1047  return m_LayerSupport->IsLayerSupported(LayerType::Rank,
1048  infos,
1049  BaseDescriptor(),
1050  EmptyOptional(),
1051  EmptyOptional(),
1052  reasonIfUnsupported);
1053 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsReduceSupported()

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

Definition at line 1055 of file BackendHelper.cpp.

References armnn::Reduce.

Referenced by LayerSupportHandle::LayerSupportHandle().

1059 {
1060  TensorInfos infos{input, output};
1061 
1062  return m_LayerSupport->IsLayerSupported(LayerType::Reduce,
1063  infos,
1064  descriptor,
1065  EmptyOptional(),
1066  EmptyOptional(),
1067  reasonIfUnsupported);
1068 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsReshapeSupported()

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

Definition at line 1070 of file BackendHelper.cpp.

References armnn::Reshape.

Referenced by LayerSupportHandle::LayerSupportHandle().

1074 {
1075  TensorInfos infos{input, output};
1076 
1077  return m_LayerSupport->IsLayerSupported(LayerType::Reshape,
1078  infos,
1079  descriptor,
1080  EmptyOptional(),
1081  EmptyOptional(),
1082  reasonIfUnsupported);
1083 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsResizeSupported()

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

Definition at line 1085 of file BackendHelper.cpp.

References armnn::Resize.

Referenced by LayerSupportHandle::LayerSupportHandle().

1089 {
1090  TensorInfos infos{input, output};
1091 
1092  return m_LayerSupport->IsLayerSupported(LayerType::Resize,
1093  infos,
1094  descriptor,
1095  EmptyOptional(),
1096  EmptyOptional(),
1097  reasonIfUnsupported);
1098 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsShapeSupported()

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

Definition at line 1100 of file BackendHelper.cpp.

References armnn::Shape.

Referenced by LayerSupportHandle::LayerSupportHandle().

1103 {
1104  TensorInfos infos{input, output};
1105 
1106  return m_LayerSupport->IsLayerSupported(LayerType::Shape,
1107  infos,
1108  BaseDescriptor(),
1109  EmptyOptional(),
1110  EmptyOptional(),
1111  reasonIfUnsupported);
1112 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsSliceSupported()

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

Definition at line 1114 of file BackendHelper.cpp.

References armnn::Slice.

Referenced by LayerSupportHandle::LayerSupportHandle().

1118 {
1119  TensorInfos infos{input, output};
1120 
1121  return m_LayerSupport->IsLayerSupported(LayerType::Slice,
1122  infos,
1123  descriptor,
1124  EmptyOptional(),
1125  EmptyOptional(),
1126  reasonIfUnsupported);
1127 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsSoftmaxSupported()

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

Definition at line 1129 of file BackendHelper.cpp.

References armnn::Softmax.

Referenced by LayerSupportHandle::LayerSupportHandle().

1133 {
1134  TensorInfos infos{input, output};
1135 
1136  return m_LayerSupport->IsLayerSupported(LayerType::Softmax,
1137  infos,
1138  descriptor,
1139  EmptyOptional(),
1140  EmptyOptional(),
1141  reasonIfUnsupported);
1142 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsSpaceToBatchNdSupported()

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

Definition at line 1144 of file BackendHelper.cpp.

References armnn::SpaceToBatchNd.

Referenced by LayerSupportHandle::LayerSupportHandle().

1148 {
1149  TensorInfos infos{input, output};
1150 
1151  return m_LayerSupport->IsLayerSupported(LayerType::SpaceToBatchNd,
1152  infos,
1153  descriptor,
1154  EmptyOptional(),
1155  EmptyOptional(),
1156  reasonIfUnsupported);
1157 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsSpaceToDepthSupported()

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

Definition at line 1159 of file BackendHelper.cpp.

References armnn::SpaceToDepth.

Referenced by LayerSupportHandle::LayerSupportHandle().

1163 {
1164  TensorInfos infos{input, output};
1165 
1166  return m_LayerSupport->IsLayerSupported(LayerType::SpaceToDepth,
1167  infos,
1168  descriptor,
1169  EmptyOptional(),
1170  EmptyOptional(),
1171  reasonIfUnsupported);
1172 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

References armnn::Splitter.

Referenced by LayerSupportHandle::LayerSupportHandle().

1178 {
1179  TensorInfos infos{input};
1180  for (TensorInfo outInfo : outputs)
1181  {
1182  infos.push_back(outInfo);
1183  }
1184 
1185  return m_LayerSupport->IsLayerSupported(LayerType::Splitter,
1186  infos,
1187  descriptor,
1188  EmptyOptional(),
1189  EmptyOptional(),
1190  reasonIfUnsupported);
1191 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsStackSupported()

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

Definition at line 1193 of file BackendHelper.cpp.

References armnn::Stack.

Referenced by LayerSupportHandle::LayerSupportHandle().

1197 {
1198  TensorInfos infos;
1199  for (const TensorInfo* inputInfo : inputs)
1200  {
1201  infos.push_back(*inputInfo);
1202  }
1203  infos.push_back(output);
1204 
1205  return m_LayerSupport->IsLayerSupported(LayerType::Stack,
1206  infos,
1207  descriptor,
1208  EmptyOptional(),
1209  EmptyOptional(),
1210  reasonIfUnsupported);
1211 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

References armnn::StandIn.

Referenced by LayerSupportHandle::LayerSupportHandle().

1217 {
1218  TensorInfos infos;
1219  for (const TensorInfo* inputInfo : inputs)
1220  {
1221  infos.push_back(*inputInfo);
1222  }
1223  for (const TensorInfo* outputInfo : outputs)
1224  {
1225  infos.push_back(*outputInfo);
1226  }
1227 
1228  return m_LayerSupport->IsLayerSupported(LayerType::StandIn,
1229  infos,
1230  descriptor,
1231  EmptyOptional(),
1232  EmptyOptional(),
1233  reasonIfUnsupported);
1234 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsStridedSliceSupported()

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

Definition at line 1237 of file BackendHelper.cpp.

References armnn::StridedSlice.

Referenced by LayerSupportHandle::LayerSupportHandle().

1241 {
1242  TensorInfos infos{input, output};
1243 
1244  return m_LayerSupport->IsLayerSupported(LayerType::StridedSlice,
1245  infos,
1246  descriptor,
1247  EmptyOptional(),
1248  EmptyOptional(),
1249  reasonIfUnsupported);
1250 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsSubtractionSupported()

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

Definition at line 1252 of file BackendHelper.cpp.

References armnn::Subtraction.

Referenced by LayerSupportHandle::LayerSupportHandle().

1256 {
1257  TensorInfos infos{input0, input1, output};
1258 
1259  return m_LayerSupport->IsLayerSupported(LayerType::Subtraction,
1260  infos,
1261  BaseDescriptor(),
1262  EmptyOptional(),
1263  EmptyOptional(),
1264  reasonIfUnsupported);
1265 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsSwitchSupported()

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

Definition at line 1267 of file BackendHelper.cpp.

References armnn::Switch.

Referenced by LayerSupportHandle::LayerSupportHandle().

1272 {
1273  TensorInfos infos{input0, input1, output0, output1};
1274 
1275  return m_LayerSupport->IsLayerSupported(LayerType::Switch,
1276  infos,
1277  BaseDescriptor(),
1278  EmptyOptional(),
1279  EmptyOptional(),
1280  reasonIfUnsupported);
1281 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

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

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

Referenced by LayerSupportHandle::LayerSupportHandle().

1290 {
1291  TensorInfo biasesVal = biases.has_value() ? biases.value() : TensorInfo();
1292  TensorInfos infos{input, output, weights, biasesVal};
1293 
1294  return m_LayerSupport->IsLayerSupported(LayerType::TransposeConvolution2d,
1295  infos,
1296  descriptor,
1297  EmptyOptional(),
1298  EmptyOptional(),
1299  reasonIfUnsupported);
1300 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsTransposeSupported()

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

Definition at line 1302 of file BackendHelper.cpp.

References armnn::Transpose.

Referenced by LayerSupportHandle::LayerSupportHandle().

1306 {
1307  TensorInfos infos{input, output};
1308 
1309  return m_LayerSupport->IsLayerSupported(LayerType::Transpose,
1310  infos,
1311  descriptor,
1312  EmptyOptional(),
1313  EmptyOptional(),
1314  reasonIfUnsupported);
1315 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151

◆ IsUnidirectionalSequenceLstmSupported()

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

Definition at line 1317 of file BackendHelper.cpp.

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

Referenced by LayerSupportHandle::LayerSupportHandle().

1326 {
1327  TensorInfo hiddenStateOutputVal = hiddenStateOutput.has_value() ? hiddenStateOutput.value() : TensorInfo();
1328  TensorInfo cellStateOutputVal = cellStateOutput.has_value() ? cellStateOutput.value() : TensorInfo();
1329  TensorInfos infos{input, outputStateIn, cellStateIn, hiddenStateOutputVal, cellStateOutputVal, output};
1330 
1331  return m_LayerSupport->IsLayerSupported(LayerType::UnidirectionalSequenceLstm,
1332  infos,
1333  descriptor,
1334  paramsInfo,
1335  EmptyOptional(),
1336  reasonIfUnsupported);
1337 }
armnn::TensorInfos
std::vector< TensorInfo > TensorInfos
Definition: BackendHelper.cpp:151
The documentation for this class was generated from the following files: