23 boost::test_tools::predicate_result CompareIAclTensorHandleShape(
IAclTensorHandle* tensorHandle,
24 std::initializer_list<unsigned int> expectedDimensions)
26 return CompareTensorHandleShape<IAclTensorHandle>(tensorHandle, expectedDimensions);
33 const arm_compute::ITensorInfo* handleInfo = handle->
GetTensor().info();
34 const arm_compute::TensorInfo expectedAclInfo = BuildArmComputeTensorInfo(expectedInfo);
36 if (handleInfo->data_type() != expectedAclInfo.data_type())
41 if (handleInfo->num_dimensions() != expectedAclInfo.num_dimensions())
46 if (handleInfo->quantization_info() != expectedAclInfo.quantization_info())
51 for (std::size_t d = 0; d < expectedAclInfo.num_dimensions(); ++d)
53 if (handleInfo->dimension(d) != expectedAclInfo.dimension(d))
64 template <
typename armnn::DataType DataType>
65 static void NeonCreateActivationWorkloadTest()
69 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
71 auto workload = CreateActivationWorkloadTest<NeonActivationWorkload, DataType>(factory, graph);
75 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
76 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
81 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 84 NeonCreateActivationWorkloadTest<DataType::Float16>();
90 NeonCreateActivationWorkloadTest<DataType::Float32>();
93 template <
typename WorkloadType,
94 typename DescriptorType,
97 static void NeonCreateElementwiseWorkloadTest()
101 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
103 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
105 DescriptorType queueDescriptor = workload->GetData();
106 auto inputHandle1 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
107 auto inputHandle2 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
108 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
114 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 132 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 158 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 192 template <
typename BatchNormalizationWorkloadType,
typename armnn::DataType DataType>
193 static void NeonCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
197 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
199 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
200 (factory, graph, dataLayout);
204 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
205 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
211 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
214 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 217 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NCHW);
222 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float16>(
DataLayout::NHWC);
228 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NCHW);
233 NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(
DataLayout::NHWC);
236 template <
typename armnn::DataType DataType>
241 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
243 auto workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload, DataType>(factory, graph, dataLayout);
250 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
251 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
253 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
256 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 259 NeonCreateConvolution2dWorkloadTest<DataType::Float16>();
270 NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
278 template <
typename armnn::DataType DataType>
279 static void NeonCreateDepthWiseConvolutionWorkloadTest(
DataLayout dataLayout)
283 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
286 DataType>(factory, graph, dataLayout);
290 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
291 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
294 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
296 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
299 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
304 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(
DataLayout::NHWC);
307 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 310 NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float16>(
DataLayout::NHWC);
314 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
315 static void NeonCreateFullyConnectedWorkloadTest()
319 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
321 auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
325 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
326 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
327 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({3, 1, 4, 5},
DataType)));
331 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 334 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float16>();
340 NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
343 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
344 static void NeonCreateNormalizationWorkloadTest(
DataLayout dataLayout)
348 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
350 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
354 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
355 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
361 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
364 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 367 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
372 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
378 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
383 NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
387 template <
typename armnn::DataType DataType>
392 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
394 auto workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>(factory, graph, dataLayout);
401 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.
m_Inputs[0]);
402 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.
m_Outputs[0]);
404 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
407 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 410 NeonCreatePooling2dWorkloadTest<DataType::Float16>();
441 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
443 auto workload = CreatePreluWorkloadTest<NeonPreluWorkload>(factory,
452 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
453 auto alphaHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
454 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
455 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo(inputShape, dataType)));
456 BOOST_TEST(TestNeonTensorHandleInfo(alphaHandle,
TensorInfo(alphaShape, dataType)));
457 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape, dataType)));
460 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 463 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
469 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
474 NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
477 template <
typename armnn::DataType DataType>
478 static void NeonCreateReshapeWorkloadTest()
482 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
484 auto workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
488 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
489 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
494 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 497 NeonCreateReshapeWorkloadTest<DataType::Float16>();
503 NeonCreateReshapeWorkloadTest<DataType::Float32>();
508 NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
511 template <
typename ResizeWorkloadType, armnn::DataType DataType>
512 static void NeonCreateResizeWorkloadTest(
DataLayout dataLayout)
516 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
517 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
519 auto queueDescriptor = workload->GetData();
521 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
522 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
527 BOOST_TEST(CompareIAclTensorHandleShape(inputHandle, { 2, 4, 4, 3 }));
528 BOOST_TEST(CompareIAclTensorHandleShape(outputHandle, { 2, 2, 2, 3 }));
532 BOOST_TEST(CompareIAclTensorHandleShape(inputHandle, { 2, 3, 4, 4 }));
533 BOOST_TEST(CompareIAclTensorHandleShape(outputHandle, { 2, 3, 2, 2 }));
539 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
544 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
549 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
554 NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
557 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
558 static void NeonCreateSoftmaxWorkloadTest()
562 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
564 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
568 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
569 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
574 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 577 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloatWorkload, DataType::Float16>();
583 NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloatWorkload, DataType::Float32>();
586 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
587 static void NeonSpaceToDepthWorkloadTest()
591 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
593 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
596 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
597 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
599 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle,
TensorInfo({ 1, 2, 2, 1 },
DataType)));
600 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo({ 1, 1, 1, 4 },
DataType)));
605 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
610 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
615 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
620 NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
627 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
629 auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
633 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
636 auto outputHandle0 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
639 auto outputHandle1 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
642 auto outputHandle2 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
656 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
662 auto wlSplitter = std::move(workloads.first);
663 auto wlConcat = std::move(workloads.second);
676 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
678 BOOST_TEST(validDataPointers);
688 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
690 std::unique_ptr<NeonSplitterWorkload> wlSplitter;
691 std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
692 std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
693 std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
694 std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
698 wlActiv1_0, wlActiv1_1);
710 BOOST_TEST(activ0_0Im);
711 BOOST_TEST(activ0_1Im);
712 BOOST_TEST(activ1_0Im);
713 BOOST_TEST(activ1_1Im);
715 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
716 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
718 BOOST_TEST(validDataPointers);
721 #if defined(ARMNNREF_ENABLED) 728 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
729 CreateMemCopyWorkloads<IAclTensorHandle>(factory);
734 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
735 static void NeonCreateL2NormalizationWorkloadTest(
DataLayout dataLayout)
739 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
742 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
746 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
747 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
755 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
758 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 761 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NCHW);
766 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float16>(
DataLayout::NHWC);
772 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NCHW);
777 NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(
DataLayout::NHWC);
780 template <
typename LstmWorkloadType>
781 static void NeonCreateLstmWorkloadTest()
785 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
787 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
791 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
792 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
800 NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
803 template <
typename ConcatWorkloadType, armnn::DataType DataType>
804 static void NeonCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
805 unsigned int concatAxis)
809 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
811 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
814 auto inputHandle0 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
815 auto inputHandle1 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
816 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
818 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle0,
TensorInfo({ 2, 3, 2, 5 },
DataType)));
819 BOOST_TEST(TestNeonTensorHandleInfo(inputHandle1,
TensorInfo({ 2, 3, 2, 5 },
DataType)));
820 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
825 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
830 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
835 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
840 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
845 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
850 NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
853 template <armnn::DataType DataType>
854 static void NeonCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
855 const std::initializer_list<unsigned int>& outputShape,
857 unsigned int numInputs)
861 NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
863 auto workload = CreateStackWorkloadTest<NeonStackWorkload, DataType>(factory,
872 for (
unsigned int i = 0; i < numInputs; ++i)
874 auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[i]);
877 auto outputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
878 BOOST_TEST(TestNeonTensorHandleInfo(outputHandle,
TensorInfo(outputShape,
DataType)));
883 NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
886 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 889 NeonCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
895 NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
898 template <
typename QuantizedLstmWorkloadType>
899 static void NeonCreateQuantizedLstmWorkloadTest()
901 using boost::polymorphic_downcast;
904 NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
906 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
910 IAclTensorHandle* inputHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
912 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
914 IAclTensorHandle* cellStateInHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
916 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
918 IAclTensorHandle* outputStateInHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
920 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
922 IAclTensorHandle* cellStateOutHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
924 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
926 IAclTensorHandle* outputStateOutHandle = polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
928 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
933 NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
This layer represents a subtraction operation.
virtual arm_compute::DataType GetDataType() const =0
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
This layer represents a multiplication operation.
virtual TensorShape GetShape() const =0
This layer represents a division operation.
BOOST_AUTO_TEST_SUITE_END()
virtual arm_compute::ITensor & GetTensor()=0
This layer represents an addition operation.
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
std::vector< ITensorHandle * > m_Outputs
std::vector< ITensorHandle * > m_Inputs