IVGCVSW-7159 Implement simple TOSA Reference Backend skeleton
* Added files based on RefBackend
* Added PreCompiled Workload skeleton
* Increment ABI version of armnnTestUtils for CreateInput which had
been left as pure virtual, added base implementation for it.
* Add IsTosaLayerSupported() for Addition
Change-Id: I4c963adf3f50593d17ecdf21554502a64ad3bd76
diff --git a/include/armnn/backends/ILayerSupport.hpp b/include/armnn/backends/ILayerSupport.hpp
index 519119b..b7f5f04 100644
--- a/include/armnn/backends/ILayerSupport.hpp
+++ b/include/armnn/backends/ILayerSupport.hpp
@@ -188,7 +188,7 @@
const TensorInfo& detectionScores,
const TensorInfo& numDetections,
const DetectionPostProcessDescriptor& descriptor,
- Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const =0;
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
"Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
diff --git a/include/armnn/backends/WorkloadFactory.hpp b/include/armnn/backends/WorkloadFactory.hpp
index 85e0312..4ccf1e2 100644
--- a/include/armnn/backends/WorkloadFactory.hpp
+++ b/include/armnn/backends/WorkloadFactory.hpp
@@ -56,9 +56,6 @@
unsigned int const* subTensorOrigin
) const = 0;
- virtual std::unique_ptr<IWorkload> CreateInput(const InputQueueDescriptor& descriptor,
- const WorkloadInfo& info) const = 0;
-
ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateTensorHandle instead")
virtual std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
const bool IsMemoryManaged = true) const = 0;
@@ -74,6 +71,11 @@
ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
"CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "23.08")
+ virtual std::unique_ptr<IWorkload> CreateInput(const InputQueueDescriptor& descriptor,
+ const WorkloadInfo& info) const;
+
+ ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use ABI stable "
+ "CreateWorkload(LayerType, const QueueDescriptor&, const WorkloadInfo& info) instead.", "23.08")
virtual std::unique_ptr<IWorkload> CreateActivation(const ActivationQueueDescriptor& descriptor,
const WorkloadInfo& info) const;
diff --git a/include/armnnTestUtils/Version.hpp b/include/armnnTestUtils/Version.hpp
index 39009d5..d7a8cd6 100644
--- a/include/armnnTestUtils/Version.hpp
+++ b/include/armnnTestUtils/Version.hpp
@@ -10,7 +10,7 @@
#define STRINGIFY_MACRO(s) #s
// ArmnnTestUtils version components
-#define ARMNN_TEST_UTILS_MAJOR_VERSION 1
+#define ARMNN_TEST_UTILS_MAJOR_VERSION 2
#define ARMNN_TEST_UTILS_MINOR_VERSION 0
#define ARMNN_TEST_UTILS_PATCH_VERSION 0
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index 70006e4..665ab3f 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -2348,4 +2348,11 @@
return std::unique_ptr<IWorkload>();
}
+std::unique_ptr<IWorkload> IWorkloadFactory::CreateInput(
+ const InputQueueDescriptor& /*descriptor*/,
+ const WorkloadInfo& /*info*/) const
+{
+ return std::unique_ptr<IWorkload>();
+}
+
} // namepsace armnn
diff --git a/src/backends/reference/workloads/RefWorkloadUtils.hpp b/src/backends/reference/workloads/RefWorkloadUtils.hpp
index e50847f..7c35966 100644
--- a/src/backends/reference/workloads/RefWorkloadUtils.hpp
+++ b/src/backends/reference/workloads/RefWorkloadUtils.hpp
@@ -23,11 +23,12 @@
/// float32 helpers
////////////////////////////////////////////
+template <typename TensorHandleType = RefTensorHandle>
inline const TensorInfo& GetTensorInfo(const ITensorHandle* tensorHandle)
{
// We know that reference workloads use RefTensorHandles for inputs and outputs
- const RefTensorHandle* refTensorHandle =
- PolymorphicDowncast<const RefTensorHandle*>(tensorHandle);
+ const TensorHandleType* refTensorHandle =
+ PolymorphicDowncast<const TensorHandleType*>(tensorHandle);
return refTensorHandle->GetTensorInfo();
}
diff --git a/src/backends/tosaCommon/CMakeLists.txt b/src/backends/tosaCommon/CMakeLists.txt
index 9653859..61434ed 100644
--- a/src/backends/tosaCommon/CMakeLists.txt
+++ b/src/backends/tosaCommon/CMakeLists.txt
@@ -8,6 +8,7 @@
list(APPEND armnnTosaBackend_sources
TosaMappings.hpp
+ TosaLayerSupportRules.hpp
)
add_subdirectory(operatorMappings)
diff --git a/src/backends/tosaCommon/TosaLayerSupportRules.hpp b/src/backends/tosaCommon/TosaLayerSupportRules.hpp
new file mode 100644
index 0000000..2a2b08d
--- /dev/null
+++ b/src/backends/tosaCommon/TosaLayerSupportRules.hpp
@@ -0,0 +1,40 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+// List of Layer Support Rules common to TOSA backends only, for use with CheckSupportRule()
+
+struct TosaOperatorAttributeOfAny : public Rule
+{
+ template<typename Container>
+ explicit TosaOperatorAttributeOfAny(TosaSerializationOperator* op, const Container& c)
+ {
+ m_Res = std::any_of(c.begin(), c.end(), [&op](Attribute attribute)
+ {
+ return attribute == op->GetAttributeType();
+ });
+ }
+};
+
+struct TosaTypeAnyOf : public Rule
+{
+ template<typename Container>
+ TosaTypeAnyOf(TosaSerializationTensor* tensor, const Container& c)
+ {
+ m_Res = std::any_of(c.begin(), c.end(), [&tensor](DType dt)
+ {
+ return dt == tensor->GetDtype();
+ });
+ }
+};
+
+struct TosaTensorNumDimensionsWithinBounds : public Rule
+{
+ explicit TosaTensorNumDimensionsWithinBounds(TosaSerializationTensor* tensor)
+ {
+ m_Res = (tensor->GetShape().size() <= MaxNumOfTensorDimensions) || (!tensor->GetShape().empty());
+ }
+};
diff --git a/src/backends/tosaReference/CMakeLists.txt b/src/backends/tosaReference/CMakeLists.txt
new file mode 100644
index 0000000..d1f9040
--- /dev/null
+++ b/src/backends/tosaReference/CMakeLists.txt
@@ -0,0 +1,43 @@
+#
+# 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})
+
+if(ARMNNTOSAREF)
+ list(APPEND armnnTosaRefBackend_sources
+ TosaRefBackend.cpp
+ TosaRefBackend.hpp
+ TosaRefBackendId.hpp
+ TosaRefTensorHandle.hpp
+ TosaRefTensorHandle.cpp
+ TosaRefLayerSupport.cpp
+ TosaRefLayerSupport.hpp
+ TosaRefMemoryManager.hpp
+ TosaRefMemoryManager.cpp
+ TosaRefRegistryInitializer.cpp
+ TosaRefWorkloadFactory.cpp
+ TosaRefWorkloadFactory.hpp
+ TosaRefTensorHandleFactory.cpp
+ TosaRefTensorHandleFactory.hpp
+ )
+
+ add_subdirectory(workloads)
+
+ if(BUILD_UNIT_TESTS)
+ add_subdirectory(test)
+ endif()
+
+else()
+ list(APPEND armnnTosaRefBackend_sources
+ TosaRefBackendId.hpp
+ )
+endif()
+
+add_library(armnnTosaRefBackend OBJECT ${armnnTosaRefBackend_sources})
+target_include_directories(armnnTosaRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnTosaRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnTosaRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
+target_include_directories(armnnTosaRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends/tosaCommon)
diff --git a/src/backends/tosaReference/TosaRefBackend.cpp b/src/backends/tosaReference/TosaRefBackend.cpp
new file mode 100644
index 0000000..0938029
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefBackend.cpp
@@ -0,0 +1,107 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "TosaRefBackend.hpp"
+#include "TosaRefBackendId.hpp"
+#include "TosaRefWorkloadFactory.hpp"
+#include "TosaRefLayerSupport.hpp"
+#include "TosaRefTensorHandleFactory.hpp"
+
+#include <armnn/BackendRegistry.hpp>
+#include <armnn/backends/IBackendContext.hpp>
+#include <armnn/backends/IMemoryManager.hpp>
+#include <armnn/utility/PolymorphicDowncast.hpp>
+#include <backendsCommon/DefaultAllocator.hpp>
+#include <backendsCommon/SubgraphUtils.hpp>
+
+#include <Optimizer.hpp>
+
+namespace armnn
+{
+
+const BackendId& TosaRefBackend::GetIdStatic()
+{
+ static const BackendId s_Id{TosaRefBackendId()};
+ return s_Id;
+}
+
+IBackendInternal::IWorkloadFactoryPtr TosaRefBackend::CreateWorkloadFactory(
+ const IBackendInternal::IMemoryManagerSharedPtr& memoryManager) const
+{
+ return std::make_unique<TosaRefWorkloadFactory>(PolymorphicPointerDowncast<TosaRefMemoryManager>(memoryManager));
+}
+
+IBackendInternal::IWorkloadFactoryPtr TosaRefBackend::CreateWorkloadFactory(
+ class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const
+{
+ auto memoryManager = std::make_shared<TosaRefMemoryManager>();
+
+ tensorHandleFactoryRegistry.RegisterMemoryManager(memoryManager);
+
+ auto factory = std::make_unique<TosaRefTensorHandleFactory>(memoryManager);
+ // Register copy and import factory pair
+ tensorHandleFactoryRegistry.RegisterCopyAndImportFactoryPair(factory->GetId(), factory->GetId());
+ // Register the factory
+ tensorHandleFactoryRegistry.RegisterFactory(std::move(factory));
+
+ return std::make_unique<TosaRefWorkloadFactory>(PolymorphicPointerDowncast<TosaRefMemoryManager>(memoryManager));
+}
+
+IBackendInternal::IBackendContextPtr TosaRefBackend::CreateBackendContext(const IRuntime::CreationOptions&) const
+{
+ return IBackendContextPtr{};
+}
+
+IBackendInternal::IBackendProfilingContextPtr TosaRefBackend::CreateBackendProfilingContext(
+ const IRuntime::CreationOptions&, IBackendProfilingPtr&)
+{
+ return IBackendProfilingContextPtr{};
+}
+
+IBackendInternal::IMemoryManagerUniquePtr TosaRefBackend::CreateMemoryManager() const
+{
+ return std::make_unique<TosaRefMemoryManager>();
+}
+
+IBackendInternal::ILayerSupportSharedPtr TosaRefBackend::GetLayerSupport() const
+{
+ static ILayerSupportSharedPtr layerSupport{new TosaRefLayerSupport};
+ return layerSupport;
+}
+
+OptimizationViews TosaRefBackend::OptimizeSubgraphView(const SubgraphView& subgraph,
+ const ModelOptions& modelOptions) const
+{
+ OptimizationViews optimizationViews(modelOptions);
+ optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
+
+ return optimizationViews;
+}
+
+std::vector<ITensorHandleFactory::FactoryId> TosaRefBackend::GetHandleFactoryPreferences() const
+{
+ return std::vector<ITensorHandleFactory::FactoryId> { TosaRefTensorHandleFactory::GetIdStatic() };
+}
+
+void TosaRefBackend::RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry)
+{
+ auto memoryManager = std::make_shared<TosaRefMemoryManager>();
+
+ registry.RegisterMemoryManager(memoryManager);
+
+ auto factory = std::make_unique<TosaRefTensorHandleFactory>(memoryManager);
+
+ // Register copy and import factory pair
+ registry.RegisterCopyAndImportFactoryPair(factory->GetId(), factory->GetId());
+ // Register the factory
+ registry.RegisterFactory(std::move(factory));
+}
+
+std::unique_ptr<ICustomAllocator> TosaRefBackend::GetDefaultAllocator() const
+{
+ return std::make_unique<DefaultAllocator>();
+}
+
+} // namespace armnn
diff --git a/src/backends/tosaReference/TosaRefBackend.hpp b/src/backends/tosaReference/TosaRefBackend.hpp
new file mode 100644
index 0000000..9ff0626
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefBackend.hpp
@@ -0,0 +1,56 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <armnn/backends/IBackendInternal.hpp>
+
+namespace armnn
+{
+
+class TosaRefBackend : public IBackendInternal
+{
+public:
+ TosaRefBackend() = default;
+ ~TosaRefBackend() = default;
+
+ static const BackendId& GetIdStatic();
+ const BackendId& GetId() const override
+ {
+ return GetIdStatic();
+ }
+
+ IBackendInternal::IMemoryManagerUniquePtr CreateMemoryManager() const override;
+
+ IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory(
+ const IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr) const override;
+
+ IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory(
+ class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const override;
+
+ IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override;
+
+ IBackendInternal::IBackendProfilingContextPtr
+ CreateBackendProfilingContext(const IRuntime::CreationOptions& creationOptions,
+ IBackendProfilingPtr& backendProfiling) override;
+
+ IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override;
+
+ OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph,
+ const ModelOptions& modelOptions) const override;
+
+ std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences() const override;
+
+ void RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry) override;
+
+ std::unique_ptr<ICustomAllocator> GetDefaultAllocator() const override;
+
+private:
+ // Private members
+
+protected:
+ // Protected members
+};
+
+} // namespace armnn
diff --git a/src/backends/tosaReference/TosaRefBackendId.hpp b/src/backends/tosaReference/TosaRefBackendId.hpp
new file mode 100644
index 0000000..470fb79
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefBackendId.hpp
@@ -0,0 +1,12 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+namespace armnn
+{
+
+constexpr const char * TosaRefBackendId() { return "TosaRef"; }
+
+} // namespace armnn
diff --git a/src/backends/tosaReference/TosaRefLayerSupport.cpp b/src/backends/tosaReference/TosaRefLayerSupport.cpp
new file mode 100644
index 0000000..80e982f
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefLayerSupport.cpp
@@ -0,0 +1,142 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "TosaRefLayerSupport.hpp"
+#include <tosaCommon/TosaMappings.hpp>
+
+#include <armnn/Types.hpp>
+#include <armnn/utility/IgnoreUnused.hpp>
+#include <tosaCommon/TosaLayerSupportRules.hpp>
+#include <LayerSupportCommon.hpp>
+
+#include <vector>
+#include <array>
+
+namespace armnn
+{
+
+static bool IsTosaLayerSupported(TosaSerializationOperator* op,
+ const std::vector<TosaSerializationTensor*>& inputs,
+ const std::vector<TosaSerializationTensor*>& outputs,
+ Optional<string&> reasonIfUnsupported)
+{
+ switch(op->GetOp())
+ {
+ case tosa::Op_ADD:
+ {
+ bool supported = true;
+
+ std::array<Attribute, 1> supportedAttributes =
+ {
+ Attribute_NONE
+ };
+
+ // Check Attribute from operator (GetAttribute)
+ supported &= CheckSupportRule(TosaOperatorAttributeOfAny(op, supportedAttributes), reasonIfUnsupported,
+ std::string("TOSA Reference addition: operator has an unsupported attribute.").c_str());
+
+ std::array<DType, 8> supportedTypes =
+ {
+ DType_BOOL,
+ DType_UINT8,
+ DType_INT4,
+ DType_INT8,
+ DType_INT16,
+ DType_INT32,
+ DType_FLOAT,
+ DType_UINT16
+ };
+
+ for (auto tensor : inputs)
+ {
+ // Check Dtype from tensor (GetDtype)
+ supported &= CheckSupportRule(TosaTypeAnyOf(tensor, supportedTypes),
+ reasonIfUnsupported,
+ std::string("TOSA Reference addition: " + tensor->GetName() +
+ " is not a supported type.").c_str());
+
+ // Check Shape from tensor (GetShape)
+ supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(tensor),
+ reasonIfUnsupported,
+ std::string("Tosa Reference addition: " + tensor->GetName() + " Shape.Size()"
+ " outside bounds of between Zero and MaxNumOfTensorDimensions.").c_str());
+ }
+
+ // Check Dtype from tensor (GetDtype)
+ supported &= CheckSupportRule(TosaTypeAnyOf(outputs[0], supportedTypes),
+ reasonIfUnsupported,
+ std::string("TOSA Reference addition: " + outputs[0]->GetName() +
+ " is not a supported type.").c_str());
+
+ // Check Shape from tensor (GetShape)
+ supported &= CheckSupportRule(TosaTensorNumDimensionsWithinBounds(outputs[0]),
+ reasonIfUnsupported,
+ std::string("Tosa Reference addition: " + outputs[0]->GetName() + " Shape.Size()"
+ " outside bounds of between Zero and MaxNumOfTensorDimensions.").c_str());
+
+ return supported;
+ }
+ default:
+ SetValueChecked(reasonIfUnsupported, "Operation is currently unsupported by the TOSA Reference Backend.");
+ return false;
+ }
+}
+
+bool TosaRefLayerSupport::IsLayerSupported(const LayerType& type,
+ const std::vector<TensorInfo>& infos,
+ const BaseDescriptor& descriptor,
+ const Optional<LstmInputParamsInfo>& lstmParamsInfo,
+ const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmInputParamsInfo,
+ Optional<std::string&> reasonIfUnsupported) const
+{
+ IgnoreUnused(lstmParamsInfo);
+ IgnoreUnused(quantizedLstmInputParamsInfo);
+
+ // Setup Inputs
+ const auto input0 = infos[0];
+ const TensorInfo* ptr0 = &input0;
+ const auto input1 = infos[1];
+ const TensorInfo* ptr1 = &input1;
+ std::vector<const TensorInfo*> inputInfos = {ptr0, ptr1};
+
+ // Setup Outputs
+ const auto output = infos[2];
+ const TensorInfo* ptr2 = &output;
+ std::vector<const TensorInfo*> outputInfos = {ptr2};
+
+ auto mappings = GetTosaMapping(type, inputInfos, outputInfos, descriptor);
+
+ // Loop through block and get each tensor and operator
+ for (long unsigned int i = 0; i < mappings->GetOperators().size(); ++i)
+ {
+ // While looping over operators check for op_UNKNOWN which is unsupported
+ if (mappings->GetOperators()[i]->GetOp() == tosa::Op_UNKNOWN) { return false;}
+
+ // Loop over operators and get GetInput/OutputTensorNames, loop over resulting names and
+ // use GetTensorByName to pass pointers to tensors on to the IsTosaLayerSupported()
+ std::vector<TosaSerializationTensor*> inputTensorsVect;
+ for (const auto& name : mappings->GetOperators()[i]->GetInputTensorNames())
+ {
+ inputTensorsVect.push_back(mappings->GetTensorByName(name));
+ }
+
+ std::vector<TosaSerializationTensor*> outputTensorsVect;
+ for (const auto& name : mappings->GetOperators()[i]->GetOutputTensorNames())
+ {
+ outputTensorsVect.push_back(mappings->GetTensorByName(name));
+ }
+
+ if (!IsTosaLayerSupported(mappings->GetOperators()[i],
+ inputTensorsVect,
+ outputTensorsVect,
+ reasonIfUnsupported))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+} // namespace armnn
diff --git a/src/backends/tosaReference/TosaRefLayerSupport.hpp b/src/backends/tosaReference/TosaRefLayerSupport.hpp
new file mode 100644
index 0000000..f2d3f55
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefLayerSupport.hpp
@@ -0,0 +1,23 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <backendsCommon/LayerSupportBase.hpp>
+#include <backendsCommon/LayerSupportRules.hpp>
+
+namespace armnn {
+
+class TosaRefLayerSupport : public ILayerSupport {
+public:
+ bool IsLayerSupported(const LayerType& type,
+ const std::vector<TensorInfo>& infos,
+ const BaseDescriptor& descriptor,
+ const Optional<LstmInputParamsInfo>& lstmParamsInfo,
+ const Optional<QuantizedLstmInputParamsInfo>&,
+ Optional<std::string&> reasonIfUnsupported) const override;
+
+};
+
+}// namespace armnn
diff --git a/src/backends/tosaReference/TosaRefMemoryManager.cpp b/src/backends/tosaReference/TosaRefMemoryManager.cpp
new file mode 100644
index 0000000..745e6be
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefMemoryManager.cpp
@@ -0,0 +1,101 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include "TosaRefMemoryManager.hpp"
+
+#include <armnn/utility/Assert.hpp>
+
+#include <algorithm>
+
+namespace armnn
+{
+
+TosaRefMemoryManager::TosaRefMemoryManager()
+{}
+
+TosaRefMemoryManager::~TosaRefMemoryManager()
+{}
+
+TosaRefMemoryManager::Pool* TosaRefMemoryManager::Manage(unsigned int numBytes)
+{
+ if (!m_FreePools.empty())
+ {
+ Pool* res = m_FreePools.back();
+ m_FreePools.pop_back();
+ res->Reserve(numBytes);
+ return res;
+ }
+ else
+ {
+ m_Pools.push_front(Pool(numBytes));
+ return &m_Pools.front();
+ }
+}
+
+void TosaRefMemoryManager::Allocate(TosaRefMemoryManager::Pool* pool)
+{
+ ARMNN_ASSERT(pool);
+ m_FreePools.push_back(pool);
+}
+
+void* TosaRefMemoryManager::GetPointer(TosaRefMemoryManager::Pool* pool)
+{
+ return pool->GetPointer();
+}
+
+void TosaRefMemoryManager::Acquire()
+{
+ for (Pool &pool: m_Pools)
+ {
+ pool.Acquire();
+ }
+}
+
+void TosaRefMemoryManager::Release()
+{
+ for (Pool &pool: m_Pools)
+ {
+ pool.Release();
+ }
+}
+
+TosaRefMemoryManager::Pool::Pool(unsigned int numBytes)
+ : m_Size(numBytes),
+ m_Pointer(nullptr)
+{}
+
+TosaRefMemoryManager::Pool::~Pool()
+{
+ if (m_Pointer)
+ {
+ Release();
+ }
+}
+
+void* TosaRefMemoryManager::Pool::GetPointer()
+{
+ ARMNN_ASSERT_MSG(m_Pointer, "TosaRefMemoryManager::Pool::GetPointer() called when memory not acquired");
+ return m_Pointer;
+}
+
+void TosaRefMemoryManager::Pool::Reserve(unsigned int numBytes)
+{
+ ARMNN_ASSERT_MSG(!m_Pointer, "TosaRefMemoryManager::Pool::Reserve() cannot be called after memory acquired");
+ m_Size = std::max(m_Size, numBytes);
+}
+
+void TosaRefMemoryManager::Pool::Acquire()
+{
+ ARMNN_ASSERT_MSG(!m_Pointer, "TosaRefMemoryManager::Pool::Acquire() called when memory already acquired");
+ m_Pointer = ::operator new(size_t(m_Size));
+}
+
+void TosaRefMemoryManager::Pool::Release()
+{
+ ARMNN_ASSERT_MSG(m_Pointer, "TosaRefMemoryManager::Pool::Release() called when memory not acquired");
+ ::operator delete(m_Pointer);
+ m_Pointer = nullptr;
+}
+
+}
diff --git a/src/backends/tosaReference/TosaRefMemoryManager.hpp b/src/backends/tosaReference/TosaRefMemoryManager.hpp
new file mode 100644
index 0000000..05a6ec0
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefMemoryManager.hpp
@@ -0,0 +1,59 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <armnn/backends/IMemoryManager.hpp>
+
+#include <forward_list>
+#include <vector>
+
+namespace armnn
+{
+
+// An implementation of IMemoryManager to be used with RefTensorHandle
+class TosaRefMemoryManager : public IMemoryManager
+{
+public:
+ TosaRefMemoryManager();
+ virtual ~TosaRefMemoryManager();
+
+ class Pool;
+
+ Pool* Manage(unsigned int numBytes);
+
+ void Allocate(Pool *pool);
+
+ void* GetPointer(Pool *pool);
+
+ void Acquire() override;
+ void Release() override;
+
+ class Pool
+ {
+ public:
+ Pool(unsigned int numBytes);
+ ~Pool();
+
+ void Acquire();
+ void Release();
+
+ void* GetPointer();
+
+ void Reserve(unsigned int numBytes);
+
+ private:
+ unsigned int m_Size;
+ void* m_Pointer;
+ };
+
+private:
+ TosaRefMemoryManager(const TosaRefMemoryManager&) = delete; // Noncopyable
+ TosaRefMemoryManager& operator=(const TosaRefMemoryManager&) = delete; // Noncopyable
+
+ std::forward_list<Pool> m_Pools;
+ std::vector<Pool*> m_FreePools;
+};
+
+}
diff --git a/src/backends/tosaReference/TosaRefRegistryInitializer.cpp b/src/backends/tosaReference/TosaRefRegistryInitializer.cpp
new file mode 100644
index 0000000..71052f7
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefRegistryInitializer.cpp
@@ -0,0 +1,25 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "TosaRefBackend.hpp"
+
+#include <armnn/BackendRegistry.hpp>
+
+namespace
+{
+
+using namespace armnn;
+
+static BackendRegistry::StaticRegistryInitializer g_RegisterHelper
+{
+ BackendRegistryInstance(),
+ TosaRefBackend::GetIdStatic(),
+ []()
+ {
+ return IBackendInternalUniquePtr(new TosaRefBackend);
+ }
+};
+
+} // Anonymous namespace
diff --git a/src/backends/tosaReference/TosaRefTensorHandle.cpp b/src/backends/tosaReference/TosaRefTensorHandle.cpp
new file mode 100644
index 0000000..38d02f1
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefTensorHandle.cpp
@@ -0,0 +1,175 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include "TosaRefTensorHandle.hpp"
+
+namespace armnn
+{
+
+TosaRefTensorHandle::TosaRefTensorHandle(const TensorInfo& tensorInfo,
+ std::shared_ptr<TosaRefMemoryManager>& memoryManager)
+ : m_TensorInfo(tensorInfo)
+ , m_MemoryManager(memoryManager)
+ , m_Pool(nullptr)
+ , m_UnmanagedMemory(nullptr)
+ , m_ImportFlags(static_cast<MemorySourceFlags>(MemorySource::Undefined))
+ , m_Imported(false)
+ , m_IsImportEnabled(false)
+{}
+
+TosaRefTensorHandle::TosaRefTensorHandle(const TensorInfo& tensorInfo,
+ MemorySourceFlags importFlags)
+ : m_TensorInfo(tensorInfo)
+ , m_Pool(nullptr)
+ , m_UnmanagedMemory(nullptr)
+ , m_ImportFlags(importFlags)
+ , m_Imported(false)
+ , m_IsImportEnabled(true)
+{}
+
+TosaRefTensorHandle::~TosaRefTensorHandle()
+{
+ if (!m_Pool)
+ {
+ // unmanaged
+ if (!m_Imported)
+ {
+ ::operator delete(m_UnmanagedMemory);
+ }
+ }
+}
+
+void TosaRefTensorHandle::Manage()
+{
+ if (!m_IsImportEnabled)
+ {
+ ARMNN_ASSERT_MSG(!m_Pool, "TosaRefTensorHandle::Manage() called twice");
+ ARMNN_ASSERT_MSG(!m_UnmanagedMemory, "TosaRefTensorHandle::Manage() called after Allocate()");
+
+ m_Pool = m_MemoryManager->Manage(m_TensorInfo.GetNumBytes());
+ }
+}
+
+void TosaRefTensorHandle::Allocate()
+{
+ // If import is enabled, do not allocate the tensor
+ if (!m_IsImportEnabled)
+ {
+
+ if (!m_UnmanagedMemory)
+ {
+ if (!m_Pool)
+ {
+ // unmanaged
+ m_UnmanagedMemory = ::operator new(m_TensorInfo.GetNumBytes());
+ }
+ else
+ {
+ m_MemoryManager->Allocate(m_Pool);
+ }
+ }
+ else
+ {
+ throw InvalidArgumentException("TosaRefTensorHandle::Allocate Trying to allocate a TosaRefTensorHandle"
+ "that already has allocated memory.");
+ }
+ }
+}
+
+const void* TosaRefTensorHandle::Map(bool /*unused*/) const
+{
+ return GetPointer();
+}
+
+void* TosaRefTensorHandle::GetPointer() const
+{
+ if (m_UnmanagedMemory)
+ {
+ return m_UnmanagedMemory;
+ }
+ else if (m_Pool)
+ {
+ return m_MemoryManager->GetPointer(m_Pool);
+ }
+ else
+ {
+ throw NullPointerException("TosaRefTensorHandle::GetPointer called on unmanaged, unallocated tensor handle");
+ }
+}
+
+void TosaRefTensorHandle::CopyOutTo(void* dest) const
+{
+ const void *src = GetPointer();
+ ARMNN_ASSERT(src);
+ memcpy(dest, src, m_TensorInfo.GetNumBytes());
+}
+
+void TosaRefTensorHandle::CopyInFrom(const void* src)
+{
+ void *dest = GetPointer();
+ ARMNN_ASSERT(dest);
+ memcpy(dest, src, m_TensorInfo.GetNumBytes());
+}
+
+bool TosaRefTensorHandle::Import(void* memory, MemorySource source)
+{
+ if (m_ImportFlags & static_cast<MemorySourceFlags>(source))
+ {
+ if (m_IsImportEnabled && source == MemorySource::Malloc)
+ {
+ // Check memory alignment
+ if(!CanBeImported(memory, source))
+ {
+ if (m_Imported)
+ {
+ m_Imported = false;
+ m_UnmanagedMemory = nullptr;
+ }
+ return false;
+ }
+
+ // m_UnmanagedMemory not yet allocated.
+ if (!m_Imported && !m_UnmanagedMemory)
+ {
+ m_UnmanagedMemory = memory;
+ m_Imported = true;
+ return true;
+ }
+
+ // m_UnmanagedMemory initially allocated with Allocate().
+ if (!m_Imported && m_UnmanagedMemory)
+ {
+ return false;
+ }
+
+ // m_UnmanagedMemory previously imported.
+ if (m_Imported)
+ {
+ m_UnmanagedMemory = memory;
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+bool TosaRefTensorHandle::CanBeImported(void* memory, MemorySource source)
+{
+ if (m_ImportFlags & static_cast<MemorySourceFlags>(source))
+ {
+ if (m_IsImportEnabled && source == MemorySource::Malloc)
+ {
+ uintptr_t alignment = GetDataTypeSize(m_TensorInfo.GetDataType());
+ if (reinterpret_cast<uintptr_t>(memory) % alignment)
+ {
+ return false;
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+}
diff --git a/src/backends/tosaReference/TosaRefTensorHandle.hpp b/src/backends/tosaReference/TosaRefTensorHandle.hpp
new file mode 100644
index 0000000..431d56b
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefTensorHandle.hpp
@@ -0,0 +1,82 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <armnn/backends/TensorHandle.hpp>
+
+#include "TosaRefMemoryManager.hpp"
+
+namespace armnn
+{
+
+// An implementation of ITensorHandle with simple "bump the pointer" memory-management behaviour
+class TosaRefTensorHandle : public ITensorHandle
+{
+public:
+ TosaRefTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<TosaRefMemoryManager> &memoryManager);
+
+ TosaRefTensorHandle(const TensorInfo& tensorInfo, MemorySourceFlags importFlags);
+
+ ~TosaRefTensorHandle();
+
+ virtual void Manage() override;
+
+ virtual void Allocate() override;
+
+ virtual ITensorHandle* GetParent() const override
+ {
+ return nullptr;
+ }
+
+ virtual const void* Map(bool /* blocking = true */) const override;
+ using ITensorHandle::Map;
+
+ virtual void Unmap() const override
+ {}
+
+ TensorShape GetStrides() const override
+ {
+ return GetUnpaddedTensorStrides(m_TensorInfo);
+ }
+
+ TensorShape GetShape() const override
+ {
+ return m_TensorInfo.GetShape();
+ }
+
+ const TensorInfo& GetTensorInfo() const
+ {
+ return m_TensorInfo;
+ }
+
+ virtual MemorySourceFlags GetImportFlags() const override
+ {
+ return m_ImportFlags;
+ }
+
+ virtual bool Import(void* memory, MemorySource source) override;
+ virtual bool CanBeImported(void* memory, MemorySource source) override;
+
+private:
+ // Only used for testing
+ void CopyOutTo(void*) const override;
+ void CopyInFrom(const void*) override;
+
+ void* GetPointer() const;
+
+ TosaRefTensorHandle(const TosaRefTensorHandle& other) = delete; // noncopyable
+ TosaRefTensorHandle& operator=(const TosaRefTensorHandle& other) = delete; //noncopyable
+
+ TensorInfo m_TensorInfo;
+
+ std::shared_ptr<TosaRefMemoryManager> m_MemoryManager;
+ TosaRefMemoryManager::Pool* m_Pool;
+ mutable void* m_UnmanagedMemory;
+ MemorySourceFlags m_ImportFlags;
+ bool m_Imported;
+ bool m_IsImportEnabled;
+};
+
+}
diff --git a/src/backends/tosaReference/TosaRefTensorHandleFactory.cpp b/src/backends/tosaReference/TosaRefTensorHandleFactory.cpp
new file mode 100644
index 0000000..62ada6f
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefTensorHandleFactory.cpp
@@ -0,0 +1,91 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "TosaRefTensorHandleFactory.hpp"
+#include "TosaRefTensorHandle.hpp"
+
+#include <armnn/utility/IgnoreUnused.hpp>
+
+namespace armnn
+{
+
+using FactoryId = ITensorHandleFactory::FactoryId;
+
+const FactoryId& TosaRefTensorHandleFactory::GetIdStatic()
+{
+ static const FactoryId s_Id(TosaRefTensorHandleFactoryId());
+ return s_Id;
+}
+
+std::unique_ptr<ITensorHandle> TosaRefTensorHandleFactory::CreateSubTensorHandle(ITensorHandle& parent,
+ const TensorShape& subTensorShape,
+ const unsigned int* subTensorOrigin)
+ const
+{
+ IgnoreUnused(parent, subTensorShape, subTensorOrigin);
+ return nullptr;
+}
+
+std::unique_ptr<ITensorHandle> TosaRefTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const
+{
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_MemoryManager);
+}
+
+std::unique_ptr<ITensorHandle> TosaRefTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
+ DataLayout dataLayout) const
+{
+ IgnoreUnused(dataLayout);
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_MemoryManager);
+}
+
+std::unique_ptr<ITensorHandle> TosaRefTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
+ const bool IsMemoryManaged) const
+{
+ if (IsMemoryManaged)
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_MemoryManager);
+ }
+ else
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_ImportFlags);
+ }
+}
+
+std::unique_ptr<ITensorHandle> TosaRefTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
+ DataLayout dataLayout,
+ const bool IsMemoryManaged) const
+{
+ IgnoreUnused(dataLayout);
+ if (IsMemoryManaged)
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_MemoryManager);
+ }
+ else
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_ImportFlags);
+ }
+}
+
+const FactoryId& TosaRefTensorHandleFactory::GetId() const
+{
+ return GetIdStatic();
+}
+
+bool TosaRefTensorHandleFactory::SupportsSubTensors() const
+{
+ return false;
+}
+
+MemorySourceFlags TosaRefTensorHandleFactory::GetExportFlags() const
+{
+ return m_ExportFlags;
+}
+
+MemorySourceFlags TosaRefTensorHandleFactory::GetImportFlags() const
+{
+ return m_ImportFlags;
+}
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/tosaReference/TosaRefTensorHandleFactory.hpp b/src/backends/tosaReference/TosaRefTensorHandleFactory.hpp
new file mode 100644
index 0000000..17dd1d4
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefTensorHandleFactory.hpp
@@ -0,0 +1,61 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaRefMemoryManager.hpp"
+
+#include <armnn/backends/ITensorHandleFactory.hpp>
+
+namespace armnn
+{
+
+constexpr const char * TosaRefTensorHandleFactoryId() { return "Arm/TosaRef/TensorHandleFactory"; }
+
+class TosaRefTensorHandleFactory : public ITensorHandleFactory
+{
+
+public:
+ TosaRefTensorHandleFactory(std::shared_ptr<TosaRefMemoryManager> mgr)
+ : m_MemoryManager(mgr)
+ , m_ImportFlags(static_cast<MemorySourceFlags>(MemorySource::Malloc))
+ , m_ExportFlags(static_cast<MemorySourceFlags>(MemorySource::Malloc))
+ {}
+
+ std::unique_ptr<ITensorHandle> CreateSubTensorHandle(ITensorHandle& parent,
+ TensorShape const& subTensorShape,
+ unsigned int const* subTensorOrigin) const override;
+
+ std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo) const override;
+
+ std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
+ DataLayout dataLayout) const override;
+
+ std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
+ const bool IsMemoryManaged) const override;
+
+ std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
+ DataLayout dataLayout,
+ const bool IsMemoryManaged) const override;
+
+ static const FactoryId& GetIdStatic();
+
+ const FactoryId& GetId() const override;
+
+ bool SupportsSubTensors() const override;
+
+ MemorySourceFlags GetExportFlags() const override;
+
+ MemorySourceFlags GetImportFlags() const override;
+
+private:
+ mutable std::shared_ptr<TosaRefMemoryManager> m_MemoryManager;
+ MemorySourceFlags m_ImportFlags;
+ MemorySourceFlags m_ExportFlags;
+
+};
+
+} // namespace armnn
+
diff --git a/src/backends/tosaReference/TosaRefWorkloadFactory.cpp b/src/backends/tosaReference/TosaRefWorkloadFactory.cpp
new file mode 100644
index 0000000..e6b5f9e
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefWorkloadFactory.cpp
@@ -0,0 +1,126 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include <Layer.hpp>
+#include <armnn/backends/MemCopyWorkload.hpp>
+#include <backendsCommon/MemImportWorkload.hpp>
+#include <backendsCommon/MakeWorkloadHelper.hpp>
+#include <armnn/backends/TensorHandle.hpp>
+#include "TosaRefWorkloadFactory.hpp"
+#include "TosaRefBackendId.hpp"
+#include "workloads/TosaRefWorkloads.hpp"
+#include "TosaRefTensorHandle.hpp"
+#include "TosaRefWorkloadFactory.hpp"
+
+
+namespace armnn
+{
+
+namespace
+{
+static const BackendId s_Id{TosaRefBackendId()};
+}
+template <typename F32Workload, typename U8Workload, typename QueueDescriptorType>
+std::unique_ptr<IWorkload> TosaRefWorkloadFactory::MakeWorkload(const QueueDescriptorType& descriptor,
+ const WorkloadInfo& info) const
+{
+ return MakeWorkloadHelper<NullWorkload, F32Workload, U8Workload, NullWorkload, NullWorkload, NullWorkload>
+ (descriptor, info);
+}
+
+template <DataType ArmnnType>
+bool IsDataType(const WorkloadInfo& info)
+{
+ auto checkType = [](const TensorInfo& tensorInfo) {return tensorInfo.GetDataType() == ArmnnType;};
+ auto it = std::find_if(std::begin(info.m_InputTensorInfos), std::end(info.m_InputTensorInfos), checkType);
+ if (it != std::end(info.m_InputTensorInfos))
+ {
+ return true;
+ }
+ it = std::find_if(std::begin(info.m_OutputTensorInfos), std::end(info.m_OutputTensorInfos), checkType);
+ if (it != std::end(info.m_OutputTensorInfos))
+ {
+ return true;
+ }
+ return false;
+}
+
+TosaRefWorkloadFactory::TosaRefWorkloadFactory(const std::shared_ptr<TosaRefMemoryManager>& memoryManager)
+ : m_MemoryManager(memoryManager)
+{
+}
+
+TosaRefWorkloadFactory::TosaRefWorkloadFactory()
+ : m_MemoryManager(new TosaRefMemoryManager())
+{
+}
+
+const BackendId& TosaRefWorkloadFactory::GetBackendId() const
+{
+ return s_Id;
+}
+
+bool TosaRefWorkloadFactory::IsLayerSupported(const Layer& layer,
+ Optional<DataType> dataType,
+ std::string& outReasonIfUnsupported)
+{
+ return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
+}
+
+bool TosaRefWorkloadFactory::IsLayerSupported(const IConnectableLayer& layer,
+ Optional<DataType> dataType,
+ std::string& outReasonIfUnsupported,
+ const ModelOptions& modelOptions)
+{
+ return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported, modelOptions);
+}
+
+std::unique_ptr<ITensorHandle> TosaRefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
+ const bool isMemoryManaged) const
+{
+ if (isMemoryManaged)
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_MemoryManager);
+ }
+ else
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, static_cast<unsigned int>(MemorySource::Malloc));
+ }
+}
+
+std::unique_ptr<ITensorHandle> TosaRefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
+ DataLayout dataLayout,
+ const bool isMemoryManaged) const
+{
+ // For TosaRef it is okay to make the TensorHandle memory managed as it can also store a pointer
+ // to unmanaged memory. This also ensures memory alignment.
+ IgnoreUnused(isMemoryManaged, dataLayout);
+
+ if (isMemoryManaged)
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, m_MemoryManager);
+ }
+ else
+ {
+ return std::make_unique<TosaRefTensorHandle>(tensorInfo, static_cast<unsigned int>(MemorySource::Malloc));
+ }
+}
+
+std::unique_ptr<IWorkload> TosaRefWorkloadFactory::CreateWorkload(LayerType type,
+ const QueueDescriptor& descriptor,
+ const WorkloadInfo& info) const
+{
+ switch(type)
+ {
+ case LayerType::PreCompiled:
+ {
+ auto precompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
+ return std::make_unique<TosaRefPreCompiledWorkload>(*precompiledQueueDescriptor, info);
+ }
+ default:
+ return nullptr;
+ }
+}
+
+} // namespace armnn
diff --git a/src/backends/tosaReference/TosaRefWorkloadFactory.hpp b/src/backends/tosaReference/TosaRefWorkloadFactory.hpp
new file mode 100644
index 0000000..1a5c1f2
--- /dev/null
+++ b/src/backends/tosaReference/TosaRefWorkloadFactory.hpp
@@ -0,0 +1,68 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "TosaRefMemoryManager.hpp"
+
+#include <armnn/Optional.hpp>
+#include <armnn/backends/WorkloadFactory.hpp>
+#include <armnn/utility/IgnoreUnused.hpp>
+
+
+namespace armnn
+{
+
+// Reference workload factory.
+class TosaRefWorkloadFactory : public IWorkloadFactory
+{
+public:
+ explicit TosaRefWorkloadFactory(const std::shared_ptr<TosaRefMemoryManager>& memoryManager);
+ TosaRefWorkloadFactory();
+
+ ~TosaRefWorkloadFactory() {}
+
+ const BackendId& GetBackendId() const override;
+
+ static bool IsLayerSupported(const Layer& layer,
+ Optional<DataType> dataType,
+ std::string& outReasonIfUnsupported);
+
+ static bool IsLayerSupported(const IConnectableLayer& layer,
+ Optional<DataType> dataType,
+ std::string& outReasonIfUnsupported,
+ const ModelOptions& modelOptions);
+
+ bool SupportsSubTensors() const override { return false; }
+
+ ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateSubTensorHandle instead")
+ std::unique_ptr<ITensorHandle> CreateSubTensorHandle(ITensorHandle& parent,
+ TensorShape const& subTensorShape,
+ unsigned int const* subTensorOrigin) const override
+ {
+ IgnoreUnused(parent, subTensorShape, subTensorOrigin);
+ return nullptr;
+ }
+
+ ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateTensorHandle instead")
+ std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
+ const bool IsMemoryManaged = true) const override;
+
+ ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateTensorHandle instead")
+ std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
+ DataLayout dataLayout,
+ const bool IsMemoryManaged = true) const override;
+
+ std::unique_ptr<IWorkload> CreateWorkload(LayerType type,
+ const QueueDescriptor& descriptor,
+ const WorkloadInfo& info) const override;
+
+private:
+ template <typename F32Workload, typename U8Workload, typename QueueDescriptorType>
+ std::unique_ptr<IWorkload> MakeWorkload(const QueueDescriptorType& descriptor, const WorkloadInfo& info) const;
+
+ mutable std::shared_ptr<TosaRefMemoryManager> m_MemoryManager;
+};
+
+} // namespace armnn
diff --git a/src/backends/tosaReference/backend.cmake b/src/backends/tosaReference/backend.cmake
new file mode 100644
index 0000000..2867b20
--- /dev/null
+++ b/src/backends/tosaReference/backend.cmake
@@ -0,0 +1,14 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/tosaReference)
+list(APPEND armnnLibraries armnnTosaRefBackend)
+
+if(ARMNNTOSAREF)
+ list(APPEND armnnLibraries armnnTosaRefBackendWorkloads)
+ list(APPEND armnnUnitTestLibraries armnnTosaRefBackendUnitTests)
+else()
+ message(STATUS "TOSA Reference backend is disabled")
+endif()
diff --git a/src/backends/tosaReference/backend.mk b/src/backends/tosaReference/backend.mk
new file mode 100644
index 0000000..d552a6a
--- /dev/null
+++ b/src/backends/tosaReference/backend.mk
@@ -0,0 +1,56 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+# BACKEND_SOURCES contains the list of files to be included
+# in the Android build and it is picked up by the Android.mk
+# file in the root of ArmNN
+
+# The variable to enable/disable the TOSA Reference backend
+# (ARMNN_TOSA_REF_ENABLED is declared in android-nn-driver/Android.mk)
+ifeq ($(ARMNN_TOSA_REF_ENABLED),1)
+
+# ARMNN_TOSA_REF_ENABLED == 1
+# Include the source files for the TOSA reference backend
+
+BACKEND_SOURCES := \
+ TosaRefBackend.cpp \
+ TosaRefLayerSupport.cpp \
+ TosaRefMemoryManager.cpp \
+ TosaRefRegistryInitializer.cpp \
+ TosaRefTensorHandle.cpp \
+ TosaRefTensorHandleFactory.cpp \
+ TosaRefWorkloadFactory.cpp \
+ workloads/TosaRefPreCompiledWorkload.cpp
+else
+
+# ARMNN_TOSA_REF_ENABLED == 0
+# No source file will be compiled for the reference backend
+
+BACKEND_SOURCES :=
+
+endif
+
+# BACKEND_TEST_SOURCES contains the list of files to be included
+# in the Android unit test build (armnn-tests) and it is picked
+# up by the Android.mk file in the root of ArmNN
+
+# The variable to enable/disable the TOSA Reference backend
+# (ARMNN_TOSA_REF_ENABLED is declared in android-nn-driver/Android.mk)
+ifeq ($(ARMNN_TOSA_REF_ENABLED),1)
+
+# ARMNN_TOSA_REF_ENABLED == 1
+# Include the source files for the TOSA Reference backend tests
+
+BACKEND_TEST_SOURCES := \
+ test/TosaRefLayerSupportTests.cpp \
+ test/TosaRefLayerTests.cpp
+else
+
+# ARMNN_TOSA_REF_ENABLED == 0
+# No source file will be compiled for the TOSA reference backend tests
+
+BACKEND_TEST_SOURCES :=
+
+endif
diff --git a/src/backends/tosaReference/test/CMakeLists.txt b/src/backends/tosaReference/test/CMakeLists.txt
new file mode 100644
index 0000000..8366901
--- /dev/null
+++ b/src/backends/tosaReference/test/CMakeLists.txt
@@ -0,0 +1,16 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+list(APPEND armnnTosaRefBackendUnitTests_sources
+ TosaRefLayerTests.cpp
+ TosaRefLayerSupportTests.cpp
+)
+
+add_library(armnnTosaRefBackendUnitTests OBJECT ${armnnTosaRefBackendUnitTests_sources})
+target_include_directories(armnnTosaRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnTosaRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnTosaRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnTestUtils)
+target_include_directories(armnnTosaRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
+target_include_directories(armnnTosaRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/third-party/doctest)
diff --git a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
new file mode 100644
index 0000000..99f7fd2
--- /dev/null
+++ b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
@@ -0,0 +1,65 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+
+#include <armnn/Optional.hpp>
+#include <armnn/Types.hpp>
+#include <tosaReference/TosaRefLayerSupport.hpp>
+
+#include <doctest/doctest.h>
+
+#include <string>
+
+TEST_SUITE("TosaRefLayerSupported")
+{
+
+TEST_CASE("IsLayerSupportedTosaReferenceAddition")
+{
+ armnn::TensorShape shape0 = {1,1,3,4};
+ armnn::TensorShape shape1 = {4};
+ armnn::TensorShape outShape = {1,1,3,4};
+ armnn::TensorInfo in0(shape0, armnn::DataType::Float32);
+ armnn::TensorInfo in1(shape1, armnn::DataType::Float32);
+ armnn::TensorInfo out(outShape, armnn::DataType::Float32);
+
+ armnn::BaseDescriptor desc;
+ armnn::TosaRefLayerSupport supportChecker;
+ std::string reasonIfNotSupported;
+ auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Addition,
+ {in0, in1, out},
+ desc,
+ armnn::EmptyOptional(),
+ armnn::EmptyOptional(),
+ reasonIfNotSupported);
+
+ CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceAdditionUnsupported")
+{
+ armnn::TensorShape shape0 = {1,1,3,4};
+ armnn::TensorShape shape1 = {4};
+ armnn::TensorShape outShape = {1,1,3,4};
+ armnn::TensorInfo in0(shape0, armnn::DataType::Signed64);
+ armnn::TensorInfo in1(shape1, armnn::DataType::Signed64);
+ armnn::TensorInfo out(outShape, armnn::DataType::Signed64);
+
+ armnn::BaseDescriptor desc;
+ armnn::TosaRefLayerSupport supportChecker;
+ std::string reasonIfNotSupported;
+ auto supported = supportChecker.IsLayerSupported(armnn::LayerType::Addition,
+ {in0, in1, out},
+ desc,
+ armnn::EmptyOptional(),
+ armnn::EmptyOptional(),
+ reasonIfNotSupported);
+
+ CHECK(!supported);
+ REQUIRE(reasonIfNotSupported.find("TOSA Reference addition: Op_ADD_input0_") != std::string::npos);
+ REQUIRE(reasonIfNotSupported.find("TOSA Reference addition: Op_ADD_input1_") != std::string::npos);
+ REQUIRE(reasonIfNotSupported.find("TOSA Reference addition: Op_ADD_output0_") != std::string::npos);
+}
+
+}
diff --git a/src/backends/tosaReference/test/TosaRefLayerTests.cpp b/src/backends/tosaReference/test/TosaRefLayerTests.cpp
new file mode 100644
index 0000000..fc0a557
--- /dev/null
+++ b/src/backends/tosaReference/test/TosaRefLayerTests.cpp
@@ -0,0 +1,13 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "TosaRefWorkloadFactoryHelper.hpp"
+
+#include <backendsCommon/test/LayerTests.hpp>
+
+#include <tosaReference/TosaRefWorkloadFactory.hpp>
+
+#include <UnitTests.hpp>
+
diff --git a/src/backends/tosaReference/test/TosaRefWorkloadFactoryHelper.hpp b/src/backends/tosaReference/test/TosaRefWorkloadFactoryHelper.hpp
new file mode 100644
index 0000000..560192a
--- /dev/null
+++ b/src/backends/tosaReference/test/TosaRefWorkloadFactoryHelper.hpp
@@ -0,0 +1,46 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
+
+#include <armnn/utility/PolymorphicDowncast.hpp>
+
+#include <tosaReference/TosaRefBackend.hpp>
+#include <tosaReference/TosaRefWorkloadFactory.hpp>
+#include "tosaReference/TosaRefTensorHandleFactory.hpp"
+
+namespace
+{
+
+template<>
+struct WorkloadFactoryHelper<armnn::TosaRefWorkloadFactory>
+{
+ static armnn::IBackendInternal::IMemoryManagerSharedPtr GetMemoryManager()
+ {
+ armnn::TosaRefBackend backend;
+ return backend.CreateMemoryManager();
+ }
+
+ static armnn::TosaRefWorkloadFactory GetFactory(
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr)
+ {
+ IgnoreUnused(memoryManager);
+ return armnn::TosaRefWorkloadFactory();
+ }
+
+ static armnn::TosaRefTensorHandleFactory GetTensorHandleFactory(
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr)
+ {
+
+ return armnn::TosaRefTensorHandleFactory(
+ armnn::PolymorphicPointerDowncast<armnn::TosaRefMemoryManager>(memoryManager));
+ }
+};
+
+using TosaRefWorkloadFactoryHelper = WorkloadFactoryHelper<armnn::TosaRefWorkloadFactory>;
+
+} // anonymous namespace
diff --git a/src/backends/tosaReference/workloads/CMakeLists.txt b/src/backends/tosaReference/workloads/CMakeLists.txt
new file mode 100644
index 0000000..7b60c84
--- /dev/null
+++ b/src/backends/tosaReference/workloads/CMakeLists.txt
@@ -0,0 +1,18 @@
+#
+# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+list(APPEND armnnTosaRefBackendWorkloads_sources
+ TosaRefBaseWorkload.hpp
+ TosaRefPreCompiledWorkload.cpp
+ TosaRefPreCompiledWorkload.hpp
+)
+
+add_library(armnnTosaRefBackendWorkloads OBJECT ${armnnTosaRefBackendWorkloads_sources})
+target_include_directories(armnnTosaRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnTosaRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnTosaRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
+target_include_directories(armnnTosaRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/profiling)
+target_include_directories(armnnTosaRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/profiling/common/include)
+target_include_directories(armnnTosaRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/profiling/client/include)
diff --git a/src/backends/tosaReference/workloads/TosaRefBaseWorkload.hpp b/src/backends/tosaReference/workloads/TosaRefBaseWorkload.hpp
new file mode 100644
index 0000000..df82abb
--- /dev/null
+++ b/src/backends/tosaReference/workloads/TosaRefBaseWorkload.hpp
@@ -0,0 +1,39 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/backends/Workload.hpp>
+
+namespace armnn
+{
+
+template <typename QueueDescriptor>
+class TosaRefBaseWorkload : public BaseWorkload<QueueDescriptor>
+{
+public:
+ TosaRefBaseWorkload(const QueueDescriptor& descriptor, const WorkloadInfo& info)
+ : BaseWorkload<QueueDescriptor>(descriptor, info)
+ {}
+
+ virtual bool SupportsTensorHandleReplacement() const override
+ {
+ return true;
+ }
+
+ // Replace input tensor handle with the given TensorHandle
+ void ReplaceInputTensorHandle(ITensorHandle* tensorHandle, unsigned int slot) override
+ {
+ this->m_Data.m_Inputs[slot] = tensorHandle;
+ }
+
+ // Replace output tensor handle with the given TensorHandle
+ void ReplaceOutputTensorHandle(ITensorHandle* tensorHandle, unsigned int slot) override
+ {
+ this->m_Data.m_Outputs[slot] = tensorHandle;
+ }
+};
+
+} //namespace armnn
\ No newline at end of file
diff --git a/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp b/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp
new file mode 100644
index 0000000..c4af4d4
--- /dev/null
+++ b/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.cpp
@@ -0,0 +1,28 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "TosaRefPreCompiledWorkload.hpp"
+
+namespace armnn
+{
+
+TosaRefPreCompiledWorkload::TosaRefPreCompiledWorkload(const PreCompiledQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : BaseWorkload<PreCompiledQueueDescriptor>(descriptor, info)
+{
+ // Do nothing for now
+}
+
+void TosaRefPreCompiledWorkload::Execute() const
+{
+ // Do nothing for now
+}
+
+bool TosaRefPreCompiledWorkloadValidate(std::string*)
+{
+ return true;
+}
+
+} //namespace armnn
diff --git a/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.hpp b/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.hpp
new file mode 100644
index 0000000..3097269
--- /dev/null
+++ b/src/backends/tosaReference/workloads/TosaRefPreCompiledWorkload.hpp
@@ -0,0 +1,43 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "armnn/backends/Workload.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace armnn
+{
+
+bool TosaRefPreCompiledWorkloadValidate(std::string* reasonIfUnsupported);
+
+class TosaRefPreCompiledWorkload : public BaseWorkload<PreCompiledQueueDescriptor>
+{
+public:
+ TosaRefPreCompiledWorkload(const PreCompiledQueueDescriptor& descriptor,
+ const WorkloadInfo& info);
+ void Execute() const override;
+
+private:
+ bool SupportsTensorHandleReplacement() const override
+ {
+ return true;
+ }
+
+ void ReplaceInputTensorHandle(ITensorHandle* tensorHandle, unsigned int slot) override
+ {
+ this->m_Data.m_Inputs[slot] = tensorHandle;
+ }
+
+ void ReplaceOutputTensorHandle(ITensorHandle* tensorHandle, unsigned int slot) override
+ {
+ this->m_Data.m_Outputs[slot] = tensorHandle;
+ }
+};
+
+} //namespace armnn
diff --git a/src/backends/tosaReference/workloads/TosaRefWorkloads.hpp b/src/backends/tosaReference/workloads/TosaRefWorkloads.hpp
new file mode 100644
index 0000000..e7b4399
--- /dev/null
+++ b/src/backends/tosaReference/workloads/TosaRefWorkloads.hpp
@@ -0,0 +1,8 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaRefPreCompiledWorkload.hpp"