29 std::initializer_list<unsigned int> expectedDimensions)
31 return CompareTensorHandleShape<IAclTensorHandle>(tensorHandle, expectedDimensions);
38 const arm_compute::ITensorInfo* handleInfo = handle->
GetTensor().info();
39 const arm_compute::TensorInfo expectedAclInfo = BuildArmComputeTensorInfo(expectedInfo);
41 if (handleInfo->data_type() != expectedAclInfo.data_type())
46 if (handleInfo->num_dimensions() != expectedAclInfo.num_dimensions())
51 if (handleInfo->quantization_info() != expectedAclInfo.quantization_info())
56 for (std::size_t d = 0; d < expectedAclInfo.num_dimensions(); ++d)
58 if (handleInfo->dimension(d) != expectedAclInfo.dimension(d))
69 template <
typename armnn::DataType DataType>
70 static void NeonCreateActivationWorkloadTest()
74 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
76 auto workload = CreateActivationWorkloadTest<NeonActivationWorkload, DataType>(factory, graph);
80 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
81 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
86 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 87 TEST_CASE(
"CreateActivationFloat16Workload")
89 NeonCreateActivationWorkloadTest<DataType::Float16>();
93 TEST_CASE(
"CreateActivationFloatWorkload")
95 NeonCreateActivationWorkloadTest<DataType::Float32>();
98 template <
typename WorkloadType,
99 typename DescriptorType,
102 static void NeonCreateElementwiseWorkloadTest()
106 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
108 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
110 DescriptorType queueDescriptor = workload->GetData();
111 auto inputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
112 auto inputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
113 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
119 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 120 TEST_CASE(
"CreateAdditionFloat16Workload")
129 TEST_CASE(
"CreateAdditionFloatWorkload")
137 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 138 TEST_CASE(
"CreateSubtractionFloat16Workload")
147 TEST_CASE(
"CreateSubtractionFloatWorkload")
155 TEST_CASE(
"CreateSubtractionUint8Workload")
163 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 164 TEST_CASE(
"CreateMultiplicationFloat16Workload")
173 TEST_CASE(
"CreateMultiplicationFloatWorkload")
181 TEST_CASE(
"CreateMultiplicationUint8Workload")
189 TEST_CASE(
"CreateDivisionFloatWorkloadTest")
197 template <
typename BatchNormalizationWorkloadType,
typename armnn::DataType DataType>
198 static void NeonCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
202 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
204 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
205 (factory, graph, dataLayout);
209 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
210 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
219 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 220 TEST_CASE(
"CreateBatchNormalizationFloat16NchwWorkload")
222 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NCHW);
225 TEST_CASE(
"CreateBatchNormalizationFloat16NhwcWorkload")
227 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NHWC);
231 TEST_CASE(
"CreateBatchNormalizationFloatNchwWorkload")
233 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NCHW);
236 TEST_CASE(
"CreateBatchNormalizationFloatNhwcWorkload")
238 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NHWC);
241 template <
typename armnn::DataType DataType>
246 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
248 auto workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload, DataType>(factory, graph, dataLayout);
255 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
256 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
261 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 262 TEST_CASE(
"CreateConvolution2dFloat16NchwWorkload")
264 NeonCreateConvolution2dWorkloadTest<DataType::Float16>();
267 TEST_CASE(
"CreateConvolution2dFloat16NhwcWorkload")
273 TEST_CASE(
"CreateConvolution2dFloatNchwWorkload")
275 NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
278 TEST_CASE(
"CreateConvolution2dFloatNhwcWorkload")
283 TEST_CASE(
"CreateConvolution2dFastMathEnabledWorkload")
290 {
"FastMathEnabled",
true }
292 modelOptions.push_back(cpuAcc);
294 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
297 CreateConvolution2dWorkloadFastMathTest<NeonConvolution2dWorkload, armnn::DataType::Float32>(factory,
303 auto conv2dWorkload = PolymorphicDowncast<NeonConvolution2dWorkload*>(workload.get());
306 ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
309 template <
typename armnn::DataType DataType>
310 static void NeonCreateDepthWiseConvolutionWorkloadTest(
DataLayout dataLayout)
314 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
317 DataType>(factory, graph, dataLayout);
321 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
322 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
325 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
327 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
333 TEST_CASE(
"CreateDepthWiseConvolution2dFloat32NhwcWorkload")
335 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(
DataLayout::NHWC);
338 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 339 TEST_CASE(
"CreateDepthWiseConvolution2dFloat16NhwcWorkload")
341 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float16>(
DataLayout::NHWC);
345 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
346 static void NeonCreateFullyConnectedWorkloadTest()
350 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
352 auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
356 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
357 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
362 CHECK(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({3, 1, 4, 5},
DataType, inputsQScale)));
363 CHECK(TestNeonTensorHandleInfo(outputHandle,
TensorInfo({3, 7},
DataType, outputQScale)));
366 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 367 TEST_CASE(
"CreateFullyConnectedFloat16Workload")
369 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float16>();
373 TEST_CASE(
"CreateFullyConnectedFloatWorkload")
375 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
378 TEST_CASE(
"CreateFullyConnectedQAsymmU8Workload")
380 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmU8>();
383 TEST_CASE(
"CreateFullyConnectedQAsymmS8Workload")
385 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmS8>();
388 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
389 static void NeonCreateNormalizationWorkloadTest(
DataLayout dataLayout)
393 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
395 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
399 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
400 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
409 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 410 TEST_CASE(
"CreateNormalizationFloat16NchwWorkload")
412 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
415 TEST_CASE(
"CreateNormalizationFloat16NhwcWorkload")
417 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
421 TEST_CASE(
"CreateNormalizationFloatNchwWorkload")
423 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
426 TEST_CASE(
"CreateNormalizationFloatNhwcWorkload")
428 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
432 template <
typename armnn::DataType DataType>
433 static void NeonCreatePooling2dWorkloadTest(
DataLayout dataLayout = DataLayout::NCHW)
437 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
439 auto workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>(factory, graph, dataLayout);
446 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
447 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
452 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 453 TEST_CASE(
"CreatePooling2dFloat16Workload")
455 NeonCreatePooling2dWorkloadTest<DataType::Float16>();
459 TEST_CASE(
"CreatePooling2dFloatNchwWorkload")
464 TEST_CASE(
"CreatePooling2dFloatNhwcWorkload")
469 TEST_CASE(
"CreatePooling2dUint8NchwWorkload")
474 TEST_CASE(
"CreatePooling2dUint8NhwcWorkload")
486 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
488 auto workload = CreatePreluWorkloadTest<NeonPreluWorkload>(factory,
497 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
498 auto alphaHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
499 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
500 CHECK(TestNeonTensorHandleInfo(inputHandle,
TensorInfo(inputShape, dataType)));
501 CHECK(TestNeonTensorHandleInfo(alphaHandle,
TensorInfo(alphaShape, dataType)));
502 CHECK(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape, dataType)));
505 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 506 TEST_CASE(
"CreatePreluFloat16Workload")
508 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
512 TEST_CASE(
"CreatePreluFloatWorkload")
514 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
517 TEST_CASE(
"CreatePreluUint8Workload")
519 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
522 template <
typename armnn::DataType DataType>
523 static void NeonCreateReshapeWorkloadTest()
527 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
529 auto workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
533 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
534 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
539 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 540 TEST_CASE(
"CreateReshapeFloat16Workload")
542 NeonCreateReshapeWorkloadTest<DataType::Float16>();
546 TEST_CASE(
"CreateReshapeFloatWorkload")
548 NeonCreateReshapeWorkloadTest<DataType::Float32>();
551 TEST_CASE(
"CreateReshapeUint8Workload")
553 NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
556 template <
typename ResizeWorkloadType, armnn::DataType DataType>
557 static void NeonCreateResizeWorkloadTest(
DataLayout dataLayout)
561 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
562 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
564 auto queueDescriptor = workload->GetData();
566 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
567 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
573 predResult = CompareIAclTensorHandleShape(inputHandle, { 2, 4, 4, 3 });
574 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
575 predResult = CompareIAclTensorHandleShape(outputHandle, { 2, 2, 2, 3 });
576 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
579 predResult = CompareIAclTensorHandleShape(inputHandle, { 2, 3, 4, 4 });
580 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
581 predResult = CompareIAclTensorHandleShape(outputHandle, { 2, 3, 2, 2 });
582 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
586 TEST_CASE(
"CreateResizeFloat32NchwWorkload")
588 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
591 TEST_CASE(
"CreateResizeUint8NchwWorkload")
593 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
596 TEST_CASE(
"CreateResizeFloat32NhwcWorkload")
598 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
601 TEST_CASE(
"CreateResizeUint8NhwcWorkload")
603 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
606 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
607 static void NeonCreateSoftmaxWorkloadTest()
611 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
613 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
617 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
618 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
623 tensorInfo.SetQuantizationScale(1.f / 256);
627 tensorInfo.SetQuantizationOffset(-128);
628 tensorInfo.SetQuantizationScale(1.f / 256);
630 CHECK(TestNeonTensorHandleInfo(inputHandle, tensorInfo));
631 CHECK(TestNeonTensorHandleInfo(outputHandle, tensorInfo));
634 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 635 TEST_CASE(
"CreateSoftmaxFloat16Workload")
637 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float16>();
641 TEST_CASE(
"CreateSoftmaxFloatWorkload")
643 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float32>();
646 TEST_CASE(
"CreateSoftmaxQAsymmU8Workload")
648 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmU8>();
651 TEST_CASE(
"CreateSoftmaxQAsymmS8Workload")
653 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmS8>();
656 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
657 static void NeonSpaceToDepthWorkloadTest()
661 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
663 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
666 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
667 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
673 TEST_CASE(
"CreateSpaceToDepthFloat32Workload")
675 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
678 TEST_CASE(
"CreateSpaceToDepthFloat16Workload")
680 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
683 TEST_CASE(
"CreateSpaceToDepthQAsymm8Workload")
685 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
688 TEST_CASE(
"CreateSpaceToDepthQSymm16Workload")
690 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
693 TEST_CASE(
"CreateSplitterWorkload")
697 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
699 auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
703 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
706 auto outputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
709 auto outputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
712 auto outputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
716 TEST_CASE(
"CreateSplitterConcat")
726 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
732 auto wlSplitter = std::move(workloads.first);
733 auto wlConcat = std::move(workloads.second);
746 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
748 CHECK(validDataPointers);
751 TEST_CASE(
"CreateSingleOutputMultipleInputs")
758 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
760 std::unique_ptr<NeonSplitterWorkload> wlSplitter;
761 std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
762 std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
763 std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
764 std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
766 CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterWorkload,
768 wlActiv1_0, wlActiv1_1);
785 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
786 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
788 CHECK(validDataPointers);
791 #if defined(ARMNNREF_ENABLED) 795 TEST_CASE(
"CreateMemCopyWorkloadsNeon")
798 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
799 CreateMemCopyWorkloads<IAclTensorHandle>(factory);
804 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
805 static void NeonCreateL2NormalizationWorkloadTest(
DataLayout dataLayout)
809 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
812 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
816 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
817 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
828 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 829 TEST_CASE(
"CreateL2NormalizationFloat16NchwWorkload")
831 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
834 TEST_CASE(
"CreateL2NormalizationFloat16NhwcWorkload")
836 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
840 TEST_CASE(
"CreateL2NormalizationNchwWorkload")
842 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
845 TEST_CASE(
"CreateL2NormalizationNhwcWorkload")
847 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
850 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
851 static void NeonCreateLogSoftmaxWorkloadTest()
855 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
857 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
861 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
862 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
865 CHECK(TestNeonTensorHandleInfo(inputHandle, tensorInfo));
866 CHECK(TestNeonTensorHandleInfo(outputHandle, tensorInfo));
869 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 870 TEST_CASE(
"CreateLogSoftmaxFloat16Workload")
872 NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float16>();
876 TEST_CASE(
"CreateLogSoftmaxFloatWorkload")
878 NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float32>();
881 template <
typename LstmWorkloadType>
882 static void NeonCreateLstmWorkloadTest()
886 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
888 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
892 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
893 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
899 TEST_CASE(
"CreateLSTMWorkloadFloatWorkload")
901 NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
904 template <
typename ConcatWorkloadType, armnn::DataType DataType>
905 static void NeonCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
906 unsigned int concatAxis)
910 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
912 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
915 auto inputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
916 auto inputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
917 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
924 TEST_CASE(
"CreateConcatDim0Float32Workload")
926 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
929 TEST_CASE(
"CreateConcatDim1Float32Workload")
931 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
934 TEST_CASE(
"CreateConcatDim3Float32Workload")
936 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
939 TEST_CASE(
"CreateConcatDim0Uint8Workload")
941 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
944 TEST_CASE(
"CreateConcatDim1Uint8Workload")
946 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
949 TEST_CASE(
"CreateConcatDim3Uint8Workload")
951 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
954 template <armnn::DataType DataType>
955 static void NeonCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
956 const std::initializer_list<unsigned int>& outputShape,
958 unsigned int numInputs)
962 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
964 auto workload = CreateStackWorkloadTest<NeonStackWorkload, DataType>(factory,
973 for (
unsigned int i = 0; i < numInputs; ++i)
975 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[i]);
978 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
982 TEST_CASE(
"CreateStackFloat32Workload")
984 NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
987 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 988 TEST_CASE(
"CreateStackFloat16Workload")
990 NeonCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
994 TEST_CASE(
"CreateStackUint8Workload")
996 NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
999 template <
typename QuantizedLstmWorkloadType>
1000 static void NeonCreateQuantizedLstmWorkloadTest()
1003 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
1005 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1009 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1011 CHECK((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1013 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1015 CHECK((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1017 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1019 CHECK((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1021 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1023 CHECK((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1025 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1027 CHECK((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1030 TEST_CASE(
"CreateQuantizedLstmWorkload")
1032 NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
1035 template <
typename QLstmWorkloadType>
1036 static void NeonCreateQLstmWorkloadTest()
1039 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
1041 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1044 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1046 CHECK((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1048 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1050 CHECK((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1052 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1054 CHECK((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1057 TEST_CASE(
"CreateQLstmWorkloadTest")
1059 NeonCreateQLstmWorkloadTest<NeonQLstmWorkload>();
virtual arm_compute::ITensor & GetTensor()=0
std::vector< BackendOptions > ModelOptions
void IgnoreUnused(Ts &&...)
virtual arm_compute::DataType GetDataType() const =0
#define ARMNN_ASSERT(COND)
virtual TensorShape GetShape() const =0
Get the number of elements for each dimension ordered from slowest iterating dimension to fastest ite...
This layer represents an addition operation.
Struct for the users to pass backend specific options.
This layer represents a subtraction operation.
std::vector< ITensorHandle * > m_Outputs
This layer represents a division operation.
void SetQuantizationOffset(int32_t offset)
std::vector< ITensorHandle * > m_Inputs
This layer represents a multiplication operation.
Depthwise Convolution 2D layer workload data.
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...