IVGCVSW-7133 Add TosaMappings backbone structure with support for Addition TosaMappings operator.

Signed-off-by: Cathal Corbett <cathal.corbett@arm.com>
Change-Id: Ibea0cf625b3af4ab38e8b985f7a129c983ca9659

10 files changed, 432 insertions, 3 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 30e526ccfb..c63d8fc0df 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -512,6 +512,37 @@ if(ARMCOMPUTENEON OR ARMCOMPUTECL)
     target_link_libraries(armnn PUBLIC ${ARMCOMPUTE_LIBRARIES})
 endif()
 
+# Flatbuffers is not included in armnn if the armnnSerializer is not present
+# Required to target link both flatbuffers and tosa_serialization_lib to armnn
+if (ARMNNTOSAREF)
+    if (FLATBUFFERS_LIBRARY)
+        target_link_libraries(armnn PUBLIC ${FLATBUFFERS_LIBRARY})
+    else()
+        # Use PATH_SUFFIXES to help find separate libs for debug/release on Windows builds
+        find_library(FLATBUFFERS_LIBRARY_DEBUG NAMES flatbuffers
+                HINTS ${FLATBUFFERS_BUILD_DIR}
+                PATH_SUFFIXES "Debug")
+        find_library(FLATBUFFERS_LIBRARY_RELEASE NAMES flatbuffers
+                HINTS ${FLATBUFFERS_BUILD_DIR}
+                PATH_SUFFIXES "Release")
+        target_link_libraries(armnn PUBLIC
+                debug ${FLATBUFFERS_LIBRARY_DEBUG}
+                optimized ${FLATBUFFERS_LIBRARY_RELEASE})
+    endif()
+
+    if (TOSA_SERIALIZATION_LIB)
+        target_link_libraries(armnn PUBLIC -Wl,--whole-archive ${TOSA_SERIALIZATION_LIB} -Wl,--no-whole-archive)
+    else()
+        find_library(TOSA_SERIALIZATION_LIB
+            NAMES libtosa_serialization_lib.a tosa_serialization_lib
+            HINTS ${TOSA_SERIALIZATION_LIB_ROOT}/lib /usr/local/lib /usr/lib)
+
+        message(STATUS "TOSA serialization library set to ${TOSA_SERIALIZATION_LIB}")
+
+        target_link_libraries(armnn PUBLIC -Wl,--whole-archive ${TOSA_SERIALIZATION_LIB} -Wl,--no-whole-archive)
+    endif()
+endif()
+
 if(PROFILING_BACKEND_STREAMLINE AND (NOT ("${CMAKE_SYSTEM_NAME}" STREQUAL Android)))
     target_link_libraries(armnn PUBLIC ${CMAKE_THREAD_LIBS_INIT})
 endif()
diff --git a/cmake/GlobalConfig.cmake b/cmake/GlobalConfig.cmake
index d5cdca2b56..9137fa33d8 100644
--- a/cmake/GlobalConfig.cmake
+++ b/cmake/GlobalConfig.cmake
@@ -1,5 +1,5 @@
 #
-# Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
 # Copyright 2020 NXP
 # SPDX-License-Identifier: MIT
 #
@@ -11,6 +11,7 @@ option(BUILD_FOR_COVERAGE "Use no optimization and output .gcno and .gcda files"
 option(ARMCOMPUTENEON "Build with ARM Compute NEON support" OFF)
 option(ARMCOMPUTECL "Build with ARM Compute OpenCL support" OFF)
 option(ARMNNREF "Build with ArmNN reference support" ON)
+option(ARMNNTOSAREF "Build with Tosa reference support" OFF)
 option(PROFILING_BACKEND_STREAMLINE "Forward the armNN profiling events to DS-5/Streamline as annotations" OFF)
 # options used for heap profiling and leak checking
 option(HEAP_PROFILING "Build with heap profiling enabled" OFF)
@@ -23,6 +24,7 @@ option(BUILD_ACCURACY_TOOL "Build Accuracy Tool" OFF)
 option(FLATC_DIR "Path to Flatbuffers compiler" OFF)
 option(TF_LITE_GENERATED_PATH "Tensorflow lite generated C++ schema location" OFF)
 option(FLATBUFFERS_ROOT "Location where the flatbuffers 'include' and 'lib' folders to be found" Off)
+option(TOSA_SERIALIZATION_LIB_ROOT "Location where the TOSA serialization library 'include' and 'lib' folders can be found" OFF)
 option(DYNAMIC_BACKEND_PATHS "Colon seperated list of paths where to load the dynamic backends from" "")
 option(SAMPLE_DYNAMIC_BACKEND "Include the sample dynamic backend and its tests in the build" OFF)
 option(BUILD_GATORD_MOCK "Build the Gatord simulator for external profiling testing." ON)
@@ -183,8 +185,8 @@ endif()
 if(BUILD_ARMNN_TFLITE_DELEGATE)
     add_definitions(-DARMNN_TFLITE_DELEGATE)
 endif()
-# Flatbuffers support for TF Lite and Armnn Serializer
-if(BUILD_TF_LITE_PARSER OR BUILD_ARMNN_SERIALIZER)
+# Flatbuffers support for TF Lite, Armnn Serializer or the TOSA backend.
+if(BUILD_TF_LITE_PARSER OR BUILD_ARMNN_SERIALIZER OR ARMNNTOSAREF)
     # verify we have a valid flatbuffers include path
     find_path(FLATBUFFERS_INCLUDE_PATH flatbuffers/flatbuffers.h
               HINTS ${FLATBUFFERS_ROOT}/include /usr/local/include /usr/include)
@@ -334,6 +336,21 @@ if(ARMNNREF)
     add_definitions(-DARMNNREF_ENABLED)
 endif()
 
+# ArmNN TOSA reference backend
+if(ARMNNTOSAREF)
+    # Locate the includes for the TOSA serialization library.
+    message(STATUS "TOSA serialization library root set to ${TOSA_SERIALIZATION_LIB_ROOT}")
+
+    find_path(TOSA_SERIALIZATION_LIB_INCLUDE tosa_serialization_handler.h HINTS
+            ${TOSA_SERIALIZATION_LIB_ROOT}/include)
+    message(STATUS "TOSA serialization library include directory located at: ${TOSA_SERIALIZATION_LIB_INCLUDE}")
+
+    find_library(TOSA_SERIALIZATION_LIB
+            NAMES tosa_serialization_lib.a tosa_serialization_lib
+            HINTS ${TOSA_SERIALIZATION_LIB_ROOT}/lib /usr/local/lib /usr/lib)
+    message(STATUS "TOSA serialization library set to ${TOSA_SERIALIZATION_LIB}")
+endif()
+
 # This is the root for the dynamic backend tests to search for dynamic
 # backends. By default it will be the project build directory.
 add_definitions(-DDYNAMIC_BACKEND_BUILD_DIR="${PROJECT_BINARY_DIR}")
diff --git a/src/backends/tosaCommon/CMakeLists.txt b/src/backends/tosaCommon/CMakeLists.txt
new file mode 100644
index 0000000000..9653859767
--- /dev/null
+++ b/src/backends/tosaCommon/CMakeLists.txt
@@ -0,0 +1,25 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+include_directories(SYSTEM ${FLATBUFFERS_INCLUDE_PATH})
+include_directories(SYSTEM ${TOSA_SERIALIZATION_LIB_INCLUDE})
+
+list(APPEND armnnTosaBackend_sources
+        TosaMappings.hpp
+    )
+
+add_subdirectory(operatorMappings)
+
+if(BUILD_UNIT_TESTS)
+    add_subdirectory(test)
+endif()
+
+add_library(armnnTosaBackend OBJECT ${armnnTosaBackend_sources})
+target_include_directories(armnnTosaBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnTosaBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnTosaBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
+target_include_directories(armnnTosaBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/profiling)
+target_include_directories(armnnTosaBackend PRIVATE ${PROJECT_SOURCE_DIR}/profiling/common/include)
+target_include_directories(armnnTosaBackend PRIVATE ${PROJECT_SOURCE_DIR}/profiling/client/include)
diff --git a/src/backends/tosaCommon/TosaMappings.hpp b/src/backends/tosaCommon/TosaMappings.hpp
new file mode 100644
index 0000000000..5728ff3203
--- /dev/null
+++ b/src/backends/tosaCommon/TosaMappings.hpp
@@ -0,0 +1,81 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+#include "operatorMappings/AdditionOperator.hpp"
+
+using namespace armnn;
+using namespace tosa;
+
+// From the input armnn::Layer, set the corresponding data field in the
+// tosa::TosaSerializationTensor where constant tensor data exists in the armnn::Layer.
+void SetBasicBlockConstantTensorData(Layer* layer, TosaSerializationBasicBlock* /*basicBlock*/)
+{
+    switch (layer->GetType())
+    {
+        case LayerType::Convolution2d:
+        {
+            // ToDo: using Convolution2d as an example as it has constant tensors for weights and bias.
+            // ToDo: manually set TosaOperator data of basicBlock where constant tensors exist.
+        }
+        default:
+            // If no switch statement for layer, no constant tensors exist in that layer, return
+            return;
+    }
+}
+
+// Populates a tosa::TosaSerializationBasicBlock from constructing
+// tosa::TosaSerializationOperator(s) and tosa::TosaSerializationTensor(s)
+// based on the input armnn::LayerType and associated armnn::TensorInfos and armnn::Descriptor.
+//
+// If an armnn::LayerType does not have a tosa mapping or the mapping is not implemented in ArmNN,
+// an empty tosa::TosaSerializationBasicBlock() is returned with operator tosa::Op_UNKNOWN.
+TosaSerializationBasicBlock* GetTosaMapping(const LayerType type,
+                                            const std::vector<const TensorInfo*>& inputs,
+                                            const std::vector<const TensorInfo*>& outputs,
+                                            const BaseDescriptor& /*descriptor*/)
+{
+    switch (type)
+    {
+        case LayerType::Addition:
+        {
+            return ConvertAdditionToTosaOperator(inputs, outputs);
+        }
+        default:
+        {
+            // empty basic block when no tosa mapping implemented/exists
+            TosaSerializationOperator* op = new TosaSerializationOperator(Op_UNKNOWN, Attribute_NONE, nullptr, {}, {});
+            return new TosaSerializationBasicBlock("", {op}, {}, {}, {});
+        }
+    }
+}
+
+// Function called in armnn::OptimizeSubgraphView() when access to armnn::Layer is available
+// and there is an option to set tosa basic block data from constant layer tenors available from the input layer.
+TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer)
+{
+    std::vector<const TensorInfo*> inputs;
+    for (auto inputSlot : layer->GetInputSlots())
+    {
+        inputs.push_back(&inputSlot.GetConnection()->GetTensorInfo());
+    }
+
+    std::vector<const TensorInfo*> outputs;
+    for (auto& outputSlot : layer->GetOutputSlots())
+    {
+        outputs.push_back(&outputSlot.GetTensorInfo());
+    }
+
+    TosaSerializationBasicBlock* basicBlock = GetTosaMapping(layer->GetType(),
+                                                             inputs,
+                                                             outputs,
+                                                             layer->GetParameters());
+    SetBasicBlockConstantTensorData(layer, basicBlock);
+    return basicBlock;
+}
diff --git a/src/backends/tosaCommon/common.cmake b/src/backends/tosaCommon/common.cmake
new file mode 100644
index 0000000000..f15c063700
--- /dev/null
+++ b/src/backends/tosaCommon/common.cmake
@@ -0,0 +1,11 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+if(ARMNNTOSAREF)
+    add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/tosaCommon)
+    list(APPEND armnnLibraries armnnTosaBackend)
+    list(APPEND armnnLibraries armnnTosaBackendOperators)
+    list(APPEND armnnUnitTestLibraries armnnTosaBackendUnitTests)
+endif()
diff --git a/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp b/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
new file mode 100644
index 0000000000..98c01e2cb8
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/AdditionOperator.hpp
@@ -0,0 +1,52 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+#include "TosaOperatorUtils.hpp"
+
+using namespace armnn;
+using namespace tosa;
+
+TosaSerializationBasicBlock* ConvertAdditionToTosaOperator(const std::vector<const TensorInfo*>& inputs,
+                                                          const std::vector<const TensorInfo*>& outputs)
+{
+    // A helper function with static global variables ensures uniqueness
+    // for dynamically generating input, output and block names
+    std::string input0Name = std::string("Op_ADD_input0_")  + GetUniqueTosaMappingID();
+    std::string input1Name = std::string("Op_ADD_input1_")  + GetUniqueTosaMappingID();
+    std::string outputName = std::string("Op_ADD_output0_") + GetUniqueTosaMappingID();
+    std::string blockName  = std::string("Op_ADD_block_")   + GetUniqueTosaMappingID();
+
+    TosaSerializationOperator* op = new TosaSerializationOperator(Op_ADD,
+                                                                  Attribute_NONE,
+                                                                  nullptr,
+                                                                  {input0Name, input1Name},
+                                                                  {outputName});
+
+    std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
+    DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
+
+    std::vector<int32_t> inputShape1 = GetTosaTensorShape(inputs[1]->GetShape());
+    DType inputDType1 = ArmNNToDType(inputs[1]->GetDataType());
+
+    std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
+    DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
+
+    TosaSerializationTensor* inputTensor0  = new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {});
+    TosaSerializationTensor* inputTensor1  = new TosaSerializationTensor(input1Name, inputShape1, inputDType1, {});
+    TosaSerializationTensor* outputTensor0 = new TosaSerializationTensor(outputName, outputShape0, outputDType0, {});
+
+    // operatorInputNames/operatorOutputNames ends up being the same as
+    // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
+    return new TosaSerializationBasicBlock(blockName, // name
+                                           {op}, // operators
+                                           {inputTensor0, inputTensor1, outputTensor0}, // tensors
+                                           {input0Name, input1Name}, // inputs
+                                           {outputName}); // outputs
+}
diff --git a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
new file mode 100644
index 0000000000..3965a6ab04
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
@@ -0,0 +1,14 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+list(APPEND armnnTosaBackendOperators_sources
+        AdditionOperator.hpp
+        TosaOperatorUtils.hpp
+    )
+
+add_library(armnnTosaBackendOperators OBJECT ${armnnTosaBackendOperators_sources})
+target_include_directories(armnnTosaBackendOperators PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnTosaBackendOperators PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnTosaBackendOperators PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
diff --git a/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
new file mode 100644
index 0000000000..b887721648
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/TosaOperatorUtils.hpp
@@ -0,0 +1,60 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/Tensor.hpp>
+#include <armnn/Types.hpp>
+
+#include <tosa_generated.h>
+
+using namespace armnn;
+using namespace tosa;
+
+// Function to return Tosa datatype from input ArmNN datatype.
+DType ArmNNToDType(const DataType& type)
+{
+    switch (type)
+    {
+        case DataType::Float16:
+        case DataType::Float32:
+        case DataType::BFloat16:
+            return DType_FLOAT;
+        case DataType::QAsymmU8:
+            return DType_UINT8;
+        case DataType::QSymmS8:
+        case DataType::QAsymmS8:
+            return DType_INT8;
+        case DataType::QSymmS16:
+            return DType_INT16;
+        case DataType::Signed32:
+            return DType_INT32;
+        case DataType::Signed64:
+            // No signed 64, only DType_INT48.
+            return DType_UNKNOWN;
+        case DataType::Boolean:
+            return DType_BOOL;
+        default:
+            return DType_UNKNOWN;
+    }
+}
+
+// Function to return Tosa tensor shape from input ArmNN tensor shape.
+std::vector<int32_t> GetTosaTensorShape(const TensorShape& shape)
+{
+    std::vector<int32_t> returnShape;
+    for (u_int32_t i = 0; i < shape.GetNumDimensions(); i++)
+    {
+        returnShape.push_back(static_cast<int32_t>(shape[i]));
+    }
+    return returnShape;
+}
+
+// Function to return unique int as a string to ensure uniqueness between all input, output and block names.
+static int uniqueTosaMappingID = 0;
+std::string GetUniqueTosaMappingID()
+{
+    return std::to_string(++uniqueTosaMappingID);
+}
diff --git a/src/backends/tosaCommon/test/CMakeLists.txt b/src/backends/tosaCommon/test/CMakeLists.txt
new file mode 100644
index 0000000000..56cc66e51c
--- /dev/null
+++ b/src/backends/tosaCommon/test/CMakeLists.txt
@@ -0,0 +1,14 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+list(APPEND armnnTosaBackendUnitTests_sources
+        TosaOperatorMappingTests.cpp
+    )
+
+add_library(armnnTosaBackendUnitTests OBJECT ${armnnTosaBackendUnitTests_sources})
+target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnTestUtils)
+target_include_directories(armnnTosaBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
diff --git a/src/backends/tosaCommon/test/TosaOperatorMappingTests.cpp b/src/backends/tosaCommon/test/TosaOperatorMappingTests.cpp
new file mode 100644
index 0000000000..2f5a56d88d
--- /dev/null
+++ b/src/backends/tosaCommon/test/TosaOperatorMappingTests.cpp
@@ -0,0 +1,124 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include <Layer.hpp>
+
+#include <tosaCommon/TosaMappings.hpp>
+
+#include <doctest/doctest.h>
+
+using namespace armnn;
+using namespace tosa;
+
+void AssertTosaOneToOneMappingBasicBlock(TosaSerializationBasicBlock* basicBlock,
+                                         std::vector<int32_t> shape,
+                                         uint32_t numInputs,
+                                         uint32_t numOutputs,
+                                         Op tosaOp,
+                                         std::string operatorString,
+                                         DType dataType = DType_FLOAT)
+{
+    std::string blockStr = operatorString + "_block_";
+    ARMNN_ASSERT(basicBlock->GetName().find(blockStr)  != std::string::npos);
+    ARMNN_ASSERT(basicBlock->GetInputs().size() == numInputs);
+    ARMNN_ASSERT(basicBlock->GetOutputs().size() == numOutputs);
+    ARMNN_ASSERT(basicBlock->GetOperators().size() == 1);
+    ARMNN_ASSERT(basicBlock->GetTensors().size() == (numInputs + numOutputs));
+
+    TosaSerializationOperator* op = basicBlock->GetOperators().at(0);
+    ARMNN_ASSERT(op->GetInputTensorNames().size() == numInputs);
+    ARMNN_ASSERT(op->GetOutputTensorNames().size() == numOutputs);
+
+    for (uint32_t i = 0; i < numInputs; i++)
+    {
+        std::basic_string<char> blockInputName = basicBlock->GetInputs()[i];
+        std::basic_string<char> operatorInputName  = op->GetInputTensorNames()[i];
+        std::basic_string<char> tensorName = basicBlock->GetTensors()[i]->GetName();
+
+        std::string opStr = operatorString + "_input" + std::to_string(i) + "_";
+
+        ARMNN_ASSERT(blockInputName == operatorInputName);
+        ARMNN_ASSERT(tensorName == operatorInputName);
+        ARMNN_ASSERT(blockInputName.find(opStr)  != std::string::npos);
+    }
+
+    for (uint32_t i = 0; i < numOutputs; i++)
+    {
+        std::basic_string<char> blockOutputName = basicBlock->GetOutputs()[i];
+        std::basic_string<char> operatorOutputName  = op->GetOutputTensorNames()[i];
+        std::basic_string<char> tensorName = basicBlock->GetTensors()[numInputs + i]->GetName();
+
+        std::string opStr = operatorString + "_output" + std::to_string(i) + "_";
+
+        ARMNN_ASSERT(blockOutputName == operatorOutputName);
+        ARMNN_ASSERT(tensorName == operatorOutputName);
+        ARMNN_ASSERT(blockOutputName.find(opStr)  != std::string::npos);
+    }
+
+    ARMNN_ASSERT(op->GetAttributeType() == Attribute_NONE);
+    ARMNN_ASSERT(op->GetOp() == tosaOp);
+
+    TosaSerializationTensor* tensor0 = basicBlock->GetTensors()[0];
+    ARMNN_ASSERT(tensor0->GetDtype() == dataType);
+    ARMNN_ASSERT(tensor0->GetData().size() == 0);
+    ARMNN_ASSERT(tensor0->GetShape() == shape);
+}
+
+TEST_SUITE("TosaOperatorMappingOneToOneTests")
+{
+TEST_CASE("GetTosaMapping_AdditionLayer")
+{
+    TensorInfo info = TensorInfo({ 1, 2, 4, 2 }, DataType::Float32, 0.0f, 0, true);
+    TosaSerializationBasicBlock* basicBlock =
+        GetTosaMapping(LayerType::Addition, {&info, &info}, {&info}, BaseDescriptor());
+    AssertTosaOneToOneMappingBasicBlock(basicBlock, { 1, 2, 4, 2 }, 2, 1, Op::Op_ADD, "Op_ADD");
+}
+
+TEST_CASE("GetTosaMappingFromLayer_AdditionLayer")
+{
+    IRuntime::CreationOptions options;
+    IRuntimePtr runtime(IRuntime::Create(options));
+
+    // Builds up the structure of the network.
+    INetworkPtr net(INetwork::Create());
+
+    IConnectableLayer* input0 = net->AddInputLayer(0, "input0");
+    IConnectableLayer* input1 = net->AddInputLayer(1, "input1");
+    IConnectableLayer* add    = net->AddAdditionLayer("add");
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+
+    input0->GetOutputSlot(0).Connect(add->GetInputSlot(0));
+    input1->GetOutputSlot(0).Connect(add->GetInputSlot(1));
+    add->GetOutputSlot(0).Connect(output->GetInputSlot(0));
+
+    TensorInfo info = TensorInfo({ 1, 2, 4, 2 }, DataType::Float32, 0.0f, 0, true);
+
+    input0->GetOutputSlot(0).SetTensorInfo(info);
+    input1->GetOutputSlot(0).SetTensorInfo(info);
+    add->GetOutputSlot(0).SetTensorInfo(info);
+
+    TosaSerializationBasicBlock* basicBlock =
+        GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(add));
+    AssertTosaOneToOneMappingBasicBlock(basicBlock, { 1, 2, 4, 2 }, 2, 1, Op::Op_ADD, "Op_ADD");
+}
+
+TEST_CASE("GetTosaMapping_Unimplemented")
+{
+    TosaSerializationBasicBlock* basicBlock =
+        GetTosaMapping(LayerType::UnidirectionalSequenceLstm, {}, {}, BaseDescriptor());
+
+    ARMNN_ASSERT(basicBlock->GetName() == "");
+    ARMNN_ASSERT(basicBlock->GetTensors().size() == 0);
+    ARMNN_ASSERT(basicBlock->GetOperators().size() == 1);
+    ARMNN_ASSERT(basicBlock->GetInputs().size() == 0);
+    ARMNN_ASSERT(basicBlock->GetOutputs().size() == 0);
+
+    TosaSerializationOperator* op = basicBlock->GetOperators()[0];
+    ARMNN_ASSERT(op->GetAttributeType() == Attribute_NONE);
+    ARMNN_ASSERT(op->GetOp() == tosa::Op_UNKNOWN);
+    ARMNN_ASSERT(op->GetInputTensorNames().size() == 0);
+    ARMNN_ASSERT(op->GetOutputTensorNames().size() == 0);
+}
+}