IVGCVSW-3993 Add frontend and reference workload for ComparisonLayer

* Added frontend for ComparisonLayer
* Added RefComparisonWorkload
* Deprecated and removed Equal and Greater layers and workloads
* Updated tests to ensure backward compatibility

Signed-off-by: Aron Virginas-Tar <Aron.Virginas-Tar@arm.com>
Change-Id: Id50c880be1b567c531efff919c0c366d0a71cbe9

5 files changed, 71 insertions, 20 deletions

diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp
index 270cb6264f..cc96f63c1a 100644
--- a/src/backends/neon/NeonLayerSupport.cpp
+++ b/src/backends/neon/NeonLayerSupport.cpp
@@ -180,6 +180,24 @@ bool NeonLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
                                    descriptor);
 }
 
+bool NeonLayerSupport::IsComparisonSupported(const TensorInfo& input0,
+                                             const TensorInfo& input1,
+                                             const TensorInfo& output,
+                                             const ComparisonDescriptor& descriptor,
+                                             Optional<std::string&> reasonIfUnsupported) const
+{
+    if (descriptor.m_Operation == ComparisonOperation::Greater)
+    {
+        FORWARD_WORKLOAD_VALIDATE_FUNC(NeonGreaterWorkloadValidate,
+                                       reasonIfUnsupported,
+                                       input0,
+                                       input1,
+                                       output);
+    }
+
+    return false;
+}
+
 bool NeonLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                                          const TensorInfo& output,
                                          const ConcatDescriptor& descriptor,
@@ -354,11 +372,8 @@ bool NeonLayerSupport::IsGreaterSupported(const armnn::TensorInfo& input0,
                                           const armnn::TensorInfo& output,
                                           armnn::Optional<std::string&> reasonIfUnsupported) const
 {
-    FORWARD_WORKLOAD_VALIDATE_FUNC(NeonGreaterWorkloadValidate,
-                                   reasonIfUnsupported,
-                                   input0,
-                                   input1,
-                                   output);
+    ComparisonDescriptor descriptor(ComparisonOperation::Greater);
+    return IsComparisonSupported(input0, input1, output, descriptor, reasonIfUnsupported);
 }
 
 bool NeonLayerSupport::IsInputSupported(const TensorInfo& input,
diff --git a/src/backends/neon/NeonLayerSupport.hpp b/src/backends/neon/NeonLayerSupport.hpp
index d6a24ad43b..9c1ca2a729 100644
--- a/src/backends/neon/NeonLayerSupport.hpp
+++ b/src/backends/neon/NeonLayerSupport.hpp
@@ -40,6 +40,12 @@ public:
                                        const BatchNormalizationDescriptor& descriptor,
                                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
+    bool IsComparisonSupported(const TensorInfo& input0,
+                               const TensorInfo& input1,
+                               const TensorInfo& output,
+                               const ComparisonDescriptor& descriptor,
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                            const TensorInfo& output,
                            const ConcatDescriptor& descriptor,
@@ -98,6 +104,7 @@ public:
                                    const FullyConnectedDescriptor& descriptor,
                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
+    ARMNN_DEPRECATED_MSG("Use IsComparisonSupported instead")
     bool IsGreaterSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index 5bd8f293c5..dda1d7a132 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -131,6 +131,20 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateBatchToSpaceNd(const Batch
     return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
 }
 
+std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateComparison(const ComparisonQueueDescriptor& descriptor,
+                                                                 const WorkloadInfo& info) const
+{
+    if (descriptor.m_Parameters.m_Operation == ComparisonOperation::Greater)
+    {
+        GreaterQueueDescriptor greaterQueueDescriptor;
+        greaterQueueDescriptor.m_Inputs  = descriptor.m_Inputs;
+        greaterQueueDescriptor.m_Outputs = descriptor.m_Outputs;
+
+        return MakeWorkloadHelper<NeonGreaterFloat32Workload, NeonGreaterUint8Workload>(greaterQueueDescriptor, info);
+    }
+    return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
+}
+
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConcat(const ConcatQueueDescriptor& descriptor,
                                                                     const WorkloadInfo&          info) const
 {
@@ -203,7 +217,12 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateDivision(
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateEqual(const EqualQueueDescriptor& descriptor,
                                                             const WorkloadInfo& info) const
 {
-    return MakeWorkloadHelper<NullWorkload, NullWorkload>(descriptor, info);
+    boost::ignore_unused(descriptor);
+
+    ComparisonQueueDescriptor comparisonDescriptor;
+    comparisonDescriptor.m_Parameters = ComparisonDescriptor(ComparisonOperation::Equal);
+
+    return CreateComparison(comparisonDescriptor, info);
 }
 
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFakeQuantization(
@@ -235,7 +254,12 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateGather(const armnn::Gather
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateGreater(const GreaterQueueDescriptor& descriptor,
                                                               const WorkloadInfo& info) const
 {
-    return MakeWorkloadHelper<NeonGreaterFloat32Workload, NeonGreaterUint8Workload>(descriptor, info);
+    boost::ignore_unused(descriptor);
+
+    ComparisonQueueDescriptor comparisonDescriptor;
+    comparisonDescriptor.m_Parameters = ComparisonDescriptor(ComparisonOperation::Greater);
+
+    return CreateComparison(comparisonDescriptor, info);
 }
 
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp
index 9546164d36..5bee771528 100644
--- a/src/backends/neon/NeonWorkloadFactory.hpp
+++ b/src/backends/neon/NeonWorkloadFactory.hpp
@@ -57,6 +57,9 @@ public:
     std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
                                                     const WorkloadInfo& Info) const override;
 
+    std::unique_ptr<IWorkload> CreateComparison(const ComparisonQueueDescriptor& descriptor,
+                                                const WorkloadInfo& Info) const override;
+
     std::unique_ptr<IWorkload> CreateConcat(const ConcatQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
@@ -90,6 +93,7 @@ public:
     std::unique_ptr<IWorkload> CreateDivision(const DivisionQueueDescriptor& descriptor,
                                               const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG("Use CreateComparison instead")
     std::unique_ptr<IWorkload> CreateEqual(const EqualQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
@@ -105,6 +109,7 @@ public:
     std::unique_ptr<IWorkload> CreateGather(const GatherQueueDescriptor& descriptor,
                                             const WorkloadInfo& info) const override;
 
+    ARMNN_DEPRECATED_MSG("Use CreateComparison instead")
     std::unique_ptr<IWorkload> CreateGreater(const GreaterQueueDescriptor& descriptor,
                                              const WorkloadInfo& info) const override;
 
diff --git a/src/backends/neon/test/NeonEndToEndTests.cpp b/src/backends/neon/test/NeonEndToEndTests.cpp
index 88f7ae7b5d..5146a598c7 100644
--- a/src/backends/neon/test/NeonEndToEndTests.cpp
+++ b/src/backends/neon/test/NeonEndToEndTests.cpp
@@ -6,7 +6,7 @@
 #include <backendsCommon/test/EndToEndTestImpl.hpp>
 
 #include <backendsCommon/test/AbsEndToEndTestImpl.hpp>
-#include <backendsCommon/test/ArithmeticTestImpl.hpp>
+#include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp>
 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
@@ -80,9 +80,9 @@ BOOST_AUTO_TEST_CASE(NeonGreaterSimpleEndToEndTest)
     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 
-    ArithmeticSimpleEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
-                                                                                 LayerType::Greater,
-                                                                                 expectedOutput);
+    ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
+                                                       ComparisonOperation::Greater,
+                                                       expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(NeonGreaterSimpleEndToEndUint8Test)
@@ -90,9 +90,9 @@ BOOST_AUTO_TEST_CASE(NeonGreaterSimpleEndToEndUint8Test)
     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 
-    ArithmeticSimpleEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
-                                                                                         LayerType::Greater,
-                                                                                         expectedOutput);
+    ComparisonSimpleEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends,
+                                                               ComparisonOperation::Greater,
+                                                               expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(NeonGreaterBroadcastEndToEndTest)
@@ -100,9 +100,9 @@ BOOST_AUTO_TEST_CASE(NeonGreaterBroadcastEndToEndTest)
     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                 1, 1, 1, 1, 1, 1 });
 
-    ArithmeticBroadcastEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
-                                                                                    LayerType::Greater,
-                                                                                    expectedOutput);
+    ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
+                                                          ComparisonOperation::Greater,
+                                                          expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(NeonGreaterBroadcastEndToEndUint8Test)
@@ -110,9 +110,9 @@ BOOST_AUTO_TEST_CASE(NeonGreaterBroadcastEndToEndUint8Test)
     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                 1, 1, 1, 1, 1, 1 });
 
-    ArithmeticBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
-                                                                                            LayerType::Greater,
-                                                                                            expectedOutput);
+    ComparisonBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends,
+                                                                  ComparisonOperation::Greater,
+                                                                  expectedOutput);
 }
 
 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim0Test)