36 std::string& outReasonIfUnsupported)
43 std::string& outReasonIfUnsupported,
54 void NeonWorkloadFactory::SetNumberOfThreads()
56 if (m_ModelContextPtr)
58 const unsigned int MIN_THREADS = 1;
59 const unsigned int MAX_THREADS = 64;
66 if (numberOfThreads != 0 && numberOfThreads >= MIN_THREADS && numberOfThreads <= MAX_THREADS)
68 arm_compute::Scheduler::get().set_num_threads(numberOfThreads);
74 : m_MemoryManager(memoryManager), m_ModelContextPtr(
IBackendInternal::IBackendSpecificModelContextPtr{})
81 : m_MemoryManager(memoryManager), m_ModelContextPtr(modelContextPtr)
88 unsigned int const* subTensorOrigin)
const
90 const arm_compute::TensorShape shape = armcomputetensorutils::BuildArmComputeTensorShape(subTensorShape);
98 coords.set(i, armnn::numeric_cast<int>(subTensorOrigin[revertedIndex]));
101 const arm_compute::TensorShape parentShape = armcomputetensorutils::BuildArmComputeTensorShape(parent.
GetShape());
102 if (!::arm_compute::error_on_invalid_subtensor(__func__, __FILE__, __LINE__, parentShape, coords, shape))
107 return std::make_unique<NeonSubTensorHandle>(
108 PolymorphicDowncast<IAclTensorHandle*>(&parent), shape, coords);
112 const bool IsMemoryManaged)
const
114 auto tensorHandle = std::make_unique<NeonTensorHandle>(tensorInfo);
117 tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
124 const bool IsMemoryManaged)
const
126 auto tensorHandle = std::make_unique<NeonTensorHandle>(tensorInfo, dataLayout);
129 tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
142 auto activationQueueDescriptor = PolymorphicDowncast<const ActivationQueueDescriptor*>(&descriptor);
143 return std::make_unique<NeonActivationWorkload>(*activationQueueDescriptor,
info);
147 auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
148 return std::make_unique<NeonAdditionWorkload>(*additionQueueDescriptor,
info);
152 auto argMinMaxQueueDescriptor = PolymorphicDowncast<const ArgMinMaxQueueDescriptor*>(&descriptor);
153 return std::make_unique<NeonArgMinMaxWorkload>(*argMinMaxQueueDescriptor,
info);
157 auto batchMatMulQueueDescriptor = PolymorphicDowncast<const BatchMatMulQueueDescriptor*>(&descriptor);
158 return std::make_unique<NeonBatchMatMulWorkload>(*batchMatMulQueueDescriptor,
info);
162 auto batchNormalizationQueueDescriptor
163 = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
164 return std::make_unique<NeonBatchNormalizationWorkload>(*batchNormalizationQueueDescriptor,
info);
168 auto batchToSpaceNdQueueDescriptor
169 = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
170 return std::make_unique<NeonBatchToSpaceNdWorkload>(*batchToSpaceNdQueueDescriptor,
info);
174 auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
175 return std::make_unique<NeonCastWorkload>(*castQueueDescriptor,
info);
179 auto channelShuffleQueueDescriptor = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
180 return std::make_unique<NeonChannelShuffleWorkload>(*channelShuffleQueueDescriptor,
info);
184 auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
185 return std::make_unique<NeonComparisonWorkload>(*comparisonQueueDescriptor,
info);
189 auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
190 return std::make_unique<NeonConcatWorkload>(*concatQueueDescriptor,
info);
194 auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
195 return std::make_unique<NeonConstantWorkload>(*constantQueueDescriptor,
info);
199 auto convertFp16ToFp32QueueDescriptor
200 = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
201 return std::make_unique<NeonConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor,
info);
205 auto convertFp32ToFp16QueueDescriptor
206 = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
207 return std::make_unique<NeonConvertFp32ToFp16Workload>(*convertFp32ToFp16QueueDescriptor,
info);
211 auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
213 bool isFastMathEnabled =
false;
214 if (m_ModelContextPtr)
216 if (m_ModelContextPtr.get() !=
nullptr)
225 return std::make_unique<NeonConvolution2dWorkload>(*convolution2dQueueDescriptor,
227 m_MemoryManager->GetIntraLayerManager(),
232 auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
234 bool isFastMathEnabled =
false;
235 if (m_ModelContextPtr)
237 if (m_ModelContextPtr.get() !=
nullptr)
246 return std::make_unique<NeonConvolution3dWorkload>(*convolution3dQueueDescriptor,
248 m_MemoryManager->GetIntraLayerManager(),
253 auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
254 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*debugQueueDescriptor,
info);
258 auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
259 return std::make_unique<NeonDepthToSpaceWorkload>(*depthToSpaceQueueDescriptor,
info);
263 auto depthwiseConvolution2dQueueDescriptor
264 = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
265 return std::make_unique<NeonDepthwiseConvolutionWorkload>(*depthwiseConvolution2dQueueDescriptor,
info);
269 auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
270 return std::make_unique<NeonDequantizeWorkload>(*dequantizeQueueDescriptor,
info);
274 auto detectionPostProcessQueueDescriptor
275 = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
276 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*detectionPostProcessQueueDescriptor,
info);
280 auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
281 return std::make_unique<NeonDivisionWorkload>(*divisionQueueDescriptor,
info);
285 auto elementwiseUnaryQueueDescriptor
286 = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
288 switch(elementwiseUnaryQueueDescriptor->m_Parameters.m_Operation)
293 absQueueDescriptor.
m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
294 absQueueDescriptor.
m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
296 return std::make_unique<NeonAbsWorkload>(absQueueDescriptor,
info);
299 return std::make_unique<NeonExpWorkload>(*elementwiseUnaryQueueDescriptor,
info);
301 return std::make_unique<NeonLogicalNotWorkload>(*elementwiseUnaryQueueDescriptor,
info);
303 return std::make_unique<NeonLogWorkload>(*elementwiseUnaryQueueDescriptor,
info);
305 return std::make_unique<NeonNegWorkload>(*elementwiseUnaryQueueDescriptor,
info);
309 rsqrtQueueDescriptor.
m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
310 rsqrtQueueDescriptor.
m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
312 return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor,
info);
315 return std::make_unique<NeonSinWorkload>(*elementwiseUnaryQueueDescriptor,
info);
317 return std::make_unique<NeonSqrtWorkload>(*elementwiseUnaryQueueDescriptor,
info);
324 auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
325 return std::make_unique<NeonFillWorkload>(*fillQueueDescriptor,
info);
329 auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
330 return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(*floorQueueDescriptor,
info);
334 auto fullyConnectedQueueDescriptor = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
335 return std::make_unique<NeonFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
337 m_MemoryManager->GetIntraLayerManager());
341 auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
342 return std::make_unique<NeonGatherWorkload>(*gatherQueueDescriptor,
info);
346 auto gatherNdQueueDescriptor = PolymorphicDowncast<const GatherNdQueueDescriptor*>(&descriptor);
347 return std::make_unique<NeonGatherNdWorkload>(*gatherNdQueueDescriptor,
info);
351 auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
352 return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor,
info);
356 auto instanceNormalizationQueueDescriptor
357 = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
358 return std::make_unique<NeonInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor,
info);
362 auto l2NormalizationQueueDescriptor
363 = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
364 return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>
365 (*l2NormalizationQueueDescriptor,
info, m_MemoryManager->GetIntraLayerManager());
369 auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
370 return std::make_unique<NeonLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
372 m_MemoryManager->GetIntraLayerManager());
376 auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
378 switch(logicalBinaryQueueDescriptor->m_Parameters.m_Operation)
381 return std::make_unique<NeonLogicalAndWorkload>(*logicalBinaryQueueDescriptor,
info);
383 return std::make_unique<NeonLogicalOrWorkload>(*logicalBinaryQueueDescriptor,
info);
390 auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
391 return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(*lstmQueueDescriptor,
info);
395 auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
396 return std::make_unique<NeonMaximumWorkload>(*maximumQueueDescriptor,
info);
400 auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
401 return std::make_unique<NeonMeanWorkload>(*meanQueueDescriptor,
info);
405 auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
406 if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
410 return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(*memCopyQueueDescriptor,
info);
414 auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
415 if (memImportQueueDescriptor->m_Inputs.empty() || !memImportQueueDescriptor->m_Inputs[0])
419 return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor,
info);
423 auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
424 return std::make_unique<NeonMinimumWorkload>(*minimumQueueDescriptor,
info);
428 auto multiplicationQueueDescriptor = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
429 return std::make_unique<NeonMultiplicationWorkload>(*multiplicationQueueDescriptor,
info);
433 auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
434 return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>
435 (*normalizationQueueDescriptor,
info, m_MemoryManager->GetIntraLayerManager());
439 auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
440 return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor,
info);
444 auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
445 return std::make_unique<NeonPadWorkload>(*padQueueDescriptor,
info);
449 auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
450 return std::make_unique<NeonPermuteWorkload>(*permuteQueueDescriptor,
info);
454 auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
455 return std::make_unique<NeonPooling2dWorkload>(*pooling2dQueueDescriptor,
info);
459 auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
460 return std::make_unique<NeonPooling3dWorkload>(*pooling3dQueueDescriptor,
info);
464 auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
465 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*preCompiledQueueDescriptor,
info);
469 auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
470 return std::make_unique<NeonPreluWorkload>(*preluQueueDescriptor,
info);
474 auto qLstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
475 return std::make_unique<NeonQLstmWorkload>(*qLstmQueueDescriptor,
info);
479 auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
480 return std::make_unique<NeonQuantizeWorkload>(*quantizeQueueDescriptor,
info);
484 auto quantizedLstmQueueDescriptor = PolymorphicDowncast<const QuantizedLstmQueueDescriptor*>(&descriptor);
485 return std::make_unique<NeonQuantizedLstmWorkload>(*quantizedLstmQueueDescriptor,
info);
489 auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
490 return std::make_unique<NeonRankWorkload>(*rankQueueDescriptor,
info);
494 auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
495 return std::make_unique<NeonReduceWorkload>(*reduceQueueDescriptor,
info);
499 auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
500 return std::make_unique<NeonReshapeWorkload>(*reshapeQueueDescriptor,
info);
504 auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
505 return std::make_unique<NeonResizeWorkload>(*resizeQueueDescriptor,
info);
509 auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
510 return std::make_unique<NeonSliceWorkload>(*sliceQueueDescriptor,
info);
514 auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
515 return std::make_unique<NeonSoftmaxWorkload>(*softmaxQueueDescriptor,
517 m_MemoryManager->GetIntraLayerManager());
521 auto spaceToBatchNdQueueDescriptor
522 = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
523 return std::make_unique<NeonSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor,
info);
527 auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
528 return std::make_unique<NeonSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor,
info);
532 auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
533 return std::make_unique<NeonSplitterWorkload>(*splitterQueueDescriptor,
info);
537 auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
538 return std::make_unique<NeonStackWorkload>(*stackQueueDescriptor,
info);
542 auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
543 return std::make_unique<NeonStridedSliceWorkload>(*stridedSliceQueueDescriptor,
info);
547 auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
548 return std::make_unique<NeonSubtractionWorkload>(*subtractionQueueDescriptor,
info);
552 auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
553 return std::make_unique<NeonTransposeWorkload>(*transposeQueueDescriptor,
info);
557 auto transposeConvolution2dQueueDescriptor
558 = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
559 return std::make_unique<NeonTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
561 m_MemoryManager->GetIntraLayerManager());
565 auto desc = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
574 return std::make_unique<NeonUnidirectionalSequenceLstmFloatWorkload>(*desc,
info);
578 return std::make_unique<NeonUnidirectionalSequenceLstmWorkload>(*desc,
info);
589 return std::make_unique<NeonActivationWorkload>(descriptor, info);
593 const WorkloadInfo& info)
const
595 return std::make_unique<NeonAdditionWorkload>(descriptor, info);
599 const WorkloadInfo& info)
const
601 return std::make_unique<NeonArgMinMaxWorkload>(descriptor, info);
605 const BatchNormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
607 return std::make_unique<NeonBatchNormalizationWorkload>(descriptor, info);
611 const WorkloadInfo& info)
const
613 return std::make_unique<NeonBatchToSpaceNdWorkload>(descriptor, info);
616 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateCast(
const CastQueueDescriptor& descriptor,
617 const WorkloadInfo& info)
const
619 return std::make_unique<NeonCastWorkload>(descriptor, info);
622 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateChannelShuffle(
const ChannelShuffleQueueDescriptor& descriptor,
623 const WorkloadInfo& info)
const
625 return std::make_unique<NeonChannelShuffleWorkload>(descriptor, info);
629 const WorkloadInfo& info)
const
631 return std::make_unique<NeonComparisonWorkload>(descriptor, info);
635 const WorkloadInfo& info)
const
637 return std::make_unique<NeonConcatWorkload>(descriptor, info);
641 const WorkloadInfo& info)
const
643 return std::make_unique<NeonConstantWorkload>(descriptor, info);
647 const ConvertFp16ToFp32QueueDescriptor& descriptor,
648 const WorkloadInfo& info)
const
650 return std::make_unique<NeonConvertFp16ToFp32Workload>(descriptor, info);
654 const ConvertFp32ToFp16QueueDescriptor& descriptor,
655 const WorkloadInfo& info)
const
657 return std::make_unique<NeonConvertFp32ToFp16Workload>(descriptor, info);
661 const Convolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
663 bool isFastMathEnabled =
false;
664 if (m_ModelContextPtr)
666 if (m_ModelContextPtr.get() !=
nullptr)
668 auto modelOptions =
dynamic_cast<NeonBackendModelContext*
>(m_ModelContextPtr.get());
671 isFastMathEnabled = modelOptions->IsFastMathEnabled();
675 return std::make_unique<NeonConvolution2dWorkload>(descriptor,
677 m_MemoryManager->GetIntraLayerManager(),
681 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConvolution3d(
682 const Convolution3dQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
684 bool isFastMathEnabled =
false;
685 if (m_ModelContextPtr)
687 if (m_ModelContextPtr.get() !=
nullptr)
689 auto modelOptions =
dynamic_cast<NeonBackendModelContext*
>(m_ModelContextPtr.get());
692 isFastMathEnabled = modelOptions->IsFastMathEnabled();
696 return std::make_unique<NeonConvolution3dWorkload>(descriptor,
698 m_MemoryManager->GetIntraLayerManager(),
703 const WorkloadInfo& info)
const
705 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
709 const WorkloadInfo& info)
const
711 return std::make_unique<NeonDepthToSpaceWorkload>(descriptor, info);
715 const DepthwiseConvolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
717 return std::make_unique<NeonDepthwiseConvolutionWorkload>(descriptor, info);
721 const WorkloadInfo& info)
const
723 return std::make_unique<NeonDequantizeWorkload>(descriptor, info);
729 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
733 const DivisionQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
735 return std::make_unique<NeonDivisionWorkload>(descriptor, info);
739 const ElementwiseUnaryQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
741 switch(descriptor.m_Parameters.m_Operation)
745 AbsQueueDescriptor absQueueDescriptor;
746 absQueueDescriptor.m_Inputs = descriptor.m_Inputs;
747 absQueueDescriptor.m_Outputs = descriptor.m_Outputs;
749 return std::make_unique<NeonAbsWorkload>(absQueueDescriptor, info);
752 return std::make_unique<NeonExpWorkload>(descriptor, info);
754 return std::make_unique<NeonLogicalNotWorkload>(descriptor, info);
756 return std::make_unique<NeonLogWorkload>(descriptor, info);
758 return std::make_unique<NeonNegWorkload>(descriptor, info);
761 RsqrtQueueDescriptor rsqrtQueueDescriptor;
762 rsqrtQueueDescriptor.m_Inputs = descriptor.m_Inputs;
763 rsqrtQueueDescriptor.m_Outputs = descriptor.m_Outputs;
765 return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor, info);
768 return std::make_unique<NeonSinWorkload>(descriptor, info);
774 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFill(
const FillQueueDescriptor& descriptor,
775 const WorkloadInfo& info)
const
777 return std::make_unique<NeonFillWorkload>(descriptor, info);
781 const WorkloadInfo& info)
const
783 return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(descriptor, info);
787 const FullyConnectedQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
789 return std::make_unique<NeonFullyConnectedWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
795 return std::make_unique<NeonGatherWorkload>(descriptor, info);
799 const WorkloadInfo& info)
const
801 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
805 const InstanceNormalizationQueueDescriptor& descriptor,
806 const WorkloadInfo& info)
const
808 return std::make_unique<NeonInstanceNormalizationWorkload>(descriptor, info);
812 const WorkloadInfo& info)
const
814 return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>(descriptor, info,
815 m_MemoryManager->GetIntraLayerManager());
819 const WorkloadInfo& info)
const
821 return std::make_unique<NeonLogSoftmaxWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
824 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateLogicalBinary(
const LogicalBinaryQueueDescriptor& descriptor,
825 const WorkloadInfo& info)
const
827 switch(descriptor.m_Parameters.m_Operation)
830 return std::make_unique<NeonLogicalAndWorkload>(descriptor, info);
832 return std::make_unique<NeonLogicalOrWorkload>(descriptor, info);
839 const WorkloadInfo& info)
const
841 return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(descriptor, info);
845 const WorkloadInfo& info)
const
847 return std::make_unique<NeonMaximumWorkload>(descriptor, info);
851 const WorkloadInfo& info)
const
853 return std::make_unique<NeonMeanWorkload>(descriptor, info);
857 const WorkloadInfo& info)
const
859 if (descriptor.m_Inputs.empty() || !descriptor.m_Inputs[0])
861 throw InvalidArgumentException(
"NeonWorkloadFactory: Invalid null input for MemCopy workload");
864 return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(descriptor, info);
868 const WorkloadInfo& info)
const
870 if (descriptor.m_Inputs.empty() || !descriptor.m_Inputs[0])
872 throw InvalidArgumentException(
"NeonWorkloadFactory: Invalid null input for MemImport workload");
875 return std::make_unique<ImportMemGenericWorkload>(descriptor, info);
879 const WorkloadInfo& info)
const
881 return std::make_unique<NeonMinimumWorkload>(descriptor, info);
885 const MultiplicationQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
887 return std::make_unique<NeonMultiplicationWorkload>(descriptor, info);
891 const NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
893 return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>(descriptor, info,
894 m_MemoryManager->GetIntraLayerManager());
898 const WorkloadInfo& info)
const
900 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
904 const WorkloadInfo& info)
const
906 return std::make_unique<NeonPadWorkload>(descriptor, info);
910 const WorkloadInfo& info)
const
912 return std::make_unique<NeonPermuteWorkload>(descriptor, info);
916 const WorkloadInfo& info)
const
918 return std::make_unique<NeonPooling2dWorkload>(descriptor, info);
922 const WorkloadInfo& info)
const
924 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
930 return std::make_unique<NeonPreluWorkload>(descriptor, info);
933 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateQLstm(
const QLstmQueueDescriptor& descriptor,
934 const WorkloadInfo& info)
const
936 return std::make_unique<NeonQLstmWorkload>(descriptor, info);
940 const WorkloadInfo& info)
const
942 return std::make_unique<NeonQuantizeWorkload>(descriptor, info);
946 const WorkloadInfo& info)
const
948 return std::make_unique<NeonQuantizedLstmWorkload>(descriptor, info);
952 const WorkloadInfo& info)
const
954 return std::make_unique<NeonRankWorkload>(descriptor, info);
957 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReduce(
const ReduceQueueDescriptor& descriptor,
958 const WorkloadInfo& info)
const
960 return std::make_unique<NeonReduceWorkload>(descriptor, info);
964 const WorkloadInfo& info)
const
966 return std::make_unique<NeonReshapeWorkload>(descriptor, info);
970 const WorkloadInfo& info)
const
972 return std::make_unique<NeonResizeWorkload>(descriptor, info);
976 const WorkloadInfo& info)
const
978 return std::make_unique<NeonSliceWorkload>(descriptor, info);
982 const WorkloadInfo& info)
const
984 return std::make_unique<NeonSoftmaxWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
988 const WorkloadInfo& info)
const
990 return std::make_unique<NeonSpaceToBatchNdWorkload>(descriptor, info);
994 const WorkloadInfo& info)
const
996 return std::make_unique<NeonSpaceToDepthWorkload>(descriptor, info);
1000 const WorkloadInfo& info)
const
1002 return std::make_unique<NeonSplitterWorkload>(descriptor, info);
1006 const WorkloadInfo& info)
const
1008 return std::make_unique<NeonStackWorkload>(descriptor, info);
1012 const WorkloadInfo& info)
const
1014 return std::make_unique<NeonStridedSliceWorkload>(descriptor, info);
1018 const SubtractionQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
1020 return std::make_unique<NeonSubtractionWorkload>(descriptor, info);
1024 const WorkloadInfo& info)
const
1026 return std::make_unique<NeonTransposeWorkload>(descriptor, info);
1030 const TransposeConvolution2dQueueDescriptor &descriptor,
1031 const WorkloadInfo &info)
const
1033 return std::make_unique<NeonTransposeConvolution2dWorkload>(descriptor, info,
1034 m_MemoryManager->GetIntraLayerManager());