ArmNN
 23.05
Public Member Functions | Static Public Member Functions | List of all members
NeonWorkloadFactory Class Reference

#include <NeonWorkloadFactory.hpp>

Inheritance diagram for NeonWorkloadFactory:
WorkloadFactoryBase IWorkloadFactory

Public Member Functions

 NeonWorkloadFactory (const std::shared_ptr< NeonMemoryManager > &memoryManager)
 
 NeonWorkloadFactory (const std::shared_ptr< NeonMemoryManager > &memoryManager, const IBackendInternal::IBackendSpecificModelContextPtr &modelContextPtr)
 
const BackendId & GetBackendId () const override
 
bool SupportsSubTensors () const override
 
std::unique_ptr< ITensorHandle > CreateSubTensorHandle (ITensorHandle &parent, TensorShape const &subTensorShape, unsigned int const *subTensorOrigin) const override
 
std::unique_ptr< ITensorHandle > CreateTensorHandle (const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const override
 
std::unique_ptr< ITensorHandle > CreateTensorHandle (const TensorInfo &tensorInfo, DataLayout dataLayout, const bool IsMemoryManaged=true) const override
 
std::unique_ptr< IWorkload > CreateWorkload (LayerType type, const QueueDescriptor &descriptor, const WorkloadInfo &info) const override
 
- Public Member Functions inherited from WorkloadFactoryBase
std::unique_ptr< IWorkload > CreateInput (const InputQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateActivation (const ActivationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateAddition (const AdditionQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateArgMinMax (const ArgMinMaxQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateBatchNormalization (const BatchNormalizationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateBatchToSpaceNd (const BatchToSpaceNdQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateComparison (const ComparisonQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateConcat (const ConcatQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateConstant (const ConstantQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateConvertFp16ToFp32 (const ConvertFp16ToFp32QueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateConvertFp32ToFp16 (const ConvertFp32ToFp16QueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateConvolution2d (const Convolution2dQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateDebug (const DebugQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateDepthToSpace (const DepthToSpaceQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateDepthwiseConvolution2d (const DepthwiseConvolution2dQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateDequantize (const DequantizeQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateDetectionPostProcess (const DetectionPostProcessQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateDivision (const DivisionQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateElementwiseUnary (const ElementwiseUnaryQueueDescriptor &descriptor, const WorkloadInfo &info) const override
 
std::unique_ptr< IWorkload > CreateFakeQuantization (const FakeQuantizationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateFloor (const FloorQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateFullyConnected (const FullyConnectedQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateGather (const GatherQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateInstanceNormalization (const InstanceNormalizationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateL2Normalization (const L2NormalizationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateLogSoftmax (const LogSoftmaxQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateLstm (const LstmQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMaximum (const MaximumQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMean (const MeanQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMemCopy (const MemCopyQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMemImport (const MemImportQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMerge (const MergeQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMinimum (const MinimumQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateMultiplication (const MultiplicationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateNormalization (const NormalizationQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateOutput (const OutputQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreatePad (const PadQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreatePermute (const PermuteQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreatePooling2d (const Pooling2dQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreatePooling3d (const Pooling3dQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreatePreCompiled (const PreCompiledQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreatePrelu (const PreluQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateQuantize (const QuantizeQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateQuantizedLstm (const QuantizedLstmQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateRank (const RankQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateReshape (const ReshapeQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateResize (const ResizeQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSlice (const SliceQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSoftmax (const SoftmaxQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSpaceToBatchNd (const SpaceToBatchNdQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSpaceToDepth (const SpaceToDepthQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSubtraction (const SubtractionQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSplitter (const SplitterQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateStack (const StackQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateStridedSlice (const StridedSliceQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateSwitch (const SwitchQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateTranspose (const TransposeQueueDescriptor &, const WorkloadInfo &) const override
 
std::unique_ptr< IWorkload > CreateTransposeConvolution2d (const TransposeConvolution2dQueueDescriptor &, const WorkloadInfo &) const override
 
- Public Member Functions inherited from IWorkloadFactory
virtual ~IWorkloadFactory ()
 
virtual void AfterWorkloadsCreated ()
 

Static Public Member Functions

static bool IsLayerSupported (const Layer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
 
static bool IsLayerSupported (const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported, const ModelOptions &modelOptions)
 
- Static Public Member Functions inherited from IWorkloadFactory
static bool IsLayerSupported (const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
 
static bool IsLayerSupported (const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
 
static bool IsLayerSupported (const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported, const ModelOptions &modelOptions)
 
static bool IsLayerSupported (const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported, const ModelOptions &modelOptions)
 

Detailed Description

Definition at line 20 of file NeonWorkloadFactory.hpp.

Constructor & Destructor Documentation

◆ NeonWorkloadFactory() [1/2]

NeonWorkloadFactory ( const std::shared_ptr< NeonMemoryManager > &  memoryManager)

Definition at line 73 of file NeonWorkloadFactory.cpp.

74  : m_MemoryManager(memoryManager), m_ModelContextPtr(IBackendInternal::IBackendSpecificModelContextPtr{})
75 {
76  SetNumberOfThreads();
77 }

◆ NeonWorkloadFactory() [2/2]

NeonWorkloadFactory ( const std::shared_ptr< NeonMemoryManager > &  memoryManager,
const IBackendInternal::IBackendSpecificModelContextPtr &  modelContextPtr 
)

Definition at line 79 of file NeonWorkloadFactory.cpp.

81  : m_MemoryManager(memoryManager), m_ModelContextPtr(modelContextPtr)
82 {
83  SetNumberOfThreads();
84 }

Member Function Documentation

◆ CreateSubTensorHandle()

std::unique_ptr< ITensorHandle > CreateSubTensorHandle ( ITensorHandle &  parent,
TensorShape const &  subTensorShape,
unsigned int const *  subTensorOrigin 
) const
overridevirtual

Reimplemented from WorkloadFactoryBase.

Definition at line 86 of file NeonWorkloadFactory.cpp.

89 {
90  const arm_compute::TensorShape shape = armcomputetensorutils::BuildArmComputeTensorShape(subTensorShape);
91 
92  arm_compute::Coordinates coords;
93  coords.set_num_dimensions(subTensorShape.GetNumDimensions());
94  for (unsigned int i = 0; i < subTensorShape.GetNumDimensions(); i++)
95  {
96  // Arm compute indexes tensor coords in reverse order.
97  unsigned int revertedIndex = subTensorShape.GetNumDimensions() - i - 1;
98  coords.set(i, armnn::numeric_cast<int>(subTensorOrigin[revertedIndex]));
99  }
100 
101  const arm_compute::TensorShape parentShape = armcomputetensorutils::BuildArmComputeTensorShape(parent.GetShape());
102  if (!::arm_compute::error_on_invalid_subtensor(__func__, __FILE__, __LINE__, parentShape, coords, shape))
103  {
104  return nullptr;
105  }
106 
107  return std::make_unique<NeonSubTensorHandle>(
108  PolymorphicDowncast<IAclTensorHandle*>(&parent), shape, coords);
109 }

◆ CreateTensorHandle() [1/2]

std::unique_ptr< ITensorHandle > CreateTensorHandle ( const TensorInfo &  tensorInfo,
const bool  IsMemoryManaged = true 
) const
overridevirtual

Reimplemented from WorkloadFactoryBase.

Definition at line 111 of file NeonWorkloadFactory.cpp.

113 {
114  auto tensorHandle = std::make_unique<NeonTensorHandle>(tensorInfo);
115  if (IsMemoryManaged)
116  {
117  tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
118  }
119  return tensorHandle;
120 }

◆ CreateTensorHandle() [2/2]

std::unique_ptr< ITensorHandle > CreateTensorHandle ( const TensorInfo &  tensorInfo,
DataLayout  dataLayout,
const bool  IsMemoryManaged = true 
) const
overridevirtual

Reimplemented from WorkloadFactoryBase.

Definition at line 122 of file NeonWorkloadFactory.cpp.

125 {
126  auto tensorHandle = std::make_unique<NeonTensorHandle>(tensorInfo, dataLayout);
127  if (IsMemoryManaged)
128  {
129  tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
130  }
131  return tensorHandle;
132 }

◆ CreateWorkload()

std::unique_ptr< IWorkload > CreateWorkload ( LayerType  type,
const QueueDescriptor &  descriptor,
const WorkloadInfo &  info 
) const
overridevirtual

Reimplemented from WorkloadFactoryBase.

Definition at line 134 of file NeonWorkloadFactory.cpp.

137 {
138  switch(type)
139  {
140  case LayerType::Activation :
141  {
142  auto activationQueueDescriptor = PolymorphicDowncast<const ActivationQueueDescriptor*>(&descriptor);
143  return std::make_unique<NeonActivationWorkload>(*activationQueueDescriptor, info);
144  }
145  case LayerType::Addition :
146  {
147  auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
148  return std::make_unique<NeonAdditionWorkload>(*additionQueueDescriptor, info);
149  }
150  case LayerType::ArgMinMax :
151  {
152  auto argMinMaxQueueDescriptor = PolymorphicDowncast<const ArgMinMaxQueueDescriptor*>(&descriptor);
153  return std::make_unique<NeonArgMinMaxWorkload>(*argMinMaxQueueDescriptor, info);
154  }
155  case LayerType::BatchMatMul :
156  {
157  auto batchMatMulQueueDescriptor = PolymorphicDowncast<const BatchMatMulQueueDescriptor*>(&descriptor);
158  bool isFastMathEnabled = false;
159  if (m_ModelContextPtr)
160  {
161  if (m_ModelContextPtr.get() != nullptr)
162  {
163  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
164  if (modelOptions)
165  {
166  isFastMathEnabled = modelOptions->IsFastMathEnabled();
167  }
168  }
169  }
170  return std::make_unique<NeonBatchMatMulWorkload>(*batchMatMulQueueDescriptor, info, isFastMathEnabled);
171  }
172  case LayerType::BatchNormalization :
173  {
174  auto batchNormalizationQueueDescriptor
175  = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
176  return std::make_unique<NeonBatchNormalizationWorkload>(*batchNormalizationQueueDescriptor, info);
177  }
178  case LayerType::BatchToSpaceNd :
179  {
180  auto batchToSpaceNdQueueDescriptor
181  = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
182  return std::make_unique<NeonBatchToSpaceNdWorkload>(*batchToSpaceNdQueueDescriptor, info);
183  }
184  case LayerType::Cast :
185  {
186  auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
187  return std::make_unique<NeonCastWorkload>(*castQueueDescriptor, info);
188  }
189  case LayerType::ChannelShuffle :
190  {
191  auto channelShuffleQueueDescriptor = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
192  return std::make_unique<NeonChannelShuffleWorkload>(*channelShuffleQueueDescriptor, info);
193  }
194  case LayerType::Comparison :
195  {
196  auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
197  return std::make_unique<NeonComparisonWorkload>(*comparisonQueueDescriptor, info);
198  }
199  case LayerType::Concat :
200  {
201  auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
202  return std::make_unique<NeonConcatWorkload>(*concatQueueDescriptor, info);
203  }
204  case LayerType::Constant :
205  {
206  auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
207  return std::make_unique<NeonConstantWorkload>(*constantQueueDescriptor, info);
208  }
209  case LayerType::ConvertFp16ToFp32 :
210  {
211  auto convertFp16ToFp32QueueDescriptor
212  = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
213  return std::make_unique<NeonConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor, info);
214  }
215  case LayerType::ConvertFp32ToFp16 :
216  {
217  auto convertFp32ToFp16QueueDescriptor
218  = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
219  return std::make_unique<NeonConvertFp32ToFp16Workload>(*convertFp32ToFp16QueueDescriptor, info);
220  }
221  case LayerType::Convolution2d :
222  {
223  auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
224 
225  bool isFastMathEnabled = false;
226  if (m_ModelContextPtr)
227  {
228  if (m_ModelContextPtr.get() != nullptr)
229  {
230  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
231  if (modelOptions)
232  {
233  isFastMathEnabled = modelOptions->IsFastMathEnabled();
234  }
235  }
236  }
237  return std::make_unique<NeonConvolution2dWorkload>(*convolution2dQueueDescriptor,
238  info,
239  m_MemoryManager->GetIntraLayerManager(),
240  isFastMathEnabled);
241  }
242  case LayerType::Convolution3d :
243  {
244  auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
245 
246  bool isFastMathEnabled = false;
247  if (m_ModelContextPtr)
248  {
249  if (m_ModelContextPtr.get() != nullptr)
250  {
251  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
252  if (modelOptions)
253  {
254  isFastMathEnabled = modelOptions->IsFastMathEnabled();
255  }
256  }
257  }
258  return std::make_unique<NeonConvolution3dWorkload>(*convolution3dQueueDescriptor,
259  info,
260  m_MemoryManager->GetIntraLayerManager(),
261  isFastMathEnabled);
262  }
263  case LayerType::Debug :
264  {
265  auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
266  return MakeWorkloadHelper<NullWorkload, NullWorkload>(*debugQueueDescriptor, info);
267  }
268  case LayerType::DepthToSpace :
269  {
270  auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
271  return std::make_unique<NeonDepthToSpaceWorkload>(*depthToSpaceQueueDescriptor, info);
272  }
273  case LayerType::DepthwiseConvolution2d :
274  {
275  auto depthwiseConvolution2dQueueDescriptor
276  = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
277  return std::make_unique<NeonDepthwiseConvolutionWorkload>(*depthwiseConvolution2dQueueDescriptor, info);
278  }
279  case LayerType::Dequantize :
280  {
281  auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
282  return std::make_unique<NeonDequantizeWorkload>(*dequantizeQueueDescriptor, info);
283  }
284  case LayerType::DetectionPostProcess :
285  {
286  auto detectionPostProcessQueueDescriptor
287  = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
288  return MakeWorkloadHelper<NullWorkload, NullWorkload>(*detectionPostProcessQueueDescriptor, info);
289  }
290  case LayerType::Division :
291  {
292  auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
293  return std::make_unique<NeonDivisionWorkload>(*divisionQueueDescriptor, info);
294  }
295  case LayerType::ElementwiseBinary :
296  {
297  auto elementwiseBinaryQueueDescriptor
298  = PolymorphicDowncast<const ElementwiseBinaryQueueDescriptor*>(&descriptor);
299 
300  switch (elementwiseBinaryQueueDescriptor->m_Parameters.m_Operation)
301  {
302  case BinaryOperation::Add:
303  {
304  AdditionQueueDescriptor additionQueueDescriptor;
305  additionQueueDescriptor.m_Inputs = descriptor.m_Inputs;
306  additionQueueDescriptor.m_Outputs = descriptor.m_Outputs;
307  return std::make_unique<NeonAdditionWorkload>(additionQueueDescriptor, info);
308  }
309  case BinaryOperation::Div:
310  {
311  DivisionQueueDescriptor divisionQueueDescriptor;
312  divisionQueueDescriptor.m_Inputs = descriptor.m_Inputs;
313  divisionQueueDescriptor.m_Outputs = descriptor.m_Outputs;
314  return std::make_unique<NeonDivisionWorkload>(divisionQueueDescriptor, info);
315  }
316  case BinaryOperation::Maximum:
317  {
318  MaximumQueueDescriptor maximumQueueDescriptor;
319  maximumQueueDescriptor.m_Inputs = descriptor.m_Inputs;
320  maximumQueueDescriptor.m_Outputs = descriptor.m_Outputs;
321  return std::make_unique<NeonMaximumWorkload>(maximumQueueDescriptor, info);
322  }
323  case BinaryOperation::Minimum:
324  {
325  MinimumQueueDescriptor minimumQueueDescriptor;
326  minimumQueueDescriptor.m_Inputs = descriptor.m_Inputs;
327  minimumQueueDescriptor.m_Outputs = descriptor.m_Outputs;
328  return std::make_unique<NeonMinimumWorkload>(minimumQueueDescriptor, info);
329  }
330  case BinaryOperation::Mul:
331  {
332  MultiplicationQueueDescriptor multiplicationQueueDescriptor;
333  multiplicationQueueDescriptor.m_Inputs = descriptor.m_Inputs;
334  multiplicationQueueDescriptor.m_Outputs = descriptor.m_Outputs;
335  return std::make_unique<NeonMultiplicationWorkload>(multiplicationQueueDescriptor, info);
336  }
337  case BinaryOperation::Sub:
338  {
339  SubtractionQueueDescriptor subtractionQueueDescriptor;
340  subtractionQueueDescriptor.m_Inputs = descriptor.m_Inputs;
341  subtractionQueueDescriptor.m_Outputs = descriptor.m_Outputs;
342  return std::make_unique<NeonSubtractionWorkload>(subtractionQueueDescriptor, info);
343  }
344  default:
345  return nullptr;
346  }
347  }
348  case LayerType::ElementwiseUnary :
349  {
350  auto elementwiseUnaryQueueDescriptor
351  = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
352 
353  switch(elementwiseUnaryQueueDescriptor->m_Parameters.m_Operation)
354  {
355  case UnaryOperation::Abs:
356  {
357  AbsQueueDescriptor absQueueDescriptor;
358  absQueueDescriptor.m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
359  absQueueDescriptor.m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
360 
361  return std::make_unique<NeonAbsWorkload>(absQueueDescriptor, info);
362  }
363  case UnaryOperation::Exp:
364  return std::make_unique<NeonExpWorkload>(*elementwiseUnaryQueueDescriptor, info);
365  case UnaryOperation::LogicalNot:
366  return std::make_unique<NeonLogicalNotWorkload>(*elementwiseUnaryQueueDescriptor, info);
367  case UnaryOperation::Log:
368  return std::make_unique<NeonLogWorkload>(*elementwiseUnaryQueueDescriptor, info);
369  case UnaryOperation::Neg:
370  return std::make_unique<NeonNegWorkload>(*elementwiseUnaryQueueDescriptor, info);
371  case UnaryOperation::Rsqrt:
372  {
373  RsqrtQueueDescriptor rsqrtQueueDescriptor;
374  rsqrtQueueDescriptor.m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
375  rsqrtQueueDescriptor.m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
376 
377  return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor, info);
378  }
379  case UnaryOperation::Sin:
380  return std::make_unique<NeonSinWorkload>(*elementwiseUnaryQueueDescriptor, info);
381  case UnaryOperation::Sqrt:
382  return std::make_unique<NeonSqrtWorkload>(*elementwiseUnaryQueueDescriptor, info);
383  default:
384  return nullptr;
385  }
386  }
387  case LayerType::Fill :
388  {
389  auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
390  return std::make_unique<NeonFillWorkload>(*fillQueueDescriptor, info);
391  }
392  case LayerType::Floor :
393  {
394  auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
395  return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(*floorQueueDescriptor, info);
396  }
397  case LayerType::FullyConnected :
398  {
399  auto fullyConnectedQueueDescriptor = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
400  return std::make_unique<NeonFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
401  info,
402  m_MemoryManager->GetIntraLayerManager());
403  }
404  case LayerType::Gather :
405  {
406  auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
407  return std::make_unique<NeonGatherWorkload>(*gatherQueueDescriptor, info);
408  }
409  case LayerType::GatherNd :
410  {
411  auto gatherNdQueueDescriptor = PolymorphicDowncast<const GatherNdQueueDescriptor*>(&descriptor);
412  return std::make_unique<NeonGatherNdWorkload>(*gatherNdQueueDescriptor, info);
413  }
414  case LayerType::Input :
415  {
416  auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
417  return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor, info);
418  }
419  case LayerType::InstanceNormalization :
420  {
421  auto instanceNormalizationQueueDescriptor
422  = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
423  return std::make_unique<NeonInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor, info);
424  }
425  case LayerType::L2Normalization :
426  {
427  auto l2NormalizationQueueDescriptor
428  = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
429  return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>
430  (*l2NormalizationQueueDescriptor, info, m_MemoryManager->GetIntraLayerManager());
431  }
432  case LayerType::LogSoftmax :
433  {
434  auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
435  return std::make_unique<NeonLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
436  info,
437  m_MemoryManager->GetIntraLayerManager());
438  }
439  case LayerType::LogicalBinary :
440  {
441  auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
442 
443  switch(logicalBinaryQueueDescriptor->m_Parameters.m_Operation)
444  {
445  case LogicalBinaryOperation::LogicalAnd:
446  return std::make_unique<NeonLogicalAndWorkload>(*logicalBinaryQueueDescriptor, info);
447  case LogicalBinaryOperation::LogicalOr:
448  return std::make_unique<NeonLogicalOrWorkload>(*logicalBinaryQueueDescriptor, info);
449  default:
450  return nullptr;
451  }
452  }
453  case LayerType::Lstm :
454  {
455  auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
456  return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(*lstmQueueDescriptor, info);
457  }
458  case LayerType::Maximum :
459  {
460  auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
461  return std::make_unique<NeonMaximumWorkload>(*maximumQueueDescriptor, info);
462  }
463  case LayerType::Mean :
464  {
465  auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
466  return std::make_unique<NeonMeanWorkload>(*meanQueueDescriptor, info);
467  }
468  case LayerType::MemCopy :
469  {
470  auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
471  if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
472  {
473  throw InvalidArgumentException("NeonWorkloadFactory: Invalid null input for MemCopy workload");
474  }
475  return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(*memCopyQueueDescriptor, info);
476  }
477  case LayerType::MemImport :
478  {
479  auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
480  if (memImportQueueDescriptor->m_Inputs.empty() || !memImportQueueDescriptor->m_Inputs[0])
481  {
482  throw InvalidArgumentException("NeonWorkloadFactory: Invalid null input for MemImport workload");
483  }
484  return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor, info);
485  }
486  case LayerType::Minimum :
487  {
488  auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
489  return std::make_unique<NeonMinimumWorkload>(*minimumQueueDescriptor, info);
490  }
491  case LayerType::Multiplication :
492  {
493  auto multiplicationQueueDescriptor = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
494  return std::make_unique<NeonMultiplicationWorkload>(*multiplicationQueueDescriptor, info);
495  }
496  case LayerType::Normalization :
497  {
498  auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
499  return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>
500  (*normalizationQueueDescriptor, info, m_MemoryManager->GetIntraLayerManager());
501  }
502  case LayerType::Output :
503  {
504  auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
505  return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor, info);
506  }
507  case LayerType::Pad :
508  {
509  auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
510  return std::make_unique<NeonPadWorkload>(*padQueueDescriptor, info);
511  }
512  case LayerType::Permute :
513  {
514  auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
515  return std::make_unique<NeonPermuteWorkload>(*permuteQueueDescriptor, info);
516  }
517  case LayerType::Pooling2d :
518  {
519  auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
520  return std::make_unique<NeonPooling2dWorkload>(*pooling2dQueueDescriptor, info);
521  }
522  case LayerType::Pooling3d :
523  {
524  auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
525  return std::make_unique<NeonPooling3dWorkload>(*pooling3dQueueDescriptor, info);
526  }
527  case LayerType::PreCompiled :
528  {
529  auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
530  return MakeWorkloadHelper<NullWorkload, NullWorkload>(*preCompiledQueueDescriptor, info);
531  }
532  case LayerType::Prelu :
533  {
534  auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
535  return std::make_unique<NeonPreluWorkload>(*preluQueueDescriptor, info);
536  }
537  case LayerType::QLstm :
538  {
539  auto qLstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
540  return std::make_unique<NeonQLstmWorkload>(*qLstmQueueDescriptor, info);
541  }
542  case LayerType::Quantize :
543  {
544  auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
545  return std::make_unique<NeonQuantizeWorkload>(*quantizeQueueDescriptor, info);
546  }
547  case LayerType::QuantizedLstm :
548  {
549  auto quantizedLstmQueueDescriptor = PolymorphicDowncast<const QuantizedLstmQueueDescriptor*>(&descriptor);
550  return std::make_unique<NeonQuantizedLstmWorkload>(*quantizedLstmQueueDescriptor, info);
551  }
552  case LayerType::Rank :
553  {
554  auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
555  return std::make_unique<NeonRankWorkload>(*rankQueueDescriptor, info);
556  }
557  case LayerType::Reduce :
558  {
559  auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
560  return std::make_unique<NeonReduceWorkload>(*reduceQueueDescriptor, info);
561  }
562  case LayerType::Reshape :
563  {
564  auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
565  return std::make_unique<NeonReshapeWorkload>(*reshapeQueueDescriptor, info);
566  }
567  case LayerType::Resize :
568  {
569  auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
570  return std::make_unique<NeonResizeWorkload>(*resizeQueueDescriptor, info);
571  }
572  case LayerType::Slice :
573  {
574  auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
575  return std::make_unique<NeonSliceWorkload>(*sliceQueueDescriptor, info);
576  }
577  case LayerType::Softmax :
578  {
579  auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
580  return std::make_unique<NeonSoftmaxWorkload>(*softmaxQueueDescriptor,
581  info,
582  m_MemoryManager->GetIntraLayerManager());
583  }
584  case LayerType::SpaceToBatchNd :
585  {
586  auto spaceToBatchNdQueueDescriptor
587  = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
588  return std::make_unique<NeonSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor, info);
589  }
590  case LayerType::SpaceToDepth :
591  {
592  auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
593  return std::make_unique<NeonSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor, info);
594  }
595  case LayerType::Splitter :
596  {
597  auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
598  return std::make_unique<NeonSplitterWorkload>(*splitterQueueDescriptor, info);
599  }
600  case LayerType::Stack :
601  {
602  auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
603  return std::make_unique<NeonStackWorkload>(*stackQueueDescriptor, info);
604  }
605  case LayerType::StridedSlice :
606  {
607  auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
608  return std::make_unique<NeonStridedSliceWorkload>(*stridedSliceQueueDescriptor, info);
609  }
610  case LayerType::Subtraction :
611  {
612  auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
613  return std::make_unique<NeonSubtractionWorkload>(*subtractionQueueDescriptor, info);
614  }
615  case LayerType::Transpose :
616  {
617  auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
618  return std::make_unique<NeonTransposeWorkload>(*transposeQueueDescriptor, info);
619  }
620  case LayerType::TransposeConvolution2d :
621  {
622  auto transposeConvolution2dQueueDescriptor
623  = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
624  return std::make_unique<NeonTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
625  info,
626  m_MemoryManager->GetIntraLayerManager());
627  }
628  case LayerType::UnidirectionalSequenceLstm :
629  {
630  auto desc = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
631 
632  if ((info.m_InputTensorInfos[0].GetDataType() == armnn::DataType::Float32) &&
633  (info.m_InputTensorInfos[1].GetDataType() == armnn::DataType::Float32) &&
634  (info.m_InputTensorInfos[2].GetDataType() == armnn::DataType::Float32) &&
635  (info.m_OutputTensorInfos[0].GetDataType() == armnn::DataType::Float32) &&
636  (info.m_OutputTensorInfos[1].GetDataType() == armnn::DataType::Float32) &&
637  (info.m_OutputTensorInfos[2].GetDataType() == armnn::DataType::Float32))
638  {
639  return std::make_unique<NeonUnidirectionalSequenceLstmFloatWorkload>(*desc, info);
640  }
641  else
642  {
643  return std::make_unique<NeonUnidirectionalSequenceLstmWorkload>(*desc, info);
644  }
645  }
646  default:
647  return nullptr;
648  }
649 }

References armnn::Abs, armnn::Activation, armnn::Add, armnn::Addition, armnn::ArgMinMax, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Cast, armnn::ChannelShuffle, armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::Debug, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Div, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::Exp, armnn::Fill, armnn::Float32, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, armnn::info, armnn::Input, armnn::InstanceNormalization, NeonBackendModelContext::IsFastMathEnabled(), armnn::L2Normalization, armnn::Log, armnn::LogicalAnd, armnn::LogicalBinary, armnn::LogicalNot, armnn::LogicalOr, armnn::LogSoftmax, armnn::Lstm, QueueDescriptor::m_Inputs, QueueDescriptor::m_Outputs, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Minimum, armnn::Mul, armnn::Multiplication, armnn::Neg, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::PreCompiled, armnn::Prelu, armnn::QLstm, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::Rsqrt, armnn::Sin, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Sqrt, armnn::Stack, armnn::StridedSlice, armnn::Sub, armnn::Subtraction, armnn::Transpose, armnn::TransposeConvolution2d, and armnn::UnidirectionalSequenceLstm.

◆ GetBackendId()

const BackendId & GetBackendId ( ) const
overridevirtual

Implements IWorkloadFactory.

Definition at line 49 of file NeonWorkloadFactory.cpp.

50 {
51  return s_Id;
52 }

◆ IsLayerSupported() [1/2]

bool IsLayerSupported ( const IConnectableLayer &  layer,
Optional< DataType >  dataType,
std::string &  outReasonIfUnsupported,
const ModelOptions &  modelOptions 
)
static

Definition at line 41 of file NeonWorkloadFactory.cpp.

45 {
46  return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported, modelOptions);
47 }

References IWorkloadFactory::IsLayerSupported().

◆ IsLayerSupported() [2/2]

bool IsLayerSupported ( const Layer &  layer,
Optional< DataType >  dataType,
std::string &  outReasonIfUnsupported 
)
static

Definition at line 34 of file NeonWorkloadFactory.cpp.

37 {
38  return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
39 }

References IWorkloadFactory::IsLayerSupported().

◆ SupportsSubTensors()

bool SupportsSubTensors ( ) const
inlineoverridevirtual

Reimplemented from WorkloadFactoryBase.

Definition at line 39 of file NeonWorkloadFactory.hpp.

39 { return true; }
The documentation for this class was generated from the following files:
armnn::LayerType::Floor
@ Floor
armnn::LayerType::MemCopy
@ MemCopy
armnn::LayerType::Softmax
@ Softmax
armnn::LayerType::Pooling3d
@ Pooling3d
armnn::LayerType::FullyConnected
@ FullyConnected
armnn::LayerType::Transpose
@ Transpose
armnn::LayerType::ChannelShuffle
@ ChannelShuffle
armnn::LayerType::ConvertFp32ToFp16
@ ConvertFp32ToFp16
armnn::LayerType::L2Normalization
@ L2Normalization
armnn::LogicalBinaryOperation::LogicalAnd
@ LogicalAnd
armnn::LayerType::TransposeConvolution2d
@ TransposeConvolution2d
armnn::LayerType::Input
@ Input
armnn::LayerType::Slice
@ Slice
armnn::LayerType::ElementwiseBinary
@ ElementwiseBinary
armnn::LayerType::Maximum
@ Maximum
armnn::LayerType::Quantize
@ Quantize
armnn::LayerType::ArgMinMax
@ ArgMinMax
armnn::LayerType::Subtraction
@ Subtraction
armnn::LayerType::SpaceToBatchNd
@ SpaceToBatchNd
armnn::LayerType::Convolution2d
@ Convolution2d
armnn::UnaryOperation::Exp
@ Exp
armnn::UnaryOperation::Sqrt
@ Sqrt
armnn::UnaryOperation::Neg
@ Neg
armnn::LayerType::Permute
@ Permute
armnn::LayerType::ConvertFp16ToFp32
@ ConvertFp16ToFp32
armnn::LayerType::QLstm
@ QLstm
armnn::LayerType::Pad
@ Pad
armnn::LayerType::Addition
@ Addition
armnn::LayerType::QuantizedLstm
@ QuantizedLstm
armnn::LayerType::BatchNormalization
@ BatchNormalization
armnn::LayerType::Reduce
@ Reduce
armnn::LayerType::Division
@ Division
armnn::LayerType::Debug
@ Debug
armnn::LayerType::InstanceNormalization
@ InstanceNormalization
armnn::LayerType::Activation
@ Activation
armnn::BinaryOperation::Sub
@ Sub
armnn::LayerType::Normalization
@ Normalization
armnn::LayerType::Comparison
@ Comparison
armnn::LayerType::Stack
@ Stack
armnn::LayerType::Reshape
@ Reshape
armnn::IBackendInternal::IBackendSpecificModelContextPtr
std::shared_ptr< IBackendModelContext > IBackendSpecificModelContextPtr
Definition: IBackendInternal.hpp:96
armnn::LayerType::Gather
@ Gather
armnn::LayerType::DepthwiseConvolution2d
@ DepthwiseConvolution2d
armnn::LogicalBinaryOperation::LogicalOr
@ LogicalOr
armnn::LayerType::Fill
@ Fill
armnn::LayerType::Resize
@ Resize
armnn::LayerType::Rank
@ Rank
armnn::BinaryOperation::Mul
@ Mul
armnn::LayerType::LogicalBinary
@ LogicalBinary
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::LayerType::Pooling2d
@ Pooling2d
armnn::DataType::Float32
@ Float32
armnn::IWorkloadFactory::IsLayerSupported
static bool IsLayerSupported(const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
Definition: WorkloadFactory.cpp:1548
armnn::LayerType::GatherNd
@ GatherNd
armnn::LayerType::Minimum
@ Minimum
armnn::LayerType::Constant
@ Constant
armnn::LayerType::Lstm
@ Lstm
armnn::LayerType::ElementwiseUnary
@ ElementwiseUnary
armnn::LayerType::SpaceToDepth
@ SpaceToDepth
armnn::BinaryOperation::Minimum
@ Minimum
armnn::BinaryOperation::Maximum
@ Maximum
armnn::UnaryOperation::Abs
@ Abs
armnn::LayerType::StridedSlice
@ StridedSlice
armnn::LayerType::DetectionPostProcess
@ DetectionPostProcess
armnn::LayerType::Mean
@ Mean
armnn::BinaryOperation::Add
@ Add
armnn::LayerType::BatchToSpaceNd
@ BatchToSpaceNd
armnn::LayerType::DepthToSpace
@ DepthToSpace
armnn::UnaryOperation::LogicalNot
@ LogicalNot
armnn::UnaryOperation::Sin
@ Sin
armnn::LayerType::Concat
@ Concat
armnn::UnaryOperation::Rsqrt
@ Rsqrt
armnn::LayerType::Cast
@ Cast
armnn::LayerType::BatchMatMul
@ BatchMatMul
armnn::LayerType::Convolution3d
@ Convolution3d
armnn::LayerType::Splitter
@ Splitter
armnn::LayerType::LogSoftmax
@ LogSoftmax
armnn::LayerType::Output
@ Output
armnn::LayerType::Multiplication
@ Multiplication
armnn::LayerType::MemImport
@ MemImport
armnn::BinaryOperation::Div
@ Div
armnn::LayerType::Prelu
@ Prelu
armnn::LayerType::Dequantize
@ Dequantize
armnn::Coordinates
std::array< unsigned int, MaxNumOfTensorDimensions > Coordinates
Definition: InternalTypes.hpp:15
armnn::UnaryOperation::Log
@ Log
armnn::BoostLogSeverityMapping::info
@ info
armnn::LayerType::PreCompiled
@ PreCompiled