IVGCVSW-7168 Add Conv2d and Constant support to TOSA Reference Backend

 * Added TOSA Conv2d and Constant mappings.
 * Added unique naming to mappings based on previous and following
   layers, so they are connected correctly.
 * Updated existing mappings with new naming convention.
 * Added all mappings to one main block in OptimizeSubgraphView.
 * Removed isMain from mapping functions.
 * Added Conv2d EndToEnd test.

Signed-off-by: Matthew Sloyan <matthew.sloyan@arm.com>
Change-Id: I27c3e238407c32379ce25a1f01dad11523ef5d2b

28 files changed, 1066 insertions, 215 deletions

diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index c9668a22f2..d833caa3fe 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -14,6 +14,7 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     ComparisonEndToEndTestImpl.hpp
     CompatibilityTests.cpp
     ConcatEndToEndTestImpl.hpp
+    Convolution2dEndToEndTestImpl.hpp
     Convolution3dEndToEndTestImpl.hpp
     CustomMemoryOptimizerStrategyTests.cpp
     DefaultAsyncExecuteTest.cpp
diff --git a/src/backends/backendsCommon/test/Convolution2dEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/Convolution2dEndToEndTestImpl.hpp
new file mode 100644
index 0000000000..bc9a94289b
--- /dev/null
+++ b/src/backends/backendsCommon/test/Convolution2dEndToEndTestImpl.hpp
@@ -0,0 +1,134 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "EndToEndTestImpl.hpp"
+#include <armnnUtils/QuantizeHelper.hpp>
+
+#include <ResolveType.hpp>
+
+#include <CommonTestUtils.hpp>
+#include <armnnTestUtils/DataLayoutUtils.hpp>
+
+#include <map>
+#include <vector>
+
+namespace
+{
+
+armnn::INetworkPtr CreateConstConvolution2dNetwork(const armnn::Convolution2dDescriptor& descriptor,
+                                                   const armnn::TensorInfo& inputInfo,
+                                                   const armnn::TensorInfo& weightsInfo,
+                                                   const armnn::TensorInfo& biasInfo,
+                                                   const armnn::TensorInfo& outputInfo,
+                                                   const armnn::ConstTensor& weights,
+                                                   const armnn::ConstTensor& biases,
+                                                   bool biasEnabled)
+{
+    using namespace armnn;
+
+    INetworkPtr network(INetwork::Create());
+    IConnectableLayer* input = network->AddInputLayer(0, "input");
+    IConnectableLayer* weightsLayer = network->AddConstantLayer(weights, "Weights");
+    IConnectableLayer* convolution2d = network->AddConvolution2dLayer(descriptor, "convolution2d");
+    IConnectableLayer* output = network->AddOutputLayer(0, "output");
+
+    Connect(input, convolution2d, inputInfo, 0, 0);
+    Connect(weightsLayer, convolution2d, weightsInfo, 0, 1);
+
+    if(biasEnabled)
+    {
+        armnn::IConnectableLayer* biasLayer = network->AddConstantLayer(biases, "Bias");
+        Connect(biasLayer, convolution2d, biasInfo, 0, 2);
+    }
+
+    Connect(convolution2d, output, outputInfo, 0, 0);
+
+    return network;
+}
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+void Convolution2dEndToEnd(const std::vector<armnn::BackendId>& backends,
+                           armnn::DataLayout dataLayout,
+                           bool biasEnabled = true)
+{
+    using namespace armnn;
+
+    const float   qScale  = IsQuantizedType<T>() ? 0.25f : 1.0f;
+    const int32_t qOffset = IsQuantizedType<T>() ? 50    : 0;
+
+    TensorInfo inputInfo({ 1, 5, 5, 1 }, ArmnnType, qScale, qOffset, true);
+    TensorInfo outputInfo({ 1, 3, 3, 1 }, ArmnnType, qScale, qOffset);
+    TensorInfo weightsInfo({ 1, 3, 3, 1 }, ArmnnType, qScale, qOffset, true);
+    TensorInfo biasesInfo({ 1 }, ArmnnType, qScale * qScale, 0, true);
+
+    std::vector<float> inputData =
+    {
+        1.0f, 5.0f, 2.0f, 3.0f, 5.0f,
+        8.0f, 7.0f, 3.0f, 6.0f, 3.0f,
+        3.0f, 3.0f, 9.0f, 1.0f, 9.0f,
+        4.0f, 1.0f, 8.0f, 1.0f, 3.0f,
+        6.0f, 8.0f, 1.0f, 9.0f, 2.0f
+    };
+
+    std::vector<float> weightsData =
+    {
+        4.0f, 5.0f, 6.0f,
+        0.0f, 0.0f, 0.0f,
+        3.0f, 2.0f, 1.0f
+    };
+
+    std::vector<float> biasesData = { 1.0f };
+
+    float bias = biasEnabled ? biasesData[0] : 0.0f;
+    std::vector<float> expectedOutputData =
+    {
+        65.0f + bias,  76.0f + bias,  91.0f + bias,
+        107.0f + bias, 99.0f + bias,  89.0f + bias,
+        116.0f + bias, 98.0f + bias,  118.0f + bias,
+    };
+
+    Convolution2dDescriptor descriptor;
+    descriptor.m_PadLeft     = 0;
+    descriptor.m_PadRight    = 0;
+    descriptor.m_PadTop      = 0;
+    descriptor.m_PadBottom   = 0;
+    descriptor.m_StrideX     = 1;
+    descriptor.m_StrideY     = 1;
+    descriptor.m_BiasEnabled = biasEnabled;
+    descriptor.m_DataLayout  = dataLayout;
+
+    if (dataLayout == DataLayout::NCHW)
+    {
+        PermuteTensorNhwcToNchw(inputInfo, inputData);
+        PermuteTensorNhwcToNchw(weightsInfo, weightsData);
+        PermuteTensorNhwcToNchw(outputInfo, expectedOutputData);
+    }
+
+    // Quantize data
+    std::vector<T> qInputData          = armnnUtils::QuantizedVector<T>(inputData, qScale, qOffset);
+    std::vector<T> qWeightsData        = armnnUtils::QuantizedVector<T>(weightsData, qScale, qOffset);
+    std::vector<T> qExpectedOutputData = armnnUtils::QuantizedVector<T>(expectedOutputData, qScale, qOffset);
+    std::vector<T> qBiasesData         = armnnUtils::QuantizedVector<T>(biasesData, qScale * qScale, 0);
+
+    ConstTensor weights(weightsInfo, qWeightsData);
+    ConstTensor biases(biasesInfo, qBiasesData);
+
+    INetworkPtr network = CreateConstConvolution2dNetwork(descriptor,
+                                                          inputInfo,
+                                                          weightsInfo,
+                                                          biasesInfo,
+                                                          outputInfo,
+                                                          weights,
+                                                          biases,
+                                                          biasEnabled);
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(std::move(network),
+                                                {{ 0, qInputData }},
+                                                {{ 0, qExpectedOutputData }},
+                                                backends);
+}
+
+} // anonymous namespace
diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp
index 218f6dd695..017330ed53 100644
--- a/src/backends/reference/test/RefEndToEndTests.cpp
+++ b/src/backends/reference/test/RefEndToEndTests.cpp
@@ -13,6 +13,7 @@
 #include <backendsCommon/test/ChannelShuffleEndToEndTestImpl.hpp>
 #include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp>
 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
+#include <backendsCommon/test/Convolution2dEndToEndTestImpl.hpp>
 #include <backendsCommon/test/Convolution3dEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
@@ -595,6 +596,21 @@ TEST_CASE("RefConcatEndToEndDim3Uint8Test")
     ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 }
 
+TEST_CASE("RefConvolution2dFloat32Test")
+{
+    Convolution2dEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+TEST_CASE("RefConvolution2dNchwFloat32Test")
+{
+    Convolution2dEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+TEST_CASE("RefConvolution2dFloat16Test")
+{
+    Convolution2dEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
 TEST_CASE("RefConvolution3dFloat32Test")
 {
     Convolution3dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(defaultBackends,
diff --git a/src/backends/tosaCommon/TosaLayerSupportRules.hpp b/src/backends/tosaCommon/TosaLayerSupportRules.hpp
index 792908c619..8855dd612d 100644
--- a/src/backends/tosaCommon/TosaLayerSupportRules.hpp
+++ b/src/backends/tosaCommon/TosaLayerSupportRules.hpp
@@ -48,14 +48,34 @@ struct TosaAssertSize : public Rule
     }
 };
 
-struct TosaContainerContains : public Rule
+struct TosaContainerContainsTwoTypes : public Rule
 {
-    explicit TosaContainerContains(std::tuple<DType, DType>& check, const std::vector<std::tuple<DType, DType>>& c)
+    explicit TosaContainerContainsTwoTypes(std::tuple<DType, DType>& check,
+                                           const std::vector<std::tuple<DType, DType>>& c)
     {
         for (auto item: c)
         {
-            if (std::get<0>(check) == std::get<0>(item)
-                && std::get<1>(check) == std::get<1>(item))
+            if (std::get<0>(check) == std::get<0>(item) &&
+                std::get<1>(check) == std::get<1>(item))
+            {
+                m_Res = true;
+                return;
+            }
+        }
+        m_Res = false;
+    }
+};
+
+struct TosaContainerContainsThreeTypes : public Rule
+{
+    explicit TosaContainerContainsThreeTypes(std::tuple<DType, DType, DType>& check,
+                                             const std::vector<std::tuple<DType, DType, DType>>& c)
+    {
+        for (auto item: c)
+        {
+            if (std::get<0>(check) == std::get<0>(item) &&
+                std::get<1>(check) == std::get<1>(item) &&
+                std::get<2>(check) == std::get<2>(item))
             {
                 m_Res = true;
                 return;
diff --git a/src/backends/tosaCommon/TosaMappings.cpp b/src/backends/tosaCommon/TosaMappings.cpp
index a37eaf29b3..00ba429555 100644
--- a/src/backends/tosaCommon/TosaMappings.cpp
+++ b/src/backends/tosaCommon/TosaMappings.cpp
@@ -8,40 +8,33 @@
 using namespace armnn;
 using namespace tosa;
 
-void SetBasicBlockConstantTensorData(Layer* layer, TosaSerializationBasicBlock* /*basicBlock*/)
-{
-    switch (layer->GetType())
-    {
-        case LayerType::Convolution2d:
-        {
-            // ToDo: using Convolution2d as an example as it has constant tensors for weights and bias.
-            // ToDo: manually set TosaOperator data of basicBlock where constant tensors exist.
-        }
-        default:
-            // If no switch statement for layer, no constant tensors exist in that layer, return
-            return;
-    }
-}
-
 TosaSerializationBasicBlock* CreateEmptyTosaSerializationBasicBlock()
 {
-    // empty basic block when no tosa mapping implemented/exists
-    TosaSerializationOperator* op =
-        new TosaSerializationOperator(Op_UNKNOWN, Attribute_NONE, nullptr, {}, {});
+    // Empty basic block when no TOSA mapping implemented/exists
+    auto* op = new TosaSerializationOperator(Op_UNKNOWN, Attribute_NONE, nullptr, {}, {});
     return new TosaSerializationBasicBlock("", {op}, {}, {}, {});
 }
 
-TosaSerializationBasicBlock* GetTosaMapping(const LayerType type,
+TosaSerializationBasicBlock* GetTosaMapping(const Layer* layer,
+                                            const LayerType type,
                                             const std::vector<const TensorInfo*>& inputs,
                                             const std::vector<const TensorInfo*>& outputs,
-                                            const BaseDescriptor& descriptor,
-                                            bool isMain = false)
+                                            const BaseDescriptor& descriptor)
 {
     switch (type)
     {
         case LayerType::Addition:
         {
-            return ConvertAdditionToTosaOperator(inputs, outputs, isMain);
+            return ConvertAdditionToTosaOperator(layer, inputs, outputs);
+        }
+        case LayerType::Constant:
+        {
+            return ConvertConstantToTosaOperator(layer, outputs);
+        }
+        case LayerType::Convolution2d:
+        {
+            auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
+            return ConvertConv2dToTosaOperator(layer, inputs, outputs, conv2dDesc);
         }
         case LayerType::Pooling2d:
         {
@@ -57,11 +50,11 @@ TosaSerializationBasicBlock* GetTosaMapping(const LayerType type,
             }
             else if (avgPoolIgnoreValue)
             {
-                return ConvertAvgPool2DIgnoreValueToTosaOperator(inputs, outputs, isMain, poolDesc);
+                return ConvertAvgPool2DIgnoreValueToTosaOperator(layer, inputs, outputs, poolDesc);
             }
             else
             {
-                return ConvertPooling2DToTosaOperator(inputs, outputs, isMain, poolDesc);
+                return ConvertPooling2DToTosaOperator(layer, inputs, outputs, poolDesc);
             }
         }
         default:
@@ -71,7 +64,7 @@ TosaSerializationBasicBlock* GetTosaMapping(const LayerType type,
     }
 }
 
-TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer, bool isMain = false)
+TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer)
 {
     std::vector<const TensorInfo*> inputs;
     for (auto inputSlot : layer->GetInputSlots())
@@ -85,11 +78,10 @@ TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer, bool isMain =
         outputs.push_back(&outputSlot.GetTensorInfo());
     }
 
-    TosaSerializationBasicBlock* basicBlock = GetTosaMapping(layer->GetType(),
+    TosaSerializationBasicBlock* basicBlock = GetTosaMapping(layer,
+                                                             layer->GetType(),
                                                              inputs,
                                                              outputs,
-                                                             layer->GetParameters(),
-                                                             isMain);
-    SetBasicBlockConstantTensorData(layer, basicBlock);
+                                                             layer->GetParameters());
     return basicBlock;
 }
diff --git a/src/backends/tosaCommon/TosaMappings.hpp b/src/backends/tosaCommon/TosaMappings.hpp
index 8df2493d6e..cc41f1b7c8 100644
--- a/src/backends/tosaCommon/TosaMappings.hpp
+++ b/src/backends/tosaCommon/TosaMappings.hpp
@@ -13,22 +13,18 @@
 using namespace armnn;
 using namespace tosa;
 
-// From the input armnn::Layer, set the corresponding data field in the
-// tosa::TosaSerializationTensor where constant tensor data exists in the armnn::Layer.
-void SetBasicBlockConstantTensorData(Layer* layer, TosaSerializationBasicBlock* /*basicBlock*/);
-
 // Populates a tosa::TosaSerializationBasicBlock from constructing
 // tosa::TosaSerializationOperator(s) and tosa::TosaSerializationTensor(s)
 // based on the input armnn::LayerType and associated armnn::TensorInfos and armnn::Descriptor.
 //
-// If an armnn::LayerType does not have a tosa mapping or the mapping is not implemented in ArmNN,
+// If an armnn::LayerType does not have a TOSA mapping or the mapping is not implemented in ArmNN,
 // an empty tosa::TosaSerializationBasicBlock() is returned with operator tosa::Op_UNKNOWN.
-TosaSerializationBasicBlock* GetTosaMapping(const LayerType type,
+TosaSerializationBasicBlock* GetTosaMapping(const Layer* layer,
+                                            const LayerType type,
                                             const std::vector<const TensorInfo*>& inputs,
                                             const std::vector<const TensorInfo*>& outputs,
-                                            const BaseDescriptor& /*descriptor*/,
-                                            bool isMain);
+                                            const BaseDescriptor& /*descriptor*/);
 
 // Function called in armnn::OptimizeSubgraphView() when access to armnn::Layer is available
-// and there is an option to set tosa basic block data from constant layer tenors available from the input layer.
-TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer, bool isMain);
+// and there is an option to set TOSA basic block data from constant layer tensors available from the input layer.
+TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer);
diff --git a/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp b/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp
index 796797728e..66ca869ac4 100644
--- a/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/AdditionOperator.cpp
@@ -5,28 +5,36 @@
 
 #include "AdditionOperator.hpp"
 
-TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const std::vector<const TensorInfo*>& inputs,
-                                                           const std::vector<const TensorInfo*>& outputs,
-                                                           bool isMain)
+TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const Layer* layer,
+                                                           const std::vector<const TensorInfo*>& inputs,
+                                                           const std::vector<const TensorInfo*>& outputs)
 {
-    // A helper function with static global variables ensures uniqueness
-    // for dynamically generating input, output and block names
-    std::string input0Name = std::string("Op_ADD_input0_")  + GetUniqueTosaMappingID();
-    std::string input1Name = std::string("Op_ADD_input1_")  + GetUniqueTosaMappingID();
-    std::string outputName = std::string("Op_ADD_output0_") + GetUniqueTosaMappingID();
-    std::string blockName  = std::string("Op_ADD_block_")   + GetUniqueTosaMappingID();
-
-    // If it's the first block, overwrite block name with main.
-    if (isMain)
+    std::string input0Name = std::string("input0_");
+    std::string input1Name = std::string("input1_");
+    std::string outputName = std::string("output0_");
+    std::string blockName  = std::string("Op_ADD_block_") + GetUniqueTosaMappingID();
+
+    // If a layer is present then the block will be used for execution, so input and output names need to be determined
+    // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+    if(layer != nullptr)
     {
-        blockName = std::string("main");
+        // Get the layers connected to the input slots and determine unique layer names.
+        Layer& connectedLayer0 = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+        input0Name = GenerateUniqueName(connectedLayer0, 0);
+
+        Layer& connectedLayer1 = layer->GetInputSlot(1).GetConnectedOutputSlot()->GetOwningLayer();
+        input1Name = GenerateUniqueName(connectedLayer1, 1);
+
+        // Get the layer connected to the output slot and determine unique layer name.
+        Layer& connectedOutputLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+        outputName = GenerateUniqueName(connectedOutputLayer, 0);
     }
 
-    TosaSerializationOperator* op = new TosaSerializationOperator(Op_ADD,
-                                                                  Attribute_NONE,
-                                                                  nullptr,
-                                                                  {input0Name, input1Name},
-                                                                  {outputName});
+    auto* op = new TosaSerializationOperator(Op_ADD,
+                                             Attribute_NONE,
+                                             nullptr,
+                                             {input0Name, input1Name},
+                                             {outputName});
 
     std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
     DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
@@ -37,9 +45,9 @@ TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const std::vector<con
     std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
     DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
 
-    TosaSerializationTensor* inputTensor0  = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
-    TosaSerializationTensor* inputTensor1  = new TosaSerializationTensor(input1Name, inputShape1, inputDType1, {});
-    TosaSerializationTensor* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
+    auto* inputTensor0  = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
+    auto* inputTensor1  = new TosaSerializationTensor(input1Name, inputShape1, inputDType1, {});
+    auto* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
 
     // operatorInputNames/operatorOutputNames ends up being the same as
     // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp b/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
index f467bb6d10..5eb7441531 100644
--- a/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
+++ b/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
@@ -5,15 +5,16 @@
 
 #pragma once
 
+#include "TosaOperatorUtils.hpp"
+
 #include <Layer.hpp>
 
 #include <tosa_serialization_handler.h>
-#include "TosaOperatorUtils.hpp"
 
 using namespace armnn;
 using namespace tosa;
 
-TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const std::vector<const TensorInfo*>& inputs,
-                                                           const std::vector<const TensorInfo*>& outputs,
-                                                           bool isMain);
+TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const Layer* layer,
+                                                           const std::vector<const TensorInfo*>& inputs,
+                                                           const std::vector<const TensorInfo*>& outputs);
 
diff --git a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp
index b3d2687c30..2601a6243d 100644
--- a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.cpp
@@ -5,23 +5,27 @@
 
 #include "Pooling2DOperator.hpp"
 
-TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const Layer* layer,
+                                                                       const std::vector<const TensorInfo*>& inputs,
                                                                        const std::vector<const TensorInfo*>& outputs,
-                                                                       bool isMain,
                                                                        const Pooling2dDescriptor* poolDescriptor)
 {
+    std::string padInputName   = std::string("input0_");
+    std::string padOutputName  = std::string("intermediate0_") + GetUniqueTosaMappingID();
+    std::string poolOutputName = std::string("output0_");
+    std::string blockName      = std::string("Op_AVG_POOL2D_block_") + GetUniqueTosaMappingID();
 
-    // A helper function with static global variables ensures uniqueness
-    // for dynamically generating input, output and block names
-    std::string padInputName   = std::string("Op_PAD_input0_")  + GetUniqueTosaMappingID();
-    std::string padOutputName  = std::string("Op_PAD_intermediate0_")  + GetUniqueTosaMappingID();
-    std::string poolOutputName = std::string("Op_AVG_POOL2D_output0_") + GetUniqueTosaMappingID();
-    std::string blockName      = std::string("Op_AVG_POOL2D_block_")   + GetUniqueTosaMappingID();
-
-    // If it's the first block, overwrite block name with main.
-    if (isMain)
+    // If a layer is present then the block will be used for execution, so input and output names need to be determined
+    // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+    if(layer != nullptr)
     {
-        blockName = std::string("main");
+        // Get the layers connected to the input slots and determine unique layer names.
+        Layer& connectedInputLayer = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+        padInputName = GenerateUniqueName(connectedInputLayer, 0);
+
+        // Get the layer connected to the output slot and determine unique layer name.
+        Layer& connectedOutputLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+        poolOutputName = GenerateUniqueName(connectedOutputLayer, 0);
     }
 
     std::vector<int> paddings;
@@ -51,11 +55,11 @@ TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std
     }
 
     TosaPadAttribute padAttribute(paddings, 0, 0.0f);
-    TosaSerializationOperator* opPad = new TosaSerializationOperator(Op_PAD,
-                                                                     Attribute_PadAttribute,
-                                                                     &padAttribute,
-                                                                     {padInputName},
-                                                                     {padOutputName});
+    auto* opPad = new TosaSerializationOperator(Op_PAD,
+                                                Attribute_PadAttribute,
+                                                &padAttribute,
+                                                {padInputName},
+                                                {padOutputName});
 
     std::vector<int> pad    = {0, 0, 0, 0};
     std::vector<int> kernel = {static_cast<int>(poolDescriptor->m_PoolHeight),
@@ -64,11 +68,11 @@ TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std
                                static_cast<int>(poolDescriptor->m_StrideX)};
     TosaPoolAttribute poolAttribute(pad, kernel, stride, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
 
-    TosaSerializationOperator* opPool = new TosaSerializationOperator(Op_AVG_POOL2D,
-                                                                      Attribute_PoolAttribute,
-                                                                      &poolAttribute,
-                                                                      {padOutputName},
-                                                                      {poolOutputName});
+    auto* opPool = new TosaSerializationOperator(Op_AVG_POOL2D,
+                                                 Attribute_PoolAttribute,
+                                                 &poolAttribute,
+                                                 {padOutputName},
+                                                 {poolOutputName});
 
     std::vector<int32_t> inputShape = GetTosaTensorShape(inputs[0]->GetShape());
     DType inputDType = ArmNNToDType(inputs[0]->GetDataType());
@@ -92,10 +96,9 @@ TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std
                              inputShape[3] + paddings[6] + paddings[7]};
     }
 
-    TosaSerializationTensor* inputTensor  = new TosaSerializationTensor(padInputName, inputShape, inputDType, {});
-    TosaSerializationTensor* intermediateTensor  = new TosaSerializationTensor(
-        padOutputName, intermediateShape, inputDType, {});
-    TosaSerializationTensor* outputTensor = new TosaSerializationTensor(poolOutputName, outputShape, outputDType, {});
+    auto* inputTensor        = new TosaSerializationTensor(padInputName, inputShape, inputDType, {});
+    auto* intermediateTensor = new TosaSerializationTensor(padOutputName, intermediateShape, inputDType, {});
+    auto* outputTensor       = new TosaSerializationTensor(poolOutputName, outputShape, outputDType, {});
 
     // operatorInputNames/operatorOutputNames ends up being the same as
     // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp
index 63ae190cc9..f9d09754b0 100644
--- a/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp
+++ b/src/backends/tosaCommon/operatorMappings/AvgPool2DIgnoreValueOperator.hpp
@@ -5,15 +5,16 @@
 
 #pragma once
 
+#include "TosaOperatorUtils.hpp"
+
 #include <Layer.hpp>
 
 #include <tosa_serialization_handler.h>
-#include "TosaOperatorUtils.hpp"
 
 using namespace armnn;
 using namespace tosa;
 
-TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const Layer* layer,
+                                                                       const std::vector<const TensorInfo*>& inputs,
                                                                        const std::vector<const TensorInfo*>& outputs,
-                                                                       bool isMain,
                                                                        const Pooling2dDescriptor* poolDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
index 7fdc9226af..b256eddda1 100644
--- a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
+++ b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
@@ -8,6 +8,10 @@ list(APPEND armnnTosaBackendOperators_sources
         AdditionOperator.cpp
         AvgPool2DIgnoreValueOperator.hpp
         AvgPool2DIgnoreValueOperator.cpp
+        ConstantOperator.hpp
+        ConstantOperator.cpp
+        Conv2dOperator.hpp
+        Conv2dOperator.cpp
         Pooling2DOperator.hpp
         Pooling2DOperator.cpp
         TosaOperatorUtils.hpp
diff --git a/src/backends/tosaCommon/operatorMappings/ConstantOperator.cpp b/src/backends/tosaCommon/operatorMappings/ConstantOperator.cpp
new file mode 100644
index 0000000000..5e3973f8ec
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/ConstantOperator.cpp
@@ -0,0 +1,44 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ConstantOperator.hpp"
+
+#include <layers/ConstantLayer.hpp>
+
+TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer,
+                                                           const std::vector<const TensorInfo*>& outputs)
+{
+    std::string outputName = std::string("constant_");
+    std::string blockName  = std::string("Op_CONST_block_") + GetUniqueTosaMappingID();
+
+    std::vector<uint8_t> uint8Data;
+
+    // If a layer is present then the block will be used for execution, so names need to be unique.
+    // Also, set constant tensor data.
+    if(layer != nullptr)
+    {
+        outputName.append(std::to_string(layer->GetGuid()));
+        blockName.append(std::to_string(layer->GetGuid()));
+
+        auto constantLayer = PolymorphicDowncast<const armnn::ConstantLayer*>(layer);
+        auto tensorInfo = constantLayer->GetOutputSlot().GetTensorInfo();
+
+        uint8Data = ConvertConstantTensorDataToBuffer(constantLayer->m_LayerOutput);
+    }
+
+    auto* op = new TosaSerializationOperator(Op_CONST, Attribute_NONE, nullptr, {}, {outputName});
+
+    std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
+    DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
+
+    // Setup output tensor with constant tensor data if available.
+    auto* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, uint8Data);
+
+    return new TosaSerializationBasicBlock(blockName,       // name
+                                           {op},            // operators
+                                           {outputTensor0}, // tensors
+                                           {},              // inputs
+                                           {outputName});   // outputs
+}
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp b/src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp
new file mode 100644
index 0000000000..df158aca3d
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/ConstantOperator.hpp
@@ -0,0 +1,19 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaOperatorUtils.hpp"
+
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+
+using namespace armnn;
+using namespace tosa;
+
+TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer,
+                                                           const std::vector<const TensorInfo*>& outputs);
+
diff --git a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
new file mode 100644
index 0000000000..9c095d627f
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.cpp
@@ -0,0 +1,123 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "Conv2dOperator.hpp"
+
+TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
+                                                         const std::vector<const TensorInfo*>& inputs,
+                                                         const std::vector<const TensorInfo*>& outputs,
+                                                         const Convolution2dDescriptor* conv2dDescriptor)
+{
+    std::vector<std::string> inputNames;
+    std::string outputName = std::string("output0_");
+    std::string blockName  = std::string("Op_CONV2D_block_") + GetUniqueTosaMappingID();
+
+    // Set input names for validation purposes only.
+    if(layer == nullptr)
+    {
+        inputNames.emplace_back("input0_");
+        inputNames.emplace_back("input1_");
+        if(conv2dDescriptor->m_BiasEnabled)
+        {
+            inputNames.emplace_back("input2_");
+        }
+    }
+    else
+    {
+        // If a layer is present then the block will be used for execution, so input and output names need to be
+        // determined using the previous and following layers so the graph is connected correctly.
+        // For validation this doesn't matter.
+        for (uint32_t i = 0; i < inputs.size(); ++i)
+        {
+            // Get the layer connected to the input slot and determine unique layer name.
+            Layer& connectedLayer = layer->GetInputSlot(i).GetConnectedOutputSlot()->GetOwningLayer();
+
+            std::string inputName = GenerateUniqueName(connectedLayer, i);
+            inputNames.push_back(inputName);
+        }
+
+        // Get the layer connected to the output slot and determine unique layer name.
+        Layer& connectedLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+
+        outputName = GenerateUniqueName(connectedLayer, 0);
+    }
+
+    std::vector<TosaSerializationTensor*> tensors;
+    std::vector<TosaSerializationOperator*> operators;
+
+    // Setup input Tensor
+    std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
+    DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
+
+    tensors.push_back(new TosaSerializationTensor(inputNames[0], inputShape0, inputDType0, {}));
+
+    // Only add input tensors if weights and bias are not constant or if running validation.
+    // Constant tensors will be created in the ConvertConstantToTosaOperator function.
+    if(!inputs[1]->IsConstant() || layer == nullptr)
+    {
+        std::vector<int32_t> inputShape1 = GetTosaTensorShape(inputs[1]->GetShape());
+        DType inputDType1 = ArmNNToDType(inputs[1]->GetDataType());
+
+        tensors.push_back(new TosaSerializationTensor(inputNames[1], inputShape1, inputDType1, {}));
+    }
+
+    if(conv2dDescriptor->m_BiasEnabled)
+    {
+        if(!inputs[2]->IsConstant() || layer == nullptr)
+        {
+            std::vector<int32_t> inputShape2 = GetTosaTensorShape(inputs[2]->GetShape());
+            DType inputDType2 = ArmNNToDType(inputs[2]->GetDataType());
+
+            tensors.push_back(new TosaSerializationTensor(inputNames[2], inputShape2, inputDType2, {}));
+        }
+    }
+    else
+    {
+        // If bias is disabled, create a constant bias of 0 as three inputs are required.
+        std::string constantName = std::string("constant_") + GetUniqueTosaMappingID();
+
+        operators.push_back(new TosaSerializationOperator(Op_CONST, Attribute_NONE, nullptr, {}, {constantName}));
+
+        std::vector<uint8_t> uint8Data;
+        std::vector<float> data = { 0.0 };
+
+        TosaSerializationHandler::ConvertF32toU8(data, uint8Data);
+
+        tensors.push_back(new TosaSerializationTensor(constantName, {1}, DType_FP32, uint8Data));
+        inputNames.emplace_back(constantName);
+    }
+
+    // Setup Output Tensor
+    std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
+    DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
+
+    tensors.push_back(new TosaSerializationTensor(outputName, outputShape0, outputDType0, {}));
+
+    // Set up CONV2D operator
+    std::vector<int> pad = {static_cast<int>(conv2dDescriptor->m_PadTop),
+                            static_cast<int>(conv2dDescriptor->m_PadBottom),
+                            static_cast<int>(conv2dDescriptor->m_PadLeft),
+                            static_cast<int>(conv2dDescriptor->m_PadRight)};
+    std::vector<int> stride = {static_cast<int>(conv2dDescriptor->m_StrideY),
+                               static_cast<int>(conv2dDescriptor->m_StrideX)};
+    std::vector<int> dilation = {static_cast<int>(conv2dDescriptor->m_DilationY),
+                                 static_cast<int>(conv2dDescriptor->m_DilationX)};
+    TosaConvAttribute attribute(pad, dilation, stride, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
+
+    auto* op = new TosaSerializationOperator(Op_CONV2D,
+                                             Attribute_ConvAttribute,
+                                             &attribute,
+                                             inputNames,
+                                             {outputName});
+    operators.push_back(op);
+
+    // operatorInputNames/operatorOutputNames ends up being the same as
+    // blockInputNames/blockOutputNames for one-to-one ArmNN to TOSA mappings
+    return new TosaSerializationBasicBlock(blockName,     // name
+                                           operators,     // operators
+                                           tensors,       // tensors
+                                           inputNames,    // inputs
+                                           {outputName}); // outputs
+}
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp
new file mode 100644
index 0000000000..909151b9ac
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/Conv2dOperator.hpp
@@ -0,0 +1,20 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaOperatorUtils.hpp"
+
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+
+using namespace armnn;
+using namespace tosa;
+
+TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
+                                                         const std::vector<const TensorInfo*>& inputs,
+                                                         const std::vector<const TensorInfo*>& outputs,
+                                                         const Convolution2dDescriptor* conv2dDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp
index cd707edb3a..eaeb8a4cde 100644
--- a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp
+++ b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.cpp
@@ -5,24 +5,29 @@
 
 #include "Pooling2DOperator.hpp"
 
-TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer,
+                                                            const std::vector<const TensorInfo*>& inputs,
                                                             const std::vector<const TensorInfo*>& outputs,
-                                                            bool isMain,
                                                             const Pooling2dDescriptor* poolDescriptor)
 {
     std::string poolType = (poolDescriptor->m_PoolType == PoolingAlgorithm::Max) ? "Op_MAX" : "Op_AVG";
     Op opcode = (poolDescriptor->m_PoolType == PoolingAlgorithm::Max) ? Op_MAX_POOL2D : Op_AVG_POOL2D;
 
-    // A helper function with static global variables ensures uniqueness
-    // for dynamically generating input, output and block names
-    std::string input0Name = poolType + std::string("_POOL2D_input0_")  + GetUniqueTosaMappingID();
-    std::string outputName = poolType + std::string("_POOL2D_output0_") + GetUniqueTosaMappingID();
-    std::string blockName  = poolType + std::string("_POOL2D_block_")   + GetUniqueTosaMappingID();
+    std::string input0Name = std::string("input0_");
+    std::string outputName = std::string("output0_");
+    std::string blockName  = std::string("Op_") + poolType + std::string("_POOL2D_block_") + GetUniqueTosaMappingID();
 
-    // If it's the first block, overwrite block name with main.
-    if (isMain)
+    // If a layer is present then the block will be used for execution, so input and output names need to be determined
+    // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+    if(layer != nullptr)
     {
-        blockName = std::string("main");
+        // Get the layers connected to the input slots and determine unique layer names.
+        Layer& connectedInputLayer = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+        input0Name = GenerateUniqueName(connectedInputLayer, 0);
+
+        // Get the layer connected to the output slot and determine unique layer name.
+        Layer& connectedOutputLayer = layer->GetOutputSlot().GetConnection(0)->GetOwningLayer();
+        outputName = GenerateUniqueName(connectedOutputLayer, 0);
     }
 
     std::vector<int> pad = {static_cast<int>(poolDescriptor->m_PadTop),
@@ -35,11 +40,11 @@ TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const std::vector<co
                                static_cast<int>(poolDescriptor->m_StrideX)};
     TosaPoolAttribute attribute(pad, kernel, stride, 0, 0, ArmNNToDType(inputs[0]->GetDataType()));
 
-    TosaSerializationOperator* op = new TosaSerializationOperator(opcode,
-                                                                  Attribute_PoolAttribute,
-                                                                  &attribute,
-                                                                  {input0Name},
-                                                                  {outputName});
+    auto* op = new TosaSerializationOperator(opcode,
+                                             Attribute_PoolAttribute,
+                                             &attribute,
+                                             {input0Name},
+                                             {outputName});
 
     std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
     DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
@@ -47,8 +52,8 @@ TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const std::vector<co
     std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
     DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
 
-    TosaSerializationTensor* inputTensor0  = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
-    TosaSerializationTensor* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
+    auto* inputTensor0  = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
+    auto* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
 
     // operatorInputNames/operatorOutputNames ends up being the same as
     // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
diff --git a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp
index 22d2a3ae29..cc9ec097f9 100644
--- a/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp
+++ b/src/backends/tosaCommon/operatorMappings/Pooling2DOperator.hpp
@@ -5,15 +5,16 @@
 
 #pragma once
 
+#include "TosaOperatorUtils.hpp"
+
 #include <Layer.hpp>
 
 #include <tosa_serialization_handler.h>
-#include "TosaOperatorUtils.hpp"
 
 using namespace armnn;
 using namespace tosa;
 
-TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer,
+                                                            const std::vector<const TensorInfo*>& inputs,
                                                             const std::vector<const TensorInfo*>& outputs,
-                                                            bool isMain,
                                                             const Pooling2dDescriptor* poolDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp b/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
index 00b5f0fa68..513db0c039 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
@@ -6,5 +6,7 @@
 #pragma once
 
 #include "AdditionOperator.hpp"
+#include "ConstantOperator.hpp"
+#include "Conv2dOperator.hpp"
 #include "AvgPool2DIgnoreValueOperator.hpp"
 #include "Pooling2DOperator.hpp"
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
index f51b2109b4..176e4e1cfb 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
@@ -5,10 +5,13 @@
 
 #pragma once
 
+#include <Layer.hpp>
 #include <armnn/Tensor.hpp>
 #include <armnn/Types.hpp>
 
-#include <tosa_generated.h>
+#include "common/include/ProfilingGuid.hpp"
+
+#include <tosa_serialization_handler.h>
 
 using namespace armnn;
 using namespace tosa;
@@ -53,6 +56,33 @@ inline std::vector<int32_t> GetTosaTensorShape(const TensorShape& shape)
     return returnShape;
 }
 
+// Function that generates unique name using the layer type, input slot and layer guid.
+inline std::string GenerateUniqueName(const Layer& layer, uint32_t layerSlot)
+{
+    std::string name;
+    std::string guid        = std::to_string(layer.GetGuid());
+    std::string slotAndGuid = std::to_string(layerSlot) + "_" + guid;
+    LayerType layerType = layer.GetType();
+
+    if (layerType == LayerType::Input)
+    {
+        name = "input" + slotAndGuid;
+    }
+    else if (layerType == LayerType::Output)
+    {
+        name = "output" + slotAndGuid;
+    }
+    else if (layerType == LayerType::Constant)
+    {
+        name = "constant_" + guid;
+    }
+    else
+    {
+        name = "intermediate" + slotAndGuid;
+    }
+    return name;
+}
+
 // Function to return unique int as a string to ensure uniqueness between all input, output and block names.
 static int uniqueTosaMappingID = 0;
 inline std::string GetUniqueTosaMappingID()
@@ -206,3 +236,72 @@ inline std::string TosaOpToString(Op tosaOp)
     }
     return "";
 }
+
+inline std::vector<uint8_t> ConvertConstantTensorDataToBuffer(const std::shared_ptr<ConstTensorHandle>& tensorHandle)
+{
+    tosa_err_t error;
+    std::vector<uint8_t> uint8Data;
+    auto tensorInfo = tensorHandle->GetTensorInfo();
+
+    switch (tensorInfo.GetDataType())
+    {
+        case DataType::Float32:
+        {
+            std::vector<float> data(tensorInfo.GetNumElements());
+            memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+            error = TosaSerializationHandler::ConvertF32toU8(data, uint8Data);
+            break;
+        }
+        case DataType::Float16:
+        {
+            std::vector<float> data(tensorInfo.GetNumElements());
+            memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+            error = TosaSerializationHandler::ConvertF16toU8(data, uint8Data);
+            break;
+        }
+        case DataType::QSymmS8:
+        case DataType::QAsymmS8:
+        {
+            std::vector<int8_t> data(tensorInfo.GetNumElements());
+            memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+            error = TosaSerializationHandler::ConvertI8toU8(data, uint8Data);
+            break;
+        }
+        case DataType::QAsymmU8:
+        {
+            memcpy(uint8Data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+            break;
+        }
+        case DataType::QSymmS16:
+        {
+            std::vector<int16_t> data(tensorInfo.GetNumElements());
+            memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+            error = TosaSerializationHandler::ConvertI16toU8(data, uint8Data);
+            break;
+        }
+        case DataType::Signed32:
+        {
+            std::vector<int32_t> data(tensorInfo.GetNumElements());
+            memcpy(data.data(), tensorHandle->Map(true), tensorInfo.GetNumBytes());
+
+            error = TosaSerializationHandler::ConvertI32toU8(data, uint8Data);
+            break;
+        }
+        default:
+        {
+            throw armnn::Exception("SetConstantTensorData: An unsupported data type was encountered.");
+        }
+    }
+
+    if(error != tosa_err_t::TOSA_OK)
+    {
+        throw armnn::Exception("SetConstantTensorData: An error occurred when converting constant data");
+    }
+
+    tensorHandle->Unmap();
+    return uint8Data;
+}
diff --git a/src/backends/tosaCommon/test/AvgPool2DIgnoreValueChecker.hpp b/src/backends/tosaCommon/test/AvgPool2DIgnoreValueChecker.hpp
index 8869b3a8ff..a38f66b466 100644
--- a/src/backends/tosaCommon/test/AvgPool2DIgnoreValueChecker.hpp
+++ b/src/backends/tosaCommon/test/AvgPool2DIgnoreValueChecker.hpp
@@ -17,10 +17,8 @@ void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
 {
     uint32_t numInputs = static_cast<uint32_t>(inputShape.size());
     uint32_t numOutputs = static_cast<uint32_t>(outputShape.size());
-    std::string operatorString0 = TosaOpToString(Op_PAD);
-    std::string operatorString1 = TosaOpToString(Op_AVG_POOL2D);
 
-    std::string blockStr = operatorString1 + "_block_";
+    std::string blockStr = TosaOpToString(Op_AVG_POOL2D) + "_block_";
     CHECK(basicBlock->GetName().find(blockStr)  != std::string::npos);
     CHECK(basicBlock->GetInputs().size() == numInputs);
     CHECK(basicBlock->GetOutputs().size() == numOutputs);
@@ -41,7 +39,7 @@ void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
         std::basic_string<char> blockInputName = basicBlock->GetInputs()[i];
         std::basic_string<char> operatorInputName  = padOp->GetInputTensorNames()[i];
 
-        std::string opStr = operatorString0 + "_input" + std::to_string(i) + "_";
+        std::string opStr = "input" + std::to_string(i) + "_";
 
         CHECK(blockInputName == operatorInputName);
         CHECK(basicBlock->GetTensorByName(blockInputName));
@@ -56,7 +54,7 @@ void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
     for (uint32_t i = 0; i < padOpOutputs; i++)
     {
         std::basic_string<char> operatorOutputName  = padOp->GetOutputTensorNames()[i];
-        std::string opStr = operatorString0 + "_intermediate" + std::to_string(i) + "_";
+        std::string opStr = "intermediate" + std::to_string(i) + "_";
 
         CHECK(basicBlock->GetTensorByName(operatorOutputName));
         CHECK(operatorOutputName.find(opStr)  != std::string::npos);
@@ -86,7 +84,7 @@ void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
     for (uint32_t i = 0; i < poolOpInputs; i++)
     {
         std::basic_string<char> operatorInputName  = poolOp->GetInputTensorNames()[i];
-        std::string opStr = operatorString0 + "_intermediate" + std::to_string(i) + "_";
+        std::string opStr = "intermediate" + std::to_string(i) + "_";
 
         CHECK(basicBlock->GetTensorByName(operatorInputName));
         CHECK(operatorInputName.find(opStr)  != std::string::npos);
@@ -102,7 +100,7 @@ void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
         std::basic_string<char> blockOutputName = basicBlock->GetOutputs()[i];
         std::basic_string<char> operatorOutputName  = poolOp->GetOutputTensorNames()[i];
 
-        std::string opStr = operatorString1 + "_output" + std::to_string(i) + "_";
+        std::string opStr = "output" + std::to_string(i) + "_";
 
         CHECK(blockOutputName == operatorOutputName);
         CHECK(basicBlock->GetTensorByName(blockOutputName));
diff --git a/src/backends/tosaCommon/test/OneToManyMappingTests.cpp b/src/backends/tosaCommon/test/OneToManyMappingTests.cpp
index 98fd563da1..dd61ba8191 100644
--- a/src/backends/tosaCommon/test/OneToManyMappingTests.cpp
+++ b/src/backends/tosaCommon/test/OneToManyMappingTests.cpp
@@ -30,7 +30,7 @@ TEST_CASE("GetTosaMapping_AvgPool2DIgnoreValueLayer")
     std::vector<std::vector<int32_t>> outputShape        = {{ 1, 1, 3, 3 }};
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMapping(LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor, false);
+        GetTosaMapping(nullptr, LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor);
     VerifyAvgPool2DIgnoreValue(basicBlock,
                                inputShape,
                                outputShape,
@@ -74,7 +74,7 @@ TEST_CASE("GetTosaMappingFromLayer_AvgPool2DIgnoreValueLayer")
     pool->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool), false);
+        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool));
     VerifyAvgPool2DIgnoreValue(basicBlock,
                               inputShape,
                               outputShape,
diff --git a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
index 04d1eb46aa..af9f9e26df 100644
--- a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
+++ b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
@@ -4,6 +4,7 @@
 //
 
 #include "TosaTestUtils.hpp"
+#include "CommonTestUtils.hpp"
 
 using namespace armnn;
 using namespace tosa;
@@ -18,7 +19,7 @@ TEST_CASE("GetTosaMapping_AdditionLayer")
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 2, 4, 2 }};
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMapping(LayerType::Addition, {&info, &info}, {&info}, BaseDescriptor(), false);
+        GetTosaMapping(nullptr, LayerType::Addition, {&info, &info}, {&info}, BaseDescriptor());
     AssertTosaOneToOneMappingBasicBlock(
         basicBlock, inputShape, outputShape, Op_ADD, Attribute_NONE, BaseDescriptor(), LayerType::Addition);
 }
@@ -50,11 +51,132 @@ TEST_CASE("GetTosaMappingFromLayer_AdditionLayer")
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 2, 4, 2 }};
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(add), false);
+        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(add));
     AssertTosaOneToOneMappingBasicBlock(
         basicBlock, inputShape, outputShape, Op_ADD, Attribute_NONE, BaseDescriptor(), LayerType::Addition);
 }
 
+TEST_CASE("GetTosaMapping_ConstantLayer")
+{
+    TensorInfo outputInfo = TensorInfo({ 1, 2, 4, 2 }, DataType::Float32, 0.0f, 0, true);
+    std::vector<std::vector<int32_t>> outputShape = {{ 1, 2, 4, 2 }};
+
+    TosaSerializationBasicBlock* basicBlock =
+            GetTosaMapping(nullptr, LayerType::Constant, {}, {&outputInfo}, BaseDescriptor());
+    AssertTosaOneToOneMappingBasicBlock(
+            basicBlock, {}, outputShape, Op_CONST, Attribute_NONE, BaseDescriptor(), LayerType::Constant);
+}
+
+TEST_CASE("GetTosaMappingFromLayer_ConstantLayer")
+{
+    IRuntime::CreationOptions options;
+    IRuntimePtr runtime(IRuntime::Create(options));
+
+    // Builds up the structure of the network.
+    INetworkPtr net(INetwork::Create());
+
+    TensorInfo info = TensorInfo({ 1, 2, 4, 2 }, DataType::Float32, 0.0f, 0, true);
+    std::vector<std::vector<int32_t>> outputShape = {{ 1, 2, 4, 2 }};
+
+    std::vector<float> data = GenerateRandomData<float>(info.GetNumElements());
+    armnn::ConstTensor constTensor(info, data);
+
+    IConnectableLayer* constant = net->AddConstantLayer(constTensor, "constant");
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+
+    constant->GetOutputSlot(0).Connect(output->GetInputSlot(0));
+    constant->GetOutputSlot(0).SetTensorInfo(info);
+
+    TosaSerializationBasicBlock* basicBlock =
+            GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(constant));
+    AssertTosaOneToOneMappingBasicBlock(
+            basicBlock, {}, outputShape, Op_CONST, Attribute_NONE, BaseDescriptor(), LayerType::Constant);
+}
+
+TEST_CASE("GetTosaMapping_Conv2dLayer")
+{
+    armnn::Convolution2dDescriptor descriptor;
+    descriptor.m_PadLeft     = 1;
+    descriptor.m_PadRight    = 1;
+    descriptor.m_PadTop      = 1;
+    descriptor.m_PadBottom   = 1;
+    descriptor.m_StrideX     = 2;
+    descriptor.m_StrideY     = 2;
+    descriptor.m_DilationX   = 2;
+    descriptor.m_DilationY   = 2;
+    descriptor.m_BiasEnabled = true;
+
+    const armnn::TensorInfo inputInfo ({ 1, 5, 5, 1 }, armnn::DataType::Float32);
+    const armnn::TensorInfo outputInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
+    const armnn::TensorInfo weightsInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32, 0.0f, 0, true);
+    const armnn::TensorInfo biasesInfo ({ 1 }, armnn::DataType::Float32, 0.0f, 0, true);
+
+    std::vector<std::vector<int32_t>> inputShape  = {{ 1, 5, 5, 1 }, { 1, 3, 3, 1 }, { 1 }};
+    std::vector<std::vector<int32_t>> outputShape = {{ 1, 3, 3, 1 }};
+
+    TosaSerializationBasicBlock* basicBlock = GetTosaMapping(nullptr,
+                                                             LayerType::Convolution2d,
+                                                             {&inputInfo, &weightsInfo, &biasesInfo},
+                                                             {&outputInfo},
+                                                             descriptor);
+    AssertTosaOneToOneMappingBasicBlock(
+        basicBlock, inputShape, outputShape, Op_CONV2D, Attribute_ConvAttribute, descriptor, LayerType::Convolution2d);
+}
+
+TEST_CASE("GetTosaMappingFromLayer_Conv2dLayer")
+{
+    IRuntime::CreationOptions options;
+    IRuntimePtr runtime(IRuntime::Create(options));
+
+    // Builds up the structure of the network.
+    INetworkPtr net(INetwork::Create());
+
+    armnn::Convolution2dDescriptor descriptor;
+    descriptor.m_PadLeft     = 1;
+    descriptor.m_PadRight    = 1;
+    descriptor.m_PadTop      = 1;
+    descriptor.m_PadBottom   = 1;
+    descriptor.m_StrideX     = 2;
+    descriptor.m_StrideY     = 2;
+    descriptor.m_DilationX   = 2;
+    descriptor.m_DilationY   = 2;
+    descriptor.m_BiasEnabled = true;
+
+    const armnn::TensorInfo inputInfo ({ 1, 5, 5, 1 }, armnn::DataType::Float32);
+    const armnn::TensorInfo outputInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
+    const armnn::TensorInfo weightsInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32, 0.0f, 0, true);
+    const armnn::TensorInfo biasesInfo ({ 1 }, armnn::DataType::Float32, 0.0f, 0, true);
+
+    std::vector<std::vector<int32_t>> inputShape  = {{ 1, 5, 5, 1 }};
+    std::vector<std::vector<int32_t>> outputShape = {{ 1, 3, 3, 1 }};
+
+    std::vector<float> weightsData = GenerateRandomData<float>(weightsInfo.GetNumElements());
+    armnn::ConstTensor weights(weightsInfo, weightsData);
+
+    std::vector<float> biasesData = GenerateRandomData<float>(biasesInfo.GetNumElements());
+    armnn::ConstTensor biases(biasesInfo, biasesData);
+
+    armnn::IConnectableLayer* const inputLayer  = net->AddInputLayer(0, "input0");
+    armnn::IConnectableLayer* const weightsLayer = net->AddConstantLayer(weights, "weights");
+    armnn::IConnectableLayer* const biasesLayer = net->AddConstantLayer(biases, "biases");
+    armnn::IConnectableLayer* const convLayer   = net->AddConvolution2dLayer(descriptor, "conv2d");
+    armnn::IConnectableLayer* const outputLayer = net->AddOutputLayer(0);
+
+    inputLayer->GetOutputSlot(0).Connect(convLayer->GetInputSlot(0));
+    weightsLayer->GetOutputSlot(0).Connect(convLayer->GetInputSlot(1));
+    biasesLayer->GetOutputSlot(0).Connect(convLayer->GetInputSlot(2));
+    convLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    weightsLayer->GetOutputSlot(0).SetTensorInfo(weightsInfo);
+    biasesLayer->GetOutputSlot(0).SetTensorInfo(biasesInfo);
+    convLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    TosaSerializationBasicBlock* basicBlock = GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(convLayer));
+    AssertTosaOneToOneMappingBasicBlock(
+        basicBlock, inputShape, outputShape, Op_CONV2D, Attribute_ConvAttribute, descriptor, LayerType::Convolution2d);
+}
+
 TEST_CASE("GetTosaMapping_MaxPool2DLayer")
 {
     armnn::Pooling2dDescriptor descriptor;
@@ -74,7 +196,7 @@ TEST_CASE("GetTosaMapping_MaxPool2DLayer")
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 1, 3, 3 }};
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMapping(LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor, false);
+        GetTosaMapping(nullptr, LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor);
     AssertTosaOneToOneMappingBasicBlock(
         basicBlock, inputShape, outputShape, Op_MAX_POOL2D, Attribute_PoolAttribute, descriptor, LayerType::Pooling2d);
 }
@@ -114,7 +236,7 @@ TEST_CASE("GetTosaMappingFromLayer_MaxPool2DLayer")
     pool->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool), false);
+        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool));
     AssertTosaOneToOneMappingBasicBlock(
         basicBlock, inputShape, outputShape, Op_MAX_POOL2D, Attribute_PoolAttribute, descriptor, LayerType::Pooling2d);
 }
@@ -138,7 +260,7 @@ TEST_CASE("GetTosaMapping_AvgPool2DLayer")
     std::vector<std::vector<int32_t>> outputShape = {{ 1, 1, 3, 3 }};
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMapping(LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor, false);
+        GetTosaMapping(nullptr, LayerType::Pooling2d, {&inputTensorInfo}, {&outputTensorInfo}, descriptor);
     AssertTosaOneToOneMappingBasicBlock(basicBlock,
                                         inputShape,
                                         outputShape,
@@ -183,7 +305,7 @@ TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
     pool->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool), false);
+        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(pool));
     AssertTosaOneToOneMappingBasicBlock(basicBlock,
                                         inputShape,
                                         outputShape,
@@ -196,7 +318,7 @@ TEST_CASE("GetTosaMappingFromLayer_AvgPool2DLayer")
 TEST_CASE("GetTosaMapping_Unimplemented")
 {
     TosaSerializationBasicBlock* basicBlock =
-        GetTosaMapping(LayerType::UnidirectionalSequenceLstm, {}, {}, BaseDescriptor(), false);
+        GetTosaMapping(nullptr, LayerType::UnidirectionalSequenceLstm, {}, {}, BaseDescriptor());
 
     CHECK(basicBlock->GetName() == "");
     CHECK(basicBlock->GetTensors().size() == 0);
diff --git a/src/backends/tosaCommon/test/TosaTestUtils.hpp b/src/backends/tosaCommon/test/TosaTestUtils.hpp
index a362bde10d..dd63c0efdf 100644
--- a/src/backends/tosaCommon/test/TosaTestUtils.hpp
+++ b/src/backends/tosaCommon/test/TosaTestUtils.hpp
@@ -21,6 +21,24 @@ inline void VerifyTosaAttributeFromDescriptor(const BaseDescriptor& descriptor,
 {
     switch (type)
     {
+        case LayerType::Convolution2d:
+        {
+            auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
+            std::vector<int> pad = {static_cast<int>(conv2dDesc->m_PadTop),
+                                    static_cast<int>(conv2dDesc->m_PadBottom),
+                                    static_cast<int>(conv2dDesc->m_PadLeft),
+                                    static_cast<int>(conv2dDesc->m_PadRight)};
+
+            std::vector<int> dilation = {static_cast<int>(conv2dDesc->m_DilationY),
+                                         static_cast<int>(conv2dDesc->m_DilationX)};
+            std::vector<int> stride = {static_cast<int>(conv2dDesc->m_StrideY),
+                                       static_cast<int>(conv2dDesc->m_StrideX)};
+            TosaConvAttribute convAttribute(attribute);
+            CHECK(pad == convAttribute.pad());
+            CHECK(dilation == convAttribute.dilation());
+            CHECK(stride == convAttribute.stride());
+            break;
+        }
         case LayerType::Pooling2d:
         {
             auto poolDesc = PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor);
@@ -80,6 +98,7 @@ inline void VerifyTosaAttributeFromDescriptor(const BaseDescriptor& descriptor,
             CHECK(pad == poolAttribute.pad());
             CHECK(kernel == poolAttribute.kernel());
             CHECK(stride == poolAttribute.stride());
+            break;
         }
         default:
             break;
@@ -97,18 +116,30 @@ inline void AssertTosaOneToOneMappingBasicBlock(TosaSerializationBasicBlock* bas
                                                 DType dataType = DType_FP32)
 {
     uint32_t numInputs = static_cast<uint32_t>(inputShape.size());
+    uint32_t numInputTensors = static_cast<uint32_t>(inputShape.size());
     uint32_t numOutputs = static_cast<uint32_t>(outputShape.size());
     std::string operatorString = TosaOpToString(tosaOp);
 
+    // The number of tensors in the block can be different if there are constant layers, as they are created separately.
+    if(type == LayerType::Convolution2d)
+    {
+        numInputTensors = 2;
+        auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
+        if(conv2dDesc->m_BiasEnabled)
+        {
+            numInputTensors = 3;
+        }
+    }
+
     std::string blockStr = operatorString + "_block_";
     CHECK(basicBlock->GetName().find(blockStr)  != std::string::npos);
-    CHECK(basicBlock->GetInputs().size() == numInputs);
+    CHECK(basicBlock->GetInputs().size() == numInputTensors);
     CHECK(basicBlock->GetOutputs().size() == numOutputs);
     CHECK(basicBlock->GetOperators().size() == 1);
     CHECK(basicBlock->GetTensors().size() == (numInputs + numOutputs));
 
     TosaSerializationOperator* op = basicBlock->GetOperators().at(0);
-    CHECK(op->GetInputTensorNames().size() == numInputs);
+    CHECK(op->GetInputTensorNames().size() == numInputTensors);
     CHECK(op->GetOutputTensorNames().size() == numOutputs);
 
     for (uint32_t i = 0; i < numInputs; i++)
@@ -117,11 +148,11 @@ inline void AssertTosaOneToOneMappingBasicBlock(TosaSerializationBasicBlock* bas
         std::basic_string<char> operatorInputName  = op->GetInputTensorNames()[i];
         std::basic_string<char> tensorName = basicBlock->GetTensors()[i]->GetName();
 
-        std::string opStr = operatorString + "_input" + std::to_string(i) + "_";
+        std::string opStr = "input" + std::to_string(i) + "_";
 
         CHECK(blockInputName == operatorInputName);
         CHECK(tensorName == operatorInputName);
-        CHECK(blockInputName.find(opStr)  != std::string::npos);
+        CHECK(blockInputName.find(opStr) != std::string::npos);
     }
 
     for (uint32_t i = 0; i < numOutputs; i++)
@@ -130,7 +161,11 @@ inline void AssertTosaOneToOneMappingBasicBlock(TosaSerializationBasicBlock* bas
         std::basic_string<char> operatorOutputName  = op->GetOutputTensorNames()[i];
         std::basic_string<char> tensorName = basicBlock->GetTensors()[numInputs + i]->GetName();
 
-        std::string opStr = operatorString + "_output" + std::to_string(i) + "_";
+        std::string opStr = "output" + std::to_string(i) + "_";
+        if (tosaOp == Op_CONST)
+        {
+            opStr = "constant_";
+        }
 
         CHECK(blockOutputName == operatorOutputName);
         CHECK(tensorName == operatorOutputName);
@@ -152,8 +187,12 @@ inline void AssertTosaOneToOneMappingBasicBlock(TosaSerializationBasicBlock* bas
     {
         TosaSerializationTensor* tensor = basicBlock->GetTensors()[i + inputShape.size()];
         CHECK(tensor->GetDtype() == dataType);
-        CHECK(tensor->GetData().size() == 0);
         CHECK(tensor->GetShape() == outputShape[static_cast<unsigned long int>(i)]);
+        if (tosaOp != Op_CONST)
+        {
+            // Const tensors contain data.
+            CHECK(tensor->GetData().size() == 0);
+        }
     }
 
     VerifyTosaAttributeFromDescriptor(descriptor,
diff --git a/src/backends/tosaReference/TosaRefBackend.cpp b/src/backends/tosaReference/TosaRefBackend.cpp
index e3a516a5f9..554bb10f0f 100644
--- a/src/backends/tosaReference/TosaRefBackend.cpp
+++ b/src/backends/tosaReference/TosaRefBackend.cpp
@@ -83,16 +83,20 @@ OptimizationViews TosaRefBackend::OptimizeSubgraphView(const SubgraphView& subgr
                                                        const ModelOptions& modelOptions) const
 {
     OptimizationViews optimizationViews(modelOptions);
+
     auto handler = std::make_unique<TosaSerializationHandler>();
 
-    // A main block should only be added once.
-    bool isMain = true;
+    std::vector<std::string> graphInputs;
+    std::vector<std::string> graphOutputs;
+
+    std::vector<TosaSerializationOperator*> operators;
+    std::vector<TosaSerializationTensor*> tensors;
 
     auto it = subgraph.endIConnectable();
     while (it != subgraph.beginIConnectable())
     {
         --it;
-        Layer &base = *(PolymorphicDowncast<Layer*>(*it));
+        Layer& base = *(PolymorphicDowncast<Layer*>(*it));
 
         if(base.GetType() == armnn::LayerType::Input ||
            base.GetType() == armnn::LayerType::Output)
@@ -100,15 +104,44 @@ OptimizationViews TosaRefBackend::OptimizeSubgraphView(const SubgraphView& subgr
             continue;
         }
 
-        tosa::TosaSerializationBasicBlock* mappings = GetTosaMappingFromLayer(&base, isMain);
-        handler.get()->GetBlocks().push_back(mappings);
+        tosa::TosaSerializationBasicBlock* mappings = GetTosaMappingFromLayer(&base);
 
-        if(isMain)
+        // Loop through inputs to see if there are any graph inputs, if so save them.
+        // If it's an input to the graph "input" can be found in the string.
+        for (uint32_t i = 0; i < mappings->GetInputs().size(); i++)
         {
-            isMain = false;
+            std::basic_string<char> blockInputName = mappings->GetInputs()[i];
+
+            if (blockInputName.find("input") != std::string::npos)
+            {
+                graphInputs.push_back(blockInputName);
+            }
         }
+
+        // Loop through outputs to see if there are any graph outputs, if so save them.
+        // If it's an output to the graph "output" can be found in the string.
+        for (uint32_t i = 0; i < mappings->GetOutputs().size(); i++)
+        {
+            std::basic_string<char> blockOutputName = mappings->GetOutputs()[i];
+
+            if (blockOutputName.find("output") != std::string::npos)
+            {
+                graphOutputs.push_back(blockOutputName);
+            }
+        }
+
+        auto blockOperators = mappings->GetOperators();
+        operators.insert(operators.end(), blockOperators.begin(), blockOperators.end());
+
+        auto blockTensors = mappings->GetTensors();
+        tensors.insert(tensors.end(), blockTensors.begin(), blockTensors.end());
     }
 
+    // Add all mappings to main block, the TOSA Reference Model requires the full graph to be in one block called main.
+    auto* block = new TosaSerializationBasicBlock("main", operators, tensors, graphInputs, graphOutputs);
+
+    handler.get()->GetBlocks().push_back(block);
+
     auto compiledBlob =
             std::make_unique<PreCompiledObjectPtr>(handler.release(), DeleteAsType<TosaSerializationHandler>);
 
diff --git a/src/backends/tosaReference/TosaRefLayerSupport.cpp b/src/backends/tosaReference/TosaRefLayerSupport.cpp
index ce4abbf921..848b7efdce 100644
--- a/src/backends/tosaReference/TosaRefLayerSupport.cpp
+++ b/src/backends/tosaReference/TosaRefLayerSupport.cpp
@@ -102,7 +102,7 @@ static bool RunTosaLayerChecksInputOutputDataType(TosaSerializationOperator* op,
         std::tuple<DType, DType> mappingType(input->GetDtype(), output->GetDtype());
 
         // Check Dtype from tensor (GetDtype)
-        supported &= CheckSupportRule(TosaContainerContains(mappingType, supportedMappingTypes),
+        supported &= CheckSupportRule(TosaContainerContainsTwoTypes(mappingType, supportedMappingTypes),
                                       reasonIfUnsupported,
                                       std::string("TOSA Reference Operator: " + opString + " for input: " +
                                           input->GetName() + " and output: " + output->GetName() +
@@ -125,6 +125,58 @@ static bool RunTosaLayerChecksInputOutputDataType(TosaSerializationOperator* op,
     return supported;
 }
 
+static bool RunTosaLayerChecksInputWeightsOutputDataType(
+        TosaSerializationOperator* op,
+        const std::vector<TosaSerializationTensor*>& inputs,
+        const std::vector<TosaSerializationTensor*>& outputs,
+        const std::vector<Attribute>& supportedAttributes,
+        const std::vector<std::tuple<DType, DType, DType>>& supportedMappingTypes,
+        Optional<string&> reasonIfUnsupported)
+{
+    bool supported = true;
+
+    std::string opString = TosaOpToString(op->GetOp());
+
+    // Check Attribute from operator (GetAttribute)
+    supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
+                                  std::string("TOSA Reference Operator: " + opString +
+                                              " has an unsupported attribute.").c_str());
+
+    // Check combination of input, weights and output types.
+    // Bias is the same as output type, so it is covered.
+    std::tuple<DType, DType, DType> mappingTypes(inputs[0]->GetDtype(), inputs[1]->GetDtype(), outputs[0]->GetDtype());
+
+    // Check Dtype from tensor (GetDtype)
+    supported &= CheckSupportRule(TosaContainerContainsThreeTypes(mappingTypes, supportedMappingTypes),
+                                  reasonIfUnsupported,
+                                  std::string("TOSA Reference Operator: " + opString + " for input 0: " +
+                                              inputs[0]->GetName() + ", input 1: " + inputs[1]->GetName() +
+                                              " and output: " + outputs[0]->GetName() +
+                                              " has an unsupported input data type combination.").c_str());
+
+    for (auto input : inputs)
+    {
+        // Check Shape from tensor (GetShape)
+        supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(input),
+                                      reasonIfUnsupported,
+                                      std::string("Tosa Reference Operator: " + opString + " for input: " +
+                                                  input->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
+    }
+
+    for (auto output : outputs)
+    {
+        // Check Shape from tensor (GetShape)
+        supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(output),
+                                      reasonIfUnsupported,
+                                      std::string("Tosa Reference Operator: " + opString + " for output: " +
+                                                  output->GetName() + " exceeds MaxNumOfTensorDimensions.").c_str());
+    }
+
+    return supported;
+}
+
+
+
 static bool IsTosaLayerSupported(TosaSerializationOperator* op,
                                  const std::vector<TosaSerializationTensor*>& inputs,
                                  const std::vector<TosaSerializationTensor*>& outputs,
@@ -134,10 +186,7 @@ static bool IsTosaLayerSupported(TosaSerializationOperator* op,
     {
         case tosa::Op_ADD:
         {
-            std::vector<Attribute> supportedAttributes =
-            {
-                Attribute_NONE
-            };
+            std::vector<Attribute> supportedAttributes = { Attribute_NONE };
 
             // Only Int32, Fp32 and Fp16 are currently supported by the TOSA Reference Model.
             std::vector<DType> supportedTypes =
@@ -148,20 +197,47 @@ static bool IsTosaLayerSupported(TosaSerializationOperator* op,
             };
 
             // Check the attribute, data types and bounds for inputs and outputs.
-            return RunTosaLayerChecksSingleDataType(op,
-                                                    inputs,
-                                                    outputs,
-                                                    supportedAttributes,
-                                                    supportedTypes,
-                                                    reasonIfUnsupported);
+            return RunTosaLayerChecksSingleDataType(
+                    op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
-        case tosa::Op_AVG_POOL2D:
+        case tosa::Op_CONST:
+        {
+            std::vector<Attribute> supportedAttributes = { Attribute_NONE };
+
+            std::vector<DType> supportedTypes =
+            {
+                DType_FP16,
+                DType_FP32,
+                DType_UINT8,
+                DType_INT8,
+                DType_INT16,
+                DType_INT32,
+                DType_BOOL
+            };
+
+            // Check the attribute, data types and bounds for inputs and outputs.
+            return RunTosaLayerChecksSingleDataType(
+                    op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
+        }
+        case tosa::Op_CONV2D:
         {
-            std::vector<Attribute> supportedAttributes =
+            std::vector<Attribute> supportedAttributes = { Attribute_ConvAttribute };
+
+            std::vector<std::tuple<DType, DType, DType>> supportedTypesMapping =
             {
-                Attribute_PoolAttribute
+                std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP16),
+                std::tuple<DType, DType, DType>(DType_FP16, DType_FP16, DType_FP32),
+                std::tuple<DType, DType, DType>(DType_FP32, DType_FP32, DType_FP32),
+                std::tuple<DType, DType, DType>(DType_INT8, DType_INT8, DType_INT32)
             };
 
+            return RunTosaLayerChecksInputWeightsOutputDataType(
+                    op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
+        }
+        case tosa::Op_AVG_POOL2D:
+        {
+            std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };
+
             std::vector<std::tuple<DType, DType>> supportedTypesMapping =
             {
                 std::tuple<DType, DType>(DType_FP16, DType_FP16),
@@ -172,19 +248,12 @@ static bool IsTosaLayerSupported(TosaSerializationOperator* op,
             };
 
             // Check the attribute, data types and bounds for inputs and outputs.
-            return RunTosaLayerChecksInputOutputDataType(op,
-                                                         inputs,
-                                                         outputs,
-                                                         supportedAttributes,
-                                                         supportedTypesMapping,
-                                                         reasonIfUnsupported);
+            return RunTosaLayerChecksInputOutputDataType(
+                    op, inputs, outputs, supportedAttributes, supportedTypesMapping, reasonIfUnsupported);
         }
         case tosa::Op_MAX_POOL2D:
         {
-            std::vector<Attribute> supportedAttributes =
-            {
-                Attribute_PoolAttribute
-            };
+            std::vector<Attribute> supportedAttributes = { Attribute_PoolAttribute };
 
             std::vector<DType> supportedTypes =
             {
@@ -195,19 +264,12 @@ static bool IsTosaLayerSupported(TosaSerializationOperator* op,
             };
 
             // Check the attribute, data types and bounds for inputs and outputs.
-            return RunTosaLayerChecksSingleDataType(op,
-                                                    inputs,
-                                                    outputs,
-                                                    supportedAttributes,
-                                                    supportedTypes,
-                                                    reasonIfUnsupported);
+            return RunTosaLayerChecksSingleDataType(
+                    op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
         case tosa::Op_PAD:
         {
-            std::vector<Attribute> supportedAttributes =
-            {
-                Attribute_PadAttribute
-            };
+            std::vector<Attribute> supportedAttributes = { Attribute_PadAttribute };
 
             std::vector<DType> supportedTypes =
             {
@@ -220,12 +282,8 @@ static bool IsTosaLayerSupported(TosaSerializationOperator* op,
             };
 
             // Check the attribute, data types and bounds for inputs and outputs.
-            return RunTosaLayerChecksSingleDataType(op,
-                                                    inputs,
-                                                    outputs,
-                                                    supportedAttributes,
-                                                    supportedTypes,
-                                                    reasonIfUnsupported);
+            return RunTosaLayerChecksSingleDataType(
+                    op, inputs, outputs, supportedAttributes, supportedTypes, reasonIfUnsupported);
         }
         default:
             SetValueChecked(reasonIfUnsupported, "Operation is currently unsupported by the TOSA Reference Backend.");
@@ -248,15 +306,31 @@ bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type,
 
     switch (type)
     {
+        case LayerType::Input:
+        case LayerType::Output:
+            return true;
         case LayerType::Addition:
             // Setup inputs and outputs
             inputInfos.push_back(&infos[0]);
             inputInfos.push_back(&infos[1]);
             outputInfos.push_back(&infos[2]);
             break;
-        case LayerType::Input:
-        case LayerType::Output:
-            return true;
+        case LayerType::Constant:
+            outputInfos.push_back(&infos[0]);
+            break;
+        case LayerType::Convolution2d:
+        {
+            inputInfos.push_back(&infos[0]); // input
+            outputInfos.push_back(&infos[1]); // output
+            inputInfos.push_back(&infos[2]); // weights
+
+            auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
+            if(conv2dDesc->m_BiasEnabled)
+            {
+                inputInfos.push_back(&infos[3]); // bias
+            }
+            break;
+        }
         case LayerType::Pooling2d:
             // Setup inputs and outputs
             inputInfos.push_back(&infos[0]);
@@ -266,7 +340,7 @@ bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type,
             break;
     }
 
-    auto mappings = GetTosaMapping(type, inputInfos, outputInfos, descriptor, false);
+    auto mappings = GetTosaMapping(nullptr, type, inputInfos, outputInfos, descriptor);
     if (mappings->GetName() == "")
     {
         // There currently isn't a TOSA mapping for this layer, as the default was returned.
diff --git a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
index fbe1265fe3..4245f0d4c4 100644
--- a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
@@ -6,6 +6,7 @@
 #include "backendsCommon/test/EndToEndTestImpl.hpp"
 
 #include "backendsCommon/test/AdditionEndToEndTestImpl.hpp"
+#include "backendsCommon/test/Convolution2dEndToEndTestImpl.hpp"
 #include "backendsCommon/test/Pooling2dEndToEndTestImpl.hpp"
 
 #include <doctest/doctest.h>
@@ -30,6 +31,17 @@ TEST_CASE("TosaRefAdditionEndtoEndTestFloat16")
     AdditionEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
 }
 
+// Conv2d
+TEST_CASE("TosaRefConv2dEndtoEndTestFloat32")
+{
+    Convolution2dEndToEnd<armnn::DataType::Float32>(tosaDefaultBackends, armnn::DataLayout::NHWC);
+}
+
+TEST_CASE("TosaRefConv2dWithoutBiasEndtoEndTestFloat32")
+{
+    Convolution2dEndToEnd<armnn::DataType::Float32>(tosaDefaultBackends, armnn::DataLayout::NHWC, false);
+}
+
 // Max Pool 2D
 TEST_CASE("TosaRefMaxPool2DEndtoEndTestFloat32")
 {
diff --git a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
index 48eca344bc..e6fbbf9688 100644
--- a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
@@ -58,11 +58,98 @@ TEST_CASE("IsLayerSupportedTosaReferenceAdditionUnsupported")
 
     CHECK(!supported);
     REQUIRE(reasonIfNotSupported.find(
-        "TOSA Reference Operator: Op_ADD for input: Op_ADD_input0_") != std::string::npos);
+        "TOSA Reference Operator: Op_ADD for input: input0_") != std::string::npos);
     REQUIRE(reasonIfNotSupported.find(
-        "TOSA Reference Operator: Op_ADD for input: Op_ADD_input1_") != std::string::npos);
+        "TOSA Reference Operator: Op_ADD for input: input1_") != std::string::npos);
     REQUIRE(reasonIfNotSupported.find(
-        "TOSA Reference Operator: Op_ADD for output: Op_ADD_output0_") != std::string::npos);
+        "TOSA Reference Operator: Op_ADD for output: output0_") != std::string::npos);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceConstant")
+{
+    armnn::TensorInfo outputInfo({1,1,3,4}, armnn::DataType::Float32);
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Constant,
+                                                     {outputInfo},
+                                                     armnn::BaseDescriptor(),
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceConstantUnsupported")
+{
+    armnn::TensorInfo outputInfo({1,1,3,4}, armnn::DataType::Signed64);
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Constant,
+                                                     {outputInfo},
+                                                     armnn::BaseDescriptor(),
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(!supported);
+    REQUIRE(reasonIfNotSupported.find(
+            "TOSA Reference Operator: Op_CONST for output: constant_") != std::string::npos);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceConv2d")
+{
+    armnn::TensorInfo inputInfo ({ 1, 5, 5, 1 }, armnn::DataType::Float32);
+    armnn::TensorInfo outputInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
+    armnn::TensorInfo weightsInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
+    armnn::TensorInfo biasesInfo ({ 1 }, armnn::DataType::Float32);
+
+    armnn::Convolution2dDescriptor desc;
+    desc.m_BiasEnabled = true;
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Convolution2d,
+                                                     {inputInfo, outputInfo, weightsInfo, biasesInfo},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceConv2dUnsupported")
+{
+    // If inputs and weights are Fp32, output must match.
+    armnn::TensorInfo inputInfo ({ 1, 5, 5, 1 }, armnn::DataType::Float32);
+    armnn::TensorInfo outputInfo({ 1, 3, 3, 1 }, armnn::DataType::Signed64);
+    armnn::TensorInfo weightsInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32, 0.0f, 0, true);
+    armnn::TensorInfo biasesInfo ({ 1 }, armnn::DataType::Float32, 0.0f, 0, true);
+
+    armnn::Convolution2dDescriptor desc;
+    desc.m_BiasEnabled = true;
+
+    armnn::TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Convolution2d,
+                                                     {inputInfo, outputInfo, weightsInfo, biasesInfo},
+                                                     desc,
+                                                     armnn::EmptyOptional(),
+                                                     armnn::EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(!supported);
+    REQUIRE(reasonIfNotSupported.find(
+            "TOSA Reference Operator: Op_CONV2D for input 0: input0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+            "input 1: input1_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+            "and output: output0_") != std::string::npos);
+    REQUIRE(reasonIfNotSupported.find(
+            "has an unsupported input data type combination.") != std::string::npos);
 }
 
 TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2d")
@@ -150,9 +237,9 @@ TEST_CASE("IsLayerSupportedTosaReferenceMaxPooling2dUnsupported")
 
     CHECK(!supported);
     REQUIRE(reasonIfNotSupported.find(
-        "TOSA Reference Operator: Op_MAX_POOL2D for input: Op_MAX_POOL2D_input0_") != std::string::npos);
+        "TOSA Reference Operator: Op_MAX_POOL2D for input: input0_") != std::string::npos);
     REQUIRE(reasonIfNotSupported.find(
-        "TOSA Reference Operator: Op_MAX_POOL2D for output: Op_MAX_POOL2D_output0_") != std::string::npos);
+        "TOSA Reference Operator: Op_MAX_POOL2D for output: output0_") != std::string::npos);
 }
 
 TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2dUnsupported_InputOutputDatatypeDifferent")
@@ -177,9 +264,9 @@ TEST_CASE("IsLayerSupportedTosaReferenceAvgPooling2dUnsupported_InputOutputDatat
 
     CHECK(!supported);
     REQUIRE(reasonIfNotSupported.find(
-        "TOSA Reference Operator: Op_AVG_POOL2D for input: Op_PAD_intermediate0_") != std::string::npos);
+        "TOSA Reference Operator: Op_AVG_POOL2D for input: intermediate0_") != std::string::npos);
     REQUIRE(reasonIfNotSupported.find(
-        " and output: Op_AVG_POOL2D_output0_") != std::string::npos);
+        " and output: output0_") != std::string::npos);
     REQUIRE(reasonIfNotSupported.find(
         " has an unsupported input data type: 8 to output data type: 10") != std::string::npos);
 }
diff --git a/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp b/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp
index ffdbf6f49b..ba353a32c7 100644
--- a/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp
+++ b/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp
@@ -23,13 +23,10 @@ TosaRefPreCompiledWorkload::TosaRefPreCompiledWorkload(const PreCompiledQueueDes
 
 void TosaRefPreCompiledWorkload::Execute() const
 {
-    uint32_t numInputBuffers  = static_cast<uint32_t>(m_Data.m_Inputs.size());
-    uint32_t numOutputBuffers = static_cast<uint32_t>(m_Data.m_Outputs.size());
-
     tosa::TosaSerializationHandler* handler = static_cast<tosa::TosaSerializationHandler*>(m_Data.m_PreCompiledObject);
 
-    std::vector<std::string> input_names = handler->GetInputs();
-    std::vector<std::string> output_names = handler->GetOutputs();
+    std::vector<std::string> inputNames = handler->GetInputs();
+    std::vector<std::string> outputNames = handler->GetOutputs();
 
     TosaReference::IModelRunner runner;
     GraphStatus status;
@@ -42,29 +39,29 @@ void TosaRefPreCompiledWorkload::Execute() const
     }
 
     // Set the inputs
-    for (uint32_t inputSlotIdx = 0; inputSlotIdx < numInputBuffers; ++inputSlotIdx)
+    for (uint32_t inputSlotIdx = 0; inputSlotIdx < inputNames.size(); ++inputSlotIdx)
     {
         DataType dataType = m_workloadInfo.m_InputTensorInfos[inputSlotIdx].GetDataType();
         switch (dataType)
         {
             case DataType::Float16:
-                SetInput<half_float::half>(runner, input_names[inputSlotIdx], inputSlotIdx);
+                SetInput<half_float::half>(runner, inputNames[inputSlotIdx], inputSlotIdx);
                 break;
             case DataType::Float32:
-                SetInput<float>(runner, input_names[inputSlotIdx], inputSlotIdx);
+                SetInput<float>(runner, inputNames[inputSlotIdx], inputSlotIdx);
                 break;
             case DataType::QAsymmU8:
             case DataType::QAsymmS8:
             case DataType::QSymmS8:
             case DataType::QSymmS16:
             case DataType::Signed32:
-                SetInput<int32_t>(runner, input_names[inputSlotIdx], inputSlotIdx);
+                SetInput<int32_t>(runner, inputNames[inputSlotIdx], inputSlotIdx);
                 break;
             case DataType::Signed64:
-                SetInput<int64_t>(runner, input_names[inputSlotIdx], inputSlotIdx);
+                SetInput<int64_t>(runner, inputNames[inputSlotIdx], inputSlotIdx);
                 break;
             case DataType::Boolean:
-                SetInput<unsigned char>(runner, input_names[inputSlotIdx], inputSlotIdx);
+                SetInput<unsigned char>(runner, inputNames[inputSlotIdx], inputSlotIdx);
                 break;
             default:
                 throw armnn::Exception("Input data type is unsupported in TOSA Reference Backend.");
@@ -79,29 +76,29 @@ void TosaRefPreCompiledWorkload::Execute() const
     }
 
     // Gets the outputs
-    for (uint32_t outputSlotIdx = 0; outputSlotIdx < numOutputBuffers; ++outputSlotIdx)
+    for (uint32_t outputSlotIdx = 0; outputSlotIdx < outputNames.size(); ++outputSlotIdx)
     {
         DataType dataType = m_workloadInfo.m_OutputTensorInfos[outputSlotIdx].GetDataType();
         switch (dataType)
         {
             case DataType::Float16:
-                GetOutput<half_float::half>(runner, output_names[outputSlotIdx], outputSlotIdx);
+                GetOutput<half_float::half>(runner, outputNames[outputSlotIdx], outputSlotIdx);
                 break;
             case DataType::Float32:
-                GetOutput<float>(runner, output_names[outputSlotIdx], outputSlotIdx);
+                GetOutput<float>(runner, outputNames[outputSlotIdx], outputSlotIdx);
                 break;
             case DataType::QAsymmU8:
             case DataType::QAsymmS8:
             case DataType::QSymmS8:
             case DataType::QSymmS16:
             case DataType::Signed32:
-                GetOutput<int32_t>(runner, output_names[outputSlotIdx], outputSlotIdx);
+                GetOutput<int32_t>(runner, outputNames[outputSlotIdx], outputSlotIdx);
                 break;
             case DataType::Signed64:
-                GetOutput<int64_t>(runner, output_names[outputSlotIdx], outputSlotIdx);
+                GetOutput<int64_t>(runner, outputNames[outputSlotIdx], outputSlotIdx);
                 break;
             case DataType::Boolean:
-                GetOutput<unsigned char>(runner, output_names[outputSlotIdx], outputSlotIdx);
+                GetOutput<unsigned char>(runner, outputNames[outputSlotIdx], outputSlotIdx);
                 break;
             default:
                 throw armnn::Exception("Output data type is unsupported in TOSA Reference Backend.");