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 convertBf16ToFp32QueueDescriptor
200 = PolymorphicDowncast<const ConvertBf16ToFp32QueueDescriptor*>(&descriptor);
201 return std::make_unique<NeonConvertBf16ToFp32Workload>(*convertBf16ToFp32QueueDescriptor,
info);
205 auto convertFp16ToFp32QueueDescriptor
206 = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
207 return std::make_unique<NeonConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor,
info);
211 auto convertFp32ToBf16QueueDescriptor
212 = PolymorphicDowncast<const ConvertFp32ToBf16QueueDescriptor*>(&descriptor);
213 return std::make_unique<NeonConvertFp32ToBf16Workload>(*convertFp32ToBf16QueueDescriptor,
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 elementwiseUnaryQueueDescriptor
298 = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
300 switch(elementwiseUnaryQueueDescriptor->m_Parameters.m_Operation)
305 absQueueDescriptor.
m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
306 absQueueDescriptor.
m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
308 return std::make_unique<NeonAbsWorkload>(absQueueDescriptor,
info);
311 return std::make_unique<NeonExpWorkload>(*elementwiseUnaryQueueDescriptor,
info);
313 return std::make_unique<NeonLogicalNotWorkload>(*elementwiseUnaryQueueDescriptor,
info);
315 return std::make_unique<NeonLogWorkload>(*elementwiseUnaryQueueDescriptor,
info);
317 return std::make_unique<NeonNegWorkload>(*elementwiseUnaryQueueDescriptor,
info);
321 rsqrtQueueDescriptor.
m_Inputs = elementwiseUnaryQueueDescriptor->m_Inputs;
322 rsqrtQueueDescriptor.
m_Outputs = elementwiseUnaryQueueDescriptor->m_Outputs;
324 return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor,
info);
327 return std::make_unique<NeonSinWorkload>(*elementwiseUnaryQueueDescriptor,
info);
329 return std::make_unique<NeonSqrtWorkload>(*elementwiseUnaryQueueDescriptor,
info);
336 auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
337 return std::make_unique<NeonFillWorkload>(*fillQueueDescriptor,
info);
341 auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
342 return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(*floorQueueDescriptor,
info);
346 auto fullyConnectedQueueDescriptor = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
347 return std::make_unique<NeonFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
349 m_MemoryManager->GetIntraLayerManager());
353 auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
354 return std::make_unique<NeonGatherWorkload>(*gatherQueueDescriptor,
info);
358 auto gatherNdQueueDescriptor = PolymorphicDowncast<const GatherNdQueueDescriptor*>(&descriptor);
359 return std::make_unique<NeonGatherNdWorkload>(*gatherNdQueueDescriptor,
info);
363 auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
364 return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor,
info);
368 auto instanceNormalizationQueueDescriptor
369 = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
370 return std::make_unique<NeonInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor,
info);
374 auto l2NormalizationQueueDescriptor
375 = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
376 return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>
377 (*l2NormalizationQueueDescriptor,
info, m_MemoryManager->GetIntraLayerManager());
381 auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
382 return std::make_unique<NeonLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
384 m_MemoryManager->GetIntraLayerManager());
388 auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
390 switch(logicalBinaryQueueDescriptor->m_Parameters.m_Operation)
393 return std::make_unique<NeonLogicalAndWorkload>(*logicalBinaryQueueDescriptor,
info);
395 return std::make_unique<NeonLogicalOrWorkload>(*logicalBinaryQueueDescriptor,
info);
402 auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
403 return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(*lstmQueueDescriptor,
info);
407 auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
408 return std::make_unique<NeonMaximumWorkload>(*maximumQueueDescriptor,
info);
412 auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
413 return std::make_unique<NeonMeanWorkload>(*meanQueueDescriptor,
info);
417 auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
418 if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
422 return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(*memCopyQueueDescriptor,
info);
426 auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
427 if (memImportQueueDescriptor->m_Inputs.empty() || !memImportQueueDescriptor->m_Inputs[0])
431 return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor,
info);
435 auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
436 return std::make_unique<NeonMinimumWorkload>(*minimumQueueDescriptor,
info);
440 auto multiplicationQueueDescriptor = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
441 return std::make_unique<NeonMultiplicationWorkload>(*multiplicationQueueDescriptor,
info);
445 auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
446 return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>
447 (*normalizationQueueDescriptor,
info, m_MemoryManager->GetIntraLayerManager());
451 auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
452 return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor,
info);
456 auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
457 return std::make_unique<NeonPadWorkload>(*padQueueDescriptor,
info);
461 auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
462 return std::make_unique<NeonPermuteWorkload>(*permuteQueueDescriptor,
info);
466 auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
467 return std::make_unique<NeonPooling2dWorkload>(*pooling2dQueueDescriptor,
info);
471 auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
472 return std::make_unique<NeonPooling3dWorkload>(*pooling3dQueueDescriptor,
info);
476 auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
477 return MakeWorkloadHelper<NullWorkload, NullWorkload>(*preCompiledQueueDescriptor,
info);
481 auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
482 return std::make_unique<NeonPreluWorkload>(*preluQueueDescriptor,
info);
486 auto qLstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
487 return std::make_unique<NeonQLstmWorkload>(*qLstmQueueDescriptor,
info);
491 auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
492 return std::make_unique<NeonQuantizeWorkload>(*quantizeQueueDescriptor,
info);
496 auto quantizedLstmQueueDescriptor = PolymorphicDowncast<const QuantizedLstmQueueDescriptor*>(&descriptor);
497 return std::make_unique<NeonQuantizedLstmWorkload>(*quantizedLstmQueueDescriptor,
info);
501 auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
502 return std::make_unique<NeonRankWorkload>(*rankQueueDescriptor,
info);
506 auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
507 return std::make_unique<NeonReduceWorkload>(*reduceQueueDescriptor,
info);
511 auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
512 return std::make_unique<NeonReshapeWorkload>(*reshapeQueueDescriptor,
info);
516 auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
517 return std::make_unique<NeonResizeWorkload>(*resizeQueueDescriptor,
info);
521 auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
522 return std::make_unique<NeonSliceWorkload>(*sliceQueueDescriptor,
info);
526 auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
527 return std::make_unique<NeonSoftmaxWorkload>(*softmaxQueueDescriptor,
529 m_MemoryManager->GetIntraLayerManager());
533 auto spaceToBatchNdQueueDescriptor
534 = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
535 return std::make_unique<NeonSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor,
info);
539 auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
540 return std::make_unique<NeonSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor,
info);
544 auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
545 return std::make_unique<NeonSplitterWorkload>(*splitterQueueDescriptor,
info);
549 auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
550 return std::make_unique<NeonStackWorkload>(*stackQueueDescriptor,
info);
554 auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
555 return std::make_unique<NeonStridedSliceWorkload>(*stridedSliceQueueDescriptor,
info);
559 auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
560 return std::make_unique<NeonSubtractionWorkload>(*subtractionQueueDescriptor,
info);
564 auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
565 return std::make_unique<NeonTransposeWorkload>(*transposeQueueDescriptor,
info);
569 auto transposeConvolution2dQueueDescriptor
570 = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
571 return std::make_unique<NeonTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
573 m_MemoryManager->GetIntraLayerManager());
577 auto desc = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
586 return std::make_unique<NeonUnidirectionalSequenceLstmFloatWorkload>(*desc,
info);
590 return std::make_unique<NeonUnidirectionalSequenceLstmWorkload>(*desc,
info);
601 return std::make_unique<NeonActivationWorkload>(descriptor,
info);
607 return std::make_unique<NeonAdditionWorkload>(descriptor,
info);
613 return std::make_unique<NeonArgMinMaxWorkload>(descriptor,
info);
619 return std::make_unique<NeonBatchNormalizationWorkload>(descriptor,
info);
625 return std::make_unique<NeonBatchToSpaceNdWorkload>(descriptor,
info);
628 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateCast(
const CastQueueDescriptor& descriptor,
631 return std::make_unique<NeonCastWorkload>(descriptor,
info);
637 return std::make_unique<NeonChannelShuffleWorkload>(descriptor,
info);
643 return std::make_unique<NeonComparisonWorkload>(descriptor,
info);
649 return std::make_unique<NeonConcatWorkload>(descriptor,
info);
655 return std::make_unique<NeonConstantWorkload>(descriptor,
info);
658 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConvertBf16ToFp32(
662 return std::make_unique<NeonConvertBf16ToFp32Workload>(descriptor,
info);
669 return std::make_unique<NeonConvertFp16ToFp32Workload>(descriptor,
info);
672 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConvertFp32ToBf16(
676 return std::make_unique<NeonConvertFp32ToBf16Workload>(descriptor,
info);
683 return std::make_unique<NeonConvertFp32ToFp16Workload>(descriptor,
info);
689 bool isFastMathEnabled =
false;
690 if (m_ModelContextPtr)
692 if (m_ModelContextPtr.get() !=
nullptr)
701 return std::make_unique<NeonConvolution2dWorkload>(descriptor,
703 m_MemoryManager->GetIntraLayerManager(),
707 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConvolution3d(
710 bool isFastMathEnabled =
false;
711 if (m_ModelContextPtr)
713 if (m_ModelContextPtr.get() !=
nullptr)
722 return std::make_unique<NeonConvolution3dWorkload>(descriptor,
724 m_MemoryManager->GetIntraLayerManager(),
731 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor,
info);
737 return std::make_unique<NeonDepthToSpaceWorkload>(descriptor,
info);
743 return std::make_unique<NeonDepthwiseConvolutionWorkload>(descriptor,
info);
749 return std::make_unique<NeonDequantizeWorkload>(descriptor,
info);
755 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor,
info);
761 return std::make_unique<NeonDivisionWorkload>(descriptor,
info);
775 return std::make_unique<NeonAbsWorkload>(absQueueDescriptor,
info);
778 return std::make_unique<NeonExpWorkload>(descriptor,
info);
780 return std::make_unique<NeonLogicalNotWorkload>(descriptor,
info);
782 return std::make_unique<NeonLogWorkload>(descriptor,
info);
784 return std::make_unique<NeonNegWorkload>(descriptor,
info);
788 rsqrtQueueDescriptor.
m_Inputs = descriptor.m_Inputs;
789 rsqrtQueueDescriptor.
m_Outputs = descriptor.m_Outputs;
791 return std::make_unique<NeonRsqrtWorkload>(rsqrtQueueDescriptor,
info);
794 return std::make_unique<NeonSinWorkload>(descriptor,
info);
800 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFill(
const FillQueueDescriptor& descriptor,
803 return std::make_unique<NeonFillWorkload>(descriptor,
info);
809 return MakeWorkloadHelper<NeonFloorFloatWorkload, NullWorkload>(descriptor,
info);
815 return std::make_unique<NeonFullyConnectedWorkload>(descriptor,
info, m_MemoryManager->GetIntraLayerManager());
821 return std::make_unique<NeonGatherWorkload>(descriptor,
info);
827 return std::make_unique<CopyMemGenericWorkload>(descriptor,
info);
834 return std::make_unique<NeonInstanceNormalizationWorkload>(descriptor,
info);
840 return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>(descriptor,
info,
841 m_MemoryManager->GetIntraLayerManager());
847 return std::make_unique<NeonLogSoftmaxWorkload>(descriptor,
info, m_MemoryManager->GetIntraLayerManager());
856 return std::make_unique<NeonLogicalAndWorkload>(descriptor,
info);
858 return std::make_unique<NeonLogicalOrWorkload>(descriptor,
info);
867 return MakeWorkloadHelper<NeonLstmFloatWorkload, NullWorkload>(descriptor,
info);
873 return std::make_unique<NeonMaximumWorkload>(descriptor,
info);
879 return std::make_unique<NeonMeanWorkload>(descriptor,
info);
890 return MakeWorkloadHelper<CopyMemGenericWorkload, CopyMemGenericWorkload>(descriptor,
info);
901 return std::make_unique<ImportMemGenericWorkload>(descriptor,
info);
907 return std::make_unique<NeonMinimumWorkload>(descriptor,
info);
913 return std::make_unique<NeonMultiplicationWorkload>(descriptor,
info);
919 return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>(descriptor,
info,
920 m_MemoryManager->GetIntraLayerManager());
926 return std::make_unique<CopyMemGenericWorkload>(descriptor,
info);
932 return std::make_unique<NeonPadWorkload>(descriptor,
info);
938 return std::make_unique<NeonPermuteWorkload>(descriptor,
info);
944 return std::make_unique<NeonPooling2dWorkload>(descriptor,
info);
950 return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor,
info);
956 return std::make_unique<NeonPreluWorkload>(descriptor,
info);
959 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateQLstm(
const QLstmQueueDescriptor& descriptor,
962 return std::make_unique<NeonQLstmWorkload>(descriptor,
info);
968 return std::make_unique<NeonQuantizeWorkload>(descriptor,
info);
974 return std::make_unique<NeonQuantizedLstmWorkload>(descriptor,
info);
980 return std::make_unique<NeonRankWorkload>(descriptor,
info);
983 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReduce(
const ReduceQueueDescriptor& descriptor,
986 return std::make_unique<NeonReduceWorkload>(descriptor,
info);
992 return std::make_unique<NeonReshapeWorkload>(descriptor,
info);
998 return std::make_unique<NeonResizeWorkload>(descriptor,
info);
1004 return std::make_unique<NeonSliceWorkload>(descriptor,
info);
1010 return std::make_unique<NeonSoftmaxWorkload>(descriptor,
info, m_MemoryManager->GetIntraLayerManager());
1016 return std::make_unique<NeonSpaceToBatchNdWorkload>(descriptor,
info);
1022 return std::make_unique<NeonSpaceToDepthWorkload>(descriptor,
info);
1028 return std::make_unique<NeonSplitterWorkload>(descriptor,
info);
1034 return std::make_unique<NeonStackWorkload>(descriptor,
info);
1040 return std::make_unique<NeonStridedSliceWorkload>(descriptor,
info);
1046 return std::make_unique<NeonSubtractionWorkload>(descriptor,
info);
1052 return std::make_unique<NeonTransposeWorkload>(descriptor,
info);
1059 return std::make_unique<NeonTransposeConvolution2dWorkload>(descriptor,
info,
1060 m_MemoryManager->GetIntraLayerManager());
std::unique_ptr< IWorkload > CreateSubtraction(const SubtractionQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateElementwiseUnary(const ElementwiseUnaryQueueDescriptor &descriptor, const WorkloadInfo &info) const override
UnaryOperation m_Operation
Specifies the elementwiseUnary operation to execute.
std::unique_ptr< IWorkload > CreateStridedSlice(const StridedSliceQueueDescriptor &, const WorkloadInfo &) const override
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
std::unique_ptr< IWorkload > CreateInput(const InputQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateL2Normalization(const L2NormalizationQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateBatchNormalization(const BatchNormalizationQueueDescriptor &, const WorkloadInfo &) const override
std::vector< BackendOptions > ModelOptions
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 > CreatePooling2d(const Pooling2dQueueDescriptor &, const WorkloadInfo &) const override
std::array< unsigned int, MaxNumOfTensorDimensions > Coordinates
constexpr const char * NeonBackendId()
std::unique_ptr< IWorkload > CreateMean(const MeanQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreatePad(const PadQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateLstm(const LstmQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateDepthToSpace(const DepthToSpaceQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateLogSoftmax(const LogSoftmaxQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateComparison(const ComparisonQueueDescriptor &, const WorkloadInfo &) const override
bool IsFastMathEnabled() const
std::unique_ptr< IWorkload > CreateTranspose(const TransposeQueueDescriptor &, const WorkloadInfo &) const override
Copyright (c) 2021 ARM Limited and Contributors.
std::unique_ptr< ITensorHandle > CreateSubTensorHandle(ITensorHandle &parent, TensorShape const &subTensorShape, unsigned int const *subTensorOrigin) const override
unsigned int GetNumberOfThreads() const
std::unique_ptr< IWorkload > CreateDequantize(const DequantizeQueueDescriptor &, const WorkloadInfo &) const override
LayerDescriptor m_Parameters
std::unique_ptr< IWorkload > CreateSplitter(const SplitterQueueDescriptor &, const WorkloadInfo &) const override
LogicalBinaryOperation m_Operation
Specifies the logical operation to execute.
std::unique_ptr< IWorkload > CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateNormalization(const NormalizationQueueDescriptor &, const WorkloadInfo &) const override
The NeonBackendModelContext is used to pass in Neon specific backend ModelOptions.
std::unique_ptr< IWorkload > CreateDepthwiseConvolution2d(const DepthwiseConvolution2dQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateInstanceNormalization(const InstanceNormalizationQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateTransposeConvolution2d(const TransposeConvolution2dQueueDescriptor &, const WorkloadInfo &) const override
NeonWorkloadFactory(const std::shared_ptr< NeonMemoryManager > &memoryManager)
static bool IsLayerSupported(const Layer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
std::unique_ptr< IWorkload > CreateSpaceToDepth(const SpaceToDepthQueueDescriptor &, const WorkloadInfo &) const override
std::vector< TensorInfo > m_InputTensorInfos
std::unique_ptr< IWorkload > CreateConcat(const ConcatQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreatePrelu(const PreluQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateArgMinMax(const ArgMinMaxQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreatePermute(const PermuteQueueDescriptor &, const WorkloadInfo &) const override
std::shared_ptr< IBackendModelContext > IBackendSpecificModelContextPtr
std::unique_ptr< IWorkload > CreateDebug(const DebugQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateConstant(const ConstantQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateConvolution2d(const Convolution2dQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateFullyConnected(const FullyConnectedQueueDescriptor &, const WorkloadInfo &) const override
const BackendId & GetBackendId() const override
std::unique_ptr< IWorkload > CreateMinimum(const MinimumQueueDescriptor &, const WorkloadInfo &) const override
std::vector< TensorInfo > m_OutputTensorInfos
std::unique_ptr< IWorkload > CreateReshape(const ReshapeQueueDescriptor &, const WorkloadInfo &) const override
static bool IsLayerSupported(const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
std::unique_ptr< IWorkload > CreateFloor(const FloorQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateRank(const RankQueueDescriptor &, const WorkloadInfo &) const override
virtual TensorShape GetShape() const =0
Get the number of elements for each dimension ordered from slowest iterating dimension to fastest ite...
std::unique_ptr< IWorkload > CreateDetectionPostProcess(const DetectionPostProcessQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateQuantize(const QuantizeQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateAddition(const AdditionQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateGather(const GatherQueueDescriptor &, const WorkloadInfo &) const override
std::vector< ITensorHandle * > m_Outputs
std::unique_ptr< IWorkload > CreateDivision(const DivisionQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreatePreCompiled(const PreCompiledQueueDescriptor &, const WorkloadInfo &) const override
unsigned int GetNumDimensions() const
Function that returns the tensor rank.
std::unique_ptr< IWorkload > CreateWorkload(LayerType type, const QueueDescriptor &descriptor, const WorkloadInfo &info) const override
std::unique_ptr< IWorkload > CreateStack(const StackQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateOutput(const OutputQueueDescriptor &, const WorkloadInfo &) const override
Contains information about TensorInfos of a layer.
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 > CreateConvertFp16ToFp32(const ConvertFp16ToFp32QueueDescriptor &, const WorkloadInfo &) const override
std::vector< ITensorHandle * > m_Inputs
std::unique_ptr< IWorkload > CreateMultiplication(const MultiplicationQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateMaximum(const MaximumQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateActivation(const ActivationQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateMemImport(const MemImportQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< IWorkload > CreateMemCopy(const MemCopyQueueDescriptor &, const WorkloadInfo &) const override
Depthwise Convolution 2D layer workload data.
std::unique_ptr< IWorkload > CreateQuantizedLstm(const QuantizedLstmQueueDescriptor &, const WorkloadInfo &) const override
std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const override
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...