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 bool isFastMathEnabled =
false;
159 if (m_ModelContextPtr)
161 if (m_ModelContextPtr.get() !=
nullptr)
170 return std::make_unique<NeonBatchMatMulWorkload>(*batchMatMulQueueDescriptor,
info, isFastMathEnabled);
174 auto batchNormalizationQueueDescriptor
175 = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
176 return std::make_unique<NeonBatchNormalizationWorkload>(*batchNormalizationQueueDescriptor,
info);
180 auto batchToSpaceNdQueueDescriptor
181 = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
182 return std::make_unique<NeonBatchToSpaceNdWorkload>(*batchToSpaceNdQueueDescriptor,
info);
186 auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
187 return std::make_unique<NeonCastWorkload>(*castQueueDescriptor,
info);
191 auto channelShuffleQueueDescriptor = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
192 return std::make_unique<NeonChannelShuffleWorkload>(*channelShuffleQueueDescriptor,
info);
196 auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
197 return std::make_unique<NeonComparisonWorkload>(*comparisonQueueDescriptor,
info);
201 auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
202 return std::make_unique<NeonConcatWorkload>(*concatQueueDescriptor,
info);
206 auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
207 return std::make_unique<NeonConstantWorkload>(*constantQueueDescriptor,
info);
211 auto convertFp16ToFp32QueueDescriptor
212 = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
213 return std::make_unique<NeonConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor,
info);
217 auto convertFp32ToFp16QueueDescriptor
218 = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
219 return std::make_unique<NeonConvertFp32ToFp16Workload>(*convertFp32ToFp16QueueDescriptor,
info);
223 auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
225 bool isFastMathEnabled =
false;
226 if (m_ModelContextPtr)
228 if (m_ModelContextPtr.get() !=
nullptr)
237 return std::make_unique<NeonConvolution2dWorkload>(*convolution2dQueueDescriptor,
239 m_MemoryManager->GetIntraLayerManager(),
244 auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
246 bool isFastMathEnabled =
false;
247 if (m_ModelContextPtr)
249 if (m_ModelContextPtr.get() !=
nullptr)
258 return std::make_unique<NeonConvolution3dWorkload>(*convolution3dQueueDescriptor,
260 m_MemoryManager->GetIntraLayerManager(),
265 auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
266 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*debugQueueDescriptor,
info);
270 auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
271 return std::make_unique<NeonDepthToSpaceWorkload>(*depthToSpaceQueueDescriptor,
info);
275 auto depthwiseConvolution2dQueueDescriptor
276 = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
277 return std::make_unique<NeonDepthwiseConvolutionWorkload>(*depthwiseConvolution2dQueueDescriptor,
info);
281 auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
282 return std::make_unique<NeonDequantizeWorkload>(*dequantizeQueueDescriptor,
info);
286 auto detectionPostProcessQueueDescriptor
287 = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
288 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*detectionPostProcessQueueDescriptor,
info);
292 auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
293 return std::make_unique<NeonDivisionWorkload>(*divisionQueueDescriptor,
info);
297 auto elementwiseBinaryQueueDescriptor
298 = PolymorphicDowncast<const ElementwiseBinaryQueueDescriptor*>(&descriptor);
300 switch (elementwiseBinaryQueueDescriptor->m_Parameters.m_Operation)
307 return std::make_unique<NeonAdditionWorkload>(additionQueueDescriptor,
info);
314 return std::make_unique<NeonDivisionWorkload>(divisionQueueDescriptor,
info);
321 return std::make_unique<NeonMaximumWorkload>(maximumQueueDescriptor,
info);
328 return std::make_unique<NeonMinimumWorkload>(minimumQueueDescriptor,
info);
335 return std::make_unique<NeonMultiplicationWorkload>(multiplicationQueueDescriptor,
info);
342 return std::make_unique<NeonSubtractionWorkload>(subtractionQueueDescriptor,
info);
350 auto elementwiseUnaryQueueDescriptor
351 = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
353 switch(elementwiseUnaryQueueDescriptor->m_Parameters.m_Operation)
358 absQueueDescriptor.
m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
359 absQueueDescriptor.
m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
361 return std::make_unique<NeonAbsWorkload>(absQueueDescriptor,
info);
364 return std::make_unique<NeonExpWorkload>(*elementwiseUnaryQueueDescriptor,
info);
366 return std::make_unique<NeonLogicalNotWorkload>(*elementwiseUnaryQueueDescriptor,
info);
368 return std::make_unique<NeonLogWorkload>(*elementwiseUnaryQueueDescriptor,
info);
370 return std::make_unique<NeonNegWorkload>(*elementwiseUnaryQueueDescriptor,
info);
374 rsqrtQueueDescriptor.
m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
375 rsqrtQueueDescriptor.
m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
377 return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor,
info);
380 return std::make_unique<NeonSinWorkload>(*elementwiseUnaryQueueDescriptor,
info);
382 return std::make_unique<NeonSqrtWorkload>(*elementwiseUnaryQueueDescriptor,
info);
389 auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
390 return std::make_unique<NeonFillWorkload>(*fillQueueDescriptor,
info);
394 auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
395 return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(*floorQueueDescriptor,
info);
399 auto fullyConnectedQueueDescriptor = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
400 return std::make_unique<NeonFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
402 m_MemoryManager->GetIntraLayerManager());
406 auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
407 return std::make_unique<NeonGatherWorkload>(*gatherQueueDescriptor,
info);
411 auto gatherNdQueueDescriptor = PolymorphicDowncast<const GatherNdQueueDescriptor*>(&descriptor);
412 return std::make_unique<NeonGatherNdWorkload>(*gatherNdQueueDescriptor,
info);
416 auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
417 return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor,
info);
421 auto instanceNormalizationQueueDescriptor
422 = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
423 return std::make_unique<NeonInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor,
info);
427 auto l2NormalizationQueueDescriptor
428 = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
429 return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>
430 (*l2NormalizationQueueDescriptor,
info, m_MemoryManager->GetIntraLayerManager());
434 auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
435 return std::make_unique<NeonLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
437 m_MemoryManager->GetIntraLayerManager());
441 auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
443 switch(logicalBinaryQueueDescriptor->m_Parameters.m_Operation)
446 return std::make_unique<NeonLogicalAndWorkload>(*logicalBinaryQueueDescriptor,
info);
448 return std::make_unique<NeonLogicalOrWorkload>(*logicalBinaryQueueDescriptor,
info);
455 auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
456 return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(*lstmQueueDescriptor,
info);
460 auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
461 return std::make_unique<NeonMaximumWorkload>(*maximumQueueDescriptor,
info);
465 auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
466 return std::make_unique<NeonMeanWorkload>(*meanQueueDescriptor,
info);
470 auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
471 if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
475 return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(*memCopyQueueDescriptor,
info);
479 auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
480 if (memImportQueueDescriptor->m_Inputs.empty() || !memImportQueueDescriptor->m_Inputs[0])
484 return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor,
info);
488 auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
489 return std::make_unique<NeonMinimumWorkload>(*minimumQueueDescriptor,
info);
493 auto multiplicationQueueDescriptor = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
494 return std::make_unique<NeonMultiplicationWorkload>(*multiplicationQueueDescriptor,
info);
498 auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
499 return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>
500 (*normalizationQueueDescriptor,
info, m_MemoryManager->GetIntraLayerManager());
504 auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
505 return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor,
info);
509 auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
510 return std::make_unique<NeonPadWorkload>(*padQueueDescriptor,
info);
514 auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
515 return std::make_unique<NeonPermuteWorkload>(*permuteQueueDescriptor,
info);
519 auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
520 return std::make_unique<NeonPooling2dWorkload>(*pooling2dQueueDescriptor,
info);
524 auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
525 return std::make_unique<NeonPooling3dWorkload>(*pooling3dQueueDescriptor,
info);
529 auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
530 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*preCompiledQueueDescriptor,
info);
534 auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
535 return std::make_unique<NeonPreluWorkload>(*preluQueueDescriptor,
info);
539 auto qLstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
540 return std::make_unique<NeonQLstmWorkload>(*qLstmQueueDescriptor,
info);
544 auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
545 return std::make_unique<NeonQuantizeWorkload>(*quantizeQueueDescriptor,
info);
549 auto quantizedLstmQueueDescriptor = PolymorphicDowncast<const QuantizedLstmQueueDescriptor*>(&descriptor);
550 return std::make_unique<NeonQuantizedLstmWorkload>(*quantizedLstmQueueDescriptor,
info);
554 auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
555 return std::make_unique<NeonRankWorkload>(*rankQueueDescriptor,
info);
559 auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
560 return std::make_unique<NeonReduceWorkload>(*reduceQueueDescriptor,
info);
564 auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
565 return std::make_unique<NeonReshapeWorkload>(*reshapeQueueDescriptor,
info);
569 auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
570 return std::make_unique<NeonResizeWorkload>(*resizeQueueDescriptor,
info);
574 auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
575 return std::make_unique<NeonSliceWorkload>(*sliceQueueDescriptor,
info);
579 auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
580 return std::make_unique<NeonSoftmaxWorkload>(*softmaxQueueDescriptor,
582 m_MemoryManager->GetIntraLayerManager());
586 auto spaceToBatchNdQueueDescriptor
587 = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
588 return std::make_unique<NeonSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor,
info);
592 auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
593 return std::make_unique<NeonSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor,
info);
597 auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
598 return std::make_unique<NeonSplitterWorkload>(*splitterQueueDescriptor,
info);
602 auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
603 return std::make_unique<NeonStackWorkload>(*stackQueueDescriptor,
info);
607 auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
608 return std::make_unique<NeonStridedSliceWorkload>(*stridedSliceQueueDescriptor,
info);
612 auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
613 return std::make_unique<NeonSubtractionWorkload>(*subtractionQueueDescriptor,
info);
617 auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
618 return std::make_unique<NeonTransposeWorkload>(*transposeQueueDescriptor,
info);
622 auto transposeConvolution2dQueueDescriptor
623 = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
624 return std::make_unique<NeonTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
626 m_MemoryManager->GetIntraLayerManager());
630 auto desc = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
639 return std::make_unique<NeonUnidirectionalSequenceLstmFloatWorkload>(*desc,
info);
643 return std::make_unique<NeonUnidirectionalSequenceLstmWorkload>(*desc,
info);
654 return std::make_unique<NeonActivationWorkload>(descriptor, info);
658 const WorkloadInfo& info)
const
660 return std::make_unique<NeonAdditionWorkload>(descriptor, info);
664 const WorkloadInfo& info)
const
666 return std::make_unique<NeonArgMinMaxWorkload>(descriptor, info);
670 const BatchNormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
672 return std::make_unique<NeonBatchNormalizationWorkload>(descriptor, info);
676 const WorkloadInfo& info)
const
678 return std::make_unique<NeonBatchToSpaceNdWorkload>(descriptor, info);
681 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateCast(
const CastQueueDescriptor& descriptor,
682 const WorkloadInfo& info)
const
684 return std::make_unique<NeonCastWorkload>(descriptor, info);
687 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateChannelShuffle(
const ChannelShuffleQueueDescriptor& descriptor,
688 const WorkloadInfo& info)
const
690 return std::make_unique<NeonChannelShuffleWorkload>(descriptor, info);
694 const WorkloadInfo& info)
const
696 return std::make_unique<NeonComparisonWorkload>(descriptor, info);
700 const WorkloadInfo& info)
const
702 return std::make_unique<NeonConcatWorkload>(descriptor, info);
706 const WorkloadInfo& info)
const
708 return std::make_unique<NeonConstantWorkload>(descriptor, info);
712 const ConvertFp16ToFp32QueueDescriptor& descriptor,
713 const WorkloadInfo& info)
const
715 return std::make_unique<NeonConvertFp16ToFp32Workload>(descriptor, info);
719 const ConvertFp32ToFp16QueueDescriptor& descriptor,
720 const WorkloadInfo& info)
const
722 return std::make_unique<NeonConvertFp32ToFp16Workload>(descriptor, info);
726 const Convolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
728 bool isFastMathEnabled =
false;
729 if (m_ModelContextPtr)
731 if (m_ModelContextPtr.get() !=
nullptr)
733 auto modelOptions =
dynamic_cast<NeonBackendModelContext*
>(m_ModelContextPtr.get());
736 isFastMathEnabled = modelOptions->IsFastMathEnabled();
740 return std::make_unique<NeonConvolution2dWorkload>(descriptor,
742 m_MemoryManager->GetIntraLayerManager(),
746 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConvolution3d(
747 const Convolution3dQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
749 bool isFastMathEnabled =
false;
750 if (m_ModelContextPtr)
752 if (m_ModelContextPtr.get() !=
nullptr)
754 auto modelOptions =
dynamic_cast<NeonBackendModelContext*
>(m_ModelContextPtr.get());
757 isFastMathEnabled = modelOptions->IsFastMathEnabled();
761 return std::make_unique<NeonConvolution3dWorkload>(descriptor,
763 m_MemoryManager->GetIntraLayerManager(),
768 const WorkloadInfo& info)
const
770 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
774 const WorkloadInfo& info)
const
776 return std::make_unique<NeonDepthToSpaceWorkload>(descriptor, info);
780 const DepthwiseConvolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
782 return std::make_unique<NeonDepthwiseConvolutionWorkload>(descriptor, info);
786 const WorkloadInfo& info)
const
788 return std::make_unique<NeonDequantizeWorkload>(descriptor, info);
794 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
798 const DivisionQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
800 return std::make_unique<NeonDivisionWorkload>(descriptor, info);
804 const ElementwiseUnaryQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
806 switch(descriptor.m_Parameters.m_Operation)
810 AbsQueueDescriptor absQueueDescriptor;
811 absQueueDescriptor.m_Inputs = descriptor.m_Inputs;
812 absQueueDescriptor.m_Outputs = descriptor.m_Outputs;
814 return std::make_unique<NeonAbsWorkload>(absQueueDescriptor, info);
817 return std::make_unique<NeonExpWorkload>(descriptor, info);
819 return std::make_unique<NeonLogicalNotWorkload>(descriptor, info);
821 return std::make_unique<NeonLogWorkload>(descriptor, info);
823 return std::make_unique<NeonNegWorkload>(descriptor, info);
826 RsqrtQueueDescriptor rsqrtQueueDescriptor;
827 rsqrtQueueDescriptor.m_Inputs = descriptor.m_Inputs;
828 rsqrtQueueDescriptor.m_Outputs = descriptor.m_Outputs;
830 return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor, info);
833 return std::make_unique<NeonSinWorkload>(descriptor, info);
839 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFill(
const FillQueueDescriptor& descriptor,
840 const WorkloadInfo& info)
const
842 return std::make_unique<NeonFillWorkload>(descriptor, info);
846 const WorkloadInfo& info)
const
848 return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(descriptor, info);
852 const FullyConnectedQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
854 return std::make_unique<NeonFullyConnectedWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
860 return std::make_unique<NeonGatherWorkload>(descriptor, info);
864 const WorkloadInfo& info)
const
866 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
870 const InstanceNormalizationQueueDescriptor& descriptor,
871 const WorkloadInfo& info)
const
873 return std::make_unique<NeonInstanceNormalizationWorkload>(descriptor, info);
877 const WorkloadInfo& info)
const
879 return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>(descriptor, info,
880 m_MemoryManager->GetIntraLayerManager());
884 const WorkloadInfo& info)
const
886 return std::make_unique<NeonLogSoftmaxWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
889 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateLogicalBinary(
const LogicalBinaryQueueDescriptor& descriptor,
890 const WorkloadInfo& info)
const
892 switch(descriptor.m_Parameters.m_Operation)
895 return std::make_unique<NeonLogicalAndWorkload>(descriptor, info);
897 return std::make_unique<NeonLogicalOrWorkload>(descriptor, info);
904 const WorkloadInfo& info)
const
906 return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(descriptor, info);
910 const WorkloadInfo& info)
const
912 return std::make_unique<NeonMaximumWorkload>(descriptor, info);
916 const WorkloadInfo& info)
const
918 return std::make_unique<NeonMeanWorkload>(descriptor, info);
922 const WorkloadInfo& info)
const
924 if (descriptor.m_Inputs.empty() || !descriptor.m_Inputs[0])
926 throw InvalidArgumentException(
"NeonWorkloadFactory: Invalid null input for MemCopy workload");
929 return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(descriptor, info);
933 const WorkloadInfo& info)
const
935 if (descriptor.m_Inputs.empty() || !descriptor.m_Inputs[0])
937 throw InvalidArgumentException(
"NeonWorkloadFactory: Invalid null input for MemImport workload");
940 return std::make_unique<ImportMemGenericWorkload>(descriptor, info);
944 const WorkloadInfo& info)
const
946 return std::make_unique<NeonMinimumWorkload>(descriptor, info);
950 const MultiplicationQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
952 return std::make_unique<NeonMultiplicationWorkload>(descriptor, info);
956 const NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
958 return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>(descriptor, info,
959 m_MemoryManager->GetIntraLayerManager());
963 const WorkloadInfo& info)
const
965 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
969 const WorkloadInfo& info)
const
971 return std::make_unique<NeonPadWorkload>(descriptor, info);
975 const WorkloadInfo& info)
const
977 return std::make_unique<NeonPermuteWorkload>(descriptor, info);
981 const WorkloadInfo& info)
const
983 return std::make_unique<NeonPooling2dWorkload>(descriptor, info);
987 const WorkloadInfo& info)
const
989 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
995 return std::make_unique<NeonPreluWorkload>(descriptor, info);
998 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateQLstm(
const QLstmQueueDescriptor& descriptor,
999 const WorkloadInfo& info)
const
1001 return std::make_unique<NeonQLstmWorkload>(descriptor, info);
1005 const WorkloadInfo& info)
const
1007 return std::make_unique<NeonQuantizeWorkload>(descriptor, info);
1011 const WorkloadInfo& info)
const
1013 return std::make_unique<NeonQuantizedLstmWorkload>(descriptor, info);
1017 const WorkloadInfo& info)
const
1019 return std::make_unique<NeonRankWorkload>(descriptor, info);
1022 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReduce(
const ReduceQueueDescriptor& descriptor,
1023 const WorkloadInfo& info)
const
1025 return std::make_unique<NeonReduceWorkload>(descriptor, info);
1029 const WorkloadInfo& info)
const
1031 return std::make_unique<NeonReshapeWorkload>(descriptor, info);
1035 const WorkloadInfo& info)
const
1037 return std::make_unique<NeonResizeWorkload>(descriptor, info);
1041 const WorkloadInfo& info)
const
1043 return std::make_unique<NeonSliceWorkload>(descriptor, info);
1047 const WorkloadInfo& info)
const
1049 return std::make_unique<NeonSoftmaxWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
1053 const WorkloadInfo& info)
const
1055 return std::make_unique<NeonSpaceToBatchNdWorkload>(descriptor, info);
1059 const WorkloadInfo& info)
const
1061 return std::make_unique<NeonSpaceToDepthWorkload>(descriptor, info);
1065 const WorkloadInfo& info)
const
1067 return std::make_unique<NeonSplitterWorkload>(descriptor, info);
1071 const WorkloadInfo& info)
const
1073 return std::make_unique<NeonStackWorkload>(descriptor, info);
1077 const WorkloadInfo& info)
const
1079 return std::make_unique<NeonStridedSliceWorkload>(descriptor, info);
1083 const SubtractionQueueDescriptor& descriptor,
const WorkloadInfo& info)
const
1085 return std::make_unique<NeonSubtractionWorkload>(descriptor, info);
1089 const WorkloadInfo& info)
const
1091 return std::make_unique<NeonTransposeWorkload>(descriptor, info);
1095 const TransposeConvolution2dQueueDescriptor &descriptor,
1096 const WorkloadInfo &info)
const
1098 return std::make_unique<NeonTransposeConvolution2dWorkload>(descriptor, info,
1099 m_MemoryManager->GetIntraLayerManager());