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

13 files changed, 346 insertions, 223 deletions

diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp
index 7d5555ce68..358106e5e9 100644
--- a/src/backends/backendsCommon/LayerSupportBase.cpp
+++ b/src/backends/backendsCommon/LayerSupportBase.cpp
@@ -84,6 +84,15 @@ bool LayerSupportBase::IsBatchToSpaceNdSupported(const TensorInfo& input,
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
+bool LayerSupportBase::IsComparisonSupported(const TensorInfo& input0,
+                                             const TensorInfo& input1,
+                                             const TensorInfo& output,
+                                             const ComparisonDescriptor& descriptor,
+                                             Optional<std::string&> reasonIfUnsupported) const
+{
+    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
+}
+
 bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                                          const TensorInfo& output,
                                          const OriginsDescriptor& descriptor,
diff --git a/src/backends/backendsCommon/LayerSupportBase.hpp b/src/backends/backendsCommon/LayerSupportBase.hpp
index cb660f5c2b..d4c37c1a91 100644
--- a/src/backends/backendsCommon/LayerSupportBase.hpp
+++ b/src/backends/backendsCommon/LayerSupportBase.hpp
@@ -46,6 +46,12 @@ public:
                                    const BatchToSpaceNdDescriptor& 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 OriginsDescriptor& descriptor,
@@ -108,6 +114,7 @@ public:
                              const TensorInfo& output,
                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
+    ARMNN_DEPRECATED_MSG("Use IsComparisonSupported instead")
     bool IsEqualSupported(const TensorInfo& input0,
                           const TensorInfo& input1,
                           const TensorInfo& output,
@@ -133,6 +140,7 @@ public:
                            const TensorInfo& output,
                            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/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp
index b8d4f0dfff..cfb38b4820 100644
--- a/src/backends/backendsCommon/WorkloadData.cpp
+++ b/src/backends/backendsCommon/WorkloadData.cpp
@@ -2779,4 +2779,28 @@ void DepthToSpaceQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) con
     }
 }
 
+void ComparisonQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
+{
+    const std::string descriptorName{"ComparisonQueueDescriptor"};
+
+    ValidateNumInputs(workloadInfo,  descriptorName, 2);
+    ValidateNumOutputs(workloadInfo, descriptorName, 1);
+
+    const TensorInfo& inputTensorInfo0 = workloadInfo.m_InputTensorInfos[0];
+    const TensorInfo& inputTensorInfo1 = workloadInfo.m_InputTensorInfos[1];
+    const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0];
+
+    ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
+                                       inputTensorInfo1,
+                                       outputTensorInfo,
+                                       descriptorName,
+                                       "input_0",
+                                       "input_1");
+
+    if (outputTensorInfo.GetDataType() != DataType::Boolean)
+    {
+        throw InvalidArgumentException(descriptorName + ": Output tensor type must be Boolean.");
+    }
+}
+
 } // namespace armnn
diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp
index 5a3600fc71..b45a1718f6 100644
--- a/src/backends/backendsCommon/WorkloadData.hpp
+++ b/src/backends/backendsCommon/WorkloadData.hpp
@@ -553,4 +553,9 @@ struct DepthToSpaceQueueDescriptor : QueueDescriptorWithParameters<DepthToSpaceD
     void Validate(const WorkloadInfo& workloadInfo) const;
 };
 
+struct ComparisonQueueDescriptor : QueueDescriptorWithParameters<ComparisonDescriptor>
+{
+    void Validate(const WorkloadInfo& workloadInfo) const;
+};
+
 } // namespace armnn
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index f19b48491a..30dfa023f9 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -148,6 +148,21 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
                                                                    reason);
             break;
         }
+        case LayerType::Comparison:
+        {
+            auto cLayer = boost::polymorphic_downcast<const ComparisonLayer*>(&layer);
+
+            const TensorInfo& input0 = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
+            const TensorInfo& input1 = layer.GetInputSlot(1).GetConnection()->GetTensorInfo();
+            const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
+
+            result = layerSupportObject->IsComparisonSupported(OverrideDataType(input0, dataType),
+                                                               OverrideDataType(input1, dataType),
+                                                               OverrideDataType(output, DataType::Boolean),
+                                                               cLayer->GetParameters(),
+                                                               reason);
+            break;
+        }
         case LayerType::Constant:
         {
             const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
@@ -268,17 +283,6 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
                                                                          reason);
             break;
         }
-        case LayerType::Equal:
-        {
-            const TensorInfo& input0 = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
-            const TensorInfo& input1 = layer.GetInputSlot(1).GetConnection()->GetTensorInfo();
-            const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
-            result = layerSupportObject->IsEqualSupported(OverrideDataType(input0, dataType),
-                                                          OverrideDataType(input1, dataType),
-                                                          OverrideDataType(output, dataType),
-                                                          reason);
-            break;
-        }
         case LayerType::FakeQuantization:
         {
             auto cLayer = boost::polymorphic_downcast<const FakeQuantizationLayer*>(&layer);
@@ -957,17 +961,6 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
                                                             reason);
             break;
         }
-        case LayerType::Greater:
-        {
-            const TensorInfo& input0 = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
-            const TensorInfo& input1 = layer.GetInputSlot(1).GetConnection()->GetTensorInfo();
-            const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
-            result = layerSupportObject->IsGreaterSupported(OverrideDataType(input0, dataType),
-                                                            OverrideDataType(input1, dataType),
-                                                            OverrideDataType(output, DataType::Boolean),
-                                                            reason);
-            break;
-        }
         case LayerType::Prelu:
         {
             const TensorInfo& input  = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
@@ -1065,6 +1058,12 @@ std::unique_ptr<IWorkload> IWorkloadFactory::CreateBatchToSpaceNd(const BatchToS
     return std::unique_ptr<IWorkload>();
 }
 
+std::unique_ptr<IWorkload> IWorkloadFactory::CreateComparison(const ComparisonQueueDescriptor& descriptor,
+                                                              const WorkloadInfo& info) const
+{
+    return std::unique_ptr<IWorkload>();
+}
+
 std::unique_ptr<IWorkload> IWorkloadFactory::CreateConcat(const ConcatQueueDescriptor& descriptor,
                                                           const WorkloadInfo& info) const
 {
diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp
index fa7a9d46a8..819b8c768b 100644
--- a/src/backends/backendsCommon/WorkloadFactory.hpp
+++ b/src/backends/backendsCommon/WorkloadFactory.hpp
@@ -69,6 +69,9 @@ public:
     virtual std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
                                                             const WorkloadInfo& Info) const;
 
+    virtual std::unique_ptr<IWorkload> CreateComparison(const ComparisonQueueDescriptor& descriptor,
+                                                        const WorkloadInfo& Info) const;
+
     virtual std::unique_ptr<IWorkload> CreateConcat(const ConcatQueueDescriptor& descriptor,
                                                     const WorkloadInfo&          info) const;
 
@@ -102,6 +105,7 @@ public:
     virtual std::unique_ptr<IWorkload> CreateDivision(const DivisionQueueDescriptor& descriptor,
                                                       const WorkloadInfo& info) const;
 
+    ARMNN_DEPRECATED_MSG("Use CreateComparison instead")
     virtual std::unique_ptr<IWorkload> CreateEqual(const EqualQueueDescriptor& descriptor,
                                                    const WorkloadInfo& Info) const;
 
@@ -117,6 +121,7 @@ public:
     virtual std::unique_ptr<IWorkload> CreateGather(const GatherQueueDescriptor& descriptor,
                                                     const WorkloadInfo& info) const;
 
+    ARMNN_DEPRECATED_MSG("Use CreateComparison instead")
     virtual std::unique_ptr<IWorkload> CreateGreater(const GreaterQueueDescriptor& descriptor,
                                                      const WorkloadInfo& info) const;
 
diff --git a/src/backends/backendsCommon/test/ArithmeticTestImpl.hpp b/src/backends/backendsCommon/test/ArithmeticTestImpl.hpp
deleted file mode 100644
index d0e85dd31d..0000000000
--- a/src/backends/backendsCommon/test/ArithmeticTestImpl.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include "CommonTestUtils.hpp"
-
-#include <ResolveType.hpp>
-
-#include <armnn/INetwork.hpp>
-
-#include <boost/test/unit_test.hpp>
-
-#include <vector>
-
-namespace
-{
-
-template<armnn::DataType ArmnnTypeInput, armnn::DataType ArmnnTypeOutput>
-INetworkPtr CreateArithmeticNetwork(const std::vector<TensorShape>& inputShapes,
-                                    const TensorShape& outputShape,
-                                    const LayerType type,
-                                    const float qScale = 1.0f,
-                                    const int32_t qOffset = 0)
-{
-    using namespace armnn;
-
-    // Builds up the structure of the network.
-    INetworkPtr net(INetwork::Create());
-
-    IConnectableLayer* arithmeticLayer = nullptr;
-
-    switch(type){
-        case LayerType::Equal: arithmeticLayer = net->AddEqualLayer("equal"); break;
-        case LayerType::Greater: arithmeticLayer = net->AddGreaterLayer("greater"); break;
-        default: BOOST_TEST_FAIL("Non-Arithmetic layer type called.");
-    }
-
-    for (unsigned int i = 0; i < inputShapes.size(); ++i)
-    {
-        TensorInfo inputTensorInfo(inputShapes[i], ArmnnTypeInput, qScale, qOffset);
-        IConnectableLayer* input = net->AddInputLayer(boost::numeric_cast<LayerBindingId>(i));
-        Connect(input, arithmeticLayer, inputTensorInfo, 0, i);
-    }
-
-    TensorInfo outputTensorInfo(outputShape, ArmnnTypeOutput, qScale, qOffset);
-    IConnectableLayer* output = net->AddOutputLayer(0, "output");
-    Connect(arithmeticLayer, output, outputTensorInfo, 0, 0);
-
-    return net;
-}
-
-template<armnn::DataType ArmnnInputType,
-         armnn::DataType ArmnnOutputType,
-         typename TInput = armnn::ResolveType<ArmnnInputType>,
-         typename TOutput = armnn::ResolveType<ArmnnOutputType>>
-void ArithmeticSimpleEndToEnd(const std::vector<BackendId>& backends,
-                              const LayerType type,
-                              const std::vector<TOutput> expectedOutput)
-{
-    using namespace armnn;
-
-    const std::vector<TensorShape> inputShapes{{ 2, 2, 2, 2 }, { 2, 2, 2, 2 }};
-    const TensorShape& outputShape = { 2, 2, 2, 2 };
-
-    // Builds up the structure of the network
-    INetworkPtr net = CreateArithmeticNetwork<ArmnnInputType, ArmnnOutputType>(inputShapes, outputShape, type);
-
-    BOOST_TEST_CHECKPOINT("create a network");
-
-    const std::vector<TInput> input0({ 1, 1, 1, 1,  5, 5, 5, 5,
-                                       3, 3, 3, 3,  4, 4, 4, 4 });
-
-    const std::vector<TInput> input1({ 1, 1, 1, 1,  3, 3, 3, 3,
-                                       5, 5, 5, 5,  4, 4, 4, 4 });
-
-    std::map<int, std::vector<TInput>> inputTensorData = {{ 0, input0 }, { 1, input1 }};
-    std::map<int, std::vector<TOutput>> expectedOutputData = {{ 0, expectedOutput }};
-
-    EndToEndLayerTestImpl<ArmnnInputType, ArmnnOutputType>(move(net), inputTensorData, expectedOutputData, backends);
-}
-
-template<armnn::DataType ArmnnInputType,
-         armnn::DataType ArmnnOutputType,
-         typename TInput = armnn::ResolveType<ArmnnInputType>,
-         typename TOutput = armnn::ResolveType<ArmnnOutputType>>
-void ArithmeticBroadcastEndToEnd(const std::vector<BackendId>& backends,
-                                 const LayerType type,
-                                 const std::vector<TOutput> expectedOutput)
-{
-    using namespace armnn;
-
-    const std::vector<TensorShape> inputShapes{{ 1, 2, 2, 3 }, { 1, 1, 1, 3 }};
-    const TensorShape& outputShape = { 1, 2, 2, 3 };
-
-    // Builds up the structure of the network
-    INetworkPtr net = CreateArithmeticNetwork<ArmnnInputType, ArmnnOutputType>(inputShapes, outputShape, type);
-
-    BOOST_TEST_CHECKPOINT("create a network");
-
-    const std::vector<TInput> input0({ 1, 2, 3, 1, 0, 6,
-                                       7, 8, 9, 10, 11, 12 });
-
-    const std::vector<TInput> input1({ 1, 1, 3 });
-
-    std::map<int, std::vector<TInput>> inputTensorData = {{ 0, input0 }, { 1, input1 }};
-    std::map<int, std::vector<TOutput>> expectedOutputData = {{ 0, expectedOutput }};
-
-    EndToEndLayerTestImpl<ArmnnInputType, ArmnnOutputType>(move(net), inputTensorData, expectedOutputData, backends);
-}
-
-} // anonymous namespace
diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index 797dc90952..7449e69dcd 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -10,6 +10,7 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     BackendRegistryTests.cpp
     CommonTestUtils.cpp
     CommonTestUtils.hpp
+    ComparisonEndToEndTestImpl.hpp
     DataLayoutUtils.hpp
     DataTypeUtils.hpp
     DepthToSpaceEndToEndTestImpl.hpp
@@ -58,6 +59,7 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     layerTests/BatchNormalizationTestImpl.cpp
     layerTests/BatchNormalizationTestImpl.hpp
     layerTests/BatchToSpaceNdTestImpl.hpp
+    layerTests/ComparisonTestImpl.hpp
     layerTests/ConcatTestImpl.cpp
     layerTests/ConcatTestImpl.hpp
     layerTests/ConstantTestImpl.cpp
diff --git a/src/backends/backendsCommon/test/ComparisonEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/ComparisonEndToEndTestImpl.hpp
new file mode 100644
index 0000000000..dc53b7b246
--- /dev/null
+++ b/src/backends/backendsCommon/test/ComparisonEndToEndTestImpl.hpp
@@ -0,0 +1,103 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "CommonTestUtils.hpp"
+
+#include <ResolveType.hpp>
+
+#include <armnn/INetwork.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace
+{
+
+template<armnn::DataType ArmnnTypeInput>
+INetworkPtr CreateComparisonNetwork(const std::vector<TensorShape>& inputShapes,
+                                    const TensorShape& outputShape,
+                                    ComparisonOperation operation,
+                                    const float qScale = 1.0f,
+                                    const int32_t qOffset = 0)
+{
+    using namespace armnn;
+
+    INetworkPtr net(INetwork::Create());
+
+    ComparisonDescriptor descriptor(operation);
+    IConnectableLayer* comparisonLayer = net->AddComparisonLayer(descriptor, "comparison");
+
+    for (unsigned int i = 0; i < inputShapes.size(); ++i)
+    {
+        TensorInfo inputTensorInfo(inputShapes[i], ArmnnTypeInput, qScale, qOffset);
+        IConnectableLayer* input = net->AddInputLayer(boost::numeric_cast<LayerBindingId>(i));
+        Connect(input, comparisonLayer, inputTensorInfo, 0, i);
+    }
+
+    TensorInfo outputTensorInfo(outputShape, DataType::Boolean, qScale, qOffset);
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+    Connect(comparisonLayer, output, outputTensorInfo, 0, 0);
+
+    return net;
+}
+
+template<armnn::DataType ArmnnInType,
+         typename TInput = armnn::ResolveType<ArmnnInType>>
+void ComparisonSimpleEndToEnd(const std::vector<BackendId>& backends,
+                              ComparisonOperation operation,
+                              const std::vector<uint8_t> expectedOutput)
+{
+    using namespace armnn;
+
+    const std::vector<TensorShape> inputShapes{{ 2, 2, 2, 2 }, { 2, 2, 2, 2 }};
+    const TensorShape& outputShape = { 2, 2, 2, 2 };
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateComparisonNetwork<ArmnnInType>(inputShapes, outputShape, operation);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    const std::vector<TInput> input0({ 1, 1, 1, 1,  5, 5, 5, 5,
+                                       3, 3, 3, 3,  4, 4, 4, 4 });
+
+    const std::vector<TInput> input1({ 1, 1, 1, 1,  3, 3, 3, 3,
+                                       5, 5, 5, 5,  4, 4, 4, 4 });
+
+    std::map<int, std::vector<TInput>>  inputTensorData    = {{ 0, input0 }, { 1, input1 }};
+    std::map<int, std::vector<uint8_t>> expectedOutputData = {{ 0, expectedOutput }};
+
+    EndToEndLayerTestImpl<ArmnnInType, DataType::Boolean>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnInType,
+         typename TInput = armnn::ResolveType<ArmnnInType>>
+void ComparisonBroadcastEndToEnd(const std::vector<BackendId>& backends,
+                                 ComparisonOperation operation,
+                                 const std::vector<uint8_t> expectedOutput)
+{
+    using namespace armnn;
+
+    const std::vector<TensorShape> inputShapes{{ 1, 2, 2, 3 }, { 1, 1, 1, 3 }};
+    const TensorShape& outputShape = { 1, 2, 2, 3 };
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateComparisonNetwork<ArmnnInType>(inputShapes, outputShape, operation);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    const std::vector<TInput> input0({ 1, 2, 3, 1, 0, 6,
+                                       7, 8, 9, 10, 11, 12 });
+
+    const std::vector<TInput> input1({ 1, 1, 3 });
+
+    std::map<int, std::vector<TInput>>  inputTensorData    = {{ 0, input0 }, { 1, input1 }};
+    std::map<int, std::vector<uint8_t>> expectedOutputData = {{ 0, expectedOutput }};
+
+    EndToEndLayerTestImpl<ArmnnInType, DataType::Boolean>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+} // anonymous namespace
diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
index 907285c5cf..9bddae9759 100644
--- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
@@ -397,6 +397,8 @@ DECLARE_LAYER_POLICY_2_PARAM(BatchNormalization)
 
 DECLARE_LAYER_POLICY_2_PARAM(BatchToSpaceNd)
 
+DECLARE_LAYER_POLICY_2_PARAM(Comparison)
+
 DECLARE_LAYER_POLICY_2_PARAM(Concat)
 
 DECLARE_LAYER_POLICY_1_PARAM(Constant)
@@ -421,8 +423,6 @@ DECLARE_LAYER_POLICY_1_PARAM(Dequantize)
 
 DECLARE_LAYER_POLICY_2_PARAM(DetectionPostProcess)
 
-DECLARE_LAYER_POLICY_1_PARAM(Equal)
-
 DECLARE_LAYER_POLICY_2_PARAM(FakeQuantization)
 
 DECLARE_LAYER_POLICY_1_PARAM(Floor)
@@ -431,8 +431,6 @@ DECLARE_LAYER_POLICY_2_PARAM(FullyConnected)
 
 DECLARE_LAYER_POLICY_1_PARAM(Gather)
 
-DECLARE_LAYER_POLICY_1_PARAM(Greater)
-
 DECLARE_LAYER_POLICY_CUSTOM_PARAM(Input, armnn::LayerBindingId)
 
 DECLARE_LAYER_POLICY_2_PARAM(InstanceNormalization)
diff --git a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp
new file mode 100644
index 0000000000..6ce9b306c0
--- /dev/null
+++ b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp
@@ -0,0 +1,126 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerTestResult.hpp"
+
+#include <armnn/ArmNN.hpp>
+
+#include <ResolveType.hpp>
+
+#include <backendsCommon/IBackendInternal.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
+
+#include <test/TensorHelpers.hpp>
+
+template <std::size_t NumDims,
+          armnn::DataType ArmnnInType,
+          typename InType = armnn::ResolveType<ArmnnInType>>
+LayerTestResult<uint8_t, NumDims> ComparisonTestImpl(
+    armnn::IWorkloadFactory & workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
+    const armnn::ComparisonDescriptor& descriptor,
+    const unsigned int shape0[NumDims],
+    std::vector<InType> values0,
+    float quantScale0,
+    int quantOffset0,
+    const unsigned int shape1[NumDims],
+    std::vector<InType> values1,
+    float quantScale1,
+    int quantOffset1,
+    const unsigned int outShape[NumDims],
+    std::vector<uint8_t> outValues,
+    float outQuantScale,
+    int outQuantOffset)
+{
+    armnn::TensorInfo inputTensorInfo0{NumDims, shape0, ArmnnInType};
+    armnn::TensorInfo inputTensorInfo1{NumDims, shape1, ArmnnInType};
+    armnn::TensorInfo outputTensorInfo{NumDims, outShape, armnn::DataType::Boolean};
+
+    auto input0 = MakeTensor<InType, NumDims>(inputTensorInfo0, values0);
+    auto input1 = MakeTensor<InType, NumDims>(inputTensorInfo1, values1);
+
+    inputTensorInfo0.SetQuantizationScale(quantScale0);
+    inputTensorInfo0.SetQuantizationOffset(quantOffset0);
+
+    inputTensorInfo1.SetQuantizationScale(quantScale1);
+    inputTensorInfo1.SetQuantizationOffset(quantOffset1);
+
+    outputTensorInfo.SetQuantizationScale(outQuantScale);
+    outputTensorInfo.SetQuantizationOffset(outQuantOffset);
+
+    LayerTestResult<uint8_t, NumDims> ret(outputTensorInfo);
+
+    std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
+    std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
+    std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
+
+    armnn::ComparisonQueueDescriptor qDescriptor;
+    qDescriptor.m_Parameters = descriptor;
+
+    armnn::WorkloadInfo info;
+    AddInputToWorkload(qDescriptor, info, inputTensorInfo0, inputHandle0.get());
+    AddInputToWorkload(qDescriptor, info, inputTensorInfo1, inputHandle1.get());
+    AddOutputToWorkload(qDescriptor, info, outputTensorInfo, outputHandle.get());
+
+    std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateComparison(qDescriptor, info);
+
+    inputHandle0->Allocate();
+    inputHandle1->Allocate();
+    outputHandle->Allocate();
+
+    CopyDataToITensorHandle(inputHandle0.get(), input0.origin());
+    CopyDataToITensorHandle(inputHandle1.get(), input1.origin());
+
+    workload->PostAllocationConfigure();
+    ExecuteWorkload(*workload, memoryManager);
+
+    CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get());
+
+    ret.outputExpected = MakeTensor<uint8_t, NumDims>(outputTensorInfo, outValues);
+    ret.compareBoolean = true;
+
+    return ret;
+}
+
+template <std::size_t NumDims,
+          armnn::DataType ArmnnInType,
+          typename InType = armnn::ResolveType<ArmnnInType>>
+LayerTestResult<uint8_t, NumDims> ComparisonTestImpl(
+    armnn::IWorkloadFactory & workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
+    const armnn::ComparisonDescriptor& descriptor,
+    const unsigned int shape0[NumDims],
+    std::vector<InType> values0,
+    const unsigned int shape1[NumDims],
+    std::vector<InType> values1,
+    const unsigned int outShape[NumDims],
+    std::vector<uint8_t> outValues,
+    float qScale = 10.f,
+    int qOffset = 0)
+{
+    return ComparisonTestImpl<NumDims, ArmnnInType>(
+        workloadFactory,
+        memoryManager,
+        descriptor,
+        shape0,
+        values0,
+        qScale,
+        qOffset,
+        shape1,
+        values1,
+        qScale,
+        qOffset,
+        outShape,
+        outValues,
+        qScale,
+        qOffset);
+}
diff --git a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp
index b0b613c137..a3d2b2796f 100644
--- a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp
@@ -4,18 +4,10 @@
 //
 
 #include "EqualTestImpl.hpp"
-#include "ElementwiseTestImpl.hpp"
 
-#include <Half.hpp>
+#include "ComparisonTestImpl.hpp"
 
-template<>
-std::unique_ptr<armnn::IWorkload> CreateWorkload<armnn::EqualQueueDescriptor>(
-    const armnn::IWorkloadFactory& workloadFactory,
-    const armnn::WorkloadInfo& info,
-    const armnn::EqualQueueDescriptor& descriptor)
-{
-    return workloadFactory.CreateEqual(descriptor, info);
-}
+#include <Half.hpp>
 
 LayerTestResult<uint8_t, 4> EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory,
                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
@@ -39,9 +31,10 @@ LayerTestResult<uint8_t, 4> EqualSimpleTest(armnn::IWorkloadFactory& workloadFac
     std::vector<uint8_t> output({ 1, 1, 1, 1,  0, 0, 0, 0,
                                   0, 0, 0, 0,  1, 1, 1, 1 });
 
-    return ElementwiseTestHelper<4, armnn::EqualQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape,
         input0,
         shape,
@@ -62,9 +55,10 @@ LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
 
     std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0, 0, 0});
 
-    return ElementwiseTestHelper<4, armnn::EqualQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape0,
         input0,
         shape1,
@@ -88,9 +82,10 @@ LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorTest(
     std::vector<uint8_t> output({ 1, 1, 1, 0, 0, 0,
                                   0, 0, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4, armnn::EqualQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape0,
         input0,
         shape1,
@@ -117,12 +112,10 @@ LayerTestResult<uint8_t, 4> EqualFloat16Test(
     std::vector<uint8_t> output({ 0, 0, 0, 0, 1, 1, 1, 1,
                                   1, 1, 1, 1, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4,
-                                 armnn::EqualQueueDescriptor,
-                                 armnn::DataType::Float16,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float16>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape,
         input0,
         shape,
@@ -148,12 +141,10 @@ LayerTestResult<uint8_t, 4> EqualBroadcast1ElementFloat16Test(
     std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0,
                                   0, 0, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4,
-                                 armnn::EqualQueueDescriptor,
-                                 armnn::DataType::Float16,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float16>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape0,
         input0,
         shape1,
@@ -179,12 +170,10 @@ LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorFloat16Test(
     std::vector<uint8_t> output({ 1, 0, 1, 0, 0, 0,
                                   0, 0, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4,
-                                 armnn::EqualQueueDescriptor,
-                                 armnn::DataType::Float16,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float16>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape0,
         input0,
         shape1,
@@ -209,12 +198,10 @@ LayerTestResult<uint8_t, 4> EqualUint8Test(
     std::vector<uint8_t> output({ 0, 0, 0, 0, 1, 1, 1, 1,
                                   1, 1, 1, 1, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4,
-                                 armnn::EqualQueueDescriptor,
-                                 armnn::DataType::QuantisedAsymm8,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape,
         input0,
         shape,
@@ -238,12 +225,10 @@ LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
     std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0,
                                   0, 0, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4,
-                                 armnn::EqualQueueDescriptor,
-                                 armnn::DataType::QuantisedAsymm8,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape0,
         input0,
         shape1,
@@ -267,12 +252,10 @@ LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorUint8Test(
     std::vector<uint8_t> output({ 1, 0, 1, 0, 0, 0,
                                   0, 0, 0, 0, 0, 0 });
 
-    return ElementwiseTestHelper<4,
-                                 armnn::EqualQueueDescriptor,
-                                 armnn::DataType::QuantisedAsymm8,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
         shape0,
         input0,
         shape1,
diff --git a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp
index 0148216285..271bc235a9 100644
--- a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp
@@ -4,18 +4,10 @@
 //
 
 #include "GreaterTestImpl.hpp"
-#include "ElementwiseTestImpl.hpp"
 
-#include <Half.hpp>
+#include "ComparisonTestImpl.hpp"
 
-template<>
-std::unique_ptr<armnn::IWorkload> CreateWorkload<armnn::GreaterQueueDescriptor>(
-    const armnn::IWorkloadFactory& workloadFactory,
-    const armnn::WorkloadInfo& info,
-    const armnn::GreaterQueueDescriptor& descriptor)
-{
-    return workloadFactory.CreateGreater(descriptor, info);
-}
+#include <Half.hpp>
 
 LayerTestResult<uint8_t, 4> GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory,
                                               const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
@@ -45,12 +37,10 @@ LayerTestResult<uint8_t, 4> GreaterSimpleTest(armnn::IWorkloadFactory& workloadF
         0, 0, 0, 0,  0, 0, 0, 0
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::Float32,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape,
         input0,
         shape,
@@ -71,12 +61,10 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
 
     std::vector<uint8_t> output = { 0, 1, 1, 1, 1, 1, 1, 1};
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::Float32,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape0,
         input0,
         shape1,
@@ -106,12 +94,10 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorTest(
         1, 1, 1, 1, 1, 1
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::Float32,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape0,
         input0,
         shape1,
@@ -151,12 +137,10 @@ LayerTestResult<uint8_t, 4> GreaterFloat16Test(
         0, 0, 0, 0,  0, 0, 0, 0
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::Float16,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4,armnn::DataType::Float16>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape,
         input0,
         shape,
@@ -179,12 +163,10 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementFloat16Test(
 
     std::vector<uint8_t> output = { 0, 1, 1, 1, 1, 1, 1, 1};
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::Float16,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float16>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape0,
         input0,
         shape1,
@@ -198,7 +180,7 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorFloat16Test(
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 {
     using namespace half_float::literal;
-    
+
     const unsigned int shape0[] = { 1, 2, 2, 3 };
     const unsigned int shape1[] = { 1, 1, 1, 3 };
 
@@ -216,12 +198,10 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorFloat16Test(
         1, 1, 1, 1, 1, 1
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::Float16,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::Float16>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape0,
         input0,
         shape1,
@@ -255,12 +235,10 @@ LayerTestResult<uint8_t, 4> GreaterUint8Test(
         1, 1, 1, 1, 0, 0, 0, 0
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::QuantisedAsymm8,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape,
         input0,
         shape,
@@ -290,12 +268,10 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
         1, 1, 1, 1, 1, 1
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::QuantisedAsymm8,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape0,
         input0,
         shape1,
@@ -325,12 +301,10 @@ LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorUint8Test(
         1, 1, 1, 1, 1, 1
     };
 
-    return ElementwiseTestHelper<4,
-                                 armnn::GreaterQueueDescriptor,
-                                 armnn::DataType::QuantisedAsymm8,
-                                 armnn::DataType::Boolean>(
+    return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
         workloadFactory,
         memoryManager,
+        armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
         shape0,
         input0,
         shape1,