26 boost::test_tools::predicate_result CompareIAclTensorHandleShape(
IAclTensorHandle* tensorHandle,
27 std::initializer_list<unsigned int> expectedDimensions)
29 return CompareTensorHandleShape<IAclTensorHandle>(tensorHandle, expectedDimensions);
36 const arm_compute::ITensorInfo* handleInfo = handle->
GetTensor().info();
37 const arm_compute::TensorInfo expectedAclInfo = BuildArmComputeTensorInfo(expectedInfo);
39 if (handleInfo->data_type() != expectedAclInfo.data_type())
44 if (handleInfo->num_dimensions() != expectedAclInfo.num_dimensions())
49 if (handleInfo->quantization_info() != expectedAclInfo.quantization_info())
54 for (std::size_t d = 0; d < expectedAclInfo.num_dimensions(); ++d)
56 if (handleInfo->dimension(d) != expectedAclInfo.dimension(d))
67 template <
typename armnn::DataType DataType>
68 static void NeonCreateActivationWorkloadTest()
72 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
74 auto workload = CreateActivationWorkloadTest<NeonActivationWorkload, DataType>(factory, graph);
78 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
79 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
84 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 87 NeonCreateActivationWorkloadTest<DataType::Float16>();
93 NeonCreateActivationWorkloadTest<DataType::Float32>();
96 template <
typename WorkloadType,
97 typename DescriptorType,
100 static void NeonCreateElementwiseWorkloadTest()
104 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
106 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
108 DescriptorType queueDescriptor = workload->GetData();
109 auto inputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
110 auto inputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
111 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
117 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 135 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 161 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 195 template <
typename BatchNormalizationWorkloadType,
typename armnn::DataType DataType>
196 static void NeonCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
200 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
202 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
203 (factory, graph, dataLayout);
207 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
208 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
214 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
217 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 220 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NCHW);
225 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NHWC);
231 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NCHW);
236 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NHWC);
239 template <
typename armnn::DataType DataType>
244 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
246 auto workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload, DataType>(factory, graph, dataLayout);
253 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
254 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
256 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
259 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 262 NeonCreateConvolution2dWorkloadTest<DataType::Float16>();
273 NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
288 {
"FastMathEnabled",
true }
290 modelOptions.push_back(cpuAcc);
292 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
295 CreateConvolution2dWorkloadFastMathTest<NeonConvolution2dWorkload, armnn::DataType::Float32>(factory,
301 auto conv2dWorkload = PolymorphicDowncast<NeonConvolution2dWorkload*>(workload.get());
304 ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
307 template <
typename armnn::DataType DataType>
308 static void NeonCreateDepthWiseConvolutionWorkloadTest(
DataLayout dataLayout)
312 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
315 DataType>(factory, graph, dataLayout);
319 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
320 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
323 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
325 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
328 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
333 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(
DataLayout::NHWC);
336 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 339 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float16>(
DataLayout::NHWC);
343 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
344 static void NeonCreateFullyConnectedWorkloadTest()
348 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
350 auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
354 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
355 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
360 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({3, 1, 4, 5},
DataType, inputsQScale)));
361 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo({3, 7},
DataType, outputQScale)));
364 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 367 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float16>();
373 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
378 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmU8>();
383 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmS8>();
386 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
387 static void NeonCreateNormalizationWorkloadTest(
DataLayout dataLayout)
391 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
393 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
397 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
398 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
404 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
407 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 410 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
415 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
421 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
426 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
430 template <
typename armnn::DataType DataType>
435 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
437 auto workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>(factory, graph, dataLayout);
444 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
445 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
447 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
450 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 453 NeonCreatePooling2dWorkloadTest<DataType::Float16>();
484 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
486 auto workload = CreatePreluWorkloadTest<NeonPreluWorkload>(factory,
495 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
496 auto alphaHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
497 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
498 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo(inputShape, dataType)));
499 BOOST_TEST(TestNeonTensorHandleInfo(alphaHandle,
TensorInfo(alphaShape, dataType)));
500 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape, dataType)));
503 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 506 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
512 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
517 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
520 template <
typename armnn::DataType DataType>
521 static void NeonCreateReshapeWorkloadTest()
525 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
527 auto workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
531 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
532 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
537 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 540 NeonCreateReshapeWorkloadTest<DataType::Float16>();
546 NeonCreateReshapeWorkloadTest<DataType::Float32>();
551 NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
554 template <
typename ResizeWorkloadType, armnn::DataType DataType>
555 static void NeonCreateResizeWorkloadTest(
DataLayout dataLayout)
559 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
560 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
562 auto queueDescriptor = workload->GetData();
564 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
565 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
570 BOOST_TEST(CompareIAclTensorHandleShape(inputHandle, { 2, 4, 4, 3 }));
571 BOOST_TEST(CompareIAclTensorHandleShape(outputHandle, { 2, 2, 2, 3 }));
575 BOOST_TEST(CompareIAclTensorHandleShape(inputHandle, { 2, 3, 4, 4 }));
576 BOOST_TEST(CompareIAclTensorHandleShape(outputHandle, { 2, 3, 2, 2 }));
582 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
587 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
592 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
597 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
600 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
601 static void NeonCreateSoftmaxWorkloadTest()
605 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
607 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
611 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
612 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
617 tensorInfo.SetQuantizationScale(1.f / 256);
621 tensorInfo.SetQuantizationOffset(-128);
622 tensorInfo.SetQuantizationScale(1.f / 256);
624 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, tensorInfo));
625 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle, tensorInfo));
628 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 631 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float16>();
637 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float32>();
642 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmU8>();
647 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmS8>();
650 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
651 static void NeonSpaceToDepthWorkloadTest()
655 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
657 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
660 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
661 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
663 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({ 1, 2, 2, 1 },
DataType)));
664 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo({ 1, 1, 1, 4 },
DataType)));
669 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
674 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
679 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
684 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
691 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
693 auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
697 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
700 auto outputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
703 auto outputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
706 auto outputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
720 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
726 auto wlSplitter = std::move(workloads.first);
727 auto wlConcat = std::move(workloads.second);
740 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
742 BOOST_TEST(validDataPointers);
752 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
754 std::unique_ptr<NeonSplitterWorkload> wlSplitter;
755 std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
756 std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
757 std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
758 std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
762 wlActiv1_0, wlActiv1_1);
774 BOOST_TEST(activ0_0Im);
775 BOOST_TEST(activ0_1Im);
776 BOOST_TEST(activ1_0Im);
777 BOOST_TEST(activ1_1Im);
779 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
780 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
782 BOOST_TEST(validDataPointers);
785 #if defined(ARMNNREF_ENABLED) 792 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
793 CreateMemCopyWorkloads<IAclTensorHandle>(factory);
798 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
799 static void NeonCreateL2NormalizationWorkloadTest(
DataLayout dataLayout)
803 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
806 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
810 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
811 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
819 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
822 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 825 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
830 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
836 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
841 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
844 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
845 static void NeonCreateLogSoftmaxWorkloadTest()
849 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
851 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
855 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
856 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
859 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, tensorInfo));
860 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle, tensorInfo));
863 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 866 NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float16>();
872 NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float32>();
875 template <
typename LstmWorkloadType>
876 static void NeonCreateLstmWorkloadTest()
880 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
882 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
886 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
887 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
895 NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
898 template <
typename ConcatWorkloadType, armnn::DataType DataType>
899 static void NeonCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
900 unsigned int concatAxis)
904 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
906 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
909 auto inputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
910 auto inputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
911 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
913 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle0,
TensorInfo({ 2, 3, 2, 5 },
DataType)));
914 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle1,
TensorInfo({ 2, 3, 2, 5 },
DataType)));
915 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
920 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
925 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
930 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
935 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
940 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
945 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
948 template <armnn::DataType DataType>
949 static void NeonCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
950 const std::initializer_list<unsigned int>& outputShape,
952 unsigned int numInputs)
956 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
958 auto workload = CreateStackWorkloadTest<NeonStackWorkload, DataType>(factory,
967 for (
unsigned int i = 0; i < numInputs; ++i)
969 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[i]);
972 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
973 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
978 NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
981 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 984 NeonCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
990 NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
993 template <
typename QuantizedLstmWorkloadType>
994 static void NeonCreateQuantizedLstmWorkloadTest()
997 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
999 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1003 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1005 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1007 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1009 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1011 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1013 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1015 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1017 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1019 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1021 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1026 NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
1029 template <
typename QLstmWorkloadType>
1030 static void NeonCreateQLstmWorkloadTest()
1033 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
1035 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1038 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1040 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1042 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1044 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1046 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1048 BOOST_TEST((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1053 NeonCreateQLstmWorkloadTest<NeonQLstmWorkload>();
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
virtual arm_compute::ITensor & GetTensor()=0
std::vector< BackendOptions > ModelOptions
void IgnoreUnused(Ts &&...)
virtual arm_compute::DataType GetDataType() const =0
#define ARMNN_ASSERT(COND)
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
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.
BOOST_AUTO_TEST_SUITE_END()
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.
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...