diff options
Diffstat (limited to 'src')
| -rwxr-xr-x | src/armnnTestUtils/CMakeLists.txt | 9 | ||||
| -rw-r--r-- | src/armnnTestUtils/MockBackend.cpp | 55 | ||||
| -rw-r--r-- | src/armnnTestUtils/MockMemoryManager.cpp | 93 | ||||
| -rw-r--r-- | src/armnnTestUtils/MockTensorHandle.cpp | 176 | ||||
| -rw-r--r-- | src/armnnTestUtils/MockTensorHandleFactory.cpp | 87 | ||||
| -rw-r--r-- | src/armnnTestUtils/MockTensorHandleFactory.hpp | 61 | ||||
| -rw-r--r-- | src/armnnTestUtils/MockWorkloadFactoryHelper.hpp | 41 |
7 files changed, 522 insertions, 0 deletions
diff --git a/src/armnnTestUtils/CMakeLists.txt b/src/armnnTestUtils/CMakeLists.txt index fae745256f..cab0ba353e 100755 --- a/src/armnnTestUtils/CMakeLists.txt +++ b/src/armnnTestUtils/CMakeLists.txt @@ -8,6 +8,9 @@ set(armnnTestUtils_sources) list(APPEND armnnTestUtils_sources ../../include/armnnTestUtils/DataLayoutUtils.hpp ../../include/armnnTestUtils/LayerTestResult.hpp + ../../include/armnnTestUtils/MockBackend.hpp + ../../include/armnnTestUtils/MockMemoryManager.hpp + ../../include/armnnTestUtils/MockTensorHandle.hpp ../../include/armnnTestUtils/PredicateResult.hpp ../../include/armnnTestUtils/TensorCopyUtils.hpp ../../include/armnnTestUtils/WorkloadTestUtils.hpp @@ -18,6 +21,12 @@ list(APPEND armnnTestUtils_sources DataTypeUtils.hpp GraphUtils.cpp GraphUtils.hpp + MockBackend.cpp + MockMemoryManager.cpp + MockTensorHandle.cpp + MockTensorHandleFactory.hpp + MockTensorHandleFactory.cpp + MockWorkloadFactoryHelper.hpp TensorCopyUtils.cpp TestUtils.cpp TestUtils.hpp diff --git a/src/armnnTestUtils/MockBackend.cpp b/src/armnnTestUtils/MockBackend.cpp new file mode 100644 index 0000000000..40f97cd28e --- /dev/null +++ b/src/armnnTestUtils/MockBackend.cpp @@ -0,0 +1,55 @@ +// +// Copyright © 2022 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include <armnn/backends/MemCopyWorkload.hpp> +#include <armnnTestUtils/MockBackend.hpp> +#include <armnnTestUtils/MockTensorHandle.hpp> + +namespace armnn +{ + +constexpr const char* MockBackendId() +{ + return "CpuMock"; +} + +namespace +{ +static const BackendId s_Id{ MockBackendId() }; +} + +MockWorkloadFactory::MockWorkloadFactory(const std::shared_ptr<MockMemoryManager>& memoryManager) + : m_MemoryManager(memoryManager) +{} + +MockWorkloadFactory::MockWorkloadFactory() + : m_MemoryManager(new MockMemoryManager()) +{} + +const BackendId& MockWorkloadFactory::GetBackendId() const +{ + return s_Id; +} + +std::unique_ptr<IWorkload> MockWorkloadFactory::CreateWorkload(LayerType type, + const QueueDescriptor& descriptor, + const WorkloadInfo& info) const +{ + switch (type) + { + case LayerType::MemCopy: { + auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor); + if (descriptor.m_Inputs.empty()) + { + throw InvalidArgumentException("MockWorkloadFactory: CreateMemCopy() expected an input tensor."); + } + return std::make_unique<CopyMemGenericWorkload>(*memCopyQueueDescriptor, info); + } + default: + return nullptr; + } +} + +} // namespace armnn
\ No newline at end of file diff --git a/src/armnnTestUtils/MockMemoryManager.cpp b/src/armnnTestUtils/MockMemoryManager.cpp new file mode 100644 index 0000000000..3ff6ec85d9 --- /dev/null +++ b/src/armnnTestUtils/MockMemoryManager.cpp @@ -0,0 +1,93 @@ +// +// Copyright © 2022 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "armnnTestUtils/MockMemoryManager.hpp" + +namespace armnn +{ + +MockMemoryManager::MockMemoryManager() +{} + +MockMemoryManager::~MockMemoryManager() +{} + +MockMemoryManager::Pool* MockMemoryManager::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 MockMemoryManager::Allocate(MockMemoryManager::Pool* pool) +{ + m_FreePools.push_back(pool); +} + +void* MockMemoryManager::GetPointer(MockMemoryManager::Pool* pool) +{ + return pool->GetPointer(); +} + +void MockMemoryManager::Acquire() +{ + for (Pool& pool : m_Pools) + { + pool.Acquire(); + } +} + +void MockMemoryManager::Release() +{ + for (Pool& pool : m_Pools) + { + pool.Release(); + } +} + +MockMemoryManager::Pool::Pool(unsigned int numBytes) + : m_Size(numBytes) + , m_Pointer(nullptr) +{} + +MockMemoryManager::Pool::~Pool() +{ + if (m_Pointer) + { + Release(); + } +} + +void* MockMemoryManager::Pool::GetPointer() +{ + return m_Pointer; +} + +void MockMemoryManager::Pool::Reserve(unsigned int numBytes) +{ + m_Size = std::max(m_Size, numBytes); +} + +void MockMemoryManager::Pool::Acquire() +{ + m_Pointer = ::operator new(size_t(m_Size)); +} + +void MockMemoryManager::Pool::Release() +{ + ::operator delete(m_Pointer); + m_Pointer = nullptr; +} + +} // namespace armnn diff --git a/src/armnnTestUtils/MockTensorHandle.cpp b/src/armnnTestUtils/MockTensorHandle.cpp new file mode 100644 index 0000000000..be4d5a8d92 --- /dev/null +++ b/src/armnnTestUtils/MockTensorHandle.cpp @@ -0,0 +1,176 @@ +// +// Copyright © 2022 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "armnnTestUtils/MockTensorHandle.hpp" + +namespace armnn +{ + +MockTensorHandle::MockTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<MockMemoryManager>& 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) +{} + +MockTensorHandle::MockTensorHandle(const TensorInfo& tensorInfo, MemorySourceFlags importFlags) + : m_TensorInfo(tensorInfo) + , m_Pool(nullptr) + , m_UnmanagedMemory(nullptr) + , m_ImportFlags(importFlags) + , m_Imported(false) + , m_IsImportEnabled(true) +{} + +MockTensorHandle::~MockTensorHandle() +{ + if (!m_Pool) + { + // unmanaged + if (!m_Imported) + { + ::operator delete(m_UnmanagedMemory); + } + } +} + +void MockTensorHandle::Manage() +{ + if (!m_IsImportEnabled) + { + ARMNN_ASSERT_MSG(!m_Pool, "MockTensorHandle::Manage() called twice"); + ARMNN_ASSERT_MSG(!m_UnmanagedMemory, "MockTensorHandle::Manage() called after Allocate()"); + + m_Pool = m_MemoryManager->Manage(m_TensorInfo.GetNumBytes()); + } +} + +void MockTensorHandle::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("MockTensorHandle::Allocate Trying to allocate a MockTensorHandle" + "that already has allocated memory."); + } + } +} + +const void* MockTensorHandle::Map(bool /*unused*/) const +{ + return GetPointer(); +} + +void* MockTensorHandle::GetPointer() const +{ + if (m_UnmanagedMemory) + { + return m_UnmanagedMemory; + } + else if (m_Pool) + { + return m_MemoryManager->GetPointer(m_Pool); + } + else + { + throw NullPointerException("MockTensorHandle::GetPointer called on unmanaged, unallocated tensor handle"); + } +} + +void MockTensorHandle::CopyOutTo(void* dest) const +{ + const void* src = GetPointer(); + ARMNN_ASSERT(src); + memcpy(dest, src, m_TensorInfo.GetNumBytes()); +} + +void MockTensorHandle::CopyInFrom(const void* src) +{ + void* dest = GetPointer(); + ARMNN_ASSERT(dest); + memcpy(dest, src, m_TensorInfo.GetNumBytes()); +} + +bool MockTensorHandle::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 MockTensorHandle::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; +} + +} // namespace armnn diff --git a/src/armnnTestUtils/MockTensorHandleFactory.cpp b/src/armnnTestUtils/MockTensorHandleFactory.cpp new file mode 100644 index 0000000000..e90f318296 --- /dev/null +++ b/src/armnnTestUtils/MockTensorHandleFactory.cpp @@ -0,0 +1,87 @@ +// +// Copyright © 2022 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "MockTensorHandleFactory.hpp" +#include <armnnTestUtils/MockTensorHandle.hpp> + +namespace armnn +{ + +using FactoryId = ITensorHandleFactory::FactoryId; + +const FactoryId& MockTensorHandleFactory::GetIdStatic() +{ + static const FactoryId s_Id(MockTensorHandleFactoryId()); + return s_Id; +} + +std::unique_ptr<ITensorHandle> MockTensorHandleFactory::CreateSubTensorHandle(ITensorHandle&, + TensorShape const&, + unsigned int const*) const +{ + return nullptr; +} + +std::unique_ptr<ITensorHandle> MockTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const +{ + return std::make_unique<MockTensorHandle>(tensorInfo, m_MemoryManager); +} + +std::unique_ptr<ITensorHandle> MockTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo, + DataLayout dataLayout) const +{ + IgnoreUnused(dataLayout); + return std::make_unique<MockTensorHandle>(tensorInfo, m_MemoryManager); +} + +std::unique_ptr<ITensorHandle> MockTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo, + const bool IsMemoryManaged) const +{ + if (IsMemoryManaged) + { + return std::make_unique<MockTensorHandle>(tensorInfo, m_MemoryManager); + } + else + { + return std::make_unique<MockTensorHandle>(tensorInfo, m_ImportFlags); + } +} + +std::unique_ptr<ITensorHandle> MockTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo, + DataLayout dataLayout, + const bool IsMemoryManaged) const +{ + IgnoreUnused(dataLayout); + if (IsMemoryManaged) + { + return std::make_unique<MockTensorHandle>(tensorInfo, m_MemoryManager); + } + else + { + return std::make_unique<MockTensorHandle>(tensorInfo, m_ImportFlags); + } +} + +const FactoryId& MockTensorHandleFactory::GetId() const +{ + return GetIdStatic(); +} + +bool MockTensorHandleFactory::SupportsSubTensors() const +{ + return false; +} + +MemorySourceFlags MockTensorHandleFactory::GetExportFlags() const +{ + return m_ExportFlags; +} + +MemorySourceFlags MockTensorHandleFactory::GetImportFlags() const +{ + return m_ImportFlags; +} + +} // namespace armnn
\ No newline at end of file diff --git a/src/armnnTestUtils/MockTensorHandleFactory.hpp b/src/armnnTestUtils/MockTensorHandleFactory.hpp new file mode 100644 index 0000000000..ffe7c8bc97 --- /dev/null +++ b/src/armnnTestUtils/MockTensorHandleFactory.hpp @@ -0,0 +1,61 @@ +// +// Copyright © 2022 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include <armnn/backends/ITensorHandleFactory.hpp> +#include <armnnTestUtils/MockMemoryManager.hpp> + +namespace armnn +{ + +constexpr const char* MockTensorHandleFactoryId() +{ + return "Arm/Mock/TensorHandleFactory"; +} + +class MockTensorHandleFactory : public ITensorHandleFactory +{ + +public: + explicit MockTensorHandleFactory(std::shared_ptr<MockMemoryManager> 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<MockMemoryManager> m_MemoryManager; + MemorySourceFlags m_ImportFlags; + MemorySourceFlags m_ExportFlags; +}; + +} // namespace armnn diff --git a/src/armnnTestUtils/MockWorkloadFactoryHelper.hpp b/src/armnnTestUtils/MockWorkloadFactoryHelper.hpp new file mode 100644 index 0000000000..6b61cf6474 --- /dev/null +++ b/src/armnnTestUtils/MockWorkloadFactoryHelper.hpp @@ -0,0 +1,41 @@ +// +// Copyright © 2022 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include <MockTensorHandleFactory.hpp> +#include <armnnTestUtils/MockBackend.hpp> +#include <backendsCommon/test/WorkloadFactoryHelper.hpp> + +namespace +{ + +template <> +struct WorkloadFactoryHelper<armnn::MockWorkloadFactory> +{ + static armnn::IBackendInternal::IMemoryManagerSharedPtr GetMemoryManager() + { + armnn::MockBackend backend; + return backend.CreateMemoryManager(); + } + + static armnn::MockWorkloadFactory + GetFactory(const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr) + { + IgnoreUnused(memoryManager); + return armnn::MockWorkloadFactory(); + } + + static armnn::MockTensorHandleFactory + GetTensorHandleFactory(const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr) + { + + return armnn::MockTensorHandleFactory(std::static_pointer_cast<armnn::MockMemoryManager>(memoryManager)); + } +}; + +using MockWorkloadFactoryHelper = WorkloadFactoryHelper<armnn::MockWorkloadFactory>; + +} // anonymous namespace |