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

5 files changed, 278 insertions, 75 deletions

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.");