Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Isolate device allocations with respect to context 

Related-To: LOCI-1996

Signed-off-by: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga 2021-04-09 09:50:15 +00:00 committed by Compute-Runtime-Automation
parent 08210f8be5
commit da7aef49e6
15 changed files with 410 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -62,16 +62,81 @@ ze_result_t ContextImp::allocHostMem(const ze_host_mem_alloc_desc_t *hostDesc,
return ZE_RESULT_SUCCESS;
}
bool ContextImp::isDeviceDefinedForThisContext(Device *inDevice) {
return (this->getDevices().find(inDevice->toHandle()) != this->getDevices().end());
}
ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment, void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->allocDeviceMem(hDevice,
deviceDesc,
size,
alignment,
ptr);
if (isDeviceDefinedForThisContext(Device::fromHandle(hDevice)) == false) {
return ZE_RESULT_ERROR_DEVICE_LOST;
}
bool relaxedSizeAllowed = false;
if (deviceDesc->pNext) {
const ze_base_desc_t *extendedDesc = reinterpret_cast<const ze_base_desc_t *>(deviceDesc->pNext);
if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC) {
const ze_external_memory_export_desc_t *externalMemoryExportDesc =
reinterpret_cast<const ze_external_memory_export_desc_t *>(extendedDesc);
// ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF supported by default for all
// device allocations for the purpose of IPC, so just check correct
// flag is passed.
if (externalMemoryExportDesc->flags & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
} else if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD) {
const ze_external_memory_import_fd_t *externalMemoryImportDesc =
reinterpret_cast<const ze_external_memory_import_fd_t *>(extendedDesc);
if (externalMemoryImportDesc->flags & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
ze_ipc_memory_flags_t flags = {};
*ptr = this->driverHandle->importFdHandle(hDevice, flags, externalMemoryImportDesc->fd);
if (nullptr == *ptr) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
return ZE_RESULT_SUCCESS;
} else if (extendedDesc->stype == ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC) {
const ze_relaxed_allocation_limits_exp_desc_t *relaxedLimitsDesc =
reinterpret_cast<const ze_relaxed_allocation_limits_exp_desc_t *>(extendedDesc);
if (!(relaxedLimitsDesc->flags & ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
relaxedSizeAllowed = true;
}
}
if (relaxedSizeAllowed == false &&
(size > this->driverHandle->devices[0]->getNEODevice()->getHardwareCapabilities().maxMemAllocSize)) {
*ptr = nullptr;
return ZE_RESULT_ERROR_UNSUPPORTED_SIZE;
}
auto neoDevice = Device::fromHandle(hDevice)->getNEODevice();
auto rootDeviceIndex = neoDevice->getRootDeviceIndex();
auto deviceBitfields = this->driverHandle->deviceBitfields;
deviceBitfields[rootDeviceIndex] = neoDevice->getDeviceBitfield();
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, this->driverHandle->rootDeviceIndices, deviceBitfields);
unifiedMemoryProperties.allocationFlags.flags.shareable = 1u;
unifiedMemoryProperties.device = neoDevice;
if (deviceDesc->flags & ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED) {
unifiedMemoryProperties.allocationFlags.flags.locallyUncachedResource = 1;
}
void *usmPtr =
this->driverHandle->svmAllocsManager->createUnifiedMemoryAllocation(size, unifiedMemoryProperties);
if (usmPtr == nullptr) {
return ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;
}
*ptr = usmPtr;
return ZE_RESULT_SUCCESS;
}
ze_result_t ContextImp::allocSharedMem(ze_device_handle_t hDevice,

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

@ -109,15 +109,17 @@ struct ContextImp : Context {
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) override;
std::vector<Device *> &getDevices() {
std::map<ze_device_handle_t, Device *> &getDevices() {
return devices;
}
std::set<uint32_t> rootDeviceIndices = {};
std::map<uint32_t, NEO::DeviceBitfield> subDeviceBitfields;
bool isDeviceDefinedForThisContext(Device *inDevice);
protected:
std::vector<Device *> devices;
std::map<ze_device_handle_t, Device *> devices;
DriverHandleImp *driverHandle = nullptr;
};

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

@ -38,9 +38,6 @@ struct DriverHandle : _ze_driver_handle_t {
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) = 0;
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;
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,

11
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@ -44,16 +44,17 @@ ze_result_t DriverHandleImp::createContext(const ze_context_desc_t *desc,
*phContext = context->toHandle();
if (numDevices == 0) {
context->getDevices().resize(numDevices);
context->getDevices() = this->devices;
for (auto device : this->devices) {
context->getDevices().insert(std::make_pair(device->toHandle(), device));
}
} else {
for (uint32_t i = 0; i < numDevices; i++) {
context->getDevices().push_back(Device::fromHandle(phDevices[i]));
context->getDevices().insert(std::make_pair(phDevices[i], Device::fromHandle(phDevices[i])));
}
}
for (auto device : context->getDevices()) {
auto neoDevice = device->getNEODevice();
for (auto devicePair : context->getDevices()) {
auto neoDevice = devicePair.second->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(),
neoDevice->getDeviceBitfield()});

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

@ -35,9 +35,6 @@ struct DriverHandleImp : public DriverHandle {
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) override;
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;
ze_result_t allocSharedMem(ze_device_handle_t hDevice,
const ze_device_mem_alloc_desc_t *deviceDesc,
const ze_host_mem_alloc_desc_t *hostDesc,

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

@ -115,73 +115,6 @@ ze_result_t DriverHandleImp::getMemAddressRange(const void *ptr, void **pBase, s
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t DriverHandleImp::allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size, size_t alignment, void **ptr) {
bool relaxedSizeAllowed = false;
if (deviceDesc->pNext) {
const ze_base_desc_t *extendedDesc = reinterpret_cast<const ze_base_desc_t *>(deviceDesc->pNext);
if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC) {
const ze_external_memory_export_desc_t *externalMemoryExportDesc =
reinterpret_cast<const ze_external_memory_export_desc_t *>(extendedDesc);
// ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF supported by default for all
// device allocations for the purpose of IPC, so just check correct
// flag is passed.
if (externalMemoryExportDesc->flags & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
} else if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD) {
const ze_external_memory_import_fd_t *externalMemoryImportDesc =
reinterpret_cast<const ze_external_memory_import_fd_t *>(extendedDesc);
if (externalMemoryImportDesc->flags & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
ze_ipc_memory_flags_t flags = {};
*ptr = this->importFdHandle(hDevice, flags, externalMemoryImportDesc->fd);
if (nullptr == *ptr) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
return ZE_RESULT_SUCCESS;
} else if (extendedDesc->stype == ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC) {
const ze_relaxed_allocation_limits_exp_desc_t *relaxedLimitsDesc =
reinterpret_cast<const ze_relaxed_allocation_limits_exp_desc_t *>(extendedDesc);
if (!(relaxedLimitsDesc->flags & ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
relaxedSizeAllowed = true;
}
}
if (relaxedSizeAllowed == false &&
(size > this->devices[0]->getNEODevice()->getHardwareCapabilities().maxMemAllocSize)) {
*ptr = nullptr;
return ZE_RESULT_ERROR_UNSUPPORTED_SIZE;
}
auto neoDevice = Device::fromHandle(hDevice)->getNEODevice();
auto rootDeviceIndex = neoDevice->getRootDeviceIndex();
auto deviceBitfields = this->deviceBitfields;
deviceBitfields[rootDeviceIndex] = neoDevice->getDeviceBitfield();
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, this->rootDeviceIndices, deviceBitfields);
unifiedMemoryProperties.allocationFlags.flags.shareable = 1u;
unifiedMemoryProperties.device = neoDevice;
if (deviceDesc->flags & ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED) {
unifiedMemoryProperties.allocationFlags.flags.locallyUncachedResource = 1;
}
void *usmPtr =
svmAllocsManager->createUnifiedMemoryAllocation(size, unifiedMemoryProperties);
if (usmPtr == nullptr) {
return ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;
}
*ptr = usmPtr;
return ZE_RESULT_SUCCESS;
}
ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,

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

@ -52,7 +52,7 @@ struct Mock<DriverHandle> : public DriverHandleImp {
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment,
void **ptr) override;
void **ptr);
ze_result_t importExternalPointer(void *ptr, size_t size) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

31
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@ -133,9 +133,9 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemAdviseReturnsSuccess) {
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto res = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
auto res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, ptr);
@ -156,9 +156,9 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemoryPrefetchReturnsSuccess) {
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto res = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
auto res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, ptr);
@ -542,7 +542,7 @@ HWTEST_F(CommandListCreate, givenCommandListWithInvalidWaitEventArgWhenAppendQue
void *alloc;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
auto result = context->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
auto eventHandle = event.toHandle();
@ -616,7 +616,8 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
void *alloc;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto result = context->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_event_handle_t events[2] = {event.toHandle(), event.toHandle()};
@ -673,10 +674,11 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
void *alloc;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto result = context->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
void *offsetAlloc;
result = driverHandle->allocDeviceMem(device, &deviceDesc, 128, 1, &offsetAlloc);
result = context->allocDeviceMem(device, &deviceDesc, 128, 1, &offsetAlloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_event_handle_t events[2] = {event.toHandle(), event.toHandle()};
@ -735,7 +737,8 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
void *alloc;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto result = context->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
size_t eventCount = device->getNEODevice()->getDeviceInfo().maxWorkItemSizes[0] * 2u;
std::unique_ptr<ze_event_handle_t[]> events = std::make_unique<ze_event_handle_t[]>(eventCount);
@ -837,7 +840,8 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
void *alloc;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(&mockDevice, &deviceDesc, 128, 1, &alloc);
context->getDevices().insert(std::make_pair(mockDevice.toHandle(), &mockDevice));
auto result = context->allocDeviceMem(&mockDevice, &deviceDesc, 128, 1, &alloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
result = commandList.appendQueryKernelTimestamps(2u, events, alloc, nullptr, nullptr, 0u, nullptr);
@ -922,7 +926,8 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
void *alloc;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(&mockDevice, &deviceDesc, 128, 1, &alloc);
context->getDevices().insert(std::make_pair(mockDevice.toHandle(), &mockDevice));
auto result = context->allocDeviceMem(&mockDevice, &deviceDesc, 128, 1, &alloc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
result = commandList.appendQueryKernelTimestamps(2u, events, alloc, nullptr, nullptr, 0u, nullptr);

6
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
View File

@ -310,9 +310,9 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionHavingDeviceMem
void *src_buffer = nullptr;
void *dst_buffer = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &src_buffer);
result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &src_buffer);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &dst_buffer);
result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &dst_buffer);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
uint32_t width = 16;
@ -377,7 +377,7 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingDeviceMemoryWit
void *dst_buffer = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &dst_buffer);
result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &dst_buffer);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ze_event_pool_desc_t eventPoolDesc = {};

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

@ -534,7 +534,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenIndirectDispatchWhenAppendingThenWo
void *alloc = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &alloc);
auto result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &alloc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandList->appendLaunchKernelIndirect(kernel.toHandle(),
@ -959,7 +959,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenAppendLaunchMult
const ze_kernel_handle_t launchFn = kernel->toHandle();
uint32_t *numLaunchArgs;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = device->getDriverHandle()->allocDeviceMem(
auto result = context->allocDeviceMem(
device->toHandle(), &deviceDesc, 16384u, 4096u, reinterpret_cast<void **>(&numLaunchArgs));
result = commandList->appendLaunchMultipleKernelsIndirect(1, &launchFn, numLaunchArgs, nullptr, nullptr, 0, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
@ -988,7 +988,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenAppendLaunchMult
uint32_t *numLaunchArgs;
const uint32_t numKernels = 3;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = device->getDriverHandle()->allocDeviceMem(
auto result = context->allocDeviceMem(
device->toHandle(), &deviceDesc, 16384u, 4096u, reinterpret_cast<void **>(&numLaunchArgs));
result = commandList->appendLaunchMultipleKernelsIndirect(numKernels, launchFn, numLaunchArgs, nullptr, nullptr, 0, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);

2
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp
View File

@ -580,7 +580,7 @@ HWTEST_F(CommandQueueIndirectAllocations, givenCommandQueueWhenExecutingCommandL
void *deviceAlloc = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &deviceAlloc);
auto result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &deviceAlloc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(deviceAlloc)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());

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

@ -37,7 +37,7 @@ TEST_F(MultiDeviceContextTests,
ContextImp *contextImp = static_cast<ContextImp *>(Context::fromHandle(hContext));
for (size_t i = 0; i < driverHandle->devices.size(); i++) {
EXPECT_EQ(driverHandle->devices[i], contextImp->getDevices()[i]);
EXPECT_NE(contextImp->getDevices().find(driverHandle->devices[i]->toHandle()), contextImp->getDevices().end());
}
res = L0::Context::fromHandle(hContext)->destroy();
@ -58,7 +58,30 @@ TEST_F(MultiDeviceContextTests,
ContextImp *contextImp = static_cast<ContextImp *>(Context::fromHandle(hContext));
EXPECT_EQ(contextImp->getDevices().size(), count);
EXPECT_EQ(contextImp->getDevices()[0], driverHandle->devices[1]);
EXPECT_FALSE(contextImp->isDeviceDefinedForThisContext(driverHandle->devices[0]));
EXPECT_TRUE(contextImp->isDeviceDefinedForThisContext(driverHandle->devices[1]));
res = L0::Context::fromHandle(hContext)->destroy();
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
TEST_F(MultiDeviceContextTests,
whenAllocatingDeviceMemoryWithDeviceNotDefinedForContextThenDeviceLostIsReturned) {
ze_context_handle_t hContext;
ze_context_desc_t desc;
ze_device_handle_t device = driverHandle->devices[1]->toHandle();
ze_result_t res = driverHandle->createContext(&desc, 1u, &device, &hContext);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
ContextImp *contextImp = static_cast<ContextImp *>(Context::fromHandle(hContext));
ze_device_mem_alloc_desc_t deviceDesc = {};
size_t size = 4096;
void *ptr = nullptr;
res = contextImp->allocDeviceMem(driverHandle->devices[0]->toHandle(), &deviceDesc, size, 0u, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, res);
res = L0::Context::fromHandle(hContext)->destroy();
EXPECT_EQ(ZE_RESULT_SUCCESS, res);

60
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -1341,11 +1341,11 @@ TEST_F(KernelBindlessUncachedMemoryTests,
{
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto alloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -1359,11 +1359,11 @@ TEST_F(KernelBindlessUncachedMemoryTests,
{
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto alloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -1392,11 +1392,11 @@ TEST_F(KernelBindlessUncachedMemoryTests,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
ze_result_t res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto alloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -1411,11 +1411,11 @@ TEST_F(KernelBindlessUncachedMemoryTests,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
ze_result_t res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto alloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -1444,11 +1444,11 @@ TEST_F(KernelBindlessUncachedMemoryTests,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
ze_result_t res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto alloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -1462,11 +1462,11 @@ TEST_F(KernelBindlessUncachedMemoryTests,
{
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto alloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());

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

@ -30,9 +30,9 @@ TEST_F(MemoryTest, givenDevicePointerThenDriverGetAllocPropertiesReturnsDeviceHa
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -55,9 +55,9 @@ TEST_F(MemoryTest, whenAllocatingDeviceMemoryWithUncachedFlagThenLocallyUncached
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -92,6 +92,66 @@ TEST_F(MemoryTest, whenAllocatingSharedMemoryWithUncachedFlagThenLocallyUncached
ASSERT_EQ(result, ZE_RESULT_SUCCESS);
}
struct SVMAllocsManagerOutOFMemoryMock : public NEO::SVMAllocsManager {
SVMAllocsManagerOutOFMemoryMock(MemoryManager *memoryManager) : NEO::SVMAllocsManager(memoryManager, false) {}
void *createUnifiedMemoryAllocation(size_t size,
const UnifiedMemoryProperties &svmProperties) override {
return nullptr;
}
};
struct DriverHandleOutOfMemoryMock : public DriverHandleImp {
};
struct OutOfMemoryTests : public ::testing::Test {
void SetUp() override {
NEO::MockCompilerEnableGuard mock(true);
neoDevice =
NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
auto mockBuiltIns = new MockBuiltins();
neoDevice->executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltIns);
NEO::DeviceVector devices;
devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
driverHandle = std::make_unique<DriverHandleOutOfMemoryMock>();
driverHandle->initialize(std::move(devices));
prevSvmAllocsManager = driverHandle->svmAllocsManager;
currSvmAllocsManager = new SVMAllocsManagerOutOFMemoryMock(driverHandle->memoryManager);
driverHandle->svmAllocsManager = currSvmAllocsManager;
device = driverHandle->devices[0];
context = std::make_unique<ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
driverHandle->svmAllocsManager = prevSvmAllocsManager;
delete currSvmAllocsManager;
}
NEO::SVMAllocsManager *prevSvmAllocsManager;
NEO::SVMAllocsManager *currSvmAllocsManager;
std::unique_ptr<DriverHandleOutOfMemoryMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<ContextImp> context;
};
TEST_F(OutOfMemoryTests,
givenCallToDeviceAllocAndFailureToAllocateThenOutOfDeviceMemoryIsReturned) {
size_t size = device->getNEODevice()->getHardwareCapabilities().maxMemAllocSize - 1;
size_t alignment = 1u;
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY, result);
}
struct SVMAllocsManagerRelaxedSizeMock : public NEO::SVMAllocsManager {
SVMAllocsManagerRelaxedSizeMock(MemoryManager *memoryManager) : NEO::SVMAllocsManager(memoryManager, false) {}
void *createUnifiedMemoryAllocation(size_t size,
@ -128,6 +188,13 @@ struct MemoryRelaxedSizeTests : public ::testing::Test {
currSvmAllocsManager = new SVMAllocsManagerRelaxedSizeMock(driverHandle->memoryManager);
driverHandle->svmAllocsManager = currSvmAllocsManager;
device = driverHandle->devices[0];
context = std::make_unique<ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
@ -139,6 +206,7 @@ struct MemoryRelaxedSizeTests : public ::testing::Test {
std::unique_ptr<DriverHandleRelaxedSizeMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<ContextImp> context;
};
TEST_F(MemoryRelaxedSizeTests,
@ -148,9 +216,9 @@ TEST_F(MemoryRelaxedSizeTests,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -165,9 +233,9 @@ TEST_F(MemoryRelaxedSizeTests,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_SIZE, result);
EXPECT_EQ(nullptr, ptr);
}
@ -184,9 +252,9 @@ TEST_F(MemoryRelaxedSizeTests,
relaxedSizeDesc.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC;
relaxedSizeDesc.flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE;
deviceDesc.pNext = &relaxedSizeDesc;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -206,9 +274,9 @@ TEST_F(MemoryRelaxedSizeTests,
relaxedSizeDesc.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC;
relaxedSizeDesc.flags = static_cast<ze_relaxed_allocation_limits_exp_flag_t>(ZE_BIT(1));
deviceDesc.pNext = &relaxedSizeDesc;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
EXPECT_EQ(nullptr, ptr);
}
@ -293,7 +361,7 @@ TEST_F(MemoryRelaxedSizeTests,
EXPECT_EQ(nullptr, ptr);
}
struct DriverHandleGetFdMock : public DriverHandleImp {
struct DriverHandleGetFdMock : public L0::DriverHandleImp {
void *importFdHandle(ze_device_handle_t hDevice, ze_ipc_memory_flags_t flags, uint64_t handle) override {
if (mockFd == allocationMap.second) {
return allocationMap.first;
@ -301,17 +369,6 @@ struct DriverHandleGetFdMock : public DriverHandleImp {
return nullptr;
}
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 {
ze_result_t res = DriverHandleImp::allocDeviceMem(hDevice, deviceDesc, size, alignment, ptr);
if (ZE_RESULT_SUCCESS == res) {
allocationMap.first = *ptr;
allocationMap.second = mockFd;
}
return res;
}
ze_result_t closeIpcMemHandle(const void *ptr) override {
return ZE_RESULT_SUCCESS;
}
@ -333,6 +390,25 @@ struct DriverHandleGetFdMock : public DriverHandleImp {
std::pair<void *, int> allocationMap;
};
struct ContextFdMock : public L0::ContextImp {
ContextFdMock(DriverHandleGetFdMock *inDriverHandle) : L0::ContextImp(static_cast<L0::DriverHandle *>(inDriverHandle)) {
driverHandle = inDriverHandle;
}
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 {
ze_result_t res = L0::ContextImp::allocDeviceMem(hDevice, deviceDesc, size, alignment, ptr);
if (ZE_RESULT_SUCCESS == res) {
driverHandle->allocationMap.first = *ptr;
driverHandle->allocationMap.second = driverHandle->mockFd;
}
return res;
}
DriverHandleGetFdMock *driverHandle = nullptr;
};
struct MemoryExportImportTest : public ::testing::Test {
void SetUp() override {
NEO::MockCompilerEnableGuard mock(true);
@ -344,20 +420,22 @@ struct MemoryExportImportTest : public ::testing::Test {
driverHandle = std::make_unique<DriverHandleGetFdMock>();
driverHandle->initialize(std::move(devices));
device = driverHandle->devices[0];
ze_context_handle_t hContext;
ze_context_desc_t desc;
ze_result_t res = driverHandle->createContext(&desc, 0u, nullptr, &hContext);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
context = static_cast<ContextImp *>(Context::fromHandle(hContext));
context = std::make_unique<ContextFdMock>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
context->destroy();
}
std::unique_ptr<DriverHandleGetFdMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
L0::ContextImp *context = nullptr;
ze_context_handle_t hContext;
std::unique_ptr<ContextFdMock> context;
};
TEST_F(MemoryExportImportTest,
@ -371,9 +449,9 @@ TEST_F(MemoryExportImportTest,
extendedDesc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC;
extendedDesc.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD;
deviceDesc.pNext = &extendedDesc;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION, result);
EXPECT_EQ(nullptr, ptr);
}
@ -389,9 +467,9 @@ TEST_F(MemoryExportImportTest,
extendedDesc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC;
extendedDesc.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF;
deviceDesc.pNext = &extendedDesc;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -406,9 +484,9 @@ TEST_F(MemoryExportImportTest,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -461,9 +539,9 @@ TEST_F(MemoryExportImportTest,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -497,9 +575,9 @@ TEST_F(MemoryExportImportTest,
extendedDesc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC;
extendedDesc.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF;
deviceDesc.pNext = &extendedDesc;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -526,9 +604,9 @@ TEST_F(MemoryExportImportTest,
importDeviceDesc.pNext = &extendedImportDesc;
void *importedPtr = nullptr;
result = driverHandle->allocDeviceMem(device->toHandle(),
&importDeviceDesc,
size, alignment, &importedPtr);
result = context->allocDeviceMem(device->toHandle(),
&importDeviceDesc,
size, alignment, &importedPtr);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION, result);
EXPECT_EQ(nullptr, importedPtr);
@ -547,9 +625,9 @@ TEST_F(MemoryExportImportTest,
extendedDesc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC;
extendedDesc.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF;
deviceDesc.pNext = &extendedDesc;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -576,9 +654,9 @@ TEST_F(MemoryExportImportTest,
importDeviceDesc.pNext = &extendedImportDesc;
void *importedPtr = nullptr;
result = driverHandle->allocDeviceMem(device->toHandle(),
&importDeviceDesc,
size, alignment, &importedPtr);
result = context->allocDeviceMem(device->toHandle(),
&importDeviceDesc,
size, alignment, &importedPtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = driverHandle->freeMem(ptr);
@ -604,9 +682,9 @@ TEST_F(MemoryIPCTests,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -625,9 +703,9 @@ TEST_F(MemoryIPCTests,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -654,38 +732,27 @@ TEST_F(MemoryIPCTests,
size_t alignment = 1u;
void *ptr = nullptr;
ze_context_handle_t hContext;
ze_context_desc_t desc;
ze_result_t result = driverHandle->createContext(&desc, 0u, nullptr, &hContext);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ContextImp *contextImp = static_cast<ContextImp *>(L0::Context::fromHandle(hContext));
ze_device_mem_alloc_desc_t deviceDesc = {};
result = contextImp->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
ze_ipc_mem_handle_t ipcHandle = {};
result = contextImp->getIpcMemHandle(ptr, &ipcHandle);
result = context->getIpcMemHandle(ptr, &ipcHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ze_ipc_memory_flags_t flags = {};
void *ipcPtr;
result = contextImp->openIpcMemHandle(device->toHandle(), ipcHandle, flags, &ipcPtr);
result = context->openIpcMemHandle(device->toHandle(), ipcHandle, flags, &ipcPtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(ipcPtr, ptr);
result = contextImp->closeIpcMemHandle(ipcPtr);
result = context->closeIpcMemHandle(ipcPtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = contextImp->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = contextImp->destroy();
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@ -695,29 +762,18 @@ TEST_F(MemoryIPCTests,
size_t alignment = 1u;
void *ptr = nullptr;
ze_context_handle_t hContext;
ze_context_desc_t desc;
ze_result_t result = driverHandle->createContext(&desc, 0u, nullptr, &hContext);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ContextImp *contextImp = static_cast<ContextImp *>(L0::Context::fromHandle(hContext));
ze_device_mem_alloc_desc_t deviceDesc = {};
result = contextImp->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
ze_ipc_mem_handle_t ipcHandle;
result = contextImp->getIpcMemHandle(ptr, &ipcHandle);
result = context->getIpcMemHandle(ptr, &ipcHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = contextImp->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = contextImp->destroy();
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@ -749,19 +805,27 @@ struct DriverHandleGetIpcHandleMock : public DriverHandleImp {
return ZE_RESULT_SUCCESS;
}
ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size,
const int mockFd = 999;
std::pair<void *, int> allocationMap;
};
struct ContextGetIpcHandleMock : public L0::ContextImp {
ContextGetIpcHandleMock(DriverHandleGetIpcHandleMock *inDriverHandle) : L0::ContextImp(static_cast<L0::DriverHandle *>(inDriverHandle)) {
driverHandle = inDriverHandle;
}
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 {
ze_result_t res = DriverHandleImp::allocDeviceMem(hDevice, deviceDesc, size, alignment, ptr);
ze_result_t res = L0::ContextImp::allocDeviceMem(hDevice, deviceDesc, size, alignment, ptr);
if (ZE_RESULT_SUCCESS == res) {
allocationMap.first = *ptr;
allocationMap.second = mockFd;
driverHandle->allocationMap.first = *ptr;
driverHandle->allocationMap.second = driverHandle->mockFd;
}
return res;
}
const int mockFd = 999;
std::pair<void *, int> allocationMap;
DriverHandleGetIpcHandleMock *driverHandle = nullptr;
};
struct MemoryGetIpcHandleTest : public ::testing::Test {
@ -775,13 +839,22 @@ struct MemoryGetIpcHandleTest : public ::testing::Test {
driverHandle = std::make_unique<DriverHandleGetIpcHandleMock>();
driverHandle->initialize(std::move(devices));
device = driverHandle->devices[0];
context = std::make_unique<ContextGetIpcHandleMock>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
}
std::unique_ptr<DriverHandleGetIpcHandleMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<ContextGetIpcHandleMock> context;
};
TEST_F(MemoryGetIpcHandleTest,
@ -791,9 +864,9 @@ TEST_F(MemoryGetIpcHandleTest,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -888,6 +961,13 @@ struct MemoryOpenIpcHandleTest : public ::testing::Test {
currMemoryManager = new MemoryManagerOpenIpcMock(*neoDevice->executionEnvironment);
driverHandle->setMemoryManager(currMemoryManager);
device = driverHandle->devices[0];
context = std::make_unique<ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
@ -899,6 +979,7 @@ struct MemoryOpenIpcHandleTest : public ::testing::Test {
std::unique_ptr<DriverHandleIpcMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<ContextImp> context;
};
TEST_F(MemoryOpenIpcHandleTest,
@ -908,9 +989,9 @@ TEST_F(MemoryOpenIpcHandleTest,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -946,6 +1027,13 @@ struct MemoryFailedOpenIpcHandleTest : public ::testing::Test {
currMemoryManager = new MemoryManagerIpcMock(*neoDevice->executionEnvironment);
driverHandle->setMemoryManager(currMemoryManager);
device = driverHandle->devices[0];
context = std::make_unique<ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
@ -957,6 +1045,7 @@ struct MemoryFailedOpenIpcHandleTest : public ::testing::Test {
std::unique_ptr<DriverHandleIpcMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<ContextImp> context;
};
TEST_F(MemoryFailedOpenIpcHandleTest,
@ -966,9 +1055,9 @@ TEST_F(MemoryFailedOpenIpcHandleTest,
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -994,9 +1083,9 @@ TEST_F(DeviceMemorySizeTest, givenSizeGreaterThanLimitThenDeviceAllocationFails)
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = driverHandle->allocDeviceMem(nullptr,
&deviceDesc,
size, alignment, &ptr);
ze_result_t result = context->allocDeviceMem(device,
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_SIZE, result);
}
@ -1118,9 +1207,9 @@ TEST_F(MemoryTest, givenCallToCheckMemoryAccessFromDeviceWithValidDeviceAllocati
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t res = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
ze_result_t res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, ptr);
@ -1189,6 +1278,13 @@ struct MemoryBitfieldTest : testing::Test {
ASSERT_NE(nullptr, driverHandle->devices[0]->toHandle());
EXPECT_NE(neoDevice->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
context = std::make_unique<ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
context->getDevices().insert(std::make_pair(device->toHandle(), device));
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.insert(neoDevice->getRootDeviceIndex());
context->subDeviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
@ -1203,14 +1299,15 @@ struct MemoryBitfieldTest : testing::Test {
size_t size = 10;
size_t alignment = 1u;
void *ptr = nullptr;
std::unique_ptr<ContextImp> context;
};
TEST_F(MemoryBitfieldTest, givenDeviceWithValidBitfieldWhenAllocatingDeviceMemoryThenPassProperBitfield) {
NEO::MockCompilerEnableGuard mock(true);
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = driverHandle->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
auto result = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(neoDevice->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);

50
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@ -115,11 +115,11 @@ HWTEST2_F(ModuleTest, givenNonPatchedTokenThenSurfaceBaseAddressIsCorrectlySet,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, res);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -156,11 +156,11 @@ HWTEST2_F(ModuleUncachedBufferTest,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -190,11 +190,11 @@ HWTEST2_F(ModuleUncachedBufferTest,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -226,11 +226,11 @@ HWTEST2_F(ModuleUncachedBufferTest,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -262,11 +262,11 @@ HWTEST2_F(ModuleUncachedBufferTest,
void *devicePtr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
res = context->allocDeviceMem(device->toHandle(),
&deviceDesc,
16384u,
0u,
&devicePtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(devicePtr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());