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, 69 insertions, 20 deletions

diff --git a/src/backends/cl/ClLayerSupport.cpp b/src/backends/cl/ClLayerSupport.cpp
index c5ed8bff2a..bd2be57386 100644
--- a/src/backends/cl/ClLayerSupport.cpp
+++ b/src/backends/cl/ClLayerSupport.cpp
@@ -209,6 +209,24 @@ bool ClLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
                                    descriptor);
 }
 
+bool ClLayerSupport::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(ClGreaterWorkloadValidate,
+                                       reasonIfUnsupported,
+                                       input0,
+                                       input1,
+                                       output);
+    }
+
+    return false;
+}
+
 bool ClLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                                        const TensorInfo& output,
                                        const ConcatDescriptor& descriptor,
@@ -398,11 +416,8 @@ bool ClLayerSupport::IsGreaterSupported(const TensorInfo& input0,
                                         const TensorInfo& output,
                                         Optional<std::string&> reasonIfUnsupported) const
 {
-    FORWARD_WORKLOAD_VALIDATE_FUNC(ClGreaterWorkloadValidate,
-                                   reasonIfUnsupported,
-                                   input0,
-                                   input1,
-                                   output);
+    ComparisonDescriptor descriptor(ComparisonOperation::Greater);
+    return IsComparisonSupported(input0, input1, output, descriptor, reasonIfUnsupported);
 }
 
 bool ClLayerSupport::IsInputSupported(const TensorInfo& input,
diff --git a/src/backends/cl/ClLayerSupport.hpp b/src/backends/cl/ClLayerSupport.hpp
index 59e849316f..26eb42e092 100644
--- a/src/backends/cl/ClLayerSupport.hpp
+++ b/src/backends/cl/ClLayerSupport.hpp
@@ -40,6 +40,12 @@ public:
                                    const BatchToSpaceNdDescriptor& descriptor,
                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
+    bool IsComparisonSupported(const TensorInfo& input0,
+                               const TensorInfo& input1,
+                               const TensorInfo& ouput,
+                               const ComparisonDescriptor& descriptor,
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                            const TensorInfo& output,
                            const ConcatDescriptor& descriptor,
@@ -102,6 +108,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& ouput,
diff --git a/src/backends/cl/ClWorkloadFactory.cpp b/src/backends/cl/ClWorkloadFactory.cpp
index c427ae7e12..04e09f4ff1 100644
--- a/src/backends/cl/ClWorkloadFactory.cpp
+++ b/src/backends/cl/ClWorkloadFactory.cpp
@@ -157,6 +157,20 @@ std::unique_ptr<IWorkload> ClWorkloadFactory::CreateBatchToSpaceNd(const BatchTo
     return MakeWorkload<ClBatchToSpaceNdWorkload>(descriptor, info);
 }
 
+std::unique_ptr<IWorkload> ClWorkloadFactory::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 MakeWorkload<ClGreaterFloat32Workload, ClGreaterUint8Workload>(greaterQueueDescriptor, info);
+    }
+    return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
+}
+
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConcat(const ConcatQueueDescriptor& descriptor,
                                                            const WorkloadInfo& info) const
 {
@@ -230,7 +244,12 @@ std::unique_ptr<IWorkload> ClWorkloadFactory::CreateDivision(const DivisionQueue
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateEqual(const EqualQueueDescriptor& descriptor,
                                                           const WorkloadInfo& info) const
 {
-    return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
+    boost::ignore_unused(descriptor);
+
+    ComparisonQueueDescriptor comparisonDescriptor;
+    comparisonDescriptor.m_Parameters = ComparisonDescriptor(ComparisonOperation::Equal);
+
+    return CreateComparison(comparisonDescriptor, info);
 }
 
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFakeQuantization(
@@ -261,7 +280,12 @@ std::unique_ptr<IWorkload> ClWorkloadFactory::CreateGather(const GatherQueueDesc
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateGreater(const GreaterQueueDescriptor& descriptor,
                                                             const WorkloadInfo& info) const
 {
-    return MakeWorkload<ClGreaterFloat32Workload, ClGreaterUint8Workload>(descriptor, info);
+    boost::ignore_unused(descriptor);
+
+    ComparisonQueueDescriptor comparisonDescriptor;
+    comparisonDescriptor.m_Parameters = ComparisonDescriptor(ComparisonOperation::Greater);
+
+    return CreateComparison(comparisonDescriptor, info);
 }
 
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
diff --git a/src/backends/cl/ClWorkloadFactory.hpp b/src/backends/cl/ClWorkloadFactory.hpp
index 9dbc615a4e..1cae6e1faf 100644
--- a/src/backends/cl/ClWorkloadFactory.hpp
+++ b/src/backends/cl/ClWorkloadFactory.hpp
@@ -53,6 +53,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;
 
diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp
index 59d26edf22..26f15b77da 100644
--- a/src/backends/cl/test/ClEndToEndTests.cpp
+++ b/src/backends/cl/test/ClEndToEndTests.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>
@@ -122,9 +122,9 @@ BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndTest)
     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(ClGreaterSimpleEndToEndUint8Test)
@@ -132,9 +132,9 @@ BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndUint8Test)
     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(ClGreaterBroadcastEndToEndTest)
@@ -142,9 +142,9 @@ BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndTest)
     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(ClGreaterBroadcastEndToEndUint8Test)
@@ -152,9 +152,9 @@ BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test)
     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);
 }
 
 // InstanceNormalization