From 2f00b7421f259851448a0be72e9eb01141faad2e Mon Sep 17 00:00:00 2001 From: Aron Virginas-Tar Date: Mon, 30 Sep 2019 13:28:08 +0100 Subject: IVGCVSW-3734 Add NEON workload for DepthToSpace Signed-off-by: Aron Virginas-Tar Change-Id: I4fa8cba57f3a2277112c02062f4d2790089d1eb5 --- src/backends/neon/NeonLayerSupport.cpp | 13 +++++ src/backends/neon/NeonLayerSupport.hpp | 6 +++ src/backends/neon/NeonWorkloadFactory.cpp | 6 +++ src/backends/neon/NeonWorkloadFactory.hpp | 3 ++ src/backends/neon/backend.mk | 1 + src/backends/neon/test/NeonLayerTests.cpp | 31 +++++++++++ src/backends/neon/workloads/CMakeLists.txt | 2 + .../neon/workloads/NeonDepthToSpaceWorkload.cpp | 61 ++++++++++++++++++++++ .../neon/workloads/NeonDepthToSpaceWorkload.hpp | 31 +++++++++++ src/backends/neon/workloads/NeonWorkloads.hpp | 1 + 10 files changed, 155 insertions(+) create mode 100644 src/backends/neon/workloads/NeonDepthToSpaceWorkload.cpp create mode 100644 src/backends/neon/workloads/NeonDepthToSpaceWorkload.hpp (limited to 'src/backends') diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp index 0d4d4c3459..b713abaef3 100644 --- a/src/backends/neon/NeonLayerSupport.cpp +++ b/src/backends/neon/NeonLayerSupport.cpp @@ -23,6 +23,7 @@ #include "workloads/NeonActivationWorkload.hpp" #include "workloads/NeonBatchNormalizationWorkload.hpp" #include "workloads/NeonConvolution2dWorkload.hpp" +#include "workloads/NeonDepthToSpaceWorkload.hpp" #include "workloads/NeonDepthwiseConvolutionWorkload.hpp" #include "workloads/NeonDequantizeWorkload.hpp" #include "workloads/NeonGreaterWorkload.hpp" @@ -249,6 +250,18 @@ bool NeonLayerSupport::IsConvolution2dSupported(const TensorInfo& input, biases); } +bool NeonLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input, + const TensorInfo& output, + const DepthToSpaceDescriptor& descriptor, + Optional reasonIfUnsupported) const +{ + FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthToSpaceWorkloadValidate, + reasonIfUnsupported, + input, + output, + descriptor); +} + bool NeonLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input, const TensorInfo& output, const DepthwiseConvolution2dDescriptor& descriptor, diff --git a/src/backends/neon/NeonLayerSupport.hpp b/src/backends/neon/NeonLayerSupport.hpp index cc4798eea5..31f9e576d7 100644 --- a/src/backends/neon/NeonLayerSupport.hpp +++ b/src/backends/neon/NeonLayerSupport.hpp @@ -58,6 +58,12 @@ public: const Optional& biases, Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsDepthToSpaceSupported(const TensorInfo& input, + const TensorInfo& output, + const DepthToSpaceDescriptor& descriptor, + Optional reasonIfUnsupported = EmptyOptional()) const override; + + bool IsDepthwiseConvolutionSupported(const TensorInfo& input, const TensorInfo& output, const DepthwiseConvolution2dDescriptor& descriptor, diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp index fb81008644..f0b738c350 100644 --- a/src/backends/neon/NeonWorkloadFactory.cpp +++ b/src/backends/neon/NeonWorkloadFactory.cpp @@ -170,6 +170,12 @@ std::unique_ptr NeonWorkloadFactory::CreateConvolution2d( m_MemoryManager->GetIntraLayerManager()); } +std::unique_ptr NeonWorkloadFactory::CreateDepthToSpace(const DepthToSpaceQueueDescriptor& descriptor, + const WorkloadInfo& info) const +{ + return std::make_unique(descriptor, info); +} + std::unique_ptr NeonWorkloadFactory::CreateDepthwiseConvolution2d( const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const { diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp index 0bee365d8a..4bdbc8e859 100644 --- a/src/backends/neon/NeonWorkloadFactory.hpp +++ b/src/backends/neon/NeonWorkloadFactory.hpp @@ -76,6 +76,9 @@ public: std::unique_ptr CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const override; + std::unique_ptr CreateDepthToSpace(const DepthToSpaceQueueDescriptor& descriptor, + const WorkloadInfo& info) const override; + std::unique_ptr CreateDepthwiseConvolution2d(const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const override; diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk index 5eae9e5137..3e46387ae4 100644 --- a/src/backends/neon/backend.mk +++ b/src/backends/neon/backend.mk @@ -30,6 +30,7 @@ BACKEND_SOURCES := \ workloads/NeonConvertFp16ToFp32Workload.cpp \ workloads/NeonConvertFp32ToFp16Workload.cpp \ workloads/NeonConvolution2dWorkload.cpp \ + workloads/NeonDepthToSpaceWorkload.cpp \ workloads/NeonDepthwiseConvolutionWorkload.cpp \ workloads/NeonDequantizeWorkload.cpp \ workloads/NeonFloorFloatWorkload.cpp \ diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp index dbd2d329fc..745d2ceece 100644 --- a/src/backends/neon/test/NeonLayerTests.cpp +++ b/src/backends/neon/test/NeonLayerTests.cpp @@ -110,6 +110,37 @@ ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dMult2, false, armnn::DataLayout::NCHW) +// DepthToSpace +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_1, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_2, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_3, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_4, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_1, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_2, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_3, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_4, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_1, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_2, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_3, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_4, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_1, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_2, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_3, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_4, DepthToSpaceTest4, DataLayout::NHWC); + +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_1, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_2, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_3, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_4, DepthToSpaceTest4, DataLayout::NHWC); + +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_1, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_2, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_3, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_4, DepthToSpaceTest4, DataLayout::NHWC); + // Depthwise Convolution ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1, DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NCHW) diff --git a/src/backends/neon/workloads/CMakeLists.txt b/src/backends/neon/workloads/CMakeLists.txt index 90043911cf..42ac641369 100644 --- a/src/backends/neon/workloads/CMakeLists.txt +++ b/src/backends/neon/workloads/CMakeLists.txt @@ -22,6 +22,8 @@ list(APPEND armnnNeonBackendWorkloads_sources NeonConvertFp32ToFp16Workload.hpp NeonConvolution2dWorkload.cpp NeonConvolution2dWorkload.hpp + NeonDepthToSpaceWorkload.cpp + NeonDepthToSpaceWorkload.hpp NeonDepthwiseConvolutionWorkload.cpp NeonDepthwiseConvolutionWorkload.hpp NeonDequantizeWorkload.cpp diff --git a/src/backends/neon/workloads/NeonDepthToSpaceWorkload.cpp b/src/backends/neon/workloads/NeonDepthToSpaceWorkload.cpp new file mode 100644 index 0000000000..b30dfcd80e --- /dev/null +++ b/src/backends/neon/workloads/NeonDepthToSpaceWorkload.cpp @@ -0,0 +1,61 @@ +// +// Copyright © 2019 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "NeonDepthToSpaceWorkload.hpp" + +#include "NeonWorkloadUtils.hpp" + +#include + +#include +#include + +namespace armnn +{ + +using namespace armcomputetensorutils; + +arm_compute::Status NeonDepthToSpaceWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const DepthToSpaceDescriptor& descriptor) +{ + DataLayout dataLayout = descriptor.m_DataLayout; + const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input, dataLayout); + const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output, dataLayout); + + int32_t blockSize = boost::numeric_cast(descriptor.m_BlockSize); + + return arm_compute::NEDepthToSpaceLayer::validate(&aclInput, &aclOutput, blockSize); +} + +NeonDepthToSpaceWorkload::NeonDepthToSpaceWorkload(const DepthToSpaceQueueDescriptor& desc, + const WorkloadInfo& info) + : BaseWorkload(desc, info) +{ + m_Data.ValidateInputsOutputs("NeonDepthToSpaceWorkload", 1, 1); + + arm_compute::DataLayout aclDataLayout = ConvertDataLayout(m_Data.m_Parameters.m_DataLayout); + + arm_compute::ITensor& input = + boost::polymorphic_pointer_downcast(m_Data.m_Inputs[0])->GetTensor(); + input.info()->set_data_layout(aclDataLayout); + + int32_t blockSize = boost::numeric_cast(desc.m_Parameters.m_BlockSize); + + arm_compute::ITensor& output = + boost::polymorphic_pointer_downcast(m_Data.m_Outputs[0])->GetTensor(); + output.info()->set_data_layout(aclDataLayout); + + m_Layer.configure(&input, &output, blockSize); + m_Layer.prepare(); +} + +void NeonDepthToSpaceWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonDepthToSpaceWorkload_Execute"); + m_Layer.run(); +} + +} // namespace armnn diff --git a/src/backends/neon/workloads/NeonDepthToSpaceWorkload.hpp b/src/backends/neon/workloads/NeonDepthToSpaceWorkload.hpp new file mode 100644 index 0000000000..95b5e44e4d --- /dev/null +++ b/src/backends/neon/workloads/NeonDepthToSpaceWorkload.hpp @@ -0,0 +1,31 @@ +// +// Copyright © 2019 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include + +#include + +#include + +namespace armnn +{ + +arm_compute::Status NeonDepthToSpaceWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const DepthToSpaceDescriptor& descriptor); + +class NeonDepthToSpaceWorkload : public BaseWorkload +{ +public: + NeonDepthToSpaceWorkload(const DepthToSpaceQueueDescriptor& descriptor, const WorkloadInfo& info); + void Execute() const override; + +private: + mutable arm_compute::NEDepthToSpaceLayer m_Layer; +}; + +} // namespace armnn diff --git a/src/backends/neon/workloads/NeonWorkloads.hpp b/src/backends/neon/workloads/NeonWorkloads.hpp index 4f30f33d1b..9d35ed42fe 100644 --- a/src/backends/neon/workloads/NeonWorkloads.hpp +++ b/src/backends/neon/workloads/NeonWorkloads.hpp @@ -12,6 +12,7 @@ #include "NeonConvertFp16ToFp32Workload.hpp" #include "NeonConvertFp32ToFp16Workload.hpp" #include "NeonConvolution2dWorkload.hpp" +#include "NeonDepthToSpaceWorkload.hpp" #include "NeonDepthwiseConvolutionWorkload.hpp" #include "NeonDequantizeWorkload.hpp" #include "NeonFloorFloatWorkload.hpp" -- cgit v1.2.1