IVGCVSW-2792 Update Neon Mul/Sub workload for latest CL master

* Update Neon Subtraction/Multiplication to use BaseWorkload
* Add Uint8 tests for Subtraction/Multiplication

Change-Id: Ied2aa048924817a4db0025b9bd9e54151667bd74
Signed-off-by: Conor Kennedy <conor.kennedy@arm.com>

11 files changed, 56 insertions, 40 deletions

diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp
index 53399a9bf3..46a7e6f79f 100644
--- a/src/backends/neon/NeonLayerSupport.cpp
+++ b/src/backends/neon/NeonLayerSupport.cpp
@@ -28,7 +28,7 @@
 #include "workloads/NeonMeanWorkload.hpp"
 #include "workloads/NeonMergerWorkload.hpp"
 #include "workloads/NeonMinimumWorkload.hpp"
-#include "workloads/NeonMultiplicationFloatWorkload.hpp"
+#include "workloads/NeonMultiplicationWorkload.hpp"
 #include "workloads/NeonNormalizationFloatWorkload.hpp"
 #include "workloads/NeonFullyConnectedWorkload.hpp"
 #include "workloads/NeonPadWorkload.hpp"
@@ -36,7 +36,7 @@
 #include "workloads/NeonPooling2dWorkload.hpp"
 #include "workloads/NeonResizeBilinearWorkload.hpp"
 #include "workloads/NeonSoftmaxBaseWorkload.hpp"
-#include "workloads/NeonSubtractionFloatWorkload.hpp"
+#include "workloads/NeonSubtractionWorkload.hpp"
 #endif
 
 using namespace boost;
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index d9bd8b5223..101e59d0c4 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -174,7 +174,7 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateAddition(const Addi
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateMultiplication(
     const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info) const
 {
-    return MakeWorkloadHelper<NeonMultiplicationFloatWorkload, NullWorkload>(descriptor, info);
+    return std::make_unique<NeonMultiplicationWorkload>(descriptor, info);
 }
 
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateDivision(
@@ -186,7 +186,7 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateDivision(
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateSubtraction(
     const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info) const
 {
-    return MakeWorkloadHelper<NeonSubtractionFloatWorkload, NullWorkload>(descriptor, info);
+    return std::make_unique<NeonSubtractionWorkload>(descriptor, info);
 }
 
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateBatchNormalization(
diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk
index d9f2ad2255..c06d05f3cc 100644
--- a/src/backends/neon/backend.mk
+++ b/src/backends/neon/backend.mk
@@ -36,7 +36,7 @@ BACKEND_SOURCES := \
         workloads/NeonMeanWorkload.cpp \
         workloads/NeonMergerWorkload.cpp \
         workloads/NeonMinimumWorkload.cpp \
-        workloads/NeonMultiplicationFloatWorkload.cpp \
+        workloads/NeonMultiplicationWorkload.cpp \
         workloads/NeonNormalizationFloatWorkload.cpp \
         workloads/NeonPadWorkload.cpp \
         workloads/NeonPermuteWorkload.cpp \
@@ -46,7 +46,7 @@ BACKEND_SOURCES := \
         workloads/NeonSoftmaxBaseWorkload.cpp \
         workloads/NeonSoftmaxFloatWorkload.cpp \
         workloads/NeonSoftmaxUint8Workload.cpp \
-        workloads/NeonSubtractionFloatWorkload.cpp
+        workloads/NeonSubtractionWorkload.cpp
 
 else
 
diff --git a/src/backends/neon/test/NeonCreateWorkloadTests.cpp b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
index 86fc457130..d4065898a8 100644
--- a/src/backends/neon/test/NeonCreateWorkloadTests.cpp
+++ b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
@@ -125,7 +125,7 @@ BOOST_AUTO_TEST_CASE(CreateAdditionFloatWorkload)
 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
 BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload)
 {
-    NeonCreateElementwiseWorkloadTest<NeonSubtractionFloatWorkload,
+    NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
                                       SubtractionQueueDescriptor,
                                       SubtractionLayer,
                                       DataType::Float16>();
@@ -134,16 +134,24 @@ BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload)
 
 BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload)
 {
-    NeonCreateElementwiseWorkloadTest<NeonSubtractionFloatWorkload,
+    NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
                                       SubtractionQueueDescriptor,
                                       SubtractionLayer,
                                       DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateSubtractionUint8Workload)
+{
+    NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
+                                      SubtractionQueueDescriptor,
+                                      SubtractionLayer,
+                                      DataType::QuantisedAsymm8>();
+}
+
 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
 BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16Workload)
 {
-    NeonCreateElementwiseWorkloadTest<NeonMultiplicationFloatWorkload,
+    NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
                                       MultiplicationQueueDescriptor,
                                       MultiplicationLayer,
                                       DataType::Float16>();
@@ -152,12 +160,20 @@ BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16Workload)
 
 BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkload)
 {
-    NeonCreateElementwiseWorkloadTest<NeonMultiplicationFloatWorkload,
+    NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
                                       MultiplicationQueueDescriptor,
                                       MultiplicationLayer,
                                       DataType::Float32>();
 }
 
+BOOST_AUTO_TEST_CASE(CreateMultiplicationUint8Workload)
+{
+    NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
+                                      MultiplicationQueueDescriptor,
+                                      MultiplicationLayer,
+                                      DataType::QuantisedAsymm8>();
+}
+
 template <typename BatchNormalizationWorkloadType, typename armnn::DataType DataType>
 static void NeonCreateBatchNormalizationWorkloadTest(DataLayout dataLayout)
 {
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index 8370da4d14..01773dba03 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -313,11 +313,17 @@ ARMNN_AUTO_TEST_CASE(AddBroadcast1Element, AdditionBroadcast1ElementTest)
 ARMNN_AUTO_TEST_CASE(SimpleSub, SubtractionTest)
 ARMNN_AUTO_TEST_CASE(SubBroadcast1Element, SubtractionBroadcast1ElementTest)
 ARMNN_AUTO_TEST_CASE(SubBroadcast, SubtractionBroadcastTest)
+ARMNN_AUTO_TEST_CASE(SubtractionUint8, SubtractionUint8Test)
+ARMNN_AUTO_TEST_CASE(SubBroadcastUint8, SubtractionBroadcastUint8Test)
+ARMNN_AUTO_TEST_CASE(SubBroadcast1ElementUint8, SubtractionBroadcast1ElementUint8Test)
 
 // Mul
 ARMNN_AUTO_TEST_CASE(SimpleMultiplication, MultiplicationTest)
 ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest)
 ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVector, MultiplicationBroadcast1DVectorTest)
+ARMNN_AUTO_TEST_CASE(MultiplicationUint8, MultiplicationUint8Test)
+ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1ElementUint8, MultiplicationBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVectorUint8, MultiplicationBroadcast1DVectorUint8Test)
 
 // Batch Norm
 ARMNN_AUTO_TEST_CASE(BatchNorm, BatchNormTest)
diff --git a/src/backends/neon/workloads/CMakeLists.txt b/src/backends/neon/workloads/CMakeLists.txt
index 31b0866e23..3bbf64d4fb 100644
--- a/src/backends/neon/workloads/CMakeLists.txt
+++ b/src/backends/neon/workloads/CMakeLists.txt
@@ -38,8 +38,8 @@ list(APPEND armnnNeonBackendWorkloads_sources
     NeonMergerWorkload.hpp
     NeonMinimumWorkload.cpp
     NeonMinimumWorkload.hpp
-    NeonMultiplicationFloatWorkload.cpp
-    NeonMultiplicationFloatWorkload.hpp
+    NeonMultiplicationWorkload.cpp
+    NeonMultiplicationWorkload.hpp
     NeonNormalizationFloatWorkload.cpp
     NeonNormalizationFloatWorkload.hpp
     NeonPadWorkload.cpp
@@ -59,8 +59,8 @@ list(APPEND armnnNeonBackendWorkloads_sources
     NeonSoftmaxUint8Workload.cpp
     NeonSoftmaxUint8Workload.hpp
     NeonSplitterWorkload.hpp
-    NeonSubtractionFloatWorkload.cpp
-    NeonSubtractionFloatWorkload.hpp
+    NeonSubtractionWorkload.cpp
+    NeonSubtractionWorkload.hpp
     NeonWorkloads.hpp
     NeonWorkloadUtils.hpp
 )
diff --git a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.cpp b/src/backends/neon/workloads/NeonMultiplicationWorkload.cpp
index 778e78213c..6398b65946 100644
--- a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.cpp
+++ b/src/backends/neon/workloads/NeonMultiplicationWorkload.cpp
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include "NeonMultiplicationFloatWorkload.hpp"
+#include "NeonMultiplicationWorkload.hpp"
 
 #include "NeonWorkloadUtils.hpp"
 
@@ -31,11 +31,11 @@ arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0,
                                                             arm_compute::RoundingPolicy::TO_ZERO);
 }
 
-NeonMultiplicationFloatWorkload::NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor,
-                                                                 const WorkloadInfo& info)
-    : FloatWorkload<MultiplicationQueueDescriptor>(descriptor, info)
+NeonMultiplicationWorkload::NeonMultiplicationWorkload(const MultiplicationQueueDescriptor& descriptor,
+                                                       const WorkloadInfo& info)
+    : BaseWorkload<MultiplicationQueueDescriptor>(descriptor, info)
 {
-    m_Data.ValidateInputsOutputs("NeonMultiplicationFloatWorkload", 2, 1);
+    m_Data.ValidateInputsOutputs("NeonMultiplicationWorkload", 2, 1);
 
     arm_compute::ITensor& input1 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
     arm_compute::ITensor& input2 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
@@ -54,12 +54,10 @@ NeonMultiplicationFloatWorkload::NeonMultiplicationFloatWorkload(const Multiplic
     m_PixelWiseMultiplication.reset(layer.release());
 }
 
-void NeonMultiplicationFloatWorkload::Execute() const
+void NeonMultiplicationWorkload::Execute() const
 {
-    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloatWorkload_Execute");
+    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationWorkload_Execute");
     m_PixelWiseMultiplication->run();
 }
 
 } //namespace armnn
-
-
diff --git a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.hpp b/src/backends/neon/workloads/NeonMultiplicationWorkload.hpp
index a65ad4ec4c..bfbaf776c1 100644
--- a/src/backends/neon/workloads/NeonMultiplicationFloatWorkload.hpp
+++ b/src/backends/neon/workloads/NeonMultiplicationWorkload.hpp
@@ -18,10 +18,10 @@ arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo& input0,
                                                        const TensorInfo& input1,
                                                        const TensorInfo& output);
 
-class NeonMultiplicationFloatWorkload : public FloatWorkload<MultiplicationQueueDescriptor>
+class NeonMultiplicationWorkload : public BaseWorkload<MultiplicationQueueDescriptor>
 {
 public:
-    NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
+    NeonMultiplicationWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
     virtual void Execute() const override;
 
 private:
@@ -29,7 +29,3 @@ private:
 };
 
 } //namespace armnn
-
-
-
-
diff --git a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.cpp b/src/backends/neon/workloads/NeonSubtractionWorkload.cpp
index e39f8aa18e..39176aac61 100644
--- a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.cpp
+++ b/src/backends/neon/workloads/NeonSubtractionWorkload.cpp
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include "NeonSubtractionFloatWorkload.hpp"
+#include "NeonSubtractionWorkload.hpp"
 
 #include "NeonWorkloadUtils.hpp"
 #include <aclCommon/ArmComputeTensorUtils.hpp>
@@ -28,11 +28,11 @@ arm_compute::Status NeonSubtractionWorkloadValidate(const TensorInfo& input0,
                                                           arm_compute::ConvertPolicy::SATURATE);
 }
 
-NeonSubtractionFloatWorkload::NeonSubtractionFloatWorkload(const SubtractionQueueDescriptor& descriptor,
-                                                           const WorkloadInfo& info)
-    : FloatWorkload<SubtractionQueueDescriptor>(descriptor, info)
+NeonSubtractionWorkload::NeonSubtractionWorkload(const SubtractionQueueDescriptor& descriptor,
+                                                 const WorkloadInfo& info)
+    : BaseWorkload<SubtractionQueueDescriptor>(descriptor, info)
 {
-    m_Data.ValidateInputsOutputs("NeonSubtractionFloatWorkload", 2, 1);
+    m_Data.ValidateInputsOutputs("NeonSubtractionWorkload", 2, 1);
 
     arm_compute::ITensor& input1 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
     arm_compute::ITensor& input2 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
@@ -43,9 +43,9 @@ NeonSubtractionFloatWorkload::NeonSubtractionFloatWorkload(const SubtractionQueu
     m_SubLayer.reset(layer.release());
 }
 
-void NeonSubtractionFloatWorkload::Execute() const
+void NeonSubtractionWorkload::Execute() const
 {
-    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSubtractionFloatWorkload_Execute");
+    ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSubtractionWorkload_Execute");
     m_SubLayer->run();
 }
 
diff --git a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.hpp b/src/backends/neon/workloads/NeonSubtractionWorkload.hpp
index 5dce112299..3326f8bf4a 100644
--- a/src/backends/neon/workloads/NeonSubtractionFloatWorkload.hpp
+++ b/src/backends/neon/workloads/NeonSubtractionWorkload.hpp
@@ -19,10 +19,10 @@ arm_compute::Status NeonSubtractionWorkloadValidate(const TensorInfo& input0,
                                                     const TensorInfo& input1,
                                                     const TensorInfo& output);
 
-class NeonSubtractionFloatWorkload : public FloatWorkload<SubtractionQueueDescriptor>
+class NeonSubtractionWorkload : public BaseWorkload<SubtractionQueueDescriptor>
 {
 public:
-    NeonSubtractionFloatWorkload(const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info);
+    NeonSubtractionWorkload(const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info);
     virtual void Execute() const override;
 
 private:
diff --git a/src/backends/neon/workloads/NeonWorkloads.hpp b/src/backends/neon/workloads/NeonWorkloads.hpp
index af85eb2f50..04ea14eff7 100644
--- a/src/backends/neon/workloads/NeonWorkloads.hpp
+++ b/src/backends/neon/workloads/NeonWorkloads.hpp
@@ -21,7 +21,7 @@
 #include "NeonMeanWorkload.hpp"
 #include "NeonMergerWorkload.hpp"
 #include "NeonMinimumWorkload.hpp"
-#include "NeonMultiplicationFloatWorkload.hpp"
+#include "NeonMultiplicationWorkload.hpp"
 #include "NeonNormalizationFloatWorkload.hpp"
 #include "NeonPadWorkload.hpp"
 #include "NeonPermuteWorkload.hpp"
@@ -31,4 +31,4 @@
 #include "NeonSoftmaxFloatWorkload.hpp"
 #include "NeonSoftmaxUint8Workload.hpp"
 #include "NeonSplitterWorkload.hpp"
-#include "NeonSubtractionFloatWorkload.hpp"
+#include "NeonSubtractionWorkload.hpp"