From b48e68674e600d68ca7059736d930ada6a3b4969 Mon Sep 17 00:00:00 2001 From: Nina Drozd Date: Tue, 9 Oct 2018 12:09:56 +0100 Subject: IVGCVSW-1982 - add create workload test for 2D Pooling (NHWC data layout) Change-Id: Ief0c91ba9abc2578944860ddbd3c19e2bad465bd --- src/armnn/test/CreateWorkload.hpp | 12 ++++++++---- src/backends/test/CreateWorkloadCl.cpp | 31 +++++++++++++++++++++++-------- src/backends/test/CreateWorkloadNeon.cpp | 29 +++++++++++++++++++++-------- 3 files changed, 52 insertions(+), 20 deletions(-) diff --git a/src/armnn/test/CreateWorkload.hpp b/src/armnn/test/CreateWorkload.hpp index f2c8b5a20a..b63e95d4cb 100644 --- a/src/armnn/test/CreateWorkload.hpp +++ b/src/armnn/test/CreateWorkload.hpp @@ -162,7 +162,6 @@ std::unique_ptr CreateBatchNormalizationWorkl // Makes the workload and checks it. auto workload = MakeAndCheckWorkload(*layer, graph, factory); - BatchNormalizationQueueDescriptor queueDescriptor = workload->GetData(); BOOST_TEST(queueDescriptor.m_Parameters.m_Eps == 0.05f); BOOST_TEST(queueDescriptor.m_Inputs.size() == 1); @@ -532,7 +531,8 @@ std::unique_ptr CreateNormalizationWorkloadTest(armnn::IW template std::unique_ptr CreatePooling2dWorkloadTest(armnn::IWorkloadFactory& factory, - armnn::Graph& graph) + armnn::Graph& graph, + DataLayout dataLayout = DataLayout::NCHW) { // Creates the layer we're testing. Pooling2dDescriptor layerDesc; @@ -546,6 +546,7 @@ std::unique_ptr CreatePooling2dWorkloadTest(armnn::IWorkloadF layerDesc.m_StrideX = 2; layerDesc.m_StrideY = 3; layerDesc.m_OutputShapeRounding = OutputShapeRounding::Floor; + layerDesc.m_DataLayout = dataLayout; Pooling2dLayer* const layer = graph.AddLayer(layerDesc, "layer"); @@ -553,9 +554,12 @@ std::unique_ptr CreatePooling2dWorkloadTest(armnn::IWorkloadF Layer* const input = graph.AddLayer(0, "input"); Layer* const output = graph.AddLayer(0, "output"); + TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{3, 2, 5, 5} : TensorShape{3, 5, 5, 2}; + TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{3, 2, 2, 4} : TensorShape{3, 2, 4, 2}; + // Connect up - Connect(input, layer, TensorInfo({3, 2, 5, 5}, DataType)); - Connect(layer, output, TensorInfo({3, 2, 2, 4}, DataType)); + Connect(input, layer, TensorInfo(inputShape, DataType)); + Connect(layer, output, TensorInfo(outputShape, DataType)); CreateTensorHandles(graph, factory); // Make the workload and checks it diff --git a/src/backends/test/CreateWorkloadCl.cpp b/src/backends/test/CreateWorkloadCl.cpp index e7e39b0f70..0314f6d92a 100644 --- a/src/backends/test/CreateWorkloadCl.cpp +++ b/src/backends/test/CreateWorkloadCl.cpp @@ -320,30 +320,45 @@ BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NhwcWorkload) } template -static void ClPooling2dWorkloadTest() +static void ClPooling2dWorkloadTest(DataLayout dataLayout) { Graph graph; ClWorkloadFactory factory; - auto workload = CreatePooling2dWorkloadTest(factory, graph); + auto workload = CreatePooling2dWorkloadTest(factory, graph, dataLayout); + + std::initializer_list inputShape = (dataLayout == DataLayout::NCHW) ? + std::initializer_list({3, 2, 5, 5}) : std::initializer_list({3, 5, 5, 2}); + std::initializer_list outputShape = (dataLayout == DataLayout::NCHW) ? + std::initializer_list({3, 2, 2, 4}) : std::initializer_list({3, 2, 4, 2}); // Check that inputs/outputs are as we expect them (see definition of CreatePooling2dWorkloadTest). Pooling2dQueueDescriptor queueDescriptor = workload->GetData(); auto inputHandle = boost::polymorphic_downcast(queueDescriptor.m_Inputs[0]); auto outputHandle = boost::polymorphic_downcast(queueDescriptor.m_Outputs[0]); - BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {3, 2, 5, 5})); - BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {3, 2, 2, 4})); + BOOST_TEST(CompareIClTensorHandleShape(inputHandle, inputShape)); + BOOST_TEST(CompareIClTensorHandleShape(outputHandle, outputShape)); +} + +BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNchwWorkload) +{ + ClPooling2dWorkloadTest(DataLayout::NCHW); +} + +BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNhwcWorkload) +{ + ClPooling2dWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreatePooling2dFloatWorkload) +BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NchwWorkload) { - ClPooling2dWorkloadTest(); + ClPooling2dWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16Workload) +BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NhwcWorkload) { - ClPooling2dWorkloadTest(); + ClPooling2dWorkloadTest(DataLayout::NHWC); } template diff --git a/src/backends/test/CreateWorkloadNeon.cpp b/src/backends/test/CreateWorkloadNeon.cpp index a6f3540994..a67e68d8a5 100644 --- a/src/backends/test/CreateWorkloadNeon.cpp +++ b/src/backends/test/CreateWorkloadNeon.cpp @@ -273,19 +273,22 @@ BOOST_AUTO_TEST_CASE(CreateNormalizationFloatNhwcWorkload) template -static void NeonCreatePooling2dWorkloadTest() +static void NeonCreatePooling2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW) { Graph graph; NeonWorkloadFactory factory; auto workload = CreatePooling2dWorkloadTest - (factory, graph); + (factory, graph, dataLayout); + + TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{3, 2, 5, 5} : TensorShape{3, 5, 5, 2}; + TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? TensorShape{3, 2, 2, 4} : TensorShape{3, 2, 4, 2}; // Checks that outputs and inputs are as we expect them (see definition of CreatePooling2dWorkloadTest). Pooling2dQueueDescriptor queueDescriptor = workload->GetData(); auto inputHandle = boost::polymorphic_downcast(queueDescriptor.m_Inputs[0]); auto outputHandle = boost::polymorphic_downcast(queueDescriptor.m_Outputs[0]); - BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, TensorInfo({3, 2, 5, 5}, DataType))); - BOOST_TEST(TestNeonTensorHandleInfo(outputHandle, TensorInfo({3, 2, 2, 4}, DataType))); + BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, TensorInfo(inputShape, DataType))); + BOOST_TEST(TestNeonTensorHandleInfo(outputHandle, TensorInfo(outputShape, DataType))); } #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC @@ -295,14 +298,24 @@ BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16Workload) } #endif -BOOST_AUTO_TEST_CASE(CreatePooling2dFloatWorkload) +BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNchwWorkload) +{ + NeonCreatePooling2dWorkloadTest(DataLayout::NCHW); +} + +BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNhwcWorkload) +{ + NeonCreatePooling2dWorkloadTest(DataLayout::NHWC); +} + +BOOST_AUTO_TEST_CASE(CreatePooling2dUint8NchwWorkload) { - NeonCreatePooling2dWorkloadTest(); + NeonCreatePooling2dWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreatePooling2dUint8Workload) +BOOST_AUTO_TEST_CASE(CreatePooling2dUint8NhwcWorkload) { - NeonCreatePooling2dWorkloadTest(); + NeonCreatePooling2dWorkloadTest(DataLayout::NHWC); } template -- cgit v1.2.1