24 boost::test_tools::predicate_result CompareIAclTensorHandleShape(
IAclTensorHandle* tensorHandle,
25 std::initializer_list<unsigned int> expectedDimensions)
27 return CompareTensorHandleShape<IAclTensorHandle>(tensorHandle, expectedDimensions);
34 const arm_compute::ITensorInfo* handleInfo = handle->
GetTensor().info();
35 const arm_compute::TensorInfo expectedAclInfo = BuildArmComputeTensorInfo(expectedInfo);
37 if (handleInfo->data_type() != expectedAclInfo.data_type())
42 if (handleInfo->num_dimensions() != expectedAclInfo.num_dimensions())
47 if (handleInfo->quantization_info() != expectedAclInfo.quantization_info())
52 for (std::size_t d = 0; d < expectedAclInfo.num_dimensions(); ++d)
54 if (handleInfo->dimension(d) != expectedAclInfo.dimension(d))
65 template <
typename armnn::DataType DataType>
66 static void NeonCreateActivationWorkloadTest()
70 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
72 auto workload = CreateActivationWorkloadTest<NeonActivationWorkload, DataType>(factory, graph);
76 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
77 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
82 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 85 NeonCreateActivationWorkloadTest<DataType::Float16>();
91 NeonCreateActivationWorkloadTest<DataType::Float32>();
94 template <
typename WorkloadType,
95 typename DescriptorType,
98 static void NeonCreateElementwiseWorkloadTest()
102 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
104 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
106 DescriptorType queueDescriptor = workload->GetData();
107 auto inputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
108 auto inputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
109 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
115 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 133 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 159 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 193 template <
typename BatchNormalizationWorkloadType,
typename armnn::DataType DataType>
194 static void NeonCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
198 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
200 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
201 (factory, graph, dataLayout);
205 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
206 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
212 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
215 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 218 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NCHW);
223 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NHWC);
229 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NCHW);
234 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NHWC);
237 template <
typename armnn::DataType DataType>
242 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
244 auto workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload, DataType>(factory, graph, dataLayout);
251 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
252 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
254 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
257 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 260 NeonCreateConvolution2dWorkloadTest<DataType::Float16>();
271 NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
279 template <
typename armnn::DataType DataType>
280 static void NeonCreateDepthWiseConvolutionWorkloadTest(
DataLayout dataLayout)
284 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
287 DataType>(factory, graph, dataLayout);
291 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
292 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
295 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
297 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
300 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
305 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(
DataLayout::NHWC);
308 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 311 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float16>(
DataLayout::NHWC);
315 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
316 static void NeonCreateFullyConnectedWorkloadTest()
320 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
322 auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
326 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
327 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
332 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({3, 1, 4, 5},
DataType, inputsQScale)));
333 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo({3, 7},
DataType, outputQScale)));
336 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 339 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float16>();
345 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
350 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmU8>();
355 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmS8>();
358 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
359 static void NeonCreateNormalizationWorkloadTest(
DataLayout dataLayout)
363 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
365 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
369 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
370 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
376 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
379 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 382 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
387 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
393 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
398 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
402 template <
typename armnn::DataType DataType>
407 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
409 auto workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>(factory, graph, dataLayout);
416 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
417 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
419 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
422 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 425 NeonCreatePooling2dWorkloadTest<DataType::Float16>();
456 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
458 auto workload = CreatePreluWorkloadTest<NeonPreluWorkload>(factory,
467 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
468 auto alphaHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
469 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
470 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo(inputShape, dataType)));
471 BOOST_TEST(TestNeonTensorHandleInfo(alphaHandle,
TensorInfo(alphaShape, dataType)));
472 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape, dataType)));
475 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 478 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
484 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
489 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
492 template <
typename armnn::DataType DataType>
493 static void NeonCreateReshapeWorkloadTest()
497 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
499 auto workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
503 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
504 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
509 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 512 NeonCreateReshapeWorkloadTest<DataType::Float16>();
518 NeonCreateReshapeWorkloadTest<DataType::Float32>();
523 NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
526 template <
typename ResizeWorkloadType, armnn::DataType DataType>
527 static void NeonCreateResizeWorkloadTest(
DataLayout dataLayout)
531 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
532 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
534 auto queueDescriptor = workload->GetData();
536 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
537 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
542 BOOST_TEST(CompareIAclTensorHandleShape(inputHandle, { 2, 4, 4, 3 }));
543 BOOST_TEST(CompareIAclTensorHandleShape(outputHandle, { 2, 2, 2, 3 }));
547 BOOST_TEST(CompareIAclTensorHandleShape(inputHandle, { 2, 3, 4, 4 }));
548 BOOST_TEST(CompareIAclTensorHandleShape(outputHandle, { 2, 3, 2, 2 }));
554 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
559 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
564 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
569 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
572 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
573 static void NeonCreateSoftmaxWorkloadTest()
577 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
579 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
583 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
584 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
589 tensorInfo.SetQuantizationScale(1.f / 256);
593 tensorInfo.SetQuantizationOffset(-128);
594 tensorInfo.SetQuantizationScale(1.f / 256);
596 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, tensorInfo));
597 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle, tensorInfo));
600 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 603 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float16>();
609 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float32>();
614 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmU8>();
619 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmS8>();
622 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
623 static void NeonSpaceToDepthWorkloadTest()
627 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
629 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
632 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
633 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
635 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({ 1, 2, 2, 1 },
DataType)));
636 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo({ 1, 1, 1, 4 },
DataType)));
641 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
646 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
651 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
656 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
663 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
665 auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
669 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
672 auto outputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
675 auto outputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
678 auto outputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
692 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
698 auto wlSplitter = std::move(workloads.first);
699 auto wlConcat = std::move(workloads.second);
712 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
714 BOOST_TEST(validDataPointers);
724 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
726 std::unique_ptr<NeonSplitterWorkload> wlSplitter;
727 std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
728 std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
729 std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
730 std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
734 wlActiv1_0, wlActiv1_1);
746 BOOST_TEST(activ0_0Im);
747 BOOST_TEST(activ0_1Im);
748 BOOST_TEST(activ1_0Im);
749 BOOST_TEST(activ1_1Im);
751 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
752 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
754 BOOST_TEST(validDataPointers);
757 #if defined(ARMNNREF_ENABLED) 764 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
765 CreateMemCopyWorkloads<IAclTensorHandle>(factory);
770 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
771 static void NeonCreateL2NormalizationWorkloadTest(
DataLayout dataLayout)
775 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
778 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
782 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
783 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
791 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
794 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 797 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
802 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
808 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
813 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
816 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
817 static void NeonCreateLogSoftmaxWorkloadTest()
821 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
823 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
827 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
828 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
831 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, tensorInfo));
832 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle, tensorInfo));
835 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 838 NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float16>();
844 NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float32>();
847 template <
typename LstmWorkloadType>
848 static void NeonCreateLstmWorkloadTest()
852 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
854 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
858 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
859 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
867 NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
870 template <
typename ConcatWorkloadType, armnn::DataType DataType>
871 static void NeonCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
872 unsigned int concatAxis)
876 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
878 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
881 auto inputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
882 auto inputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
883 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
885 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle0,
TensorInfo({ 2, 3, 2, 5 },
DataType)));
886 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle1,
TensorInfo({ 2, 3, 2, 5 },
DataType)));
887 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
892 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
897 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
902 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
907 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
912 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
917 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
920 template <armnn::DataType DataType>
921 static void NeonCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
922 const std::initializer_list<unsigned int>& outputShape,
924 unsigned int numInputs)
928 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
930 auto workload = CreateStackWorkloadTest<NeonStackWorkload, DataType>(factory,
939 for (
unsigned int i = 0; i < numInputs; ++i)
941 auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[i]);
944 auto outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
945 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
950 NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
953 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 956 NeonCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
962 NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
965 template <
typename QuantizedLstmWorkloadType>
966 static void NeonCreateQuantizedLstmWorkloadTest()
969 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
971 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
975 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
977 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
979 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
981 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
983 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
985 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
987 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
989 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
991 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
993 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
998 NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
1001 template <
typename QLstmWorkloadType>
1002 static void NeonCreateQLstmWorkloadTest()
1005 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
1007 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1010 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1012 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1014 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1016 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1018 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1020 BOOST_TEST((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1025 NeonCreateQLstmWorkloadTest<NeonQLstmWorkload>();
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
virtual arm_compute::ITensor & GetTensor()=0
virtual arm_compute::DataType GetDataType() const =0
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.
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.