intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 09:09:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Context implementation (2/N)

Browse Source 
Add memory allocators.

Change-Id: Ie93d077e7a55b9c9c51c4a594a7db0c10f770091
Signed-off: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga
2020-07-22 10:40:20 -07:00
committed by sys_ocldev
parent 59ffe4ba4b
commit b011d76586
10 changed files with 698 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
level_zero/core/source/context/context.h
View File

@@ -24,6 +24,34 @@ struct Context : _ze_context_handle_t {
virtual ze_result_t destroy() = 0;
virtual ze_result_t getStatus() = 0;
virtual DriverHandle *getDriverHandle() = 0;
virtual ze_result_t allocHostMem(ze_host_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr) = 0;
virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
size_t size,
size_t alignment, void **ptr) = 0;
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
size_t size,
size_t alignment,
void **ptr) = 0;
virtual ze_result_t freeMem(const void *ptr) = 0;
virtual ze_result_t getMemAddressRange(const void *ptr,
void **pBase,
size_t *pSize) = 0;
virtual ze_result_t closeIpcMemHandle(const void *ptr) = 0;
virtual ze_result_t getIpcMemHandle(const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) = 0;
virtual ze_result_t openIpcMemHandle(ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **ptr) = 0;
virtual ze_result_t getMemAllocProperties(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) = 0;
static Context *fromHandle(ze_context_handle_t handle) { return static_cast<Context *>(handle); }
inline ze_context_handle_t toHandle() { return this; }

84
level_zero/core/source/context/context_imp.cpp
View File

@@ -27,4 +27,88 @@ ContextImp::ContextImp(DriverHandle *driverHandle) {
this->driverHandle = driverHandle;
}
ze_result_t ContextImp::allocHostMem(ze_host_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->allocHostMem(flags,
size,
alignment,
ptr);
}
ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
size_t size,
size_t alignment, void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->allocDeviceMem(hDevice,
flags,
size,
alignment,
ptr);
}
ze_result_t ContextImp::allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
size_t size,
size_t alignment,
void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->allocSharedMem(hDevice,
deviceFlags,
hostFlags,
size,
alignment,
ptr);
}
ze_result_t ContextImp::freeMem(const void *ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->freeMem(ptr);
}
ze_result_t ContextImp::getMemAddressRange(const void *ptr,
void **pBase,
size_t *pSize) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->getMemAddressRange(ptr,
pBase,
pSize);
}
ze_result_t ContextImp::closeIpcMemHandle(const void *ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->closeIpcMemHandle(ptr);
}
ze_result_t ContextImp::getIpcMemHandle(const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->getIpcMemHandle(ptr,
pIpcHandle);
}
ze_result_t ContextImp::openIpcMemHandle(ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->openIpcMemHandle(hDevice,
handle,
ZE_IPC_MEMORY_FLAG_NONE,
ptr);
}
ze_result_t ContextImp::getMemAllocProperties(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->getMemAllocProperties(ptr,
pMemAllocProperties,
phDevice);
}
} // namespace L0

28
level_zero/core/source/context/context_imp.h
View File

@@ -18,6 +18,34 @@ struct ContextImp : Context {
ze_result_t destroy() override;
ze_result_t getStatus() override;
DriverHandle *getDriverHandle() override;
ze_result_t allocHostMem(ze_host_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr) override;
ze_result_t allocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
size_t size,
size_t alignment, void **ptr) override;
ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
size_t size,
size_t alignment,
void **ptr) override;
ze_result_t freeMem(const void *ptr) override;
ze_result_t getMemAddressRange(const void *ptr,
void **pBase,
size_t *pSize) override;
ze_result_t closeIpcMemHandle(const void *ptr) override;
ze_result_t getIpcMemHandle(const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) override;
ze_result_t openIpcMemHandle(ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **ptr) override;
ze_result_t getMemAllocProperties(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) override;
protected:
DriverHandle *driverHandle = nullptr;

20
level_zero/core/test/unit_tests/fixtures/device_fixture.h
View File

@@ -12,6 +12,7 @@
#include "shared/test/unit_test/helpers/default_hw_info.h"
#include "shared/test/unit_test/mocks/mock_device.h"
#include "level_zero/core/test/unit_tests/mocks/mock_context.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
@@ -53,5 +54,24 @@ struct MultiDeviceFixture {
const uint32_t numRootDevices = 4u;
};
struct ContextFixture : DeviceFixture {
void SetUp() override {
DeviceFixture::SetUp();
ze_context_handle_t hContext = {};
ze_context_desc_t desc;
ze_result_t res = driverHandle->createContext(&desc, &hContext);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, hContext);
context = L0::Context::fromHandle(hContext);
}
void TearDown() override {
context->destroy();
DeviceFixture::TearDown();
}
L0::Context *context = nullptr;
};
} // namespace ult
} // namespace L0

56
level_zero/core/test/unit_tests/mocks/mock_context.h
View File

@@ -37,6 +37,62 @@ struct Mock<Context> : public Context {
getDriverHandle,
(),
(override));
MOCK_METHOD(ze_result_t,
allocHostMem,
(ze_host_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
allocDeviceMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
allocSharedMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
size_t size,
size_t alignment,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
freeMem,
(const void *ptr),
(override));
MOCK_METHOD(ze_result_t,
getMemAllocProperties,
(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice),
(override));
MOCK_METHOD(ze_result_t,
getMemAddressRange,
(const void *ptr,
void **pBase,
size_t *pSize),
(override));
MOCK_METHOD(ze_result_t,
getIpcMemHandle,
(const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle),
(override));
MOCK_METHOD(ze_result_t,
closeIpcMemHandle,
(const void *ptr),
(override));
MOCK_METHOD(ze_result_t,
openIpcMemHandle,
(ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **ptr),
(override));
};
} // namespace ult

9
level_zero/core/test/unit_tests/mocks/mock_driver_handle.h
View File

@@ -112,6 +112,15 @@ struct Mock<DriverHandle> : public DriverHandleImp {
size_t alignment,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
allocSharedMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
size_t size,
size_t alignment,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
freeMem,
(const void *ptr),

2
level_zero/core/test/unit_tests/sources/context/test_context.cpp
View File

@@ -24,7 +24,7 @@ TEST_F(ContextTest, givenCallToContextGetStatusThenUnsupportedIsReturned) {
ze_result_t res = driverHandle->createContext(&desc, &hContext);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
Context *context = L0::Context::fromHandle(hContext);
L0::Context *context = L0::Context::fromHandle(hContext);
res = context->getStatus();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, res);

85
level_zero/core/test/unit_tests/sources/memory/test_memory.cpp
View File

@@ -347,5 +347,90 @@ TEST_F(AllocHostMemoryTest,
EXPECT_EQ(nullptr, ptr);
}
using ContextMemoryTest = Test<ContextFixture>;
TEST_F(ContextMemoryTest, whenAllocatingSharedAllocationFromContextThenAllocationSucceeds) {
size_t size = 10u;
size_t alignment = 1u;
void *ptr = nullptr;
ze_result_t result = context->allocSharedMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
result = context->freeMem(ptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(ContextMemoryTest, whenAllocatingHostAllocationFromContextThenAllocationSucceeds) {
size_t size = 10u;
size_t alignment = 1u;
void *ptr = nullptr;
ze_result_t result = context->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
result = context->freeMem(ptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(ContextMemoryTest, whenAllocatingDeviceAllocationFromContextThenAllocationSucceeds) {
size_t size = 10u;
size_t alignment = 1u;
void *ptr = nullptr;
ze_result_t result = context->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
result = context->freeMem(ptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(ContextMemoryTest, whenRetrievingAddressRangeForDeviceAllocationThenRangeIsCorrect) {
size_t allocSize = 4096u;
size_t alignment = 1u;
void *allocPtr = nullptr;
ze_result_t result = context->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
allocSize, alignment, &allocPtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, allocPtr);
void *base = nullptr;
size_t size = 0u;
void *pPtr = reinterpret_cast<void *>(reinterpret_cast<uint64_t>(allocPtr) + 77);
result = context->getMemAddressRange(pPtr, &base, &size);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(base, allocPtr);
EXPECT_GE(size, allocSize);
result = context->freeMem(allocPtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(ContextMemoryTest, givenSystemAllocatedPointerThenGetAllocPropertiesReturnsUnknownType) {
size_t size = 10;
int *ptr = new int[size];
ze_memory_allocation_properties_t memoryProperties = {};
memoryProperties.version = ZE_MEMORY_ALLOCATION_PROPERTIES_VERSION_CURRENT;
ze_device_handle_t deviceHandle;
ze_result_t result = context->getMemAllocProperties(ptr, &memoryProperties, &deviceHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(memoryProperties.type, ZE_MEMORY_TYPE_UNKNOWN);
delete[] ptr;
}
} // namespace ult
} // namespace L0