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

Correctly pass descriptors to L0 shared alloc function

Browse Source 
Signed-off-by: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga
2020-11-10 17:23:14 -08:00
committed by Compute-Runtime-Automation
parent 9473abc86a
commit 3f6d1f5ee9
11 changed files with 51 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/api/core/ze_memory.cpp
View File

@@ -17,7 +17,7 @@ zeMemAllocShared(
size_t alignment, size_t alignment,
ze_device_handle_t hDevice, ze_device_handle_t hDevice,
void **pptr) { void **pptr) {
return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc->flags, hostDesc->flags, size, alignment, pptr); return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc, hostDesc, size, alignment, pptr);
} }
ZE_APIEXPORT ze_result_t ZE_APICALL ZE_APIEXPORT ze_result_t ZE_APICALL

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

@@ -32,8 +32,8 @@ struct Context : _ze_context_handle_t {
size_t size, size_t size,
size_t alignment, void **ptr) = 0; size_t alignment, void **ptr) = 0;
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flags_t deviceFlags, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size, size_t size,
size_t alignment, size_t alignment,
void **ptr) = 0; void **ptr) = 0;

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

@@ -64,15 +64,15 @@ ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
} }
ze_result_t ContextImp::allocSharedMem(ze_device_handle_t hDevice, ze_result_t ContextImp::allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flags_t deviceFlags, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size, size_t size,
size_t alignment, size_t alignment,
void **ptr) { void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle); DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->allocSharedMem(hDevice, return this->driverHandle->allocSharedMem(hDevice,
deviceFlags, deviceDesc,
hostFlags, hostDesc,
size, size,
alignment, alignment,
ptr); ptr);

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

@@ -27,8 +27,8 @@ struct ContextImp : Context {
size_t size, size_t size,
size_t alignment, void **ptr) override; size_t alignment, void **ptr) override;
ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flags_t deviceFlags, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size, size_t size,
size_t alignment, size_t alignment,
void **ptr) override; void **ptr) override;

6
level_zero/core/source/driver/driver_handle.h
View File

@@ -41,8 +41,10 @@ struct DriverHandle : _ze_driver_handle_t {
virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size, virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size,
size_t alignment, void **ptr) = 0; size_t alignment, void **ptr) = 0;
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags, virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **ptr) = 0; void **ptr) = 0;
virtual ze_result_t freeMem(const void *ptr) = 0; virtual ze_result_t freeMem(const void *ptr) = 0;
virtual NEO::MemoryManager *getMemoryManager() = 0; virtual NEO::MemoryManager *getMemoryManager() = 0;

7
level_zero/core/source/driver/driver_handle_imp.h
View File

@@ -33,8 +33,11 @@ struct DriverHandleImp : public DriverHandle {
ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size, ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size,
size_t alignment, void **ptr) override; size_t alignment, void **ptr) override;
ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags, ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment, const ze_device_mem_alloc_desc_t *deviceDesc,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **ptr) override; void **ptr) override;
ze_result_t getMemAddressRange(const void *ptr, void **pBase, size_t *pSize) override; ze_result_t getMemAddressRange(const void *ptr, void **pBase, size_t *pSize) override;

6
level_zero/core/source/memory/memory.cpp
View File

@@ -139,8 +139,10 @@ ze_result_t DriverHandleImp::allocDeviceMem(ze_device_handle_t hDevice, const ze
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }
ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags, ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **ptr) { void **ptr) {
ze_device_handle_t device; ze_device_handle_t device;
void *unifiedMemoryPropertiesDevice = nullptr; void *unifiedMemoryPropertiesDevice = nullptr;

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

@@ -57,8 +57,8 @@ struct Mock<Context> : public Context {
MOCK_METHOD(ze_result_t, MOCK_METHOD(ze_result_t,
allocSharedMem, allocSharedMem,
(ze_device_handle_t hDevice, (ze_device_handle_t hDevice,
ze_device_mem_alloc_flags_t deviceFlags, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size, size_t size,
size_t alignment, size_t alignment,
void **ptr), void **ptr),

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

@@ -115,8 +115,8 @@ struct Mock<DriverHandle> : public DriverHandleImp {
MOCK_METHOD(ze_result_t, MOCK_METHOD(ze_result_t,
allocSharedMem, allocSharedMem,
(ze_device_handle_t hDevice, (ze_device_handle_t hDevice,
ze_device_mem_alloc_flags_t deviceFlags, const ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_flags_t hostFlags, const ze_host_mem_alloc_desc_t *hostDesc,
size_t size, size_t size,
size_t alignment, size_t alignment,
void **ptr), void **ptr),

4
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp
View File

@@ -488,7 +488,9 @@ HWTEST_F(CommandListDualStroage, givenIndirectDispatchWithSharedDualStorageMemor
std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, returnValue)); std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, returnValue));
void *alloc = nullptr; void *alloc = nullptr;
auto result = device->getDriverHandle()->allocSharedMem(device->toHandle(), 0u, 0u, 16384u, 4096u, &alloc); ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc = {};
auto result = device->getDriverHandle()->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &alloc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result); ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ze_group_count_t *pThreadGroupDimensions = static_cast<ze_group_count_t *>(ptrOffset(alloc, sizeof(ze_group_count_t))); ze_group_count_t *pThreadGroupDimensions = static_cast<ze_group_count_t *>(ptrOffset(alloc, sizeof(ze_group_count_t)));

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

@@ -61,9 +61,11 @@ TEST_F(MemoryTest, givenSharedPointerThenDriverGetAllocPropertiesReturnsDeviceHa
size_t alignment = 1u; size_t alignment = 1u;
void *ptr = nullptr; void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc = {};
ze_result_t result = driverHandle->allocSharedMem(device->toHandle(), ze_result_t result = driverHandle->allocSharedMem(device->toHandle(),
0u, &deviceDesc,
0u, &hostDesc,
size, alignment, &ptr); size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result); EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr); EXPECT_NE(nullptr, ptr);
@@ -125,9 +127,11 @@ TEST_F(MemoryTest, givenSharedPointerAndDeviceHandleAsNullThenDriverReturnsSucce
void *ptr = nullptr; void *ptr = nullptr;
ASSERT_NE(nullptr, device->toHandle()); ASSERT_NE(nullptr, device->toHandle());
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc = {};
ze_result_t result = driverHandle->allocSharedMem(nullptr, ze_result_t result = driverHandle->allocSharedMem(nullptr,
0u, &deviceDesc,
0u, &hostDesc,
size, alignment, &ptr); size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result); EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr); EXPECT_NE(nullptr, ptr);
@@ -142,9 +146,11 @@ TEST_F(MemoryTest, givenNoDeviceWhenAllocatingSharedMemoryThenDeviceInAllocation
void *ptr = nullptr; void *ptr = nullptr;
ASSERT_NE(nullptr, device->toHandle()); ASSERT_NE(nullptr, device->toHandle());
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc = {};
ze_result_t result = driverHandle->allocSharedMem(nullptr, ze_result_t result = driverHandle->allocSharedMem(nullptr,
0u, &deviceDesc,
0u, &hostDesc,
size, alignment, &ptr); size, alignment, &ptr);
auto alloc = driverHandle->svmAllocsManager->getSVMAlloc(ptr); auto alloc = driverHandle->svmAllocsManager->getSVMAlloc(ptr);
EXPECT_EQ(alloc->device, nullptr); EXPECT_EQ(alloc->device, nullptr);
@@ -227,9 +233,11 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
ASSERT_NE(nullptr, driverHandle->devices[1]->toHandle()); ASSERT_NE(nullptr, driverHandle->devices[1]->toHandle());
EXPECT_NE(neoDevice0->getDeviceBitfield(), neoDevice1->getDeviceBitfield()); EXPECT_NE(neoDevice0->getDeviceBitfield(), neoDevice1->getDeviceBitfield());
EXPECT_NE(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield); EXPECT_NE(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc = {};
auto result = driverHandle->allocSharedMem(nullptr, auto result = driverHandle->allocSharedMem(nullptr,
ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD, &deviceDesc,
0u, &hostDesc,
size, alignment, &ptr); size, alignment, &ptr);
EXPECT_EQ(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield); EXPECT_EQ(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
@@ -241,8 +249,8 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
memoryManager->recentlyPassedDeviceBitfield = {}; memoryManager->recentlyPassedDeviceBitfield = {};
EXPECT_NE(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield); EXPECT_NE(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
result = driverHandle->allocSharedMem(driverHandle->devices[1]->toHandle(), result = driverHandle->allocSharedMem(driverHandle->devices[1]->toHandle(),
ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD, &deviceDesc,
0u, &hostDesc,
size, alignment, &ptr); size, alignment, &ptr);
EXPECT_EQ(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield); EXPECT_EQ(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
@@ -362,9 +370,11 @@ TEST_F(ContextMemoryTest, whenAllocatingSharedAllocationFromContextThenAllocatio
size_t alignment = 1u; size_t alignment = 1u;
void *ptr = nullptr; void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc = {};
ze_result_t result = context->allocSharedMem(device->toHandle(), ze_result_t result = context->allocSharedMem(device->toHandle(),
0u, &deviceDesc,
0u, &hostDesc,
size, alignment, &ptr); size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result); EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr); EXPECT_NE(nullptr, ptr);