23 template <
typename F32Workload,
typename U8Workload,
typename QueueDescriptorType>
24 std::unique_ptr<IWorkload> RefWorkloadFactory::MakeWorkload(
const QueueDescriptorType& descriptor,
25 const WorkloadInfo& info)
const
27 return MakeWorkloadHelper<NullWorkload, F32Workload, U8Workload, NullWorkload, NullWorkload, NullWorkload>
31 template <DataType ArmnnType>
34 auto checkType = [](
const TensorInfo& tensorInfo) {
return tensorInfo.GetDataType() == ArmnnType;};
35 auto it = std::find_if(std::begin(
info.m_InputTensorInfos), std::end(
info.m_InputTensorInfos), checkType);
36 if (it != std::end(
info.m_InputTensorInfos))
40 it = std::find_if(std::begin(
info.m_OutputTensorInfos), std::end(
info.m_OutputTensorInfos), checkType);
41 if (it != std::end(
info.m_OutputTensorInfos))
50 return IsDataType<DataType::Signed32>(
info);
55 return IsDataType<DataType::BFloat16>(
info);
60 return IsDataType<DataType::Float16>(
info);
65 return IsDataType<DataType::QSymmS16>(
info);
70 return IsDataType<DataType::QSymmS8>(
info);
75 return IsDataType<DataType::QAsymmS8>(
info);
80 return IsDataType<DataType::QAsymmU8>(
info);
84 : m_MemoryManager(memoryManager)
100 std::string& outReasonIfUnsupported)
107 std::string& outReasonIfUnsupported,
114 const bool isMemoryManaged)
const
118 return std::make_unique<RefTensorHandle>(tensorInfo, m_MemoryManager);
122 return std::make_unique<RefTensorHandle>(tensorInfo);
128 const bool isMemoryManaged)
const
136 return std::make_unique<RefTensorHandle>(tensorInfo, m_MemoryManager);
140 return std::make_unique<RefTensorHandle>(tensorInfo);
152 auto activationQueueDescriptor = PolymorphicDowncast<const ActivationQueueDescriptor*>(&descriptor);
153 return std::make_unique<RefActivationWorkload>(*activationQueueDescriptor,
info);
157 auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
161 return std::make_unique<RefAdditionWorkload<int32_t>>(*additionQueueDescriptor,
info);
165 return std::make_unique<RefAdditionWorkload<float>>(*additionQueueDescriptor,
info);
170 auto argMinMaxQueueDescriptor = PolymorphicDowncast<const ArgMinMaxQueueDescriptor*>(&descriptor);
171 return std::make_unique<RefArgMinMaxWorkload>(*argMinMaxQueueDescriptor,
info);
175 auto batchMatMulQueueDescriptor = PolymorphicDowncast<const BatchMatMulQueueDescriptor*>(&descriptor);
176 return std::make_unique<RefBatchMatMulWorkload>(*batchMatMulQueueDescriptor,
info);
180 auto batchNormQueueDescriptor = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
181 return std::make_unique<RefBatchNormalizationWorkload>(*batchNormQueueDescriptor,
info);
185 auto batchToSpaceNdQueueDescriptor
186 = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
187 return std::make_unique<RefBatchToSpaceNdWorkload>(*batchToSpaceNdQueueDescriptor,
info);
191 auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
192 return std::make_unique<RefCastWorkload>(*castQueueDescriptor,
info);
196 auto channelShuffleQueueDescriptor
197 = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
198 return std::make_unique<RefChannelShuffleWorkload>(*channelShuffleQueueDescriptor,
info);
202 auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
203 return std::make_unique<RefComparisonWorkload>(*comparisonQueueDescriptor,
info);
207 auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
208 return std::make_unique<RefConcatWorkload>(*concatQueueDescriptor,
info);
212 auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
213 return std::make_unique<RefConstantWorkload>(*constantQueueDescriptor,
info);
217 auto convertFp16ToFp32QueueDescriptor
218 = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
219 return std::make_unique<RefConvertFp16ToFp32Workload>(*convertFp16ToFp32QueueDescriptor,
info);
223 auto convertFp32ToFp16QueueDescriptor
224 = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
225 return std::make_unique<RefConvertFp32ToFp16Workload>(*convertFp32ToFp16QueueDescriptor,
info);
229 auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
230 return std::make_unique<RefConvolution2dWorkload>(*convolution2dQueueDescriptor,
info);
234 auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
235 return std::make_unique<RefConvolution3dWorkload>(*convolution3dQueueDescriptor,
info);
239 auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
242 return std::make_unique<RefDebugBFloat16Workload>(*debugQueueDescriptor,
info);
246 return std::make_unique<RefDebugFloat16Workload>(*debugQueueDescriptor,
info);
250 return std::make_unique<RefDebugQSymmS16Workload>(*debugQueueDescriptor,
info);
254 return std::make_unique<RefDebugQSymmS8Workload>(*debugQueueDescriptor,
info);
258 return std::make_unique<RefDebugQAsymmU8Workload>(*debugQueueDescriptor,
info);
262 return std::make_unique<RefDebugQAsymmS8Workload>(*debugQueueDescriptor,
info);
266 return std::make_unique<RefDebugSigned32Workload>(*debugQueueDescriptor,
info);
269 return MakeWorkload<RefDebugFloat32Workload, RefDebugQAsymmU8Workload>(*debugQueueDescriptor,
info);
273 auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
274 return std::make_unique<RefDepthToSpaceWorkload>(*depthToSpaceQueueDescriptor,
info);
278 auto depthwiseConvolution2DQueueDescriptor
279 = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
280 return std::make_unique<RefDepthwiseConvolution2dWorkload>(*depthwiseConvolution2DQueueDescriptor,
info);
284 auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
285 return std::make_unique<RefDequantizeWorkload>(*dequantizeQueueDescriptor,
info);
289 auto detectionPostProcessQueueDescriptor
290 = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
291 return std::make_unique<RefDetectionPostProcessWorkload>(*detectionPostProcessQueueDescriptor,
info);
295 auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
298 return std::make_unique<RefDivisionWorkload<int32_t>>(*divisionQueueDescriptor,
info);
302 return std::make_unique<RefDivisionWorkload<float>>(*divisionQueueDescriptor,
info);
307 auto elementwiseUnaryQueueDescriptor
308 = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
311 return std::make_unique<RefLogicalUnaryWorkload>(*elementwiseUnaryQueueDescriptor,
info);
313 return std::make_unique<RefElementwiseUnaryWorkload>(*elementwiseUnaryQueueDescriptor,
info);
317 auto fakeQuantizationQueueDescriptor
318 = PolymorphicDowncast<const FakeQuantizationQueueDescriptor*>(&descriptor);
319 return std::make_unique<RefFakeQuantizationFloat32Workload>(*fakeQuantizationQueueDescriptor,
info);
323 auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
324 return std::make_unique<RefFillWorkload>(*fillQueueDescriptor,
info);
328 auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
335 return std::make_unique<RefFloorWorkload>(*floorQueueDescriptor,
info);
340 auto fullyConnectedQueueDescriptor
341 = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
342 return std::make_unique<RefFullyConnectedWorkload>(*fullyConnectedQueueDescriptor,
info);
346 auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
347 return std::make_unique<RefGatherWorkload>(*gatherQueueDescriptor,
info);
351 auto gatherNdQueueDescriptor = PolymorphicDowncast<const GatherNdQueueDescriptor*>(&descriptor);
352 return std::make_unique<RefGatherNdWorkload>(*gatherNdQueueDescriptor,
info);
356 auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
357 if (
info.m_InputTensorInfos.empty() )
361 if (
info.m_OutputTensorInfos.empty())
366 if (
info.m_InputTensorInfos[0].GetNumBytes() !=
info.m_OutputTensorInfos[0].GetNumBytes())
369 "data input and output differ in byte count.");
372 return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor,
info);
376 auto instanceNormalizationQueueDescriptor
377 = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
378 return std::make_unique<RefInstanceNormalizationWorkload>(*instanceNormalizationQueueDescriptor,
info);
382 auto l2NormalizationQueueDescriptor
383 = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
384 return std::make_unique<RefL2NormalizationWorkload>(*l2NormalizationQueueDescriptor,
info);
388 auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
389 return std::make_unique<RefLogicalBinaryWorkload>(*logicalBinaryQueueDescriptor,
info);
393 auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
394 return std::make_unique<RefLogSoftmaxWorkload>(*logSoftmaxQueueDescriptor,
info);
398 auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
399 return std::make_unique<RefLstmWorkload>(*lstmQueueDescriptor,
info);
403 auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
406 return std::make_unique<RefMaximumWorkload<int32_t>>(*maximumQueueDescriptor,
info);
410 return std::make_unique<RefMaximumWorkload<float>>(*maximumQueueDescriptor,
info);
415 auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
416 return std::make_unique<RefMeanWorkload>(*meanQueueDescriptor,
info);
420 auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
425 return std::make_unique<CopyMemGenericWorkload>(*memCopyQueueDescriptor,
info);
429 auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
434 return std::make_unique<ImportMemGenericWorkload>(*memImportQueueDescriptor,
info);
438 auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
441 return std::make_unique<RefMinimumWorkload<int32_t>>(*minimumQueueDescriptor,
info);
445 return std::make_unique<RefMinimumWorkload<float>>(*minimumQueueDescriptor,
info);
450 auto multiplicationQueueDescriptor
451 = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
454 return std::make_unique<RefMultiplicationWorkload<int32_t>>(*multiplicationQueueDescriptor,
info);
458 return std::make_unique<RefMultiplicationWorkload<float>>(*multiplicationQueueDescriptor,
info);
463 auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
464 return std::make_unique<RefNormalizationWorkload>(*normalizationQueueDescriptor,
info);
468 auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
469 if (
info.m_InputTensorInfos.empty() )
473 if (
info.m_OutputTensorInfos.empty())
477 if (
info.m_InputTensorInfos[0].GetNumBytes() !=
info.m_OutputTensorInfos[0].GetNumBytes())
480 "differ in byte count.");
483 return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor,
info);
487 auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
488 return std::make_unique<RefPadWorkload>(*padQueueDescriptor,
info);
492 auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
495 return std::make_unique<RefPermuteQSymm16Workload>(*permuteQueueDescriptor,
info);
499 return std::make_unique<RefPermuteBFloat16Workload>(*permuteQueueDescriptor,
info);
503 return std::make_unique<RefPermuteQAsymmS8Workload>(*permuteQueueDescriptor,
info);
510 auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
511 return std::make_unique<RefPooling2dWorkload>(*pooling2dQueueDescriptor,
info);
515 auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
516 return std::make_unique<RefPooling3dWorkload>(*pooling3dQueueDescriptor,
info);
524 auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
525 return std::make_unique<RefPreluWorkload>(*preluQueueDescriptor,
info);
529 auto qlstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
530 return std::make_unique<RefQLstmWorkload>(*qlstmQueueDescriptor,
info);
534 auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
535 return std::make_unique<RefQuantizeWorkload>(*quantizeQueueDescriptor,
info);
539 auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
540 return std::make_unique<RefRankWorkload>(*rankQueueDescriptor,
info);
544 auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
545 return std::make_unique<RefReduceWorkload>(*reduceQueueDescriptor,
info);
549 auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
550 return std::make_unique<RefReshapeWorkload>(*reshapeQueueDescriptor,
info);
554 auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
555 return std::make_unique<RefResizeWorkload>(*resizeQueueDescriptor,
info);
559 auto shapeQueueDescriptor = PolymorphicDowncast<const ShapeQueueDescriptor*>(&descriptor);
560 return std::make_unique<RefShapeWorkload>(*shapeQueueDescriptor,
info);
564 auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
565 return std::make_unique<RefSliceWorkload>(*sliceQueueDescriptor,
info);
569 auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
570 return std::make_unique<RefSoftmaxWorkload>(*softmaxQueueDescriptor,
info);
574 auto spaceToBatchNdQueueDescriptor
575 = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
576 return std::make_unique<RefSpaceToBatchNdWorkload>(*spaceToBatchNdQueueDescriptor,
info);
580 auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
581 return std::make_unique<RefSpaceToDepthWorkload>(*spaceToDepthQueueDescriptor,
info);
585 auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
586 return std::make_unique<RefSplitterWorkload>(*splitterQueueDescriptor,
info);
590 auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
591 return std::make_unique<RefStackWorkload>(*stackQueueDescriptor,
info);
595 auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
596 return std::make_unique<RefStridedSliceWorkload>(*stridedSliceQueueDescriptor,
info);
600 auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
603 return std::make_unique<RefSubtractionWorkload<int32_t>>(*subtractionQueueDescriptor,
info);
607 return std::make_unique<RefSubtractionWorkload<float>>(*subtractionQueueDescriptor,
info);
612 auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
615 return std::make_unique<RefTransposeQSymm16Workload>(*transposeQueueDescriptor,
info);
619 return std::make_unique<RefTransposeBFloat16Workload>(*transposeQueueDescriptor,
info);
623 return std::make_unique<RefTransposeQAsymmS8Workload>(*transposeQueueDescriptor,
info);
627 (*transposeQueueDescriptor,
info);
631 auto transposeConvolution2dQueueDescriptor
632 = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
633 return std::make_unique<RefTransposeConvolution2dWorkload>(*transposeConvolution2dQueueDescriptor,
info);
637 auto unidirectionalSequenceLstmQueueDescriptor
638 = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
639 return std::make_unique<RefUnidirectionalSequenceLstmWorkload>(*unidirectionalSequenceLstmQueueDescriptor,
650 return std::make_unique<RefActivationWorkload>(descriptor, info);
653 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateAddition(
const AdditionQueueDescriptor& descriptor,
654 const WorkloadInfo& info)
const
658 return std::make_unique<RefAdditionWorkload<int32_t>>(descriptor, info);
662 return std::make_unique<RefAdditionWorkload<float>>(descriptor,
info);
666 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateArgMinMax(
const ArgMinMaxQueueDescriptor& descriptor,
667 const WorkloadInfo& info)
const
669 return std::make_unique<RefArgMinMaxWorkload>(descriptor, info);
672 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateBatchNormalization(
673 const BatchNormalizationQueueDescriptor& descriptor,
674 const WorkloadInfo& info)
const
676 return std::make_unique<RefBatchNormalizationWorkload>(descriptor, info);
679 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateBatchToSpaceNd(
const BatchToSpaceNdQueueDescriptor& descriptor,
680 const WorkloadInfo& info)
const
682 return std::make_unique<RefBatchToSpaceNdWorkload>(descriptor, info);
685 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateCast(
const CastQueueDescriptor& descriptor,
686 const WorkloadInfo& info)
const
688 return std::make_unique<RefCastWorkload>(descriptor, info);
691 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateChannelShuffle(
const ChannelShuffleQueueDescriptor &descriptor,
692 const WorkloadInfo &info)
const
694 return std::make_unique<RefChannelShuffleWorkload>(descriptor,info);
697 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateComparison(
const ComparisonQueueDescriptor& descriptor,
698 const WorkloadInfo& info)
const
700 return std::make_unique<RefComparisonWorkload>(descriptor, info);
703 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConcat(
const ConcatQueueDescriptor& descriptor,
704 const WorkloadInfo& info)
const
706 return std::make_unique<RefConcatWorkload>(descriptor, info);
709 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConstant(
const ConstantQueueDescriptor& descriptor,
710 const WorkloadInfo& info)
const
712 return std::make_unique<RefConstantWorkload>(descriptor, info);
715 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvertFp16ToFp32(
716 const ConvertFp16ToFp32QueueDescriptor& descriptor,
717 const WorkloadInfo& info)
const
719 return std::make_unique<RefConvertFp16ToFp32Workload>(descriptor, info);
722 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvertFp32ToFp16(
723 const ConvertFp32ToFp16QueueDescriptor& descriptor,
724 const WorkloadInfo& info)
const
726 return std::make_unique<RefConvertFp32ToFp16Workload>(descriptor, info);
729 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvolution2d(
const Convolution2dQueueDescriptor& descriptor,
730 const WorkloadInfo& info)
const
732 return std::make_unique<RefConvolution2dWorkload>(descriptor, info);
735 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateConvolution3d(
const Convolution3dQueueDescriptor& descriptor,
736 const WorkloadInfo& info)
const
738 return std::make_unique<RefConvolution3dWorkload>(descriptor, info);
741 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDebug(
const DebugQueueDescriptor& descriptor,
742 const WorkloadInfo& info)
const
746 return std::make_unique<RefDebugBFloat16Workload>(descriptor, info);
750 return std::make_unique<RefDebugFloat16Workload>(descriptor, info);
754 return std::make_unique<RefDebugQSymmS16Workload>(descriptor, info);
758 return std::make_unique<RefDebugQSymmS8Workload>(descriptor, info);
762 return std::make_unique<RefDebugQAsymmU8Workload>(descriptor, info);
766 return std::make_unique<RefDebugQAsymmS8Workload>(descriptor, info);
770 return std::make_unique<RefDebugSigned32Workload>(descriptor, info);
773 return MakeWorkload<RefDebugFloat32Workload, RefDebugQAsymmU8Workload>(descriptor, info);
776 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDepthToSpace(
const DepthToSpaceQueueDescriptor& descriptor,
777 const WorkloadInfo& info)
const
779 return std::make_unique<RefDepthToSpaceWorkload>(descriptor, info);
782 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDepthwiseConvolution2d(
783 const DepthwiseConvolution2dQueueDescriptor& descriptor,
784 const WorkloadInfo& info)
const
786 return std::make_unique<RefDepthwiseConvolution2dWorkload>(descriptor, info);
789 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDequantize(
const DequantizeQueueDescriptor& descriptor,
790 const WorkloadInfo& info)
const
792 return std::make_unique<RefDequantizeWorkload>(descriptor, info);
795 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDetectionPostProcess(
796 const DetectionPostProcessQueueDescriptor& descriptor,
797 const WorkloadInfo& info)
const
799 return std::make_unique<RefDetectionPostProcessWorkload>(descriptor, info);
802 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateDivision(
const DivisionQueueDescriptor& descriptor,
803 const WorkloadInfo& info)
const
807 return std::make_unique<RefDivisionWorkload<int32_t>>(descriptor,
info);
811 return std::make_unique<RefDivisionWorkload<float>>(descriptor,
info);
815 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateElementwiseUnary(
const ElementwiseUnaryQueueDescriptor& descriptor,
816 const WorkloadInfo& info)
const
820 return std::make_unique<RefLogicalUnaryWorkload>(descriptor, info);
822 return std::make_unique<RefElementwiseUnaryWorkload>(descriptor, info);
825 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFakeQuantization(
const FakeQuantizationQueueDescriptor& descriptor,
826 const WorkloadInfo& info)
const
828 return MakeWorkload<RefFakeQuantizationFloat32Workload, NullWorkload>(descriptor, info);
831 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFill(
const FillQueueDescriptor& descriptor,
832 const WorkloadInfo& info)
const
834 return std::make_unique<RefFillWorkload>(descriptor, info);
837 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFloor(
const FloorQueueDescriptor& descriptor,
838 const WorkloadInfo& info)
const
846 return std::make_unique<RefFloorWorkload>(descriptor, info);
850 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFullyConnected(
851 const FullyConnectedQueueDescriptor& descriptor,
852 const WorkloadInfo& info)
const
854 return std::make_unique<RefFullyConnectedWorkload>(descriptor, info);
857 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateGather(
const GatherQueueDescriptor& descriptor,
858 const WorkloadInfo& info)
const
860 return std::make_unique<RefGatherWorkload>(descriptor, info);
863 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateInput(
const InputQueueDescriptor& descriptor,
864 const WorkloadInfo& info)
const
866 if (
info.m_InputTensorInfos.empty() )
868 throw InvalidArgumentException(
"RefWorkloadFactory::CreateInput: Input cannot be zero length");
870 if (
info.m_OutputTensorInfos.empty())
872 throw InvalidArgumentException(
"RefWorkloadFactory::CreateInput: Output cannot be zero length");
875 if (
info.m_InputTensorInfos[0].GetNumBytes() !=
info.m_OutputTensorInfos[0].GetNumBytes())
877 throw InvalidArgumentException(
"RefWorkloadFactory::CreateInput: data input and output differ in byte count.");
880 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
883 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateInstanceNormalization(
884 const InstanceNormalizationQueueDescriptor& descriptor,
885 const WorkloadInfo& info)
const
887 return std::make_unique<RefInstanceNormalizationWorkload>(descriptor, info);
890 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateL2Normalization(
const L2NormalizationQueueDescriptor& descriptor,
891 const WorkloadInfo& info)
const
893 return std::make_unique<RefL2NormalizationWorkload>(descriptor, info);
896 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateLogicalBinary(
const LogicalBinaryQueueDescriptor& descriptor,
897 const WorkloadInfo& info)
const
899 return std::make_unique<RefLogicalBinaryWorkload>(descriptor, info);
902 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateLogSoftmax(
const LogSoftmaxQueueDescriptor& descriptor,
903 const WorkloadInfo& info)
const
905 return std::make_unique<RefLogSoftmaxWorkload>(descriptor, info);
908 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateLstm(
const LstmQueueDescriptor& descriptor,
909 const WorkloadInfo& info)
const
911 return std::make_unique<RefLstmWorkload>(descriptor, info);
914 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMaximum(
const MaximumQueueDescriptor& descriptor,
915 const WorkloadInfo& info)
const
919 return std::make_unique<RefMaximumWorkload<int32_t>>(descriptor,
info);
923 return std::make_unique<RefMaximumWorkload<float>>(descriptor,
info);
927 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMean(
const MeanQueueDescriptor& descriptor,
928 const WorkloadInfo& info)
const
930 return std::make_unique<RefMeanWorkload>(descriptor, info);
933 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMemCopy(
const MemCopyQueueDescriptor& descriptor,
934 const WorkloadInfo& info)
const
936 if (descriptor.m_Inputs.empty())
938 throw InvalidArgumentException(
"RefWorkloadFactory: CreateMemCopy() expected an input tensor.");
940 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
943 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMemImport(
const MemImportQueueDescriptor& descriptor,
944 const WorkloadInfo& info)
const
946 if (descriptor.m_Inputs.empty())
948 throw InvalidArgumentException(
"RefWorkloadFactory: CreateMemImport() expected an input tensor.");
950 return std::make_unique<ImportMemGenericWorkload>(descriptor, info);
953 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMinimum(
const MinimumQueueDescriptor& descriptor,
954 const WorkloadInfo& info)
const
958 return std::make_unique<RefMinimumWorkload<int32_t>>(descriptor,
info);
962 return std::make_unique<RefMinimumWorkload<float>>(descriptor,
info);
966 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateMultiplication(
const MultiplicationQueueDescriptor& descriptor,
967 const WorkloadInfo& info)
const
971 return std::make_unique<RefMultiplicationWorkload<int32_t>>(descriptor,
info);
975 return std::make_unique<RefMultiplicationWorkload<float>>(descriptor,
info);
979 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateNormalization(
const NormalizationQueueDescriptor& descriptor,
980 const WorkloadInfo& info)
const
982 return std::make_unique<RefNormalizationWorkload>(descriptor, info);
986 const WorkloadInfo& info)
const
988 if (
info.m_InputTensorInfos.empty() )
990 throw InvalidArgumentException(
"RefWorkloadFactory::CreateOutput: Input cannot be zero length");
992 if (
info.m_OutputTensorInfos.empty())
994 throw InvalidArgumentException(
"RefWorkloadFactory::CreateOutput: Output cannot be zero length");
996 if (
info.m_InputTensorInfos[0].GetNumBytes() !=
info.m_OutputTensorInfos[0].GetNumBytes())
998 throw InvalidArgumentException(
"RefWorkloadFactory::CreateOutput: data input and output differ in byte count.");
1001 return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
1004 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePad(
const PadQueueDescriptor& descriptor,
1005 const WorkloadInfo& info)
const
1007 return std::make_unique<RefPadWorkload>(descriptor, info);
1010 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePermute(
const PermuteQueueDescriptor& descriptor,
1011 const WorkloadInfo& info)
const
1015 return std::make_unique<RefPermuteQSymm16Workload>(descriptor, info);
1019 return std::make_unique<RefPermuteBFloat16Workload>(descriptor, info);
1023 return std::make_unique<RefPermuteQAsymmS8Workload>(descriptor, info);
1026 NullWorkload, NullWorkload, NullWorkload>(descriptor,
info);
1029 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePooling2d(
const Pooling2dQueueDescriptor& descriptor,
1030 const WorkloadInfo& info)
const
1032 return std::make_unique<RefPooling2dWorkload>(descriptor, info);
1035 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePooling3d(
const Pooling3dQueueDescriptor& descriptor,
1036 const WorkloadInfo& info)
const
1038 return std::make_unique<RefPooling3dWorkload>(descriptor, info);
1041 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePreCompiled(
const PreCompiledQueueDescriptor& ,
1042 const WorkloadInfo& )
const
1047 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePrelu(
const PreluQueueDescriptor& descriptor,
1048 const WorkloadInfo& info)
const
1050 return std::make_unique<RefPreluWorkload>(descriptor, info);
1053 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateQLstm(
const QLstmQueueDescriptor& descriptor,
1054 const WorkloadInfo& info)
const
1056 return std::make_unique<RefQLstmWorkload>(descriptor, info);
1059 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateQuantize(
const QuantizeQueueDescriptor& descriptor,
1060 const WorkloadInfo& info)
const
1062 return std::make_unique<RefQuantizeWorkload>(descriptor, info);
1065 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateRank(
const RankQueueDescriptor& descriptor,
1066 const WorkloadInfo& info)
const
1068 return std::make_unique<RefRankWorkload>(descriptor, info);
1071 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateReduce(
const ReduceQueueDescriptor& descriptor,
1072 const WorkloadInfo& info)
const
1074 return std::make_unique<RefReduceWorkload>(descriptor, info);
1077 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateReshape(
const ReshapeQueueDescriptor& descriptor,
1078 const WorkloadInfo& info)
const
1080 return std::make_unique<RefReshapeWorkload>(descriptor, info);
1083 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateResize(
const ResizeQueueDescriptor& descriptor,
1084 const WorkloadInfo& info)
const
1086 return std::make_unique<RefResizeWorkload>(descriptor, info);
1089 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateShape(
const ShapeQueueDescriptor& descriptor,
1090 const WorkloadInfo& info)
const
1092 return std::make_unique<RefShapeWorkload>(descriptor, info);
1095 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSlice(
const SliceQueueDescriptor& descriptor,
1096 const WorkloadInfo& info)
const
1098 return std::make_unique<RefSliceWorkload>(descriptor, info);
1101 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSoftmax(
const SoftmaxQueueDescriptor& descriptor,
1102 const WorkloadInfo& info)
const
1104 return std::make_unique<RefSoftmaxWorkload>(descriptor, info);
1107 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSpaceToBatchNd(
const SpaceToBatchNdQueueDescriptor& descriptor,
1108 const WorkloadInfo& info)
const
1110 return std::make_unique<RefSpaceToBatchNdWorkload>(descriptor, info);
1113 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSpaceToDepth(
const SpaceToDepthQueueDescriptor& descriptor,
1114 const WorkloadInfo& info)
const
1116 return std::make_unique<RefSpaceToDepthWorkload>(descriptor, info);
1119 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSplitter(
const SplitterQueueDescriptor& descriptor,
1120 const WorkloadInfo& info)
const
1122 return std::make_unique<RefSplitterWorkload>(descriptor, info);
1125 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateStack(
const StackQueueDescriptor& descriptor,
1126 const WorkloadInfo& info)
const
1128 return std::make_unique<RefStackWorkload>(descriptor, info);
1131 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateStridedSlice(
const StridedSliceQueueDescriptor& descriptor,
1132 const WorkloadInfo& info)
const
1134 return std::make_unique<RefStridedSliceWorkload>(descriptor, info);
1137 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSubtraction(
const SubtractionQueueDescriptor& descriptor,
1138 const WorkloadInfo& info)
const
1142 return std::make_unique<RefSubtractionWorkload<int32_t>>(descriptor,
info);
1146 return std::make_unique<RefSubtractionWorkload<float>>(descriptor,
info);
1150 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateTranspose(
const TransposeQueueDescriptor& descriptor,
1151 const WorkloadInfo& info)
const
1155 return std::make_unique<RefTransposeQSymm16Workload>(descriptor, info);
1159 return std::make_unique<RefTransposeBFloat16Workload>(descriptor, info);
1163 return std::make_unique<RefTransposeQAsymmS8Workload>(descriptor, info);
1166 NullWorkload, NullWorkload, NullWorkload>(descriptor,
info);
1169 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateTransposeConvolution2d(
1170 const TransposeConvolution2dQueueDescriptor& descriptor,
1171 const WorkloadInfo& info)
const
1173 return std::make_unique<RefTransposeConvolution2dWorkload>(descriptor, info);
1176 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateUnidirectionalSequenceLstm(
1177 const UnidirectionalSequenceLstmQueueDescriptor& descriptor,
1178 const WorkloadInfo& info)
const
1180 return std::make_unique<RefUnidirectionalSequenceLstmWorkload>(descriptor, info);;