IVGCVSW-1951 Remove type templating from NeonConvolution2dWorkload

Change-Id: Id3d8137d60b14e93863ad5b6db752a7f6ef9b7fb

12 files changed, 39 insertions, 172 deletions

diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp
index 99e227897f..e28c4f5add 100644
--- a/src/backends/neon/NeonLayerSupport.cpp
+++ b/src/backends/neon/NeonLayerSupport.cpp
@@ -17,7 +17,7 @@
 #include "workloads/NeonAdditionFloatWorkload.hpp"
 #include "workloads/NeonActivationWorkload.hpp"
 #include "workloads/NeonBatchNormalizationFloatWorkload.hpp"
-#include "workloads/NeonConvolution2dBaseWorkload.hpp"
+#include "workloads/NeonConvolution2dWorkload.hpp"
 #include "workloads/NeonDepthwiseConvolutionBaseWorkload.hpp"
 #include "workloads/NeonL2NormalizationFloatWorkload.hpp"
 #include "workloads/NeonMultiplicationFloatWorkload.hpp"
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index a43722728d..f73f3aac1a 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -135,8 +135,8 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreatePooling2d(const Poo
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConvolution2d(
     const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
 {
-    return MakeWorkload<NeonConvolution2dFloatWorkload, NeonConvolution2dUint8Workload>(descriptor, info,
-                                                                              m_MemoryManager.GetIntraLayerManager());
+    return std::make_unique<NeonConvolution2dWorkload>(descriptor, info,
+                                                       m_MemoryManager.GetIntraLayerManager());
 }
 
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateDepthwiseConvolution2d(
diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk
index 6dfd951957..97105ec17e 100644
--- a/src/backends/neon/backend.mk
+++ b/src/backends/neon/backend.mk
@@ -19,9 +19,7 @@ BACKEND_SOURCES := \
         workloads/NeonConstantWorkload.cpp \
         workloads/NeonConvertFp16ToFp32Workload.cpp \
         workloads/NeonConvertFp32ToFp16Workload.cpp \
-        workloads/NeonConvolution2dBaseWorkload.cpp \
-        workloads/NeonConvolution2dFloatWorkload.cpp \
-        workloads/NeonConvolution2dUint8Workload.cpp \
+        workloads/NeonConvolution2dWorkload.cpp \
         workloads/NeonDepthwiseConvolutionBaseWorkload.cpp \
         workloads/NeonDepthwiseConvolutionFloatWorkload.cpp \
         workloads/NeonDepthwiseConvolutionUint8Workload.cpp \
diff --git a/src/backends/neon/test/NeonCreateWorkloadTests.cpp b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
index ec8fe803a1..63b3d41500 100644
--- a/src/backends/neon/test/NeonCreateWorkloadTests.cpp
+++ b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
@@ -179,12 +179,12 @@ BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatWorkload)
     NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationFloatWorkload, DataType::Float32>();
 }
 
-template <typename Convolution2dWorkloadType, typename armnn::DataType DataType>
+template <typename armnn::DataType DataType>
 static void NeonCreateConvolution2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW)
 {
     Graph                graph;
     NeonWorkloadFactory  factory;
-    auto                 workload = CreateConvolution2dWorkloadTest<Convolution2dWorkloadType,
+    auto                 workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload,
                                     DataType>(factory, graph, dataLayout);
 
     TensorShape inputShape  = (dataLayout == DataLayout::NCHW) ? TensorShape{2, 3, 8, 16} : TensorShape{2, 8, 16, 3};
@@ -201,23 +201,23 @@ static void NeonCreateConvolution2dWorkloadTest(DataLayout dataLayout = DataLayo
 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NchwWorkload)
 {
-    NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloatWorkload, DataType::Float16>();
+    NeonCreateConvolution2dWorkloadTest<DataType::Float16>();
 }
 
 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NhwcWorkload)
 {
-    NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloatWorkload, DataType::Float16>(DataLayout::NHWC);
+    NeonCreateConvolution2dWorkloadTest<DataType::Float16>(DataLayout::NHWC);
 }
 
 #endif
 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNchwWorkload)
 {
-    NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloatWorkload, DataType::Float32>();
+    NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
 }
 
 BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNhwcWorkload)
 {
-    NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloatWorkload, DataType::Float32>(DataLayout::NHWC);
+    NeonCreateConvolution2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
 }
 
 template <typename DepthwiseConvolution2dFloat32WorkloadType, typename armnn::DataType DataType>
diff --git a/src/backends/neon/workloads/CMakeLists.txt b/src/backends/neon/workloads/CMakeLists.txt
index d847df70fd..9c57dffd23 100644
--- a/src/backends/neon/workloads/CMakeLists.txt
+++ b/src/backends/neon/workloads/CMakeLists.txt
@@ -16,12 +16,8 @@ list(APPEND armnnNeonBackendWorkloads_sources
     NeonConvertFp16ToFp32Workload.hpp
     NeonConvertFp32ToFp16Workload.cpp
     NeonConvertFp32ToFp16Workload.hpp
-    NeonConvolution2dBaseWorkload.cpp
-    NeonConvolution2dBaseWorkload.hpp
-    NeonConvolution2dFloatWorkload.cpp
-    NeonConvolution2dFloatWorkload.hpp
-    NeonConvolution2dUint8Workload.cpp
-    NeonConvolution2dUint8Workload.hpp
+    NeonConvolution2dWorkload.cpp
+    NeonConvolution2dWorkload.hpp
     NeonDepthwiseConvolutionBaseWorkload.cpp
     NeonDepthwiseConvolutionBaseWorkload.hpp
     NeonDepthwiseConvolutionFloatWorkload.cpp
diff --git a/src/backends/neon/workloads/NeonConvolution2dFloatWorkload.cpp b/src/backends/neon/workloads/NeonConvolution2dFloatWorkload.cpp
deleted file mode 100644
index 9969154421..0000000000
--- a/src/backends/neon/workloads/NeonConvolution2dFloatWorkload.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "NeonConvolution2dFloatWorkload.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/neon/NeonLayerSupport.hpp>
-
-namespace armnn
-{
-using namespace armcomputetensorutils;
-
-NeonConvolution2dFloatWorkload::NeonConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor,
-    const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
-    : NeonConvolution2dBaseWorkload(descriptor, info, memoryManager)
-{
-    if (m_Data.m_Parameters.m_BiasEnabled)
-    {
-        InitializeArmComputeTensorData(*m_BiasTensor, m_Data.m_Bias);
-    }
-
-    m_ConvolutionLayer->prepare();
-    FreeUnusedTensors();
-}
-
-void NeonConvolution2dFloatWorkload::Execute() const
-{
-    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dFloatWorkload_Execute");
-    m_ConvolutionLayer->run();
-}
-
-void NeonConvolution2dFloatWorkload::ValidateData() const
-{
-    m_Data.ValidateInputsOutputs("NeonConvolution2dFloatWorkload", 1, 1);
-}
-
-} //namespace armnn
diff --git a/src/backends/neon/workloads/NeonConvolution2dFloatWorkload.hpp b/src/backends/neon/workloads/NeonConvolution2dFloatWorkload.hpp
deleted file mode 100644
index 14c77c8bd0..0000000000
--- a/src/backends/neon/workloads/NeonConvolution2dFloatWorkload.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include "NeonConvolution2dBaseWorkload.hpp"
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
-
-#include "arm_compute/runtime/MemoryManagerOnDemand.h"
-
-#include <memory>
-
-namespace armnn
-{
-
-class NeonConvolution2dFloatWorkload : public NeonConvolution2dBaseWorkload<DataType::Float16, DataType::Float32>
-{
-public:
-    NeonConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
-                                   std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
-
-    void Execute() const override;
-    void ValidateData() const override;
-};
-
-} //namespace armnn
-
diff --git a/src/backends/neon/workloads/NeonConvolution2dUint8Workload.cpp b/src/backends/neon/workloads/NeonConvolution2dUint8Workload.cpp
deleted file mode 100644
index 8572cbfb08..0000000000
--- a/src/backends/neon/workloads/NeonConvolution2dUint8Workload.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "NeonConvolution2dUint8Workload.hpp"
-
-namespace armnn
-{
-
-NeonConvolution2dUint8Workload::NeonConvolution2dUint8Workload(const Convolution2dQueueDescriptor& descriptor,
-    const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
-    : NeonConvolution2dBaseWorkload(descriptor, info, memoryManager)
-{
-    if (m_Data.m_Parameters.m_BiasEnabled)
-    {
-        InitializeArmComputeTensorData(*m_BiasTensor, m_Data.m_Bias);
-    }
-
-    m_ConvolutionLayer->prepare();
-    FreeUnusedTensors();
-}
-
-void NeonConvolution2dUint8Workload::Execute() const
-{
-    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dUint8Workload_Execute");
-    m_ConvolutionLayer->run();
-}
-
-void NeonConvolution2dUint8Workload::ValidateData() const
-{
-    m_Data.ValidateInputsOutputs("NeonConvolution2dUint8Workload", 1, 1);
-}
-
-} //namespace armnn
diff --git a/src/backends/neon/workloads/NeonConvolution2dUint8Workload.hpp b/src/backends/neon/workloads/NeonConvolution2dUint8Workload.hpp
deleted file mode 100644
index ef60fc3e84..0000000000
--- a/src/backends/neon/workloads/NeonConvolution2dUint8Workload.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include "NeonConvolution2dBaseWorkload.hpp"
-
-#include "arm_compute/runtime/MemoryManagerOnDemand.h"
-
-#include <memory>
-
-namespace armnn
-{
-
-class NeonConvolution2dUint8Workload : public NeonConvolution2dBaseWorkload<DataType::QuantisedAsymm8>
-{
-public:
-    NeonConvolution2dUint8Workload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
-                                   std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
-
-    virtual void ValidateData() const override;
-    virtual void Execute() const override;
-private:
-};
-
-} //namespace armnnn
-
diff --git a/src/backends/neon/workloads/NeonConvolution2dBaseWorkload.cpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp
index b11d10fd2f..c26cdea92b 100644
--- a/src/backends/neon/workloads/NeonConvolution2dBaseWorkload.cpp
+++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.cpp
@@ -3,12 +3,12 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonConvolution2dWorkload.hpp"
+
 #include <backends/CpuTensorHandle.hpp>
 #include <backends/aclCommon/ArmComputeTensorUtils.hpp>
 #include <backends/neon/NeonLayerSupport.hpp>
 
-#include "NeonConvolution2dBaseWorkload.hpp"
-
 #include <armnn/Types.hpp>
 #include <armnnUtils/Half.hpp>
 
@@ -47,15 +47,14 @@ arm_compute::Status NeonConvolution2dWorkloadValidate(const TensorInfo& input,
                                                      layerInfo);
 }
 
-template<armnn::DataType... dataTypes>
-NeonConvolution2dBaseWorkload<dataTypes...>::NeonConvolution2dBaseWorkload(
+NeonConvolution2dWorkload::NeonConvolution2dWorkload(
     const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
     std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
-    : TypedWorkload<Convolution2dQueueDescriptor, dataTypes...>(descriptor, info)
+    : BaseWorkload<Convolution2dQueueDescriptor>(descriptor, info)
 {
     using arm_compute::NEDirectConvolutionLayer;
 
-    ValidateData();
+    m_Data.ValidateInputsOutputs("NeonConvolution2dWorkload", 1, 1);
 
     // todo: check tensor shapes match.
 
@@ -111,17 +110,25 @@ NeonConvolution2dBaseWorkload<dataTypes...>::NeonConvolution2dBaseWorkload(
 
     InitializeArmComputeTensorData(*m_KernelTensor, m_Data.m_Weight);
 
+    if (m_Data.m_Parameters.m_BiasEnabled)
+    {
+        InitializeArmComputeTensorData(*m_BiasTensor, m_Data.m_Bias);
+    }
+
+    m_ConvolutionLayer->prepare();
+    FreeUnusedTensors();
 }
 
-template<armnn::DataType... dataTypes>
-void NeonConvolution2dBaseWorkload<dataTypes...>::FreeUnusedTensors()
+void NeonConvolution2dWorkload::Execute() const
+{
+    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dWorkload_Execute");
+    m_ConvolutionLayer->run();
+}
+
+void NeonConvolution2dWorkload::FreeUnusedTensors()
 {
     FreeTensorIfUnused(m_KernelTensor);
     FreeTensorIfUnused(m_BiasTensor);
 }
 
-// Generates known implementations for linker.
-template class NeonConvolution2dBaseWorkload<armnn::DataType::Float16, armnn::DataType::Float32>;
-template class NeonConvolution2dBaseWorkload<armnn::DataType::QuantisedAsymm8>;
-
 } //namespace armnn
diff --git a/src/backends/neon/workloads/NeonConvolution2dBaseWorkload.hpp b/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp
index 1cd30c70f9..573bb1a3e2 100644
--- a/src/backends/neon/workloads/NeonConvolution2dBaseWorkload.hpp
+++ b/src/backends/neon/workloads/NeonConvolution2dWorkload.hpp
@@ -24,24 +24,24 @@ arm_compute::Status NeonConvolution2dWorkloadValidate(const TensorInfo& input,
     const TensorInfo& weights,
     const Optional<TensorInfo>& biases);
 
-template<armnn::DataType... dataTypes>
-class NeonConvolution2dBaseWorkload : public TypedWorkload<Convolution2dQueueDescriptor, dataTypes...>
+class NeonConvolution2dWorkload : public BaseWorkload<Convolution2dQueueDescriptor>
 {
 public:
-    using TypedWorkload<Convolution2dQueueDescriptor, dataTypes...>::m_Data;
+    using BaseWorkload<Convolution2dQueueDescriptor>::m_Data;
 
-    NeonConvolution2dBaseWorkload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
-                                  std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+    NeonConvolution2dWorkload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
+                              std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
 
-    virtual void ValidateData() const {};
+    void Execute() const override;
 
-protected:
+private:
     std::unique_ptr<arm_compute::IFunction> m_ConvolutionLayer;
 
     std::unique_ptr<arm_compute::Tensor> m_KernelTensor;
     std::unique_ptr<arm_compute::Tensor> m_BiasTensor;
 
     void FreeUnusedTensors();
+
 };
 
 } //namespace armnn
diff --git a/src/backends/neon/workloads/NeonWorkloads.hpp b/src/backends/neon/workloads/NeonWorkloads.hpp
index 702ddb5c82..688b1f5828 100644
--- a/src/backends/neon/workloads/NeonWorkloads.hpp
+++ b/src/backends/neon/workloads/NeonWorkloads.hpp
@@ -10,9 +10,7 @@
 #include "NeonConstantWorkload.hpp"
 #include "NeonConvertFp16ToFp32Workload.hpp"
 #include "NeonConvertFp32ToFp16Workload.hpp"
-#include "NeonConvolution2dBaseWorkload.hpp"
-#include "NeonConvolution2dFloatWorkload.hpp"
-#include "NeonConvolution2dUint8Workload.hpp"
+#include "NeonConvolution2dWorkload.hpp"
 #include "NeonDepthwiseConvolutionFloatWorkload.hpp"
 #include "NeonDepthwiseConvolutionUint8Workload.hpp"
 #include "NeonFloorFloatWorkload.hpp"