IVGCVSW-3119 Rename MergerLayer to ConcatLayer

!android-nn-driver:1210

Change-Id: I940b3b9e421c92bfd55ae996f7bc54ac077f2604
Signed-off-by: Jim Flynn <jim.flynn@arm.com>

12 files changed, 67 insertions, 68 deletions

diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp
index 9fcb496ba3..71b17456c1 100644
--- a/src/backends/backendsCommon/LayerSupportBase.cpp
+++ b/src/backends/backendsCommon/LayerSupportBase.cpp
@@ -73,9 +73,7 @@ bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*> in
                                          const OriginsDescriptor& descriptor,
                                          Optional<std::string&> reasonIfUnsupported) const
 {
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    return IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported);
-    ARMNN_NO_DEPRECATE_WARN_END
+    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
 bool LayerSupportBase::IsConstantSupported(const TensorInfo& output,
@@ -286,7 +284,7 @@ bool LayerSupportBase::IsMergerSupported(const std::vector<const TensorInfo*> in
                                          const OriginsDescriptor& descriptor,
                                          Optional<std::string&> reasonIfUnsupported) const
 {
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
+    return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
 }
 
 bool LayerSupportBase::IsMinimumSupported(const TensorInfo& input0,
diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp
index ea84c0b9f2..9bb95f67af 100644
--- a/src/backends/backendsCommon/WorkloadData.cpp
+++ b/src/backends/backendsCommon/WorkloadData.cpp
@@ -378,26 +378,26 @@ void SplitterQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
 }
 
 //---------------------------------------------------------------
-void MergerQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
+void ConcatQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
 {
-    ValidateNumOutputs(workloadInfo, "MergerQueueDescriptor", 1);
+    ValidateNumOutputs(workloadInfo, "ConcatQueueDescriptor", 1);
 
     if (m_Inputs.size() <= 0)
     {
-        throw InvalidArgumentException("MergerQueueDescriptor: At least one input needs to be provided.");
+        throw InvalidArgumentException("ConcatQueueDescriptor: At least one input needs to be provided.");
     }
     if (m_Outputs.size() <= 0)
     {
-        throw InvalidArgumentException("MergerQueueDescriptor: At least one output needs to be provided.");
+        throw InvalidArgumentException("ConcatQueueDescriptor: At least one output needs to be provided.");
     }
 
     if (workloadInfo.m_InputTensorInfos.size() <= 0)
     {
-        throw InvalidArgumentException("MergerQueueDescriptor: At least one TensorInfo input needs to be provided.");
+        throw InvalidArgumentException("ConcatQueueDescriptor: At least one TensorInfo input needs to be provided.");
     }
     if (workloadInfo.m_OutputTensorInfos.size() <= 0)
     {
-        throw InvalidArgumentException("MergerQueueDescriptor: At least one TensorInfo output needs to be provided.");
+        throw InvalidArgumentException("ConcatQueueDescriptor: At least one TensorInfo output needs to be provided.");
     }
 
     if(m_Parameters.GetConcatAxis() > workloadInfo.m_InputTensorInfos[0].GetShape().GetNumDimensions())
@@ -413,7 +413,7 @@ void MergerQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
     if (workloadInfo.m_InputTensorInfos.size() != m_ViewOrigins.size())
     {
         throw InvalidArgumentException(
-            "MergerQueueDescriptor: Number of split windows "
+            "ConcatQueueDescriptor: Number of split windows "
             "has to match number of workloadInfo.m_InputTensorInfos. "
             "Number of windows: " +
             to_string(m_ViewOrigins.size()) +
@@ -428,7 +428,7 @@ void MergerQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
         ViewOrigin const& e = m_ViewOrigins[w];
         if (e.m_Origin.size() != outputDims)
         {
-            throw InvalidArgumentException("MergerQueueDescriptor: Window origin have to "
+            throw InvalidArgumentException("ConcatQueueDescriptor: Window origin have to "
                                            "have the same dimensionality as the output tensor. "
                                            "Window origin (index: " +
                                            to_string(w) + ") has " + to_string(e.m_Origin.size()) +
@@ -442,7 +442,7 @@ void MergerQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
             if (e.m_Origin[i] + workloadInfo.m_InputTensorInfos[w].GetShape()[i]
                 > workloadInfo.m_OutputTensorInfos[0].GetShape()[i])
             {
-                throw InvalidArgumentException("MergerQueueDescriptor: Window extent coordinates have to "
+                throw InvalidArgumentException("ConcatQueueDescriptor: Window extent coordinates have to "
                                                "be smaller or equal than the size of the output in that coord.");
             }
         }
@@ -463,11 +463,11 @@ void MergerQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
     {
         ValidateDataTypes(workloadInfo.m_InputTensorInfos[i],
                           supportedTypes,
-                          "MergerQueueDescriptor");
+                          "ConcatQueueDescriptor");
     }
     ValidateDataTypes(workloadInfo.m_OutputTensorInfos[0],
                       {workloadInfo.m_InputTensorInfos[0].GetDataType()},
-                      "MergerQueueDescriptor");
+                      "ConcatQueueDescriptor");
 }
 
 //---------------------------------------------------------------
diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp
index 689c6d26c6..3e33b946e9 100644
--- a/src/backends/backendsCommon/WorkloadData.hpp
+++ b/src/backends/backendsCommon/WorkloadData.hpp
@@ -9,6 +9,7 @@
 
 #include <InternalTypes.hpp>
 
+#include <armnn/Deprecated.hpp>
 #include <armnn/Descriptors.hpp>
 #include <armnn/Exceptions.hpp>
 #include <armnn/Types.hpp>
@@ -87,8 +88,8 @@ struct SplitterQueueDescriptor : QueueDescriptorWithParameters<ViewsDescriptor>
     void Validate(const WorkloadInfo& workloadInfo) const;
 };
 
-// Merger layer workload data.
-struct MergerQueueDescriptor : QueueDescriptorWithParameters<OriginsDescriptor>
+// Concat layer workload data.
+struct ConcatQueueDescriptor : QueueDescriptorWithParameters<OriginsDescriptor>
 {
     struct ViewOrigin
     {
@@ -106,6 +107,9 @@ struct MergerQueueDescriptor : QueueDescriptorWithParameters<OriginsDescriptor>
     void Validate(const WorkloadInfo& workloadInfo) const;
 };
 
+// Deprecated. Use ConcatQueueDescriptor instead
+using MergerQueueDescriptor = ConcatQueueDescriptor;
+
 // Activation layer workload data.
 struct ActivationQueueDescriptor : QueueDescriptorWithParameters<ActivationDescriptor>
 {
diff --git a/src/backends/backendsCommon/WorkloadDataFwd.hpp b/src/backends/backendsCommon/WorkloadDataFwd.hpp
index 9fbd81b326..abee3166f4 100644
--- a/src/backends/backendsCommon/WorkloadDataFwd.hpp
+++ b/src/backends/backendsCommon/WorkloadDataFwd.hpp
@@ -12,7 +12,7 @@ template <typename LayerDescriptor>
 struct QueueDescriptorWithParameters;
 struct SoftmaxQueueDescriptor;
 struct SplitterQueueDescriptor;
-struct MergerQueueDescriptor;
+struct ConcatQueueDescriptor;
 struct ActivationQueueDescriptor;
 struct FullyConnectedQueueDescriptor;
 struct PermuteQueueDescriptor;
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index 763107123f..f026e1ecd6 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -512,9 +512,9 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
                                                           reason);
             break;
         }
-        case LayerType::Merger:
+        case LayerType::Concat:
         {
-            auto cLayer = boost::polymorphic_downcast<const MergerLayer*>(&layer);
+            auto cLayer = boost::polymorphic_downcast<const ConcatLayer*>(&layer);
 
             // Get vector of all inputs.
             auto getTensorInfo = [&dataType](const InputSlot& slot)
@@ -535,9 +535,9 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
 
             const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
 
-            ARMNN_NO_DEPRECATE_WARN_BEGIN
-            result = layerSupportObject->IsMergerSupported(inputPtrs, output, cLayer->GetParameters(), reason);
-            ARMNN_NO_DEPRECATE_WARN_END
+            result = layerSupportObject->IsConcatSupported(inputPtrs, output, cLayer->GetParameters(), reason);
+
+
             break;
         }
         case LayerType::Multiplication:
@@ -816,7 +816,7 @@ std::unique_ptr<IWorkload> IWorkloadFactory::CreateBatchToSpaceNd(const BatchToS
     return std::unique_ptr<IWorkload>();
 }
 
-std::unique_ptr<IWorkload> IWorkloadFactory::CreateConcat(const MergerQueueDescriptor& descriptor,
+std::unique_ptr<IWorkload> IWorkloadFactory::CreateConcat(const ConcatQueueDescriptor& descriptor,
                                                           const WorkloadInfo& info) const
 {
     return std::unique_ptr<IWorkload>();
diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp
index 0b0ba7ddf1..11c36eb774 100644
--- a/src/backends/backendsCommon/WorkloadFactory.hpp
+++ b/src/backends/backendsCommon/WorkloadFactory.hpp
@@ -61,7 +61,7 @@ public:
     virtual std::unique_ptr<IWorkload> CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
                                                             const WorkloadInfo& Info) const;
 
-    virtual std::unique_ptr<IWorkload> CreateConcat(const MergerQueueDescriptor& descriptor,
+    virtual std::unique_ptr<IWorkload> CreateConcat(const ConcatQueueDescriptor& descriptor,
                                                     const WorkloadInfo&          info) const;
 
     virtual std::unique_ptr<IWorkload> CreateConstant(const ConstantQueueDescriptor& descriptor,
diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index 8050a0ab63..508fc77ba6 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -30,7 +30,7 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     LayerTests.hpp
     LstmTestImpl.hpp
     NormTestImpl.hpp
-    MergerTestImpl.hpp
+    ConcatTestImpl.hpp
     MockBackend.cpp
     MockBackend.hpp
     MockBackendId.hpp
diff --git a/src/backends/backendsCommon/test/MergerTestImpl.hpp b/src/backends/backendsCommon/test/ConcatTestImpl.hpp
index 8483cf02d8..ded3857282 100644
--- a/src/backends/backendsCommon/test/MergerTestImpl.hpp
+++ b/src/backends/backendsCommon/test/ConcatTestImpl.hpp
@@ -18,8 +18,8 @@ namespace
 {
 
 template<typename armnn::DataType DataType>
-INetworkPtr CreateMergerNetwork(const std::vector<TensorShape>& inputShapes,
-                                const TensorShape& outputShape,
+INetworkPtr CreateConcatNetwork(const std::vector<TensorShape>& inputShapes,
+                                const TensorShape &outputShape,
                                 unsigned int concatAxis,
                                 const float qScale = 1.0f,
                                 const int32_t qOffset = 0)
@@ -33,26 +33,24 @@ INetworkPtr CreateMergerNetwork(const std::vector<TensorShape>& inputShapes,
     descriptor = CreateDescriptorForConcatenation(inputShapes.begin(),
                                                   inputShapes.end(),
                                                   concatAxis);
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    IConnectableLayer* merger = net->AddMergerLayer(descriptor, "merger");
-    ARMNN_NO_DEPRECATE_WARN_END
+    IConnectableLayer* concat = net->AddConcatLayer(descriptor, "concat");
 
     for (unsigned int i = 0; i < inputShapes.size(); ++i)
     {
         TensorInfo inputTensorInfo(inputShapes[i], DataType, qScale, qOffset);
         IConnectableLayer* input = net->AddInputLayer(boost::numeric_cast<LayerBindingId>(i));
-        Connect(input, merger, inputTensorInfo, 0, i);
+        Connect(input, concat, inputTensorInfo, 0, i);
     }
 
     TensorInfo outputTensorInfo(outputShape, DataType, qScale, qOffset);
     IConnectableLayer* output = net->AddOutputLayer(0, "output");
-    Connect(merger, output, outputTensorInfo, 0, 0);
+    Connect(concat, output, outputTensorInfo, 0, 0);
 
     return net;
 }
 
 template<armnn::DataType ArmnnType>
-void MergerDim0EndToEnd(const std::vector<BackendId>& backends)
+void ConcatDim0EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;
@@ -62,7 +60,7 @@ void MergerDim0EndToEnd(const std::vector<BackendId>& backends)
     const TensorShape& outputShape = { 4, 3, 2, 2 };
 
     // Builds up the structure of the network
-    INetworkPtr net = CreateMergerNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
+    INetworkPtr net = CreateConcatNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
 
     BOOST_TEST_CHECKPOINT("create a network");
 
@@ -116,7 +114,7 @@ void MergerDim0EndToEnd(const std::vector<BackendId>& backends)
 }
 
 template<armnn::DataType ArmnnType>
-void MergerDim1EndToEnd(const std::vector<BackendId>& backends)
+void ConcatDim1EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;
@@ -126,7 +124,7 @@ void MergerDim1EndToEnd(const std::vector<BackendId>& backends)
     const TensorShape& outputShape = { 2, 6, 2, 2 };
 
     // Builds up the structure of the network
-    INetworkPtr net = CreateMergerNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
+    INetworkPtr net = CreateConcatNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
 
     BOOST_TEST_CHECKPOINT("create a network");
 
@@ -180,7 +178,7 @@ void MergerDim1EndToEnd(const std::vector<BackendId>& backends)
 }
 
 template<armnn::DataType ArmnnType>
-void MergerDim2EndToEnd(const std::vector<BackendId>& backends)
+void ConcatDim2EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;
@@ -190,7 +188,7 @@ void MergerDim2EndToEnd(const std::vector<BackendId>& backends)
     const TensorShape& outputShape = { 2, 3, 4, 2 };
 
     // Builds up the structure of the network
-    INetworkPtr net = CreateMergerNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
+    INetworkPtr net = CreateConcatNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
 
     BOOST_TEST_CHECKPOINT("create a network");
 
@@ -244,7 +242,7 @@ void MergerDim2EndToEnd(const std::vector<BackendId>& backends)
 }
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
-void MergerDim3EndToEnd(const std::vector<BackendId>& backends)
+void ConcatDim3EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
 
@@ -253,7 +251,7 @@ void MergerDim3EndToEnd(const std::vector<BackendId>& backends)
     const TensorShape& outputShape = { 2, 3, 2, 4 };
 
     // Builds up the structure of the network
-    INetworkPtr net = CreateMergerNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
+    INetworkPtr net = CreateConcatNetwork<ArmnnType>(inputShapes, outputShape, concatAxis);
 
     BOOST_TEST_CHECKPOINT("create a network");
 
diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
index 3ff7376e91..71614643c3 100644
--- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
@@ -135,19 +135,19 @@ struct DummyLayer<armnn::InputLayer, armnn::LayerBindingId>
 };
 
 template<>
-struct DummyLayer<armnn::MergerLayer>
+struct DummyLayer<armnn::ConcatLayer>
 {
     DummyLayer()
     {
         armnn::OriginsDescriptor desc(2);
-        m_Layer = dummyGraph.AddLayer<armnn::MergerLayer>(desc, "");
+        m_Layer = dummyGraph.AddLayer<armnn::ConcatLayer>(desc, "");
 
     }
     ~DummyLayer()
     {
         dummyGraph.EraseLayer(m_Layer);
     }
-    armnn::MergerLayer* m_Layer;
+    armnn::ConcatLayer* m_Layer;
 };
 
 template<>
@@ -322,6 +322,8 @@ DECLARE_LAYER_POLICY_2_PARAM(BatchNormalization)
 
 DECLARE_LAYER_POLICY_2_PARAM(BatchToSpaceNd)
 
+DECLARE_LAYER_POLICY_2_PARAM(Concat)
+
 DECLARE_LAYER_POLICY_1_PARAM(Constant)
 
 DECLARE_LAYER_POLICY_1_PARAM(ConvertFp16ToFp32)
@@ -364,10 +366,6 @@ DECLARE_LAYER_POLICY_2_PARAM(Mean)
 
 DECLARE_LAYER_POLICY_1_PARAM(Merge)
 
-ARMNN_NO_DEPRECATE_WARN_BEGIN
-DECLARE_LAYER_POLICY_2_PARAM(Merger)
-ARMNN_NO_DEPRECATE_WARN_END
-
 DECLARE_LAYER_POLICY_1_PARAM(Minimum)
 
 DECLARE_LAYER_POLICY_1_PARAM(Multiplication)
@@ -422,7 +420,7 @@ unsigned int GetNumOutputs(const armnn::Layer& layer)
 }
 
 template<>
-unsigned int GetNumInputs<armnn::LayerType::Merger>(const armnn::Layer& layer)
+unsigned int GetNumInputs<armnn::LayerType::Concat>(const armnn::Layer& layer)
 {
     boost::ignore_unused(layer);
     return 2;
diff --git a/src/backends/backendsCommon/test/LayerTests.cpp b/src/backends/backendsCommon/test/LayerTests.cpp
index c84a530454..402e86de00 100644
--- a/src/backends/backendsCommon/test/LayerTests.cpp
+++ b/src/backends/backendsCommon/test/LayerTests.cpp
@@ -1362,10 +1362,10 @@ LayerTestResult<float,3> ConcatTest(
     );
 
     std::vector<unsigned int> wOrigin1 = {0, 0, 0}; //Extent of the window is defined by size of input[0].
-    armnn::MergerQueueDescriptor::ViewOrigin window1(wOrigin1);
+    armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
 
     std::vector<unsigned int> wOrigin2 = {2, 0, 0}; //Extent of the window is defined by size of input[1].
-    armnn::MergerQueueDescriptor::ViewOrigin window2(wOrigin2);
+    armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
 
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
 
@@ -1381,7 +1381,7 @@ LayerTestResult<float,3> ConcatTest(
             workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
             workloadFactory.CreateTensorHandle(inputTensorInfo2);
 
-    armnn::MergerQueueDescriptor data;
+    armnn::ConcatQueueDescriptor data;
     armnn::WorkloadInfo info;
     AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
     AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
@@ -3554,7 +3554,7 @@ void Concatenate(
 
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
 
-    armnn::MergerQueueDescriptor queueDescriptor;
+    armnn::ConcatQueueDescriptor queueDescriptor;
     armnn::OriginsDescriptor viewsDescriptor = CreateDescriptorForConcatenation(inputTensorInfos, concatDim);
     queueDescriptor.m_Parameters = viewsDescriptor;
 
@@ -6625,10 +6625,10 @@ LayerTestResult<uint8_t, 3> ConcatUint8DifferentQParamsTest(
     inputTensorInfo2.SetQuantizationOffset(inputOffset2);
 
     std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
-    armnn::MergerQueueDescriptor::ViewOrigin window1(wOrigin1);
+    armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
 
     std::vector<unsigned int> wOrigin2 = { 2, 0, 0 }; //Extent of the window is defined by size of input[1].
-    armnn::MergerQueueDescriptor::ViewOrigin window2(wOrigin2);
+    armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
 
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
 
@@ -6644,7 +6644,7 @@ LayerTestResult<uint8_t, 3> ConcatUint8DifferentQParamsTest(
             workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
             workloadFactory.CreateTensorHandle(inputTensorInfo2);
 
-    armnn::MergerQueueDescriptor data;
+    armnn::ConcatQueueDescriptor data;
     armnn::WorkloadInfo info;
     AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
     AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
@@ -6759,10 +6759,10 @@ LayerTestResult<uint8_t, 3> ConcatUint8Test(
     );
 
     std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
-    armnn::MergerQueueDescriptor::ViewOrigin window1(wOrigin1);
+    armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
 
     std::vector<unsigned int> wOrigin2 = { 2, 0, 0 }; //Extent of the window is defined by size of input[1].
-    armnn::MergerQueueDescriptor::ViewOrigin window2(wOrigin2);
+    armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
 
 
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
@@ -6780,7 +6780,7 @@ LayerTestResult<uint8_t, 3> ConcatUint8Test(
             workloadFactory.CreateTensorHandle(inputTensorInfo2);
 
 
-    armnn::MergerQueueDescriptor data;
+    armnn::ConcatQueueDescriptor data;
     armnn::WorkloadInfo info;
     AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
     AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
@@ -6892,10 +6892,10 @@ LayerTestResult<uint16_t, 3> ConcatUint16Test(
     }));
 
     std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
-    armnn::MergerQueueDescriptor::ViewOrigin window1(wOrigin1);
+    armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
 
     std::vector<unsigned int> wOrigin2 = { 2, 0, 0 }; //Extent of the window is defined by size of input[1].
-    armnn::MergerQueueDescriptor::ViewOrigin window2(wOrigin2);
+    armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
 
 
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
@@ -6913,7 +6913,7 @@ LayerTestResult<uint16_t, 3> ConcatUint16Test(
             workloadFactory.CreateTensorHandle(inputTensorInfo2);
 
 
-    armnn::MergerQueueDescriptor data;
+    armnn::ConcatQueueDescriptor data;
     armnn::WorkloadInfo info;
     AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
     AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
diff --git a/src/backends/backendsCommon/test/QuantizeHelper.hpp b/src/backends/backendsCommon/test/QuantizeHelper.hpp
index b3b0631e18..a0c6553e24 100644
--- a/src/backends/backendsCommon/test/QuantizeHelper.hpp
+++ b/src/backends/backendsCommon/test/QuantizeHelper.hpp
@@ -2,6 +2,7 @@
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
+
 #pragma once
 
 #include <armnn/ArmNN.hpp>
diff --git a/src/backends/backendsCommon/test/WorkloadDataValidation.cpp b/src/backends/backendsCommon/test/WorkloadDataValidation.cpp
index 067cca8319..94bef9b50a 100644
--- a/src/backends/backendsCommon/test/WorkloadDataValidation.cpp
+++ b/src/backends/backendsCommon/test/WorkloadDataValidation.cpp
@@ -234,7 +234,7 @@ BOOST_AUTO_TEST_CASE(SplitterQueueDescriptor_Validate_WrongWindow)
 }
 
 
-BOOST_AUTO_TEST_CASE(MergerQueueDescriptor_Validate_WrongWindow)
+BOOST_AUTO_TEST_CASE(ConcatQueueDescriptor_Validate_WrongWindow)
 {
     constexpr unsigned int inputNum = 1;
     constexpr unsigned int inputChannels = 3;
@@ -256,7 +256,7 @@ BOOST_AUTO_TEST_CASE(MergerQueueDescriptor_Validate_WrongWindow)
     inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32);
     outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32);
 
-    MergerQueueDescriptor invalidData;
+    ConcatQueueDescriptor invalidData;
     WorkloadInfo          invalidInfo;
 
     AddInputToWorkload(invalidData, invalidInfo, inputTensorInfo, nullptr);
@@ -264,7 +264,7 @@ BOOST_AUTO_TEST_CASE(MergerQueueDescriptor_Validate_WrongWindow)
 
     // Invalid, since it has only 3 dimensions while the input tensor is 4d.
     std::vector<unsigned int> wOrigin = {0, 0, 0};
-    armnn::MergerQueueDescriptor::ViewOrigin window(wOrigin);
+    armnn::ConcatQueueDescriptor::ViewOrigin window(wOrigin);
     invalidData.m_ViewOrigins.push_back(window);
 
     BOOST_TEST_INFO("Invalid argument exception is expected, because merge window dimensionality does not "
@@ -273,18 +273,18 @@ BOOST_AUTO_TEST_CASE(MergerQueueDescriptor_Validate_WrongWindow)
 
     // Invalid, since window extends past the boundary of output tensor.
     std::vector<unsigned int> wOrigin3 = {0, 0, 15, 0};
-    armnn::MergerQueueDescriptor::ViewOrigin window3(wOrigin3);
+    armnn::ConcatQueueDescriptor::ViewOrigin window3(wOrigin3);
     invalidData.m_ViewOrigins[0] = window3;
     BOOST_TEST_INFO("Invalid argument exception is expected (wOrigin3[2]+ inputHeight > outputHeight");
     BOOST_CHECK_THROW(RefConcatWorkload(invalidData, invalidInfo), armnn::InvalidArgumentException);
 
 
     std::vector<unsigned int> wOrigin4 = {0, 0, 0, 0};
-    armnn::MergerQueueDescriptor::ViewOrigin window4(wOrigin4);
+    armnn::ConcatQueueDescriptor::ViewOrigin window4(wOrigin4);
     invalidData.m_ViewOrigins[0] = window4;
 
     std::vector<unsigned int> wOrigin5 = {1, 16, 20, 2};
-    armnn::MergerQueueDescriptor::ViewOrigin window5(wOrigin4);
+    armnn::ConcatQueueDescriptor::ViewOrigin window5(wOrigin4);
     invalidData.m_ViewOrigins.push_back(window5);
 
     BOOST_TEST_INFO("Invalid exception due to number of merge windows not matching number of inputs.");