Add support for list of tensors as input parameter

Some operators (e.g. Concat) expect list of tensor as an input
parameter. Currently operators API does not support passing
such parameters from the client code.

In order to enable it:
- Add new type tensor_list_t
- Update operators API generation script to support new type
- Add unit test for operator Concat

Signed-off-by: Dmitrii Agibov <dmitrii.agibov@arm.com>
Change-Id: Ib2f61bcea5e5ecabf56ce031d905cb46a4cc68ea

6 files changed, 1042 insertions, 651 deletions

diff --git a/reference_model/include/operators.h b/reference_model/include/operators.h
index d037631..62e6db1 100644
--- a/reference_model/include/operators.h
+++ b/reference_model/include/operators.h
@@ -320,7 +320,7 @@ extern "C"
                                       tosa_tensor_t client_output,
                                       const func_ctx_t& func_ctx);
 
-    tosa_status_t tosa_run_concat(tosa_tensor_t client_input1,
+    tosa_status_t tosa_run_concat(const tosa_tensor_list_t client_input1,
                                   const int32_t client_axis,
                                   tosa_tensor_t client_output,
                                   const func_ctx_t& func_ctx);
diff --git a/reference_model/include/types.h b/reference_model/include/types.h
index a371d04..2be884d 100644
--- a/reference_model/include/types.h
+++ b/reference_model/include/types.h
@@ -75,6 +75,12 @@ extern "C"
         size_t size;
     };
 
+    struct tosa_tensor_list_t
+    {
+        tosa_tensor_t* tensors;
+        size_t size;
+    };
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/reference_model/src/operators.cc b/reference_model/src/operators.cc
index 015b28f..1c97455 100644
--- a/reference_model/src/operators.cc
+++ b/reference_model/src/operators.cc
@@ -20,6 +20,15 @@
 #include "model_runner_impl.h"
 #include "ops/op_factory.h"
 
+#define TOSA_PROPAGATE_ERROR(status)                                                                                   \
+    do                                                                                                                 \
+    {                                                                                                                  \
+        if (status != 0)                                                                                               \
+        {                                                                                                              \
+            return status;                                                                                             \
+        }                                                                                                              \
+    } while (false)
+
 #define TOSA_RETURN_ON_ERROR(status)                                                                                   \
     do                                                                                                                 \
     {                                                                                                                  \
@@ -75,12 +84,63 @@ tosa::DType translate_client_datatype(tosa_datatype_t type)
     }
 };
 
+using TosaTensorInfo = std::pair<tosa::TosaSerializationTensor*, tosa_tensor_t*>;
+
 tosa::TosaSerializationTensor* translate_client_tensor(tosa_tensor_t& tensor, const std::string& name)
 {
     std::vector<int32_t> shape(tensor.shape, tensor.shape + tensor.num_dims);
     return new tosa::TosaSerializationTensor(name, shape, translate_client_datatype(tensor.data_type), {});
 }
 
+void addTensor(std::vector<TosaTensorInfo>& tensors, tosa_tensor_t& tensor, std::string tensorName)
+{
+    auto tensorDescr = translate_client_tensor(tensor, tensorName);
+    tensors.push_back(std::make_pair(tensorDescr, &tensor));
+}
+
+int setInputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& inputTensors)
+{
+    for (const auto& [tensorDescr, tensorData] : inputTensors)
+    {
+        auto status = runner.setInput(tensorDescr->GetName(), tensorData->data, tensorData->size);
+        TOSA_PROPAGATE_ERROR(status);
+    }
+
+    return 0;
+}
+
+int getOutputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& outputTensors)
+{
+    for (const auto& [tensorDescr, tensorData] : outputTensors)
+    {
+        auto status = runner.getOutput(tensorDescr->GetName(), tensorData->data, tensorData->size);
+        TOSA_PROPAGATE_ERROR(status);
+    }
+
+    return 0;
+}
+
+std::vector<std::string> getTensorNames(std::vector<TosaTensorInfo>& tensors)
+{
+    std::vector<std::string> tensorNames;
+    const auto mapping = [](const TosaTensorInfo& info) { return info.first->GetName(); };
+
+    std::transform(tensors.cbegin(), tensors.cend(), std::back_inserter(tensorNames), mapping);
+    return tensorNames;
+}
+
+std::vector<TosaSerializationTensor*> allTensors(std::vector<TosaTensorInfo>& inputTensors,
+                                                 std::vector<TosaTensorInfo>& outputTensors)
+{
+    std::vector<TosaSerializationTensor*> result;
+    const auto mapping = [](const TosaTensorInfo& info) { return info.first; };
+
+    std::transform(inputTensors.cbegin(), inputTensors.cend(), std::back_inserter(result), mapping);
+    std::transform(outputTensors.cbegin(), outputTensors.cend(), std::back_inserter(result), mapping);
+
+    return result;
+}
+
 tosa::ResizeMode translate_client_tosa_mode(tosa_mode_t mode)
 {
     switch (mode)
@@ -124,27 +184,32 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARGMAX, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_ARGMAX, tosa::Attribute::Attribute_AxisAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("argmax", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("argmax", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -167,27 +232,32 @@ extern "C"
         TosaPoolAttribute attr(pad, kernel, stride, client_input_zp, client_output_zp, accum_dtype);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_AVG_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_AVG_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("avg_pool2d", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("avg_pool2d", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -211,33 +281,34 @@ extern "C"
         TosaConvAttribute attr(pad, stride, dilation, client_input_zp, client_weight_zp, client_local_bound);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
-        tosa::TosaSerializationTensor* bias   = translate_client_tensor(client_bias, "bias");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+        addTensor(inputTensors, client_weight, "weight");
+        addTensor(inputTensors, client_bias, "bias");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONV2D, tosa::Attribute::Attribute_ConvAttribute,
-                                                      &attr, { input->GetName(), weight->GetName(), bias->GetName() },
-                                                      { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("conv2d", "main", { op }, { input, weight, bias, output },
-                                                { input->GetName(), weight->GetName(), bias->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("conv2d", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -261,33 +332,34 @@ extern "C"
         TosaConvAttribute attr(pad, stride, dilation, client_input_zp, client_weight_zp, client_local_bound);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
-        tosa::TosaSerializationTensor* bias   = translate_client_tensor(client_bias, "bias");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+        addTensor(inputTensors, client_weight, "weight");
+        addTensor(inputTensors, client_bias, "bias");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONV3D, tosa::Attribute::Attribute_ConvAttribute,
-                                                      &attr, { input->GetName(), weight->GetName(), bias->GetName() },
-                                                      { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_CONV3D, tosa::Attribute::Attribute_ConvAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("conv3d", "main", { op }, { input, weight, bias, output },
-                                                { input->GetName(), weight->GetName(), bias->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("conv3d", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -311,33 +383,35 @@ extern "C"
         TosaConvAttribute attr(pad, stride, dilation, client_input_zp, client_weight_zp, client_local_bound);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
-        tosa::TosaSerializationTensor* bias   = translate_client_tensor(client_bias, "bias");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+        addTensor(inputTensors, client_weight, "weight");
+        addTensor(inputTensors, client_bias, "bias");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(
-            tosa::Op::Op_DEPTHWISE_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,
-            { input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_DEPTHWISE_CONV2D, tosa::Attribute::Attribute_ConvAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("depthwise_conv2d", "main", { op }, { input, weight, bias, output },
-                                                { input->GetName(), weight->GetName(), bias->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("depthwise_conv2d", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -354,35 +428,34 @@ extern "C"
         TosaFFTAttribute attr(client_inverse, client_local_bound);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input_real  = translate_client_tensor(client_input_real, "input_real");
-        tosa::TosaSerializationTensor* input_imag  = translate_client_tensor(client_input_imag, "input_imag");
-        tosa::TosaSerializationTensor* output_real = translate_client_tensor(client_output_real, "output_real");
-        tosa::TosaSerializationTensor* output_imag = translate_client_tensor(client_output_imag, "output_imag");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input_real, "input_real");
+        addTensor(inputTensors, client_input_imag, "input_imag");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output_real, "output_real");
+        addTensor(outputTensors, client_output_imag, "output_imag");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FFT2D, tosa::Attribute::Attribute_FFTAttribute,
-                                                      &attr, { input_real->GetName(), input_imag->GetName() },
-                                                      { output_real->GetName(), output_imag->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_FFT2D, tosa::Attribute::Attribute_FFTAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block(
-            "fft2d", "main", { op }, { input_real, input_imag, output_real, output_imag },
-            { input_real->GetName(), input_imag->GetName() }, { output_real->GetName(), output_imag->GetName() });
+        tosa::TosaSerializationBasicBlock block("fft2d", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input_real->GetName(), client_input_real.data, client_input_real.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input_imag->GetName(), client_input_imag.data, client_input_imag.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(
-            runner.getOutput(output_real->GetName(), client_output_real.data, client_output_real.size));
-        TOSA_RETURN_ON_ERROR(
-            runner.getOutput(output_imag->GetName(), client_output_imag.data, client_output_imag.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -399,33 +472,35 @@ extern "C"
         TosaFullyConnectedAttribute attr(client_input_zp, client_weight_zp);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
-        tosa::TosaSerializationTensor* bias   = translate_client_tensor(client_bias, "bias");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+        addTensor(inputTensors, client_weight, "weight");
+        addTensor(inputTensors, client_bias, "bias");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(
-            tosa::Op::Op_FULLY_CONNECTED, tosa::Attribute::Attribute_FullyConnectedAttribute, &attr,
-            { input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });
+        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FULLY_CONNECTED,
+                                                      tosa::Attribute::Attribute_FullyConnectedAttribute, &attr,
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("fully_connected", "main", { op }, { input, weight, bias, output },
-                                                { input->GetName(), weight->GetName(), bias->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("fully_connected", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -441,29 +516,33 @@ extern "C"
         TosaMatMulAttribute attr(client_a_zp, client_b_zp);
 
         // Create tensors
-        tosa::TosaSerializationTensor* a      = translate_client_tensor(client_a, "a");
-        tosa::TosaSerializationTensor* b      = translate_client_tensor(client_b, "b");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_a, "a");
+        addTensor(inputTensors, client_b, "b");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MATMUL, tosa::Attribute::Attribute_MatMulAttribute,
-                                                      &attr, { a->GetName(), b->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_MATMUL, tosa::Attribute::Attribute_MatMulAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("matmul", "main", { op }, { a, b, output },
-                                                { a->GetName(), b->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("matmul", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(a->GetName(), client_a.data, client_a.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(b->GetName(), client_b.data, client_b.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -485,27 +564,32 @@ extern "C"
         TosaPoolAttribute attr(pad, kernel, stride, client_input_zp, client_output_zp, accum_dtype);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAX_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_MAX_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("max_pool2d", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("max_pool2d", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -520,33 +604,33 @@ extern "C"
         TosaRFFTAttribute attr(client_local_bound);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input       = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output_real = translate_client_tensor(client_output_real, "output_real");
-        tosa::TosaSerializationTensor* output_imag = translate_client_tensor(client_output_imag, "output_imag");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output_real, "output_real");
+        addTensor(outputTensors, client_output_imag, "output_imag");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RFFT2D, tosa::Attribute::Attribute_RFFTAttribute,
-                                                      &attr, { input->GetName() },
-                                                      { output_real->GetName(), output_imag->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_RFFT2D, tosa::Attribute::Attribute_RFFTAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("rfft2d", "main", { op }, { input, output_real, output_imag },
-                                                { input->GetName() },
-                                                { output_real->GetName(), output_imag->GetName() });
+        tosa::TosaSerializationBasicBlock block("rfft2d", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(
-            runner.getOutput(output_real->GetName(), client_output_real.data, client_output_real.size));
-        TOSA_RETURN_ON_ERROR(
-            runner.getOutput(output_imag->GetName(), client_output_imag.data, client_output_imag.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -571,33 +655,35 @@ extern "C"
                                         client_local_bound);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
-        tosa::TosaSerializationTensor* bias   = translate_client_tensor(client_bias, "bias");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+        addTensor(inputTensors, client_weight, "weight");
+        addTensor(inputTensors, client_bias, "bias");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(
-            tosa::Op::Op_TRANSPOSE_CONV2D, tosa::Attribute::Attribute_TransposeConvAttribute, &attr,
-            { input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });
+        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TRANSPOSE_CONV2D,
+                                                      tosa::Attribute::Attribute_TransposeConvAttribute, &attr,
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("transpose_conv2d", "main", { op }, { input, weight, bias, output },
-                                                { input->GetName(), weight->GetName(), bias->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("transpose_conv2d", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -614,27 +700,32 @@ extern "C"
         TosaClampAttribute attr(client_min_int, client_max_int, client_min_fp, client_max_fp);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLAMP, tosa::Attribute::Attribute_ClampAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_CLAMP, tosa::Attribute::Attribute_ClampAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("clamp", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("clamp", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -645,27 +736,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ERF, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("erf", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("erf", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -676,27 +771,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SIGMOID, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("sigmoid", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("sigmoid", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -707,27 +806,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TANH, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("tanh", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("tanh", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -741,29 +844,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ADD, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("add", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("add", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -778,30 +884,34 @@ extern "C"
         TosaArithmeticRightShiftAttribute attr(client_round);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARITHMETIC_RIGHT_SHIFT,
                                                       tosa::Attribute::Attribute_ArithmeticRightShiftAttribute, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("arithmetic_right_shift", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("arithmetic_right_shift", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -815,29 +925,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_AND, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_and", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("bitwise_and", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -851,29 +964,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_OR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_or", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("bitwise_or", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -887,29 +1003,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_XOR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_xor", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("bitwise_xor", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -923,29 +1042,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_INTDIV, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("intdiv", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("intdiv", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -959,29 +1081,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_AND, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_and", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("logical_and", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -995,30 +1120,34 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op =
             new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_LEFT_SHIFT, tosa::Attribute::Attribute_NONE, &attr,
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_left_shift", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("logical_left_shift", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1032,30 +1161,34 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op =
             new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_RIGHT_SHIFT, tosa::Attribute::Attribute_NONE,
-                                                &attr, { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_right_shift", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("logical_right_shift", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1069,29 +1202,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_OR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_or", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("logical_or", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1105,29 +1241,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_XOR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_xor", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("logical_xor", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1141,29 +1280,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAXIMUM, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("maximum", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("maximum", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1177,29 +1319,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MINIMUM, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("minimum", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("minimum", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1214,29 +1359,32 @@ extern "C"
         TosaMulAttribute attr(client_shift);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MUL, tosa::Attribute::Attribute_MulAttribute, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("mul", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("mul", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1250,29 +1398,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_POW, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("pow", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("pow", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1286,29 +1437,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SUB, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("sub", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("sub", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1324,27 +1478,32 @@ extern "C"
         TosaTableAttribute attr(table);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TABLE, tosa::Attribute::Attribute_TableAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_TABLE, tosa::Attribute::Attribute_TableAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("table", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("table", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1355,27 +1514,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ABS, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("abs", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("abs", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1387,27 +1550,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_NOT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_not", "main", { op }, { input1, output },
-                                                { input1->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("bitwise_not", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1418,27 +1585,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CEIL, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("ceil", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("ceil", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1449,27 +1620,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLZ, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("clz", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("clz", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1480,27 +1655,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EXP, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("exp", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("exp", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1511,27 +1690,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FLOOR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("floor", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("floor", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1542,27 +1725,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOG, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("log", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("log", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1574,27 +1761,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_NOT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_not", "main", { op }, { input1, output },
-                                                { input1->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("logical_not", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1609,27 +1800,32 @@ extern "C"
         TosaNegateAttribute attr(client_input1_zp, client_output_zp);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_NEGATE, tosa::Attribute::Attribute_NegateAttribute,
-                                                      &attr, { input1->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_NEGATE, tosa::Attribute::Attribute_NegateAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("negate", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("negate", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1641,27 +1837,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RECIPROCAL, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reciprocal", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reciprocal", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1672,27 +1872,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RSQRT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("rsqrt", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("rsqrt", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1707,33 +1911,33 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* input3 = translate_client_tensor(client_input3, "input3");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+        addTensor(inputTensors, client_input3, "input3");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SELECT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName(), input3->GetName() },
-                                                      { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("select", "main", { op }, { input1, input2, input3, output },
-                                                { input1->GetName(), input2->GetName(), input3->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("select", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input3->GetName(), client_input3.data, client_input3.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1747,29 +1951,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EQUAL, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("equal", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("equal", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1783,29 +1990,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("greater", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("greater", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1819,30 +2029,34 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+        addTensor(inputTensors, client_input2, "input2");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op =
             new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER_EQUAL, tosa::Attribute::Attribute_NONE, &attr,
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("greater_equal", "main", { op }, { input1, input2, output },
-                                                { input1->GetName(), input2->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("greater_equal", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1856,27 +2070,32 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ALL, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ALL, tosa::Attribute::Attribute_AxisAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_all", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reduce_all", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1890,27 +2109,32 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ANY, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ANY, tosa::Attribute::Attribute_AxisAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_any", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reduce_any", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1924,27 +2148,32 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MAX, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MAX, tosa::Attribute::Attribute_AxisAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_max", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reduce_max", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1958,27 +2187,32 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MIN, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MIN, tosa::Attribute::Attribute_AxisAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_min", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reduce_min", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -1992,28 +2226,33 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op =
             new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_PRODUCT, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, { input->GetName() }, { output->GetName() });
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_product", "main", { op }, { input, output },
-                                                { input->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reduce_product", "main", { op },
+                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
+                                                op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2027,32 +2266,37 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_SUM, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_SUM, tosa::Attribute::Attribute_AxisAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_sum", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reduce_sum", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_concat(tosa_tensor_t client_input1,
+    tosa_status_t tosa_run_concat(const tosa_tensor_list_t client_input1,
                                   const int32_t client_axis,
                                   tosa_tensor_t client_output,
                                   const func_ctx_t& func_ctx)
@@ -2061,27 +2305,35 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        for (int i = 0; i < client_input1.size; i++)
+        {
+            addTensor(inputTensors, client_input1.tensors[i], "input1-" + std::to_string(i));
+        }
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONCAT, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input1->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_CONCAT, tosa::Attribute::Attribute_AxisAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("concat", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("concat", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2101,27 +2353,31 @@ extern "C"
         TosaPadAttribute attr(padding, client_pad_const_int, client_pad_const_fp);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_PAD, tosa::Attribute::Attribute_PadAttribute, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("pad", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("pad", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2135,27 +2391,31 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_DIM, tosa::Attribute::Attribute_AxisAttribute, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("dim", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("dim", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2173,27 +2433,32 @@ extern "C"
         TosaReshapeAttribute attr(shape);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESHAPE, tosa::Attribute::Attribute_ReshapeAttribute,
-                                                      &attr, { input1->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_RESHAPE, tosa::Attribute::Attribute_ReshapeAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reshape", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reshape", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2207,27 +2472,32 @@ extern "C"
         TosaAxisAttribute attr(client_axis);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REVERSE, tosa::Attribute::Attribute_AxisAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_REVERSE, tosa::Attribute::Attribute_AxisAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reverse", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("reverse", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2246,27 +2516,32 @@ extern "C"
         TosaSliceAttribute attr(start, size);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SLICE, tosa::Attribute::Attribute_SliceAttribute,
-                                                      &attr, { input1->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_SLICE, tosa::Attribute::Attribute_SliceAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("slice", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("slice", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2284,27 +2559,32 @@ extern "C"
         TosaTileAttribute attr(multiples);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TILE, tosa::Attribute::Attribute_TileAttribute,
-                                                      &attr, { input1->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_TILE, tosa::Attribute::Attribute_TileAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("tile", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("tile", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2320,28 +2600,32 @@ extern "C"
         TosaTransposeAttribute attr(perms);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op =
             new tosa::TosaSerializationOperator(tosa::Op::Op_TRANSPOSE, tosa::Attribute::Attribute_TransposeAttribute,
-                                                &attr, { input1->GetName() }, { output->GetName() });
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("transpose", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("transpose", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2355,29 +2639,32 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* values  = translate_client_tensor(client_values, "values");
-        tosa::TosaSerializationTensor* indices = translate_client_tensor(client_indices, "indices");
-        tosa::TosaSerializationTensor* output  = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_values, "values");
+        addTensor(inputTensors, client_indices, "indices");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GATHER, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { values->GetName(), indices->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("gather", "main", { op }, { values, indices, output },
-                                                { values->GetName(), indices->GetName() }, { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("gather", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(values->GetName(), client_values.data, client_values.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2392,33 +2679,33 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* values_in  = translate_client_tensor(client_values_in, "values_in");
-        tosa::TosaSerializationTensor* indices    = translate_client_tensor(client_indices, "indices");
-        tosa::TosaSerializationTensor* input      = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* values_out = translate_client_tensor(client_values_out, "values_out");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_values_in, "values_in");
+        addTensor(inputTensors, client_indices, "indices");
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_values_out, "values_out");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SCATTER, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { values_in->GetName(), indices->GetName(), input->GetName() },
-                                                      { values_out->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("scatter", "main", { op }, { values_in, indices, input, values_out },
-                                                { values_in->GetName(), indices->GetName(), input->GetName() },
-                                                { values_out->GetName() });
+        tosa::TosaSerializationBasicBlock block("scatter", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(values_in->GetName(), client_values_in.data, client_values_in.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(values_out->GetName(), client_values_out.data, client_values_out.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2448,27 +2735,32 @@ extern "C"
         TosaResizeAttribute attr(scale, offset, border, mode);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESIZE, tosa::Attribute::Attribute_ResizeAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_RESIZE, tosa::Attribute::Attribute_ResizeAttribute, &attr,
+                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("resize", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("resize", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2479,27 +2771,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CAST, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("cast", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("cast", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2527,27 +2823,32 @@ extern "C"
                                   client_output_unsigned);
 
         // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input, "input");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESCALE, tosa::Attribute::Attribute_RescaleAttribute,
-                                                      &attr, { input->GetName() }, { output->GetName() });
+        auto op =
+            new tosa::TosaSerializationOperator(tosa::Op::Op_RESCALE, tosa::Attribute::Attribute_RescaleAttribute,
+                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("rescale", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("rescale", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
@@ -2559,27 +2860,31 @@ extern "C"
         TosaNoneAttribute attr;
 
         // Create tensors
-        tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+        std::vector<TosaTensorInfo> inputTensors;
+        addTensor(inputTensors, client_input1, "input1");
+
+        std::vector<TosaTensorInfo> outputTensors;
+        addTensor(outputTensors, client_output, "output");
 
         // Create operator
         auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_IDENTITY, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input1->GetName() }, { output->GetName() });
+                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("identity", "main", { op }, { input1, output }, { input1->GetName() },
-                                                { output->GetName() });
+        tosa::TosaSerializationBasicBlock block("identity", "main", { op }, allTensors(inputTensors, outputTensors),
+                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }
diff --git a/reference_model/test/model_runner_tests.cpp b/reference_model/test/model_runner_tests.cpp
index 35e3aa2..5292dd8 100644
--- a/reference_model/test/model_runner_tests.cpp
+++ b/reference_model/test/model_runner_tests.cpp
@@ -152,6 +152,53 @@ TEST_SUITE("model_runner")
         compareOutput(dstData, expectedData, expectedData.size());
     }
 
+    TEST_CASE("op_entry_concat")
+    {
+        // Concat parameters
+        const int32_t axis = 2;
+
+        // Inputs/Outputs
+        tosa_datatype_t dt                = tosa_datatype_fp32_t;
+        std::vector<int32_t> input1_shape = { 1, 2, 3, 4 };
+        std::vector<int32_t> input2_shape = { 1, 2, 5, 4 };
+        std::vector<int32_t> output_shape = { 1, 2, 8, 4 };
+        std::vector<float> src1Data(24, 1.0f);
+        std::vector<float> src2Data(40, 1.0f);
+        std::vector<float> dstData(64, 0.f);
+
+        tosa_tensor_t input1;
+        input1.shape     = input1_shape.data();
+        input1.num_dims  = input1_shape.size();
+        input1.data_type = dt;
+        input1.data      = reinterpret_cast<uint8_t*>(src1Data.data());
+        input1.size      = src1Data.size() * sizeof(float);
+
+        tosa_tensor_t input2;
+        input2.shape     = input2_shape.data();
+        input2.num_dims  = input2_shape.size();
+        input2.data_type = dt;
+        input2.data      = reinterpret_cast<uint8_t*>(src2Data.data());
+        input2.size      = src2Data.size() * sizeof(float);
+
+        tosa_tensor_list_t input_list;
+        tosa_tensor_t inputs[]{ input1, input2 };
+        input_list.size    = 2;
+        input_list.tensors = inputs;
+
+        tosa_tensor_t output;
+        output.shape     = output_shape.data();
+        output.num_dims  = output_shape.size();
+        output.data_type = dt;
+        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
+        output.size      = dstData.size() * sizeof(float);
+
+        auto status = tosa_run_concat(input_list, axis, output, {});
+        CHECK((status == tosa_status_valid));
+
+        std::vector<float> expectedData(64, 1.0f);
+        compareOutput(dstData, expectedData, expectedData.size());
+    }
+
     TEST_CASE("op_entry_conv2d")
     {
         // Conv parameters
diff --git a/scripts/operator_api/generate_api.py b/scripts/operator_api/generate_api.py
index 7f10568..e511f19 100644
--- a/scripts/operator_api/generate_api.py
+++ b/scripts/operator_api/generate_api.py
@@ -10,8 +10,6 @@ from xml.dom import minidom
 from jinja2 import Environment
 from jinja2 import FileSystemLoader
 
-# Note: main script designed to be run from the scripts/operator_api/ directory
-
 
 def getBasePath():
     return Path(__file__).resolve().parent.parent.parent
@@ -82,10 +80,7 @@ def getSerializeOpType(tosaOpName):
         "cond_if": "CondIf",
         "while_loop": "WhileLoop",
     }
-    if tosaOpName not in map.keys():
-        return "None"
-    else:
-        return map[tosaOpName]
+    return map.get(tosaOpName, "None")
 
 
 def getSerialLibAttsForOp(tosaOpName, allSerialLibAtts, tosaArgs):
@@ -268,7 +263,7 @@ def getOperators(tosaXml):
             operator["serialLibAtts"] = serialLibAtts
             serializationAttNames = [att["name"] for att in serialLibAtts]
             operator["inputs"] = [
-                arg["name"]
+                {"name": arg["name"], "type": arg["type"]}
                 for arg in tosaArgs
                 if arg["category"] == "input"
                 and arg["name"] not in serializationAttNames
@@ -308,7 +303,7 @@ def getTosaArgs(opXml):
         if argType[-1:] == "*":
             argType = argType[:-1]
         if argCategory in ["input", "output"] and argType in tosaTensorTypes:
-            argType = "tosa_tensor_t"
+            argType = f"tosa_{argType}"
             argShape = ""
         if argType in tosaTypeMap:
             argType = tosaTypeMap[argType]
@@ -386,7 +381,7 @@ def getSerialLibAtts():
     return serialLibAtts
 
 
-def renderTemplate(environment, dataTypes, operators, template, outfile):
+def renderTemplate(dataTypes, operators, template, outfile):
     content = template.render(dataTypes=dataTypes, operators=operators)
     with open(outfile, mode="w", encoding="utf-8") as output:
         output.write(content)
@@ -399,12 +394,12 @@ def generate(environment, dataTypes, operators, base_path):
     # Generate include/operators.h
     template = environment.get_template("operators_h.j2")
     outfile = base_path / "reference_model/include/operators.h"
-    renderTemplate(environment, dataTypes, operators, template, outfile)
+    renderTemplate(dataTypes, operators, template, outfile)
 
     # Generate src/operators.cc
     template = environment.get_template("operators_cc.j2")
     outfile = base_path / "reference_model/src/operators.cc"
-    renderTemplate(environment, dataTypes, operators, template, outfile)
+    renderTemplate(dataTypes, operators, template, outfile)
 
 
 if __name__ == "__main__":
diff --git a/scripts/operator_api/templates/operators_cc.j2 b/scripts/operator_api/templates/operators_cc.j2
index 1de103a..0fc52ab 100644
--- a/scripts/operator_api/templates/operators_cc.j2
+++ b/scripts/operator_api/templates/operators_cc.j2
@@ -20,6 +20,17 @@
 #include "model_runner_impl.h"
 #include "ops/op_factory.h"
 
+
+#define TOSA_PROPAGATE_ERROR(status)                                                                                   \
+    do                                                                                                                 \
+    {                                                                                                                  \
+        if (status != 0)                                                                                               \
+        {                                                                                                              \
+            return status;                                                                                             \
+        }                                                                                                              \
+    } while (false)
+
+
 #define TOSA_RETURN_ON_ERROR(status)                                                                                   \
     do                                                                                                                 \
     {                                                                                                                  \
@@ -74,12 +85,60 @@ tosa::DType translate_client_datatype(tosa_datatype_t type)
     }
 };
 
+using TosaTensorInfo = std::pair<tosa::TosaSerializationTensor*, tosa_tensor_t*>;
+
 tosa::TosaSerializationTensor* translate_client_tensor(tosa_tensor_t& tensor, const std::string& name)
 {
     std::vector<int32_t> shape(tensor.shape, tensor.shape + tensor.num_dims);
     return new tosa::TosaSerializationTensor(name, shape, translate_client_datatype(tensor.data_type), {});
 }
 
+void addTensor(std::vector<TosaTensorInfo> &tensors, tosa_tensor_t& tensor, std::string tensorName) {
+    auto tensorDescr = translate_client_tensor(tensor, tensorName);
+    tensors.push_back(std::make_pair(tensorDescr, &tensor));
+}
+
+int setInputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& inputTensors)
+{
+    for (const auto& [tensorDescr, tensorData] : inputTensors)
+    {
+        auto status = runner.setInput(tensorDescr->GetName(), tensorData->data, tensorData->size);
+        TOSA_PROPAGATE_ERROR(status);
+    }
+
+    return 0;
+}
+
+int getOutputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& outputTensors)
+{
+    for (const auto& [tensorDescr, tensorData] : outputTensors)
+    {
+        auto status = runner.getOutput(tensorDescr->GetName(), tensorData->data, tensorData->size);
+        TOSA_PROPAGATE_ERROR(status);
+    }
+
+    return 0;
+}
+
+std::vector<std::string> getTensorNames(std::vector<TosaTensorInfo>& tensors)
+{
+    std::vector<std::string> tensorNames;
+    const auto mapping = [](const TosaTensorInfo &info){ return info.first->GetName(); };
+
+    std::transform(tensors.cbegin(), tensors.cend(), std::back_inserter(tensorNames), mapping);
+    return tensorNames;
+}
+
+std::vector<TosaSerializationTensor*> allTensors(std::vector<TosaTensorInfo> &inputTensors, std::vector<TosaTensorInfo> &outputTensors) {
+    std::vector<TosaSerializationTensor*> result;
+    const auto mapping = [](const TosaTensorInfo &info){ return info.first; };
+
+    std::transform(inputTensors.cbegin(), inputTensors.cend(), std::back_inserter(result), mapping);
+    std::transform(outputTensors.cbegin(), outputTensors.cend(), std::back_inserter(result), mapping);
+
+    return result;
+}
+
 tosa::ResizeMode translate_client_tosa_mode(tosa_mode_t mode) {
     switch(mode) {
         case tosa_mode_nearest:
@@ -113,7 +172,7 @@ extern "C"
     tosa_status_t tosa_run_{{ operator.name }} (
         {%- for arg in operator.arguments: -%}
             {% if arg.type != "tosa_tensor_t" -%}const {% endif -%}{{arg.type}} client_{{arg.name}}{{arg.shape}}
-            {% if loop.index < operator.arguments|length %},{% endif %}
+            {% if not loop.last %},{% endif %}
         {%- endfor -%},const func_ctx_t& func_ctx
     )
     {
@@ -131,17 +190,26 @@ extern "C"
                 {%- else -%}
                     {{att.name}}
                 {%- endif -%}
-                {% if loop.index < operator.serialLibAtts|length %}, {% endif %}
+                {% if not loop.last %}, {% endif %}
             {%- endfor -%}
         )
         {%- endif -%};
 
         // Create tensors
+        std::vector<TosaTensorInfo> inputTensors;
         {% for input in operator.inputs: -%}
-            tosa::TosaSerializationTensor* {{input}}  = translate_client_tensor(client_{{input}}, "{{input}}");
-        {%- endfor -%}
-        {% for output in operator.outputs: %}
-            tosa::TosaSerializationTensor* {{output}}  = translate_client_tensor(client_{{output}}, "{{output}}");
+            {%- if input.type == "tosa_tensor_list_t" -%}
+                for (int i = 0; i < client_{{input.name}}.size; i++) {
+                    addTensor(inputTensors, client_{{input.name}}.tensors[i], "{{input.name}}-" + std::to_string(i));
+                }
+            {%- else -%}
+                addTensor(inputTensors, client_{{input.name}}, "{{input.name}}");
+            {%- endif -%}
+        {%- endfor %}
+
+        std::vector<TosaTensorInfo> outputTensors;
+        {% for output in operator.outputs: -%}
+            addTensor(outputTensors, client_{{output}}, "{{output}}");
         {%- endfor %}
 
         // Create operator
@@ -151,57 +219,27 @@ extern "C"
                                                       {%- else -%}
                                                         tosa::Attribute::Attribute_NONE
                                                       {%- endif -%},
-                                                      &attr, {
-                                                                {%- for input in operator.inputs: -%}
-                                                                    {{input}}->GetName()
-                                                                    {%- if loop.index < operator.inputs|length -%},{%- endif -%}
-                                                                {%- endfor -%}
-                                                             },
-                                                             {
-                                                                {%- for output in operator.outputs: -%}
-                                                                    {{output}}->GetName()
-                                                                    {%- if loop.index < operator.outputs|length -%},{%- endif -%}
-                                                                {%- endfor -%}
-                                                             });
+                                                      &attr,
+                                                      getTensorNames(inputTensors),
+                                                      getTensorNames(outputTensors));
 
         // Create a tosa single-op basic block
         tosa::TosaSerializationBasicBlock block("{{operator.name}}", "main", { op },
-                                                 {
-                                                    {%- for input in operator.inputs: -%}
-                                                        {{input}},
-                                                    {%- endfor -%}
-                                                    {%- for output in operator.outputs: -%}
-                                                        {{output}}
-                                                        {%- if loop.index < operator.outputs|length -%},{%- endif -%}
-                                                    {%- endfor -%}
-                                                 },
-                                                 {
-                                                    {%- for input in operator.inputs: -%}
-                                                        {{input}}->GetName()
-                                                        {%- if loop.index < operator.inputs|length -%},{%- endif -%}
-                                                    {%- endfor -%}
-                                                 },
-                                                 {
-                                                    {%- for output in operator.outputs: -%}
-                                                        {{output}}->GetName()
-                                                        {%- if loop.index < operator.outputs|length -%},{%- endif -%}
-                                                    {%- endfor -%}
-                                                 });
+                                                 allTensors(inputTensors, outputTensors),
+                                                 op->GetInputTensorNames(),
+                                                 op->GetOutputTensorNames());
 
         // Setup model
         TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        {% for input in operator.inputs: -%}
-            TOSA_RETURN_ON_ERROR(runner.setInput({{input}}->GetName(), client_{{input}}.data, client_{{input}}.size));
-        {%- endfor %}
+
+        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
 
         // Execute
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
 
         // Extract outputs
-        {% for output in operator.outputs: -%}
-            TOSA_RETURN_ON_ERROR(runner.getOutput({{output}}->GetName(), client_{{output}}.data, client_{{output}}.size));
-        {%- endfor %}
+        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
 
         return tosa_status_valid;
     }