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

#include <ClWorkloadFactory.hpp>

Inheritance diagram for ClWorkloadFactory:
WorkloadFactoryBase IWorkloadFactory

Public Member Functions

 ClWorkloadFactory (const std::shared_ptr< ClMemoryManager > &memoryManager)
 
 ClWorkloadFactory (const std::shared_ptr< ClMemoryManager > &memoryManager, const IBackendInternal::IBackendSpecificModelContextPtr &modelContextPtr)
 
void AfterWorkloadsCreated () override
 
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 ()
 

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 21 of file ClWorkloadFactory.hpp.

Constructor & Destructor Documentation

◆ ClWorkloadFactory() [1/2]

ClWorkloadFactory ( const std::shared_ptr< ClMemoryManager > &  memoryManager)

Definition at line 188 of file ClWorkloadFactory.cpp.

189  : m_MemoryManager(memoryManager), m_ModelContextPtr(IBackendInternal::IBackendSpecificModelContextPtr{})
190 {
191  InitializeCLCompileContext();
192 }

◆ ClWorkloadFactory() [2/2]

ClWorkloadFactory ( const std::shared_ptr< ClMemoryManager > &  memoryManager,
const IBackendInternal::IBackendSpecificModelContextPtr &  modelContextPtr 
)

Definition at line 194 of file ClWorkloadFactory.cpp.

196  : m_MemoryManager(memoryManager), m_ModelContextPtr(modelContextPtr)
197 {
198  InitializeCLCompileContext();
199 }

Member Function Documentation

◆ AfterWorkloadsCreated()

void AfterWorkloadsCreated ( )
overridevirtual

Reimplemented from IWorkloadFactory.

Definition at line 66 of file ClWorkloadFactory.cpp.

67 {
68  if(m_ModelContextPtr)
69  {
70  auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
71  if (modelOptions->SaveCachedNetwork())
72  {
73  ClContextSerializer serializer;
74  serializer.Serialize(m_CLCompileContext);
75  auto cachedFd = modelOptions->GetCachedFileDescriptor();
76  if (cachedFd != -1)
77  {
78  std::vector<uint8_t> compiledContextData;
79  std::stringstream stream;
80  bool serialized = serializer.SaveSerializedToStream(stream);
81  if (serialized)
82  {
83  std::string const serializedString{stream.str()};
84  std::copy(serializedString.begin(),
85  serializedString.end(),
86  std::back_inserter(compiledContextData));
87  auto success = write(cachedFd, compiledContextData.data(), compiledContextData.size());
88  if (success == -1)
89  {
90  ARMNN_LOG(info) << "ClWorkloadFactory:: Could not cache the compiled context!";
91  }
92  }
93  }
94 
95  // Save map to a filepath provided in ModelOptions
96  auto filePath = modelOptions->GetCachedNetworkFilePath();
97  if (filePath != "" && fs::exists(filePath) && fs::is_regular_file(filePath))
98  {
99  // Serialize ClContext to the file specified
100  std::ofstream file(filePath, std::ios::out | std::ios::binary);
101  serializer.SaveSerializedToStream(file);
102  }
103  }
104  }
105 }

References ARMNN_LOG, and armnn::info.

◆ CreateSubTensorHandle()

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

Reimplemented from WorkloadFactoryBase.

Definition at line 222 of file ClWorkloadFactory.cpp.

225 {
226  arm_compute::Coordinates coords;
227  arm_compute::TensorShape shape = armcomputetensorutils::BuildArmComputeTensorShape(subTensorShape);
228 
229  coords.set_num_dimensions(subTensorShape.GetNumDimensions());
230  for (unsigned int i = 0; i < subTensorShape.GetNumDimensions(); i++)
231  {
232  // Arm compute indexes tensor coords in reverse order.
233  unsigned int revertedIndex = subTensorShape.GetNumDimensions() - i - 1;
234  coords.set(i, armnn::numeric_cast<int>(subTensorOrigin[revertedIndex]));
235  }
236 
237  const arm_compute::TensorShape parentShape = armcomputetensorutils::BuildArmComputeTensorShape(parent.GetShape());
238  if (!::arm_compute::error_on_invalid_subtensor(__func__, __FILE__, __LINE__, parentShape, coords, shape))
239  {
240  return nullptr;
241  }
242 
243  return std::make_unique<ClSubTensorHandle>(
244  PolymorphicDowncast<IClTensorHandle*>(&parent), shape, coords);
245 }

◆ CreateTensorHandle() [1/2]

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

Reimplemented from WorkloadFactoryBase.

Definition at line 201 of file ClWorkloadFactory.cpp.

203 {
204  IgnoreUnused(IsMemoryManaged);
205  std::unique_ptr<ClTensorHandle> tensorHandle = std::make_unique<ClTensorHandle>(tensorInfo);
206  tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
207 
208  return tensorHandle;
209 }

References armnn::IgnoreUnused().

◆ 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 211 of file ClWorkloadFactory.cpp.

214 {
215  IgnoreUnused(IsMemoryManaged);
216  std::unique_ptr<ClTensorHandle> tensorHandle = std::make_unique<ClTensorHandle>(tensorInfo, dataLayout);
217  tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
218 
219  return tensorHandle;
220 }

References armnn::IgnoreUnused().

◆ CreateWorkload()

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

Reimplemented from WorkloadFactoryBase.

Definition at line 247 of file ClWorkloadFactory.cpp.

250 {
251  switch(type)
252  {
253  case LayerType::Activation :
254  {
255  auto activationQueueDescriptor = PolymorphicDowncast<const ActivationQueueDescriptor*>(&descriptor);
256  return MakeWorkload<ClActivationWorkload>(*activationQueueDescriptor, info, m_CLCompileContext);
257  }
258  case LayerType::Addition :
259  {
260  auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
261  return MakeWorkload<ClAdditionWorkload>(*additionQueueDescriptor, info, m_CLCompileContext);
262  }
263  case LayerType::ArgMinMax :
264  {
265  auto argMinMaxQueueDescriptor = PolymorphicDowncast<const ArgMinMaxQueueDescriptor*>(&descriptor);
266  return MakeWorkload<ClArgMinMaxWorkload>(*argMinMaxQueueDescriptor, info, m_CLCompileContext);
267  }
268  case LayerType::BatchMatMul :
269  {
270  auto batchMatMulQueueDescriptor = PolymorphicDowncast<const BatchMatMulQueueDescriptor*>(&descriptor);
271  return std::make_unique<ClBatchMatMulWorkload>(*batchMatMulQueueDescriptor, info, m_CLCompileContext);
272  }
273  case LayerType::BatchNormalization :
274  {
275  auto batchNormalizationQueueDescriptor
276  = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
277  return MakeWorkload<ClBatchNormalizationFloatWorkload, NullWorkload>
278  (*batchNormalizationQueueDescriptor, info, m_CLCompileContext);
279  }
280  case LayerType::BatchToSpaceNd :
281  {
282  auto batchToSpaceNdQueueDescriptor
283  = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
284  return MakeWorkload<ClBatchToSpaceNdWorkload>(*batchToSpaceNdQueueDescriptor, info, m_CLCompileContext);
285  }
286  case LayerType::Cast :
287  {
288  auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
289  return MakeWorkload<ClCastWorkload>(*castQueueDescriptor, info, m_CLCompileContext);
290  }
291  case LayerType::ChannelShuffle :
292  {
293  auto channelShuffleQueueDescriptor
294  = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
295  return MakeWorkload<ClChannelShuffleWorkload>(*channelShuffleQueueDescriptor, info, m_CLCompileContext);
296  }
297  case LayerType::Comparison :
298  {
299  auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
300  return MakeWorkload<ClComparisonWorkload>(*comparisonQueueDescriptor, info, m_CLCompileContext);
301  }
302  case LayerType::Concat :
303  {
304  auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
305  return MakeWorkload<ClConcatWorkload>(*concatQueueDescriptor, info, m_CLCompileContext);
306  }
307  case LayerType::Constant :
308  {
309  auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
310  return MakeWorkload<ClConstantWorkload>(*constantQueueDescriptor, info, m_CLCompileContext);
311  }
312  case LayerType::ConvertFp16ToFp32 :
313  {
314  auto convertFp16ToFp32QueueDescriptor
315  = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
316  return MakeWorkload<ClConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor,
317  info,
318  m_CLCompileContext);
319  }
320  case LayerType::ConvertFp32ToFp16 :
321  {
322  auto convertFp32ToFp16QueueDescriptor
323  = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
324  return MakeWorkload<ClConvertFp32ToFp16Workload>(*convertFp32ToFp16QueueDescriptor,
325  info,
326  m_CLCompileContext);
327  }
328  case LayerType::Convolution2d :
329  {
330  auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
331 
332  bool isFastMathEnabled = false;
333  if (m_ModelContextPtr)
334  {
335  if (m_ModelContextPtr.get() != nullptr)
336  {
337  auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
338  if (modelOptions)
339  {
340  isFastMathEnabled = modelOptions->IsFastMathEnabled();
341  }
342  }
343  }
344  return MakeWorkload<ClConvolution2dWorkload>(*convolution2dQueueDescriptor,
345  info,
346  m_MemoryManager->GetIntraLayerManager(),
347  m_CLCompileContext,
348  isFastMathEnabled);
349  }
350  case LayerType::Convolution3d :
351  {
352  auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
353 
354  bool isFastMathEnabled = false;
355  if (m_ModelContextPtr)
356  {
357  if (m_ModelContextPtr.get() != nullptr)
358  {
359  auto modelOptions = dynamic_cast<ClBackendModelContext*>(m_ModelContextPtr.get());
360  if (modelOptions)
361  {
362  isFastMathEnabled = modelOptions->IsFastMathEnabled();
363  }
364  }
365  }
366  return MakeWorkload<ClConvolution3dWorkload>(*convolution3dQueueDescriptor,
367  info,
368  m_MemoryManager->GetIntraLayerManager(),
369  m_CLCompileContext,
370  isFastMathEnabled);
371  }
372  case LayerType::Debug :
373  {
374  auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
375  return MakeWorkload<NullWorkload, NullWorkload>(*debugQueueDescriptor, info, m_CLCompileContext);
376  }
377  case LayerType::DepthToSpace :
378  {
379  auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
380  return MakeWorkload<ClDepthToSpaceWorkload>(*depthToSpaceQueueDescriptor, info, m_CLCompileContext);
381  }
382  case LayerType::DepthwiseConvolution2d :
383  {
384  auto depthwiseConvolution2dQueueDescriptor
385  = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
386  return MakeWorkload<ClDepthwiseConvolutionWorkload>(*depthwiseConvolution2dQueueDescriptor,
387  info,
388  m_CLCompileContext);
389  }
390  case LayerType::Dequantize :
391  {
392  auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
393  return MakeWorkload<ClDequantizeWorkload>(*dequantizeQueueDescriptor, info, m_CLCompileContext);
394  }
395  case LayerType::DetectionPostProcess :
396  {
397  auto detectionPostProcessQueueDescriptor
398  = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
399  return MakeWorkload<NullWorkload, NullWorkload>(*detectionPostProcessQueueDescriptor,
400  info,
401  m_CLCompileContext);
402  }
403  case LayerType::Division :
404  {
405  auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
406  return std::make_unique<ClDivisionWorkload>(*divisionQueueDescriptor, info, m_CLCompileContext);
407  }
408  case LayerType::ElementwiseBinary :
409  {
410  auto elementwiseBinaryQueueDescriptor
411  = PolymorphicDowncast<const ElementwiseBinaryQueueDescriptor*>(&descriptor);
412 
413  switch (elementwiseBinaryQueueDescriptor->m_Parameters.m_Operation)
414  {
415  case BinaryOperation::Add:
416  {
417  AdditionQueueDescriptor additionQueueDescriptor;
418  additionQueueDescriptor.m_Inputs = descriptor.m_Inputs;
419  additionQueueDescriptor.m_Outputs = descriptor.m_Outputs;
420  additionQueueDescriptor.m_AdditionalInfoObject =
421  elementwiseBinaryQueueDescriptor->m_AdditionalInfoObject;
422  return std::make_unique<ClAdditionWorkload>(additionQueueDescriptor, info, m_CLCompileContext);
423  }
424  case BinaryOperation::Div:
425  {
426  DivisionQueueDescriptor divisionQueueDescriptor;
427  divisionQueueDescriptor.m_Inputs = descriptor.m_Inputs;
428  divisionQueueDescriptor.m_Outputs = descriptor.m_Outputs;
429  divisionQueueDescriptor.m_AdditionalInfoObject =
430  elementwiseBinaryQueueDescriptor->m_AdditionalInfoObject;
431  return std::make_unique<ClDivisionWorkload>(divisionQueueDescriptor, info, m_CLCompileContext);
432  }
433  case BinaryOperation::Maximum:
434  {
435  MaximumQueueDescriptor maximumQueueDescriptor;
436  maximumQueueDescriptor.m_Inputs = descriptor.m_Inputs;
437  maximumQueueDescriptor.m_Outputs = descriptor.m_Outputs;
438  maximumQueueDescriptor.m_AdditionalInfoObject =
439  elementwiseBinaryQueueDescriptor->m_AdditionalInfoObject;
440  return std::make_unique<ClMaximumWorkload>(maximumQueueDescriptor, info, m_CLCompileContext);
441  }
442  case BinaryOperation::Minimum:
443  {
444  MinimumQueueDescriptor minimumQueueDescriptor;
445  minimumQueueDescriptor.m_Inputs = descriptor.m_Inputs;
446  minimumQueueDescriptor.m_Outputs = descriptor.m_Outputs;
447  minimumQueueDescriptor.m_AdditionalInfoObject =
448  elementwiseBinaryQueueDescriptor->m_AdditionalInfoObject;
449  return std::make_unique<ClMinimumWorkload>(minimumQueueDescriptor, info, m_CLCompileContext);
450  }
451  case BinaryOperation::Mul:
452  {
453  MultiplicationQueueDescriptor multiplicationQueueDescriptor;
454  multiplicationQueueDescriptor.m_Inputs = descriptor.m_Inputs;
455  multiplicationQueueDescriptor.m_Outputs = descriptor.m_Outputs;
456  multiplicationQueueDescriptor.m_AdditionalInfoObject =
457  elementwiseBinaryQueueDescriptor->m_AdditionalInfoObject;
458  return std::make_unique<ClMultiplicationWorkload>(multiplicationQueueDescriptor,
459  info,
460  m_CLCompileContext);
461  }
462  case BinaryOperation::Sub:
463  {
464  SubtractionQueueDescriptor subtractionQueueDescriptor;
465  subtractionQueueDescriptor.m_Inputs = descriptor.m_Inputs;
466  subtractionQueueDescriptor.m_Outputs = descriptor.m_Outputs;
467  subtractionQueueDescriptor.m_AdditionalInfoObject =
468  elementwiseBinaryQueueDescriptor->m_AdditionalInfoObject;
469  return std::make_unique<ClSubtractionWorkload>(subtractionQueueDescriptor,
470  info,
471  m_CLCompileContext);
472  }
473  default:
474  return nullptr;
475  }
476  }
477  case LayerType::ElementwiseUnary :
478  {
479  auto elementwiseUnaryQueueDescriptor
480  = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
481 
482  switch(elementwiseUnaryQueueDescriptor->m_Parameters.m_Operation)
483  {
484  case UnaryOperation::Abs:
485  {
486  AbsQueueDescriptor absQueueDescriptor;
487  absQueueDescriptor.m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
488  absQueueDescriptor.m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
489 
490  return std::make_unique<ClAbsWorkload>(absQueueDescriptor, info, m_CLCompileContext);
491  }
492  case UnaryOperation::Exp:
493  return std::make_unique<ClExpWorkload>(*elementwiseUnaryQueueDescriptor, info, m_CLCompileContext);
494  case UnaryOperation::Log:
495  return std::make_unique<ClLogWorkload>(*elementwiseUnaryQueueDescriptor, info, m_CLCompileContext);
496  case UnaryOperation::LogicalNot:
497  return std::make_unique<ClLogicalNotWorkload>(*elementwiseUnaryQueueDescriptor,
498  info,
499  m_CLCompileContext);
500  case UnaryOperation::Neg:
501  return std::make_unique<ClNegWorkload>(*elementwiseUnaryQueueDescriptor, info, m_CLCompileContext);
502  case UnaryOperation::Rsqrt:
503  {
504  RsqrtQueueDescriptor rsqrtQueueDescriptor;
505  rsqrtQueueDescriptor.m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
506  rsqrtQueueDescriptor.m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
507 
508  return std::make_unique<ClRsqrtWorkload>(rsqrtQueueDescriptor, info, m_CLCompileContext);
509  }
510  case UnaryOperation::Sin:
511  return std::make_unique<ClSinWorkload>(*elementwiseUnaryQueueDescriptor, info, m_CLCompileContext);
512  case UnaryOperation::Sqrt:
513  return std::make_unique<ClSqrtWorkload>(*elementwiseUnaryQueueDescriptor, info, m_CLCompileContext);
514  default:
515  return nullptr;
516  }
517  }
518  case LayerType::Fill :
519  {
520  auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
521  return std::make_unique<ClFillWorkload>(*fillQueueDescriptor, info, m_CLCompileContext);
522  }
523  case LayerType::Floor :
524  {
525  auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
526  return MakeWorkload<ClFloorFloatWorkload, NullWorkload>(*floorQueueDescriptor, info, m_CLCompileContext);
527  }
528  case LayerType::FullyConnected :
529  {
530  auto fullyConnectedQueueDescriptor
531  = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
532  return MakeWorkload<ClFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
533  info,
534  m_MemoryManager->GetIntraLayerManager(),
535  m_CLCompileContext);
536  }
537  case LayerType::Gather :
538  {
539  auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
540  return MakeWorkload<ClGatherWorkload>(*gatherQueueDescriptor, info, m_CLCompileContext);
541  }
542  case LayerType::GatherNd :
543  {
544  auto gatherNdQueueDescriptor = PolymorphicDowncast<const GatherNdQueueDescriptor*>(&descriptor);
545  return MakeWorkload<ClGatherNdWorkload>(*gatherNdQueueDescriptor, info, m_CLCompileContext);
546  }
547  case LayerType::Input :
548  {
549  auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
550  return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor, info);
551  }
552  case LayerType::InstanceNormalization :
553  {
554  auto instanceNormalizationQueueDescriptor
555  = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
556  return MakeWorkload<ClInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor,
557  info,
558  m_CLCompileContext);
559  }
560  case LayerType::L2Normalization :
561  {
562  auto l2NormalizationQueueDescriptor
563  = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
564  return MakeWorkload<ClL2NormalizationFloatWorkload, NullWorkload>(*l2NormalizationQueueDescriptor,
565  info,
566  m_CLCompileContext);
567  }
568  case LayerType::LogicalBinary :
569  {
570  auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
571 
572  switch(logicalBinaryQueueDescriptor->m_Parameters.m_Operation)
573  {
574  case LogicalBinaryOperation::LogicalAnd:
575  return std::make_unique<ClLogicalAndWorkload>(*logicalBinaryQueueDescriptor,
576  info,
577  m_CLCompileContext);
578  case LogicalBinaryOperation::LogicalOr:
579  return std::make_unique<ClLogicalOrWorkload>(*logicalBinaryQueueDescriptor,
580  info,
581  m_CLCompileContext);
582  default:
583  return nullptr;
584  }
585  }
586  case LayerType::LogSoftmax :
587  {
588  auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
589 
590  return MakeWorkload<ClLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
591  info,
592  m_MemoryManager->GetIntraLayerManager(),
593  m_CLCompileContext);
594  }
595  case LayerType::Lstm :
596  {
597  auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
598  return MakeWorkload<ClLstmFloatWorkload, NullWorkload>(*lstmQueueDescriptor, info, m_CLCompileContext);
599  }
600  case LayerType::Maximum :
601  {
602  auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
603  return MakeWorkload<ClMaximumWorkload>(*maximumQueueDescriptor, info, m_CLCompileContext);
604  }
605  case LayerType::Mean :
606  {
607  auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
608  return MakeWorkload<ClMeanWorkload>(*meanQueueDescriptor, info, m_CLCompileContext);
609  }
610  case LayerType::MemCopy :
611  {
612  auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
613  if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
614  {
615  throw InvalidArgumentException("ClWorkloadFactory: Invalid null input for MemCopy workload");
616  }
617  return MakeWorkload<CopyMemGenericWorkload>(*memCopyQueueDescriptor, info);
618  }
619  case LayerType::MemImport :
620  {
621  auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
622  if (memImportQueueDescriptor->m_Inputs.empty() || !memImportQueueDescriptor->m_Inputs[0])
623  {
624  throw InvalidArgumentException("ClWorkloadFactory: Invalid null input for MemImport workload");
625  }
626  return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor, info);
627  }
628  case LayerType::Minimum :
629  {
630  auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
631  return MakeWorkload<ClMinimumWorkload>(*minimumQueueDescriptor, info, m_CLCompileContext);
632  }
633  case LayerType::Multiplication :
634  {
635  auto multiplicationQueueDescriptor = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
636  return MakeWorkload<ClMultiplicationWorkload>(*multiplicationQueueDescriptor, info, m_CLCompileContext);
637  }
638  case LayerType::Normalization :
639  {
640  auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
641  return MakeWorkload<ClNormalizationFloatWorkload, NullWorkload>(*normalizationQueueDescriptor,
642  info,
643  m_CLCompileContext);
644  }
645  case LayerType::Output :
646  {
647  auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
648  return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor, info);
649  }
650  case LayerType::Pad :
651  {
652  auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
653  return MakeWorkload<ClPadWorkload>(*padQueueDescriptor, info, m_CLCompileContext);
654  }
655  case LayerType::Permute :
656  {
657  auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
658  return MakeWorkload<ClPermuteWorkload>(*permuteQueueDescriptor, info, m_CLCompileContext);
659  }
660  case LayerType::Pooling2d :
661  {
662  auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
663  return MakeWorkload<ClPooling2dWorkload>(*pooling2dQueueDescriptor, info, m_CLCompileContext);
664  }
665  case LayerType::Pooling3d :
666  {
667  auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
668  return MakeWorkload<ClPooling3dWorkload>(*pooling3dQueueDescriptor, info, m_CLCompileContext);
669  }
670  case LayerType::PreCompiled :
671  {
672  auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
673  return MakeWorkload<NullWorkload, NullWorkload>(*preCompiledQueueDescriptor, info, m_CLCompileContext);
674  }
675  case LayerType::Prelu :
676  {
677  auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
678  return MakeWorkload<ClPreluWorkload>(*preluQueueDescriptor, info, m_CLCompileContext);
679  }
680  case LayerType::QLstm :
681  {
682  auto qLstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
683  return std::make_unique<ClQLstmWorkload>(*qLstmQueueDescriptor, info, m_CLCompileContext);
684  }
685  case LayerType::Quantize :
686  {
687  auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
688  return MakeWorkload<ClQuantizeWorkload>(*quantizeQueueDescriptor, info, m_CLCompileContext);
689  }
690  case LayerType::QuantizedLstm :
691  {
692  auto quantizedLstmQueueDescriptor = PolymorphicDowncast<const QuantizedLstmQueueDescriptor*>(&descriptor);
693  return MakeWorkload<ClQuantizedLstmWorkload>(*quantizedLstmQueueDescriptor, info, m_CLCompileContext);
694  }
695  case LayerType::Rank :
696  {
697  auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
698  return std::make_unique<ClRankWorkload>(*rankQueueDescriptor, info);
699  }
700  case LayerType::Reduce :
701  {
702  auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
703  return std::make_unique<ClReduceWorkload>(*reduceQueueDescriptor, info);
704  }
705  case LayerType::Reshape :
706  {
707  auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
708  return MakeWorkload<ClReshapeWorkload>(*reshapeQueueDescriptor, info, m_CLCompileContext);
709  }
710  case LayerType::Resize :
711  {
712  auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
713  return MakeWorkload<ClResizeWorkload>(*resizeQueueDescriptor, info, m_CLCompileContext);
714  }
715  case LayerType::Slice :
716  {
717  auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
718  return MakeWorkload<ClSliceWorkload>(*sliceQueueDescriptor, info, m_CLCompileContext);
719  }
720  case LayerType::Softmax :
721  {
722  auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
723  return std::make_unique<ClSoftmaxWorkload>(*softmaxQueueDescriptor,
724  info,
725  m_MemoryManager->GetIntraLayerManager(),
726  m_CLCompileContext);
727  }
728  case LayerType::SpaceToBatchNd :
729  {
730  auto spaceToBatchNdQueueDescriptor
731  = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
732  return MakeWorkload<ClSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor, info, m_CLCompileContext);
733  }
734  case LayerType::SpaceToDepth :
735  {
736  auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
737  return MakeWorkload<ClSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor, info, m_CLCompileContext);
738  }
739  case LayerType::Splitter :
740  {
741  auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
742  return MakeWorkload<ClSplitterWorkload>(*splitterQueueDescriptor, info, m_CLCompileContext);
743  }
744  case LayerType::Stack :
745  {
746  auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
747  return MakeWorkload<ClStackWorkload>(*stackQueueDescriptor, info, m_CLCompileContext);
748  }
749  case LayerType::StridedSlice :
750  {
751  auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
752  return MakeWorkload<ClStridedSliceWorkload>(*stridedSliceQueueDescriptor, info, m_CLCompileContext);
753  }
754  case LayerType::Subtraction :
755  {
756  auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
757  return MakeWorkload<ClSubtractionWorkload>(*subtractionQueueDescriptor, info, m_CLCompileContext);
758  }
759  case LayerType::Transpose :
760  {
761  auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
762  return MakeWorkload<ClTransposeWorkload>(*transposeQueueDescriptor, info, m_CLCompileContext);
763  }
764  case LayerType::TransposeConvolution2d :
765  {
766  auto transposeConvolution2dQueueDescriptor
767  = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
768  return MakeWorkload<ClTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
769  info,
770  m_MemoryManager->GetIntraLayerManager(),
771  m_CLCompileContext);
772  }
773  case LayerType::UnidirectionalSequenceLstm :
774  {
775  auto desc = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
776  return MakeWorkloadHelper<ClUnidirectionalSequenceLstmFloatWorkload, NullWorkload>(*desc,
777  info,
778  m_CLCompileContext);
779  }
780  default:
781  return nullptr;
782  }
783 }

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::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, armnn::info, armnn::Input, armnn::InstanceNormalization, ClBackendModelContext::IsFastMathEnabled(), armnn::L2Normalization, armnn::Log, armnn::LogicalAnd, armnn::LogicalBinary, armnn::LogicalNot, armnn::LogicalOr, armnn::LogSoftmax, armnn::Lstm, QueueDescriptor::m_AdditionalInfoObject, 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 61 of file ClWorkloadFactory.cpp.

62 {
63  return s_Id;
64 }

◆ IsLayerSupported() [1/2]

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

Definition at line 53 of file ClWorkloadFactory.cpp.

57 {
58  return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported, modelOptions);
59 }

References IWorkloadFactory::IsLayerSupported().

◆ IsLayerSupported() [2/2]

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

Definition at line 46 of file ClWorkloadFactory.cpp.

49 {
50  return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
51 }

References IWorkloadFactory::IsLayerSupported().

◆ SupportsSubTensors()

bool SupportsSubTensors ( ) const
inlineoverridevirtual

Reimplemented from WorkloadFactoryBase.

Definition at line 42 of file ClWorkloadFactory.hpp.

42 { 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
armnnSerializer
Definition: ISerializer.hpp:11
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::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
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_LOG
#define ARMNN_LOG(severity)
Definition: Logging.hpp:212
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::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::LayerType::PreCompiled
@ PreCompiled