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

Revert "Fail when handle cannot be obtain for an allocation" 

This reverts commit 4391ad21bb.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation 2022-11-23 04:53:51 +01:00 committed by Compute-Runtime-Automation
parent 4391ad21bb
commit 565d44e59c
23 changed files with 115 additions and 1007 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,6 +16,7 @@
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/event/event.h"
#include "level_zero/core/source/helpers/allocation_extensions.h"
#include "level_zero/core/source/helpers/properties_parser.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/source/image/image.h"
@ -437,11 +438,7 @@ ze_result_t ContextImp::getIpcMemHandle(const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) {
NEO::SvmAllocationData *allocData = this->driverHandle->svmAllocsManager->getSVMAlloc(ptr);
if (allocData) {
uint64_t handle = 0;
int ret = allocData->gpuAllocations.getDefaultGraphicsAllocation()->peekInternalHandle(this->driverHandle->getMemoryManager(), handle);
if (ret < 0) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
uint64_t handle = allocData->gpuAllocations.getDefaultGraphicsAllocation()->peekInternalHandle(this->driverHandle->getMemoryManager());
memcpy_s(reinterpret_cast<void *>(pIpcHandle->data),
sizeof(ze_ipc_mem_handle_t),
&handle,
@ -470,15 +467,11 @@ ze_result_t ContextImp::getIpcMemHandles(const void *ptr,
}
for (uint32_t i = 0; i < *numIpcHandles; i++) {
uint64_t handle = 0;
int ret = allocData->gpuAllocations.getDefaultGraphicsAllocation()->peekInternalHandle(this->driverHandle->getMemoryManager(), i, handle);
if (ret < 0) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
int handle = static_cast<int>(allocData->gpuAllocations.getDefaultGraphicsAllocation()->peekInternalHandle(this->driverHandle->getMemoryManager(), i));
memcpy_s(reinterpret_cast<void *>(pIpcHandles[i].data),
sizeof(ze_ipc_mem_handle_t),
&handle,
sizeof(int));
sizeof(handle));
}
return ZE_RESULT_SUCCESS;
@ -547,11 +540,7 @@ ze_result_t EventPoolImp::getIpcHandle(ze_ipc_event_pool_handle_t *pIpcHandle) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
uint64_t handle = 0;
int ret = this->eventPoolAllocations->getDefaultGraphicsAllocation()->peekInternalHandle(this->context->getDriverHandle()->getMemoryManager(), handle);
if (ret < 0) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
uint64_t handle = this->eventPoolAllocations->getDefaultGraphicsAllocation()->peekInternalHandle(this->context->getDriverHandle()->getMemoryManager());
memcpy_s(pIpcHandle->data, sizeof(int), &handle, sizeof(int));
@ -641,44 +630,6 @@ ze_result_t ContextImp::openEventPoolIpcHandle(const ze_ipc_event_pool_handle_t
return ZE_RESULT_SUCCESS;
}
ze_result_t ContextImp::handleAllocationExtensions(NEO::GraphicsAllocation *alloc, ze_memory_type_t type, void *pNext, struct DriverHandleImp *driverHandle) {
if (pNext != nullptr) {
ze_base_properties_t *extendedProperties =
reinterpret_cast<ze_base_properties_t *>(pNext);
if (extendedProperties->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_FD) {
ze_external_memory_export_fd_t *extendedMemoryExportProperties =
reinterpret_cast<ze_external_memory_export_fd_t *>(extendedProperties);
if (extendedMemoryExportProperties->flags & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
if (type != ZE_MEMORY_TYPE_DEVICE) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
uint64_t handle = 0;
int ret = alloc->peekInternalHandle(driverHandle->getMemoryManager(), handle);
if (ret < 0) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
extendedMemoryExportProperties->fd = static_cast<int>(handle);
} else if (extendedProperties->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_WIN32) {
ze_external_memory_export_win32_handle_t *exportStructure = reinterpret_cast<ze_external_memory_export_win32_handle_t *>(extendedProperties);
if (exportStructure->flags != ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
uint64_t handle = 0;
int ret = alloc->peekInternalHandle(driverHandle->getMemoryManager(), handle);
if (ret < 0) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
exportStructure->handle = reinterpret_cast<void *>(handle);
} else {
return ZE_RESULT_ERROR_INVALID_ENUMERATION;
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t ContextImp::getMemAllocProperties(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) {

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

@ -8,7 +8,6 @@
#pragma once
#include "shared/source/helpers/common_types.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/utilities/stackvec.h"
#include "level_zero/core/source/context/context.h"
@ -143,9 +142,6 @@ struct ContextImp : Context {
void freePeerAllocations(const void *ptr, bool blocking, Device *device);
ze_result_t handleAllocationExtensions(NEO::GraphicsAllocation *alloc, ze_memory_type_t type,
void *pNext, struct DriverHandleImp *driverHandle);
RootDeviceIndicesContainer rootDeviceIndices;
std::map<uint32_t, NEO::DeviceBitfield> deviceBitfields;

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

@ -567,21 +567,13 @@ NEO::GraphicsAllocation *DriverHandleImp::getPeerAllocation(Device *device,
UNRECOVERABLE_IF(numHandles == 0);
std::vector<NEO::osHandle> handles;
for (uint32_t i = 0; i < numHandles; i++) {
uint64_t handle = 0;
int ret = alloc->peekInternalHandle(this->getMemoryManager(), i, handle);
if (ret < 0) {
return nullptr;
}
handles.push_back(static_cast<NEO::osHandle>(handle));
int handle = static_cast<int>(alloc->peekInternalHandle(this->getMemoryManager(), i));
handles.push_back(handle);
}
auto neoDevice = device->getNEODevice()->getRootDevice();
peerPtr = this->importFdHandles(neoDevice, flags, handles, &alloc);
} else {
uint64_t handle = 0;
int ret = alloc->peekInternalHandle(this->getMemoryManager(), handle);
if (ret < 0) {
return nullptr;
}
uint64_t handle = alloc->peekInternalHandle(this->getMemoryManager());
peerPtr = this->importFdHandle(device->getNEODevice(), flags, handle, &alloc);
}

2
level_zero/core/source/helpers/CMakeLists.txt
View File

@ -7,6 +7,8 @@
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/allocation_extensions.h
${CMAKE_CURRENT_SOURCE_DIR}/allocation_extensions.cpp
${CMAKE_CURRENT_SOURCE_DIR}/api_specific_config_l0.cpp
${CMAKE_CURRENT_SOURCE_DIR}/error_code_helper_l0.cpp
${CMAKE_CURRENT_SOURCE_DIR}/error_code_helper_l0.h

47
level_zero/core/source/helpers/allocation_extensions.cpp Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/core/source/helpers/allocation_extensions.h"
#include "shared/source/helpers/memory_properties_helpers.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/memory_manager/unified_memory_manager.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
namespace L0 {
ze_result_t handleAllocationExtensions(NEO::GraphicsAllocation *alloc, ze_memory_type_t type, void *pNext, struct DriverHandleImp *driverHandle) {
if (pNext != nullptr) {
ze_base_properties_t *extendedProperties =
reinterpret_cast<ze_base_properties_t *>(pNext);
if (extendedProperties->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_FD) {
ze_external_memory_export_fd_t *extendedMemoryExportProperties =
reinterpret_cast<ze_external_memory_export_fd_t *>(extendedProperties);
if (extendedMemoryExportProperties->flags & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
if (type != ZE_MEMORY_TYPE_DEVICE) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
uint64_t handle = alloc->peekInternalHandle(driverHandle->getMemoryManager());
extendedMemoryExportProperties->fd = static_cast<int>(handle);
} else if (extendedProperties->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_WIN32) {
ze_external_memory_export_win32_handle_t *exportStructure = reinterpret_cast<ze_external_memory_export_win32_handle_t *>(extendedProperties);
if (exportStructure->flags != ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32) {
return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
}
uint64_t handle = alloc->peekInternalHandle(driverHandle->getMemoryManager());
exportStructure->handle = reinterpret_cast<void *>(handle);
} else {
return ZE_RESULT_ERROR_INVALID_ENUMERATION;
}
}
return ZE_RESULT_SUCCESS;
}
} // namespace L0

18
level_zero/core/source/helpers/allocation_extensions.h Normal file
View File

@ -0,0 +1,18 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/memory_manager/memory_manager.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
namespace L0 {
ze_result_t handleAllocationExtensions(NEO::GraphicsAllocation *alloc, ze_memory_type_t type,
void *pNext, struct DriverHandleImp *driverHandle);
} // namespace L0

1
level_zero/core/test/unit_tests/sources/memory/CMakeLists.txt
View File

@ -9,4 +9,3 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_memory.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_memory_${DRIVER_MODEL}.cpp
)
add_subdirectories()

12
level_zero/core/test/unit_tests/sources/memory/linux/CMakeLists.txt
View File

@ -1,12 +0,0 @@
#
# Copyright (C) 2022 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(UNIX)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_memory_linux.cpp
)
endif()

706
level_zero/core/test/unit_tests/sources/memory/linux/test_memory_linux.cpp
View File

@ -1,706 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/drm_allocation.h"
#include "shared/source/os_interface/linux/drm_buffer_object.h"
#include "shared/source/os_interface/linux/drm_gem_close_worker.h"
#include "shared/source/os_interface/linux/drm_memory_manager.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/mocks/linux/mock_drm_allocation.h"
#include "shared/test/common/mocks/mock_driver_model.h"
#include "level_zero/core/source/context/context_imp.h"
#include "level_zero/core/test/unit_tests/fixtures/memory_ipc_fixture.h"
namespace L0 {
namespace ult {
class IpcImplicitScalingObtainFdMockGraphicsAllocation : public NEO::DrmAllocation {
public:
using NEO::DrmAllocation::bufferObjects;
IpcImplicitScalingObtainFdMockGraphicsAllocation(uint32_t rootDeviceIndex,
AllocationType allocationType,
BufferObject *bo,
void *ptrIn,
size_t sizeIn,
NEO::osHandle sharedHandle,
MemoryPool pool,
uint64_t canonizedGpuAddress) : NEO::DrmAllocation(rootDeviceIndex,
allocationType,
bo,
ptrIn,
sizeIn,
sharedHandle,
pool,
canonizedGpuAddress) {
bufferObjects.resize(2u);
}
uint32_t getNumHandles() override {
return 2u;
}
bool isResident(uint32_t contextId) const override {
return false;
}
};
class MemoryManagerIpcImplicitScalingObtainFdMock : public NEO::DrmMemoryManager {
public:
MemoryManagerIpcImplicitScalingObtainFdMock(NEO::ExecutionEnvironment &executionEnvironment) : NEO::DrmMemoryManager(gemCloseWorkerMode::gemCloseWorkerInactive, false, false, executionEnvironment) {}
NEO::GraphicsAllocation *createGraphicsAllocationFromSharedHandle(osHandle handle, const AllocationProperties &properties, bool requireSpecificBitness, bool isHostIpcAllocation) override { return nullptr; }
void addAllocationToHostPtrManager(NEO::GraphicsAllocation *memory) override{};
void removeAllocationFromHostPtrManager(NEO::GraphicsAllocation *memory) override{};
NEO::GraphicsAllocation *createGraphicsAllocationFromNTHandle(void *handle, uint32_t rootDeviceIndex, AllocationType allocType) override { return nullptr; };
AllocationStatus populateOsHandles(NEO::OsHandleStorage &handleStorage, uint32_t rootDeviceIndex) override { return AllocationStatus::Success; };
void cleanOsHandles(NEO::OsHandleStorage &handleStorage, uint32_t rootDeviceIndex) override{};
void freeGraphicsMemoryImpl(NEO::GraphicsAllocation *gfxAllocation) override{};
void freeGraphicsMemoryImpl(GraphicsAllocation *gfxAllocation, bool isImportedAllocation) override{};
uint64_t getSystemSharedMemory(uint32_t rootDeviceIndex) override { return 0; };
uint64_t getLocalMemorySize(uint32_t rootDeviceIndex, uint32_t deviceBitfield) override { return 0; };
double getPercentOfGlobalMemoryAvailable(uint32_t rootDeviceIndex) override { return 0; }
AddressRange reserveGpuAddress(size_t size, uint32_t rootDeviceIndex) override {
return {};
}
void freeGpuAddress(AddressRange addressRange, uint32_t rootDeviceIndex) override{};
NEO::GraphicsAllocation *createGraphicsAllocation(OsHandleStorage &handleStorage, const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryForNonSvmHostPtr(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryWithAlignment(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateUSMHostGraphicsMemory(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemory64kb(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocate32BitGraphicsMemoryImpl(const NEO::AllocationData &allocationData, bool useLocalMemory) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const NEO::AllocationData &allocationData, AllocationStatus &status) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const NEO::AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override { return nullptr; };
NEO::GraphicsAllocation *allocateMemoryByKMD(const NEO::AllocationData &allocationData) override { return nullptr; };
void *lockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override { return nullptr; };
void unlockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override{};
NEO::GraphicsAllocation *allocateGraphicsMemoryInPreferredPool(const AllocationProperties &properties, const void *hostPtr) override {
auto ptr = reinterpret_cast<void *>(sharedHandleAddress++);
auto gmmHelper = getGmmHelper(0);
auto canonizedGpuAddress = gmmHelper->canonize(castToUint64(ptr));
size_t size = 0x1000;
auto alloc = new IpcImplicitScalingObtainFdMockGraphicsAllocation(0u,
NEO::AllocationType::BUFFER,
nullptr,
ptr,
size,
0u,
MemoryPool::System4KBPages,
canonizedGpuAddress);
auto &drm = this->getDrm(0u);
MockBufferObject bo0(&drm);
MockBufferObject bo1(&drm);
alloc->bufferObjects[0] = &bo0;
alloc->bufferObjects[1] = &bo1;
alloc->setGpuBaseAddress(0xabcd);
return alloc;
}
NEO::GraphicsAllocation *allocateGraphicsMemoryWithProperties(const AllocationProperties &properties) override {
auto ptr = reinterpret_cast<void *>(sharedHandleAddress++);
auto gmmHelper = getGmmHelper(0);
auto canonizedGpuAddress = gmmHelper->canonize(castToUint64(ptr));
size_t size = 0x1000;
auto alloc = new IpcImplicitScalingObtainFdMockGraphicsAllocation(0u,
NEO::AllocationType::BUFFER,
nullptr,
ptr,
size,
0u,
MemoryPool::System4KBPages,
canonizedGpuAddress);
auto &drm = this->getDrm(0u);
MockBufferObject bo0(&drm);
MockBufferObject bo1(&drm);
alloc->bufferObjects[0] = &bo0;
alloc->bufferObjects[1] = &bo1;
alloc->setGpuBaseAddress(0xabcd);
return alloc;
}
NEO::GraphicsAllocation *createGraphicsAllocationFromMultipleSharedHandles(const std::vector<osHandle> &handles,
AllocationProperties &properties,
bool requireSpecificBitness,
bool isHostIpcAllocation) override {
if (failOnCreateGraphicsAllocationFromSharedHandle) {
return nullptr;
}
auto ptr = reinterpret_cast<void *>(sharedHandleAddress++);
auto gmmHelper = getGmmHelper(0);
auto canonizedGpuAddress = gmmHelper->canonize(castToUint64(ptr));
size_t size = 0x1000;
auto alloc = new IpcImplicitScalingObtainFdMockGraphicsAllocation(0u,
NEO::AllocationType::BUFFER,
nullptr,
ptr,
size,
0u,
MemoryPool::System4KBPages,
canonizedGpuAddress);
auto &drm = this->getDrm(0u);
MockBufferObject bo0(&drm);
MockBufferObject bo1(&drm);
alloc->bufferObjects[0] = &bo0;
alloc->bufferObjects[1] = &bo1;
alloc->setGpuBaseAddress(0xabcd);
return alloc;
}
void freeGraphicsMemory(NEO::GraphicsAllocation *alloc, bool isImportedAllocation) override {
delete alloc;
}
int obtainFdFromHandle(int boHandle, uint32_t rootDeviceIndex) override {
if (failOnObtainFdFromHandle) {
return -1;
}
return NEO::DrmMemoryManager::obtainFdFromHandle(boHandle, rootDeviceIndex);
}
bool failOnObtainFdFromHandle = false;
uint64_t sharedHandleAddress = 0x1234;
bool failOnCreateGraphicsAllocationFromSharedHandle = false;
};
struct MemoryExportImportObtainFdTest : public ::testing::Test {
void SetUp() override {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableImplicitScaling.set(1);
executionEnvironment = new NEO::ExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(numRootDevices);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(&hwInfo);
}
deviceFactory = std::make_unique<UltDeviceFactory>(numRootDevices, numSubDevices, *executionEnvironment);
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
devices.push_back(std::unique_ptr<NEO::Device>(deviceFactory->rootDevices[i]));
executionEnvironment->rootDeviceEnvironments[i]->osInterface.reset(new NEO::OSInterface());
auto drmMock = new DrmMockResources(*executionEnvironment->rootDeviceEnvironments[i]);
executionEnvironment->rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<Drm>(drmMock));
}
driverHandle = std::make_unique<DriverHandleImp>();
driverHandle->initialize(std::move(devices));
prevMemoryManager = driverHandle->getMemoryManager();
currMemoryManager = new MemoryManagerIpcImplicitScalingObtainFdMock(*executionEnvironment);
driverHandle->setMemoryManager(currMemoryManager);
prevSvmAllocsManager = driverHandle->svmAllocsManager;
currSvmAllocsManager = new NEO::SVMAllocsManager(currMemoryManager, false);
driverHandle->svmAllocsManager = currSvmAllocsManager;
context = std::make_unique<L0::ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
for (auto i = 0u; i < numRootDevices; i++) {
auto dev = driverHandle->devices[i];
context->getDevices().insert(std::make_pair(dev->getRootDeviceIndex(), dev->toHandle()));
}
device = driverHandle->devices[0];
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.push_back(neoDevice->getRootDeviceIndex());
context->deviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
driverHandle->svmAllocsManager = prevSvmAllocsManager;
delete currSvmAllocsManager;
driverHandle->setMemoryManager(prevMemoryManager);
delete currMemoryManager;
}
static constexpr uint32_t numRootDevices = 2u;
static constexpr uint32_t numSubDevices = 2u;
std::vector<std::unique_ptr<NEO::Device>> devices;
std::unique_ptr<UltDeviceFactory> deviceFactory;
SVMAllocsManager *prevSvmAllocsManager;
NEO::SVMAllocsManager *currSvmAllocsManager;
NEO::ExecutionEnvironment *executionEnvironment = nullptr;
NEO::MemoryManager *prevMemoryManager = nullptr;
MemoryManagerIpcImplicitScalingObtainFdMock *currMemoryManager = nullptr;
std::unique_ptr<L0::DriverHandleImp> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<L0::ContextImp> context;
};
TEST_F(MemoryExportImportObtainFdTest,
givenCallToGetIpcHandlesWithFailureToGetFdHandleThenOutOfHostMemoryIsReturned) {
size_t size = 10;
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_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
uint32_t numIpcHandles = 0;
result = context->getIpcMemHandles(ptr, &numIpcHandles, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(numIpcHandles, 2u);
currMemoryManager->failOnObtainFdFromHandle = true;
std::vector<ze_ipc_mem_handle_t> ipcHandles(numIpcHandles);
result = context->getIpcMemHandles(ptr, &numIpcHandles, ipcHandles.data());
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(MemoryExportImportObtainFdTest,
givenCallToGetIpcHandlesWithFdHandleThenSuccessIsReturned) {
size_t size = 10;
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_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
uint32_t numIpcHandles = 0;
result = context->getIpcMemHandles(ptr, &numIpcHandles, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(numIpcHandles, 2u);
currMemoryManager->failOnObtainFdFromHandle = false;
std::vector<ze_ipc_mem_handle_t> ipcHandles(numIpcHandles);
result = context->getIpcMemHandles(ptr, &numIpcHandles, ipcHandles.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(MemoryExportImportObtainFdTest,
givenCallToGetIpcHandleWithFailureToGetFdHandleThenOutOfHostMemoryIsReturned) {
size_t size = 10;
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_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
currMemoryManager->failOnObtainFdFromHandle = true;
ze_ipc_mem_handle_t ipcHandle{};
result = context->getIpcMemHandle(ptr, &ipcHandle);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(MemoryExportImportObtainFdTest,
givenCallToGetIpcHandleWithFdHandleThenSuccessIsReturned) {
size_t size = 10;
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_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
currMemoryManager->failOnObtainFdFromHandle = false;
ze_ipc_mem_handle_t ipcHandle{};
result = context->getIpcMemHandle(ptr, &ipcHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(MemoryExportImportObtainFdTest,
givenCallToEventPoolGetIpcHandleWithFailureToGetFdHandleThenOutOfHostMemoryIsReturned) {
uint32_t numEvents = 4;
ze_event_pool_desc_t eventPoolDesc = {
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_IPC,
numEvents};
auto deviceHandle = device->toHandle();
ze_result_t result = ZE_RESULT_SUCCESS;
auto eventPool = static_cast<EventPoolImp *>(EventPool::create(driverHandle.get(),
context.get(),
1,
&deviceHandle,
&eventPoolDesc,
result));
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, eventPool);
eventPool->isShareableEventMemory = true;
currMemoryManager->failOnObtainFdFromHandle = true;
ze_ipc_event_pool_handle_t ipcHandle = {};
result = eventPool->getIpcHandle(&ipcHandle);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
result = eventPool->destroy();
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(MemoryExportImportObtainFdTest,
givenCallToEventPoolGetIpcHandleWithFdHandleThenSuccessIsReturned) {
uint32_t numEvents = 4;
ze_event_pool_desc_t eventPoolDesc = {
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_IPC,
numEvents};
auto deviceHandle = device->toHandle();
ze_result_t result = ZE_RESULT_SUCCESS;
auto eventPool = static_cast<EventPoolImp *>(EventPool::create(driverHandle.get(),
context.get(),
1,
&deviceHandle,
&eventPoolDesc,
result));
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, eventPool);
eventPool->isShareableEventMemory = true;
currMemoryManager->failOnObtainFdFromHandle = false;
ze_ipc_event_pool_handle_t ipcHandle = {};
result = eventPool->getIpcHandle(&ipcHandle);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
result = eventPool->destroy();
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(MemoryExportImportObtainFdTest,
whenPeerAllocationForDeviceAllocationIsRequestedThenPeerAllocationIsReturned) {
L0::Device *device0 = driverHandle->devices[0];
L0::Device *device1 = driverHandle->devices[1];
size_t size = 1024;
size_t alignment = 1u;
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = context->allocDeviceMem(device0->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
uintptr_t peerGpuAddress = 0u;
auto allocData = context->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
EXPECT_NE(allocData, nullptr);
currMemoryManager->failOnObtainFdFromHandle = false;
auto peerAlloc = driverHandle->getPeerAllocation(device1, allocData, ptr, &peerGpuAddress);
EXPECT_NE(peerAlloc, nullptr);
result = context->freeMem(ptr);
ASSERT_EQ(result, ZE_RESULT_SUCCESS);
}
TEST_F(MemoryExportImportObtainFdTest,
whenPeerAllocationForDeviceAllocationIsRequestedThenNullptrIsReturned) {
L0::Device *device0 = driverHandle->devices[0];
L0::Device *device1 = driverHandle->devices[1];
size_t size = 1024;
size_t alignment = 1u;
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = context->allocDeviceMem(device0->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
uintptr_t peerGpuAddress = 0u;
auto allocData = context->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
EXPECT_NE(allocData, nullptr);
currMemoryManager->failOnObtainFdFromHandle = true;
auto peerAlloc = driverHandle->getPeerAllocation(device1, allocData, ptr, &peerGpuAddress);
EXPECT_EQ(peerAlloc, nullptr);
result = context->freeMem(ptr);
ASSERT_EQ(result, ZE_RESULT_SUCCESS);
}
class IpcObtainFdMockGraphicsAllocation : public NEO::DrmAllocation {
public:
using NEO::DrmAllocation::bufferObjects;
IpcObtainFdMockGraphicsAllocation(uint32_t rootDeviceIndex,
AllocationType allocationType,
BufferObject *bo,
void *ptrIn,
size_t sizeIn,
NEO::osHandle sharedHandle,
MemoryPool pool,
uint64_t canonizedGpuAddress) : NEO::DrmAllocation(rootDeviceIndex,
allocationType,
bo,
ptrIn,
sizeIn,
sharedHandle,
pool,
canonizedGpuAddress) {
bufferObjects.resize(1u);
}
uint32_t getNumHandles() override {
return 1u;
}
bool isResident(uint32_t contextId) const override {
return false;
}
};
class MemoryManagerIpcObtainFdMock : public NEO::DrmMemoryManager {
public:
MemoryManagerIpcObtainFdMock(NEO::ExecutionEnvironment &executionEnvironment) : NEO::DrmMemoryManager(gemCloseWorkerMode::gemCloseWorkerInactive, false, false, executionEnvironment) {}
NEO::GraphicsAllocation *createGraphicsAllocationFromSharedHandle(osHandle handle, const AllocationProperties &properties, bool requireSpecificBitness, bool isHostIpcAllocation) override { return nullptr; }
void addAllocationToHostPtrManager(NEO::GraphicsAllocation *memory) override{};
void removeAllocationFromHostPtrManager(NEO::GraphicsAllocation *memory) override{};
NEO::GraphicsAllocation *createGraphicsAllocationFromNTHandle(void *handle, uint32_t rootDeviceIndex, AllocationType allocType) override { return nullptr; };
AllocationStatus populateOsHandles(NEO::OsHandleStorage &handleStorage, uint32_t rootDeviceIndex) override { return AllocationStatus::Success; };
void cleanOsHandles(NEO::OsHandleStorage &handleStorage, uint32_t rootDeviceIndex) override{};
void freeGraphicsMemoryImpl(NEO::GraphicsAllocation *gfxAllocation) override{};
void freeGraphicsMemoryImpl(GraphicsAllocation *gfxAllocation, bool isImportedAllocation) override{};
uint64_t getSystemSharedMemory(uint32_t rootDeviceIndex) override { return 0; };
uint64_t getLocalMemorySize(uint32_t rootDeviceIndex, uint32_t deviceBitfield) override { return 0; };
double getPercentOfGlobalMemoryAvailable(uint32_t rootDeviceIndex) override { return 0; }
AddressRange reserveGpuAddress(size_t size, uint32_t rootDeviceIndex) override {
return {};
}
void freeGpuAddress(AddressRange addressRange, uint32_t rootDeviceIndex) override{};
NEO::GraphicsAllocation *createGraphicsAllocation(OsHandleStorage &handleStorage, const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryForNonSvmHostPtr(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryWithAlignment(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateUSMHostGraphicsMemory(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemory64kb(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocate32BitGraphicsMemoryImpl(const NEO::AllocationData &allocationData, bool useLocalMemory) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const NEO::AllocationData &allocationData, AllocationStatus &status) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const NEO::AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override { return nullptr; };
NEO::GraphicsAllocation *allocateMemoryByKMD(const NEO::AllocationData &allocationData) override { return nullptr; };
void *lockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override { return nullptr; };
void unlockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override{};
NEO::GraphicsAllocation *allocateGraphicsMemoryInPreferredPool(const AllocationProperties &properties, const void *hostPtr) override {
auto ptr = reinterpret_cast<void *>(sharedHandleAddress++);
auto gmmHelper = getGmmHelper(0);
auto canonizedGpuAddress = gmmHelper->canonize(castToUint64(ptr));
size_t size = 0x1000;
auto alloc = new IpcObtainFdMockGraphicsAllocation(0u,
NEO::AllocationType::BUFFER,
nullptr,
ptr,
size,
0u,
MemoryPool::System4KBPages,
canonizedGpuAddress);
auto &drm = this->getDrm(0u);
MockBufferObject bo0(&drm);
alloc->bufferObjects[0] = &bo0;
alloc->setGpuBaseAddress(0xabcd);
return alloc;
}
NEO::GraphicsAllocation *allocateGraphicsMemoryWithProperties(const AllocationProperties &properties) override {
auto ptr = reinterpret_cast<void *>(sharedHandleAddress++);
auto gmmHelper = getGmmHelper(0);
auto canonizedGpuAddress = gmmHelper->canonize(castToUint64(ptr));
size_t size = 0x1000;
auto alloc = new IpcObtainFdMockGraphicsAllocation(0u,
NEO::AllocationType::BUFFER,
nullptr,
ptr,
size,
0u,
MemoryPool::System4KBPages,
canonizedGpuAddress);
auto &drm = this->getDrm(0u);
MockBufferObject bo0(&drm);
alloc->bufferObjects[0] = &bo0;
alloc->setGpuBaseAddress(0xabcd);
return alloc;
}
NEO::GraphicsAllocation *createGraphicsAllocationFromMultipleSharedHandles(const std::vector<osHandle> &handles,
AllocationProperties &properties,
bool requireSpecificBitness,
bool isHostIpcAllocation) override {
if (failOnCreateGraphicsAllocationFromSharedHandle) {
return nullptr;
}
auto ptr = reinterpret_cast<void *>(sharedHandleAddress++);
auto gmmHelper = getGmmHelper(0);
auto canonizedGpuAddress = gmmHelper->canonize(castToUint64(ptr));
size_t size = 0x1000;
auto alloc = new IpcObtainFdMockGraphicsAllocation(0u,
NEO::AllocationType::BUFFER,
nullptr,
ptr,
size,
0u,
MemoryPool::System4KBPages,
canonizedGpuAddress);
auto &drm = this->getDrm(0u);
MockBufferObject bo0(&drm);
alloc->bufferObjects[0] = &bo0;
alloc->setGpuBaseAddress(0xabcd);
return alloc;
}
void freeGraphicsMemory(NEO::GraphicsAllocation *alloc, bool isImportedAllocation) override {
delete alloc;
}
int obtainFdFromHandle(int boHandle, uint32_t rootDeviceIndex) override {
if (failOnObtainFdFromHandle) {
return -1;
}
return NEO::DrmMemoryManager::obtainFdFromHandle(boHandle, rootDeviceIndex);
}
bool failOnObtainFdFromHandle = false;
uint64_t sharedHandleAddress = 0x1234;
bool failOnCreateGraphicsAllocationFromSharedHandle = false;
};
struct DriverHandleObtaindFdMock : public L0::DriverHandleImp {
void *importFdHandle(NEO::Device *neoDevice, ze_ipc_memory_flags_t flags, uint64_t handle, NEO::GraphicsAllocation **pAloc) override {
DeviceBitfield deviceBitfield{0x0};
AllocationProperties properties(0, MemoryConstants::pageSize,
AllocationType::BUFFER,
deviceBitfield);
auto alloc = getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
return reinterpret_cast<void *>(alloc->getGpuAddress());
}
};
struct MemoryObtainFdTest : public ::testing::Test {
void SetUp() override {
DebugManagerStateRestore restorer;
executionEnvironment = new NEO::ExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(numRootDevices);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(&hwInfo);
}
deviceFactory = std::make_unique<UltDeviceFactory>(numRootDevices, numSubDevices, *executionEnvironment);
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
devices.push_back(std::unique_ptr<NEO::Device>(deviceFactory->rootDevices[i]));
executionEnvironment->rootDeviceEnvironments[i]->osInterface.reset(new NEO::OSInterface());
auto drmMock = new DrmMockResources(*executionEnvironment->rootDeviceEnvironments[i]);
executionEnvironment->rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<Drm>(drmMock));
}
driverHandle = std::make_unique<DriverHandleObtaindFdMock>();
driverHandle->initialize(std::move(devices));
prevMemoryManager = driverHandle->getMemoryManager();
currMemoryManager = new MemoryManagerIpcObtainFdMock(*executionEnvironment);
driverHandle->setMemoryManager(currMemoryManager);
prevSvmAllocsManager = driverHandle->svmAllocsManager;
currSvmAllocsManager = new NEO::SVMAllocsManager(currMemoryManager, false);
driverHandle->svmAllocsManager = currSvmAllocsManager;
context = std::make_unique<L0::ContextImp>(driverHandle.get());
EXPECT_NE(context, nullptr);
for (auto i = 0u; i < numRootDevices; i++) {
auto dev = driverHandle->devices[i];
context->getDevices().insert(std::make_pair(dev->getRootDeviceIndex(), dev->toHandle()));
}
device = driverHandle->devices[0];
auto neoDevice = device->getNEODevice();
context->rootDeviceIndices.push_back(neoDevice->getRootDeviceIndex());
context->deviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
}
void TearDown() override {
driverHandle->svmAllocsManager = prevSvmAllocsManager;
delete currSvmAllocsManager;
driverHandle->setMemoryManager(prevMemoryManager);
delete currMemoryManager;
}
static constexpr uint32_t numRootDevices = 2u;
static constexpr uint32_t numSubDevices = 2u;
std::vector<std::unique_ptr<NEO::Device>> devices;
std::unique_ptr<UltDeviceFactory> deviceFactory;
SVMAllocsManager *prevSvmAllocsManager;
NEO::SVMAllocsManager *currSvmAllocsManager;
NEO::ExecutionEnvironment *executionEnvironment = nullptr;
NEO::MemoryManager *prevMemoryManager = nullptr;
MemoryManagerIpcObtainFdMock *currMemoryManager = nullptr;
std::unique_ptr<DriverHandleObtaindFdMock> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
std::unique_ptr<L0::ContextImp> context;
};
TEST_F(MemoryObtainFdTest,
whenPeerAllocationForDeviceAllocationIsRequestedThenNullptrIsReturned) {
L0::Device *device0 = driverHandle->devices[0];
L0::Device *device1 = driverHandle->devices[1];
size_t size = 1024;
size_t alignment = 1u;
void *ptr = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_result_t result = context->allocDeviceMem(device0->toHandle(),
&deviceDesc,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
uintptr_t peerGpuAddress = 0u;
auto allocData = context->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
EXPECT_NE(allocData, nullptr);
currMemoryManager->failOnObtainFdFromHandle = true;
auto peerAlloc = driverHandle->getPeerAllocation(device1, allocData, ptr, &peerGpuAddress);
EXPECT_EQ(peerAlloc, nullptr);
result = context->freeMem(ptr);
ASSERT_EQ(result, ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

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

@ -7,7 +7,6 @@
#include "shared/source/helpers/file_io.h"
#include "shared/source/helpers/string.h"
#include "shared/source/memory_manager/graphics_allocation.h"
#include "shared/source/memory_manager/memory_operations_status.h"
#include "shared/source/os_interface/device_factory.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
@ -1802,53 +1801,6 @@ TEST_F(MemoryExportImportTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(MemoryExportImportTest,
givenCallToMemAllocPropertiesWithExtendedExportPropertiesAndNoFdHandleThenErrorIsReturned) {
class ExportImportMockGraphicsAllocation : public NEO::MemoryAllocation {
public:
ExportImportMockGraphicsAllocation() : NEO::MemoryAllocation(0, AllocationType::BUFFER, nullptr, 0u, 0, MemoryPool::MemoryNull, MemoryManager::maxOsContextCount, 0llu) {}
int peekInternalHandle(NEO::MemoryManager *memoryManager, uint64_t &handle) override {
return -1;
}
};
ze_memory_allocation_properties_t memoryProperties = {};
ze_external_memory_export_fd_t extendedProperties = {};
extendedProperties.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_FD;
extendedProperties.fd = std::numeric_limits<int>::max();
memoryProperties.pNext = &extendedProperties;
ze_memory_type_t type = ZE_MEMORY_TYPE_DEVICE;
ExportImportMockGraphicsAllocation alloc;
ze_result_t result = context->handleAllocationExtensions(&alloc, type, &extendedProperties, driverHandle.get());
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
}
TEST_F(MemoryExportImportTest,
givenCallToMemAllocPropertiesWithExtendedExportPropertiesAndNoFdHandleForWin32FormatThenErrorIsReturned) {
class ExportImportMockGraphicsAllocation : public NEO::MemoryAllocation {
public:
ExportImportMockGraphicsAllocation() : NEO::MemoryAllocation(0, AllocationType::BUFFER, nullptr, 0u, 0, MemoryPool::MemoryNull, MemoryManager::maxOsContextCount, 0llu) {}
int peekInternalHandle(NEO::MemoryManager *memoryManager, uint64_t &handle) override {
return -1;
}
};
ze_memory_allocation_properties_t memoryProperties = {};
ze_external_memory_export_fd_t extendedProperties = {};
extendedProperties.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_WIN32;
extendedProperties.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32;
extendedProperties.fd = std::numeric_limits<int>::max();
memoryProperties.pNext = &extendedProperties;
ze_memory_type_t type = ZE_MEMORY_TYPE_DEVICE;
ExportImportMockGraphicsAllocation alloc;
ze_result_t result = context->handleAllocationExtensions(&alloc, type, &extendedProperties, driverHandle.get());
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
}
TEST_F(MemoryExportImportTest,
givenCallToMemAllocPropertiesWithExtendedExportPropertiesForNonDeviceAllocationThenUnsupportedFeatureIsReturned) {
size_t size = 10;

2
opencl/source/mem_obj/mem_obj.cpp
View File

@ -193,7 +193,7 @@ cl_int MemObj::getMemObjectInfo(cl_mem_info paramName,
break;
case CL_MEM_ALLOCATION_HANDLE_INTEL:
multiGraphicsAllocation.getDefaultGraphicsAllocation()->peekInternalHandle(this->memoryManager, internalHandle);
internalHandle = multiGraphicsAllocation.getDefaultGraphicsAllocation()->peekInternalHandle(this->memoryManager);
srcParamSize = sizeof(internalHandle);
srcParam = &internalHandle;
break;

9
opencl/test/unit_test/os_interface/windows/wddm20_tests.cpp
View File

@ -481,9 +481,7 @@ TEST_F(WddmTestWithMockGdiDll, givenShareableAllocationWhenCreateThenSharedHandl
allocation.setDefaultGmm(gmm.get());
auto status = memoryManager.createGpuAllocationsWithRetry(&allocation);
EXPECT_TRUE(status);
uint64_t handle = 0;
allocation.peekInternalHandle(&memoryManager, handle);
EXPECT_NE(0u, handle);
EXPECT_NE(0u, allocation.peekInternalHandle(&memoryManager));
}
TEST(WddmAllocationTest, whenAllocationIsShareableThenSharedHandleToModifyIsSharedHandleOfAllocation) {
@ -491,10 +489,7 @@ TEST(WddmAllocationTest, whenAllocationIsShareableThenSharedHandleToModifyIsShar
auto sharedHandleToModify = allocation.getSharedHandleToModify();
EXPECT_NE(nullptr, sharedHandleToModify);
*sharedHandleToModify = 1234u;
uint64_t handle = 0;
int ret = allocation.peekInternalHandle(nullptr, handle);
EXPECT_EQ(ret, 0);
EXPECT_EQ(*sharedHandleToModify, handle);
EXPECT_EQ(*sharedHandleToModify, allocation.peekInternalHandle(nullptr));
}
TEST(WddmAllocationTest, whenAllocationIsNotShareableThenItDoesntReturnSharedHandleToModify) {

8
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_allocate_in_device_pool_tests.cpp
View File

@ -75,9 +75,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenShareableAllocationWhenAllocateInDevice
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_EQ(0u, allocation->getDefaultGmm()->resourceParams.Flags.Info.NonLocalOnly);
uint64_t handle = 0;
allocation->peekInternalHandle(memoryManager.get(), handle);
EXPECT_NE(handle, 0u);
EXPECT_NE(allocation->peekInternalHandle(memoryManager.get()), 0u);
EXPECT_EQ(1u, allocation->getDefaultGmm()->resourceParams.Flags.Info.LocalOnly);
EXPECT_EQ(1u, allocation->getDefaultGmm()->resourceParams.Flags.Info.NotLockable);
@ -104,9 +102,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenShareableAllocationWhenAllocateGraphics
EXPECT_NE(nullptr, allocation);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_EQ(0u, allocation->getDefaultGmm()->resourceParams.Flags.Info.NonLocalOnly);
uint64_t handle = 0;
allocation->peekInternalHandle(memoryManager.get(), handle);
EXPECT_NE(handle, 0u);
EXPECT_NE(allocation->peekInternalHandle(memoryManager.get()), 0u);
EXPECT_EQ(1u, allocation->getDefaultGmm()->resourceParams.Flags.Info.LocalOnly);
EXPECT_EQ(1u, allocation->getDefaultGmm()->resourceParams.Flags.Info.NotLockable);

6
shared/source/memory_manager/graphics_allocation.h
View File

@ -169,10 +169,10 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
bool isResidencyTaskCountBelow(uint32_t taskCount, uint32_t contextId) const { return !isResident(contextId) || getResidencyTaskCount(contextId) < taskCount; }
virtual std::string getAllocationInfoString() const;
virtual int peekInternalHandle(MemoryManager *memoryManager, uint64_t &handle) { return 0; }
virtual uint64_t peekInternalHandle(MemoryManager *memoryManager) { return 0llu; }
virtual int peekInternalHandle(MemoryManager *memoryManager, uint32_t handleId, uint64_t &handle) {
return 0;
virtual uint64_t peekInternalHandle(MemoryManager *memoryManager, uint32_t handleId) {
return 0u;
}
virtual uint32_t getNumHandles() {

26
shared/source/os_interface/linux/drm_allocation.cpp
View File

@ -37,24 +37,20 @@ std::string DrmAllocation::getAllocationInfoString() const {
return ss.str();
}
int DrmAllocation::peekInternalHandle(MemoryManager *memoryManager, uint64_t &handle) {
return peekInternalHandle(memoryManager, 0u, handle);
uint64_t DrmAllocation::peekInternalHandle(MemoryManager *memoryManager) {
if (handles[0] != std::numeric_limits<uint32_t>::max()) {
return handles[0];
}
handles[0] = static_cast<uint64_t>((static_cast<DrmMemoryManager *>(memoryManager))->obtainFdFromHandle(getBO()->peekHandle(), this->rootDeviceIndex));
return handles[0];
}
int DrmAllocation::peekInternalHandle(MemoryManager *memoryManager, uint32_t handleId, uint64_t &handle) {
if (handles[handleId] != std::numeric_limits<uint64_t>::max()) {
handle = handles[handleId];
return 0;
uint64_t DrmAllocation::peekInternalHandle(MemoryManager *memoryManager, uint32_t handleId) {
if (handles[handleId] != std::numeric_limits<uint32_t>::max()) {
return handles[handleId];
}
int64_t ret = static_cast<int64_t>((static_cast<DrmMemoryManager *>(memoryManager))->obtainFdFromHandle(getBufferObjectToModify(handleId)->peekHandle(), this->rootDeviceIndex));
if (ret < 0) {
return -1;
}
handle = handles[handleId] = ret;
return 0;
handles[handleId] = static_cast<uint64_t>((static_cast<DrmMemoryManager *>(memoryManager))->obtainFdFromHandle(getBufferObjectToModify(handleId)->peekHandle(), this->rootDeviceIndex));
return handles[handleId];
}
void DrmAllocation::setCachePolicy(CachePolicy memType) {

12
shared/source/os_interface/linux/drm_allocation.h
View File

@ -40,7 +40,7 @@ class DrmAllocation : public GraphicsAllocation {
DrmAllocation(uint32_t rootDeviceIndex, size_t numGmms, AllocationType allocationType, BufferObject *bo, void *ptrIn, size_t sizeIn, osHandle sharedHandle, MemoryPool pool, uint64_t canonizedGpuAddress)
: GraphicsAllocation(rootDeviceIndex, numGmms, allocationType, ptrIn, sizeIn, sharedHandle, pool, MemoryManager::maxOsContextCount, canonizedGpuAddress), bufferObjects(EngineLimits::maxHandleCount) {
bufferObjects[0] = bo;
handles.resize(EngineLimits::maxHandleCount, std::numeric_limits<uint64_t>::max());
handles.resize(EngineLimits::maxHandleCount, std::numeric_limits<uint32_t>::max());
}
DrmAllocation(uint32_t rootDeviceIndex, AllocationType allocationType, BufferObject *bo, void *ptrIn, uint64_t canonizedGpuAddress, size_t sizeIn, MemoryPool pool)
@ -49,7 +49,7 @@ class DrmAllocation : public GraphicsAllocation {
DrmAllocation(uint32_t rootDeviceIndex, size_t numGmms, AllocationType allocationType, BufferObject *bo, void *ptrIn, uint64_t canonizedGpuAddress, size_t sizeIn, MemoryPool pool)
: GraphicsAllocation(rootDeviceIndex, numGmms, allocationType, ptrIn, canonizedGpuAddress, 0, sizeIn, pool, MemoryManager::maxOsContextCount), bufferObjects(EngineLimits::maxHandleCount) {
bufferObjects[0] = bo;
handles.resize(EngineLimits::maxHandleCount, std::numeric_limits<uint64_t>::max());
handles.resize(EngineLimits::maxHandleCount, std::numeric_limits<uint32_t>::max());
}
DrmAllocation(uint32_t rootDeviceIndex, AllocationType allocationType, BufferObjects &bos, void *ptrIn, uint64_t canonizedGpuAddress, size_t sizeIn, MemoryPool pool)
@ -58,7 +58,7 @@ class DrmAllocation : public GraphicsAllocation {
DrmAllocation(uint32_t rootDeviceIndex, size_t numGmms, AllocationType allocationType, BufferObjects &bos, void *ptrIn, uint64_t canonizedGpuAddress, size_t sizeIn, MemoryPool pool)
: GraphicsAllocation(rootDeviceIndex, numGmms, allocationType, ptrIn, canonizedGpuAddress, 0, sizeIn, pool, MemoryManager::maxOsContextCount),
bufferObjects(bos) {
handles.resize(EngineLimits::maxHandleCount, std::numeric_limits<uint64_t>::max());
handles.resize(EngineLimits::maxHandleCount, std::numeric_limits<uint32_t>::max());
}
~DrmAllocation() override;
@ -74,7 +74,7 @@ class DrmAllocation : public GraphicsAllocation {
const BufferObjects &getBOs() const {
return this->bufferObjects;
}
MOCKABLE_VIRTUAL BufferObject *&getBufferObjectToModify(uint32_t handleIndex) {
BufferObject *&getBufferObjectToModify(uint32_t handleIndex) {
return bufferObjects[handleIndex];
}
@ -90,9 +90,9 @@ class DrmAllocation : public GraphicsAllocation {
this->numHandles = numHandles;
}
int peekInternalHandle(MemoryManager *memoryManager, uint64_t &handle) override;
uint64_t peekInternalHandle(MemoryManager *memoryManager) override;
int peekInternalHandle(MemoryManager *memoryManager, uint32_t handleId, uint64_t &handle) override;
uint64_t peekInternalHandle(MemoryManager *memoryManager, uint32_t handleId) override;
bool setCacheRegion(Drm *drm, CacheRegion regionIndex);
bool setCacheAdvice(Drm *drm, size_t regionSize, CacheRegion regionIndex);

11
shared/source/os_interface/linux/drm_memory_manager.cpp
View File

@ -978,11 +978,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromExistingStorag
properties.size = defaultAlloc->getUnderlyingBufferSize();
properties.gpuAddress = castToUint64(ptr);
uint64_t internalHandle = 0;
int ret = defaultAlloc->peekInternalHandle(this, internalHandle);
if (ret < 0) {
return nullptr;
}
auto internalHandle = defaultAlloc->peekInternalHandle(this);
return createUSMHostAllocationFromSharedHandle(static_cast<osHandle>(internalHandle), properties, true);
} else {
return allocateGraphicsMemoryWithProperties(properties, ptr);
@ -1118,10 +1114,7 @@ int DrmMemoryManager::obtainFdFromHandle(int boHandle, uint32_t rootDeviceIndex)
openFd.flags = ioctlHelper->getFlagsForPrimeHandleToFd();
openFd.handle = boHandle;
int ret = ioctlHelper->ioctl(DrmIoctl::PrimeHandleToFd, &openFd);
if (ret < 0) {
return -1;
}
ioctlHelper->ioctl(DrmIoctl::PrimeHandleToFd, &openFd);
return openFd.fileDescriptor;
}

5
shared/source/os_interface/windows/wddm_allocation.h
View File

@ -72,9 +72,8 @@ class WddmAllocation : public GraphicsAllocation {
handles[handleIndex] = handle;
}
int peekInternalHandle(MemoryManager *memoryManager, uint64_t &handle) override {
handle = ntSecureHandle;
return 0;
uint64_t peekInternalHandle(MemoryManager *memoryManager) override {
return ntSecureHandle;
}
uint64_t *getSharedHandleToModify() {

6
shared/source/os_interface/windows/wddm_memory_manager.cpp
View File

@ -557,10 +557,8 @@ void WddmMemoryManager::freeGraphicsMemoryImpl(GraphicsAllocation *gfxAllocation
for (auto handleId = 0u; handleId < gfxAllocation->getNumGmms(); handleId++) {
delete gfxAllocation->getGmm(handleId);
}
uint64_t handle = 0;
int ret = input->peekInternalHandle(nullptr, handle);
if (ret == 0) {
[[maybe_unused]] auto status = SysCalls::closeHandle(reinterpret_cast<void *>(reinterpret_cast<uintptr_t *>(handle)));
if (input->peekInternalHandle(nullptr) != 0u) {
[[maybe_unused]] auto status = SysCalls::closeHandle(reinterpret_cast<void *>(reinterpret_cast<uintptr_t *>(input->peekInternalHandle(nullptr))));
DEBUG_BREAK_IF(!status);
}

9
shared/test/common/mocks/linux/mock_drm_memory_manager.h
View File

@ -160,15 +160,6 @@ class TestedDrmMemoryManager : public MemoryManagerCreate<DrmMemoryManager> {
bool failOnfindAndReferenceSharedBufferObject = false;
bool failOnObtainFdFromHandle = false;
int obtainFdFromHandle(int boHandle, uint32_t rootDeviceIndex) override {
if (failOnObtainFdFromHandle) {
return -1;
}
return DrmMemoryManager::obtainFdFromHandle(boHandle, rootDeviceIndex);
}
ExecutionEnvironment *executionEnvironment = nullptr;
protected:

4
shared/test/unit_test/memory_manager/graphics_allocation_tests.cpp
View File

@ -227,9 +227,7 @@ TEST(GraphicsAllocationTest, givenAlwaysResidentAllocationWhenUpdateTaskCountThe
TEST(GraphicsAllocationTest, givenDefaultGraphicsAllocationWhenInternalHandleIsBeingObtainedThenZeroIsReturned) {
MockGraphicsAllocation graphicsAllocation;
uint64_t handle = 0;
graphicsAllocation.peekInternalHandle(nullptr, handle);
EXPECT_EQ(0ull, handle);
EXPECT_EQ(0llu, graphicsAllocation.peekInternalHandle(nullptr));
}
TEST(GraphicsAllocationTest, givenDefaultGraphicsAllocationWhenGettingNumHandlesThenZeroIsReturned) {

40
shared/test/unit_test/os_interface/linux/drm_memory_manager_localmem_prelim_tests.cpp
View File

@ -131,46 +131,6 @@ TEST_F(DrmMemoryManagerLocalMemoryPrelimTest, givenMultiRootDeviceEnvironmentAnd
executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(osInterface);
}
TEST_F(DrmMemoryManagerLocalMemoryPrelimTest, givenMultiRootDeviceEnvironmentAndMemoryInfoWhenCreateMultiGraphicsAllocationAndObtainFdFromHandleFailsThenNullptrIsReturned) {
uint32_t rootDevicesNumber = 3u;
MultiGraphicsAllocation multiGraphics(rootDevicesNumber);
RootDeviceIndicesContainer rootDeviceIndices;
auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.release();
executionEnvironment->prepareRootDeviceEnvironments(rootDevicesNumber);
for (uint32_t i = 0; i < rootDevicesNumber; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
executionEnvironment->rootDeviceEnvironments[i]->initGmm();
auto mock = new DrmQueryMock(*executionEnvironment->rootDeviceEnvironments[i]);
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {drm_i915_gem_memory_class::I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, DrmMockHelper::getEngineOrMemoryInstanceValue(0, 0)};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, *mock));
mock->queryEngineInfo();
mock->ioctlCallsCount = 0;
executionEnvironment->rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
executionEnvironment->rootDeviceEnvironments[i]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock, 0u);
executionEnvironment->rootDeviceEnvironments[i]->initGmm();
rootDeviceIndices.push_back(i);
}
memoryManager = new TestedDrmMemoryManager(true, false, false, *executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
size_t size = 4096u;
AllocationProperties properties(rootDeviceIndex, true, size, AllocationType::BUFFER_HOST_MEMORY, false, {});
memoryManager->failOnObtainFdFromHandle = true;
auto ptr = memoryManager->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndices, properties, multiGraphics);
EXPECT_EQ(ptr, nullptr);
executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(osInterface);
}
TEST_F(DrmMemoryManagerLocalMemoryPrelimTest, givenMultiRootDeviceEnvironmentAndMemoryInfoWhenCreateMultiGraphicsAllocationAndImportFailsThenNullptrIsReturned) {
uint32_t rootDevicesNumber = 3u;
MultiGraphicsAllocation multiGraphics(rootDevicesNumber);

73
shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp
View File

@ -452,25 +452,7 @@ TEST_F(DrmMemoryManagerTest, whenPeekInternalHandleIsCalledThenBoIsReturned) {
mock->outputFd = 1337;
auto allocation = static_cast<DrmAllocation *>(this->memoryManager->allocateGraphicsMemoryWithProperties(createAllocationProperties(rootDeviceIndex, 10 * MemoryConstants::pageSize, true)));
ASSERT_NE(allocation->getBO(), nullptr);
uint64_t handle = 0;
int ret = allocation->peekInternalHandle(this->memoryManager, handle);
ASSERT_EQ(ret, 0);
ASSERT_EQ(handle, static_cast<uint64_t>(1337));
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerTest, whenPeekInternalHandleIsCalledAndObtainFdFromHandleFailsThenErrorIsReturned) {
mock->ioctl_expected.gemUserptr = 1;
mock->ioctl_expected.gemWait = 1;
mock->ioctl_expected.gemClose = 1;
mock->outputFd = 1337;
auto allocation = static_cast<DrmAllocation *>(this->memoryManager->allocateGraphicsMemoryWithProperties(createAllocationProperties(rootDeviceIndex, 10 * MemoryConstants::pageSize, true)));
ASSERT_NE(allocation->getBO(), nullptr);
memoryManager->failOnObtainFdFromHandle = true;
uint64_t handle = 0;
int ret = allocation->peekInternalHandle(this->memoryManager, handle);
ASSERT_EQ(ret, -1);
ASSERT_EQ(allocation->peekInternalHandle(this->memoryManager), static_cast<uint64_t>(1337));
memoryManager->freeGraphicsMemory(allocation);
}
@ -487,18 +469,11 @@ TEST_F(DrmMemoryManagerTest, whenCallingPeekInternalHandleSeveralTimesThenSameHa
ASSERT_NE(allocation->getBO(), nullptr);
EXPECT_EQ(mock->outputFd, static_cast<int32_t>(expectedFd));
uint64_t handle0 = 0;
int ret = allocation->peekInternalHandle(this->memoryManager, handle0);
ASSERT_EQ(ret, 0);
uint64_t handle0 = allocation->peekInternalHandle(this->memoryManager);
EXPECT_NE(mock->outputFd, static_cast<int32_t>(expectedFd));
uint64_t handle1 = 0;
uint64_t handle2 = 0;
ret = allocation->peekInternalHandle(this->memoryManager, handle1);
ASSERT_EQ(ret, 0);
ret = allocation->peekInternalHandle(this->memoryManager, handle2);
ASSERT_EQ(ret, 0);
uint64_t handle1 = allocation->peekInternalHandle(this->memoryManager);
uint64_t handle2 = allocation->peekInternalHandle(this->memoryManager);
ASSERT_EQ(handle0, expectedFd);
ASSERT_EQ(handle1, expectedFd);
@ -516,11 +491,8 @@ TEST_F(DrmMemoryManagerTest, whenPeekInternalHandleWithHandleIdIsCalledThenBoIsR
auto allocation = static_cast<DrmAllocation *>(this->memoryManager->allocateGraphicsMemoryWithProperties(createAllocationProperties(rootDeviceIndex, 10 * MemoryConstants::pageSize, true)));
ASSERT_NE(allocation->getBO(), nullptr);
uint64_t handle = 0;
uint32_t handleId = 0;
int ret = allocation->peekInternalHandle(this->memoryManager, handleId, handle);
ASSERT_EQ(ret, 0);
ASSERT_EQ(handle, static_cast<uint64_t>(1337));
ASSERT_EQ(allocation->peekInternalHandle(this->memoryManager, handleId), static_cast<uint64_t>(1337));
memoryManager->freeGraphicsMemory(allocation);
}
@ -538,17 +510,11 @@ TEST_F(DrmMemoryManagerTest, whenCallingPeekInternalHandleWithIdSeveralTimesThen
EXPECT_EQ(mock->outputFd, static_cast<int32_t>(expectedFd));
uint32_t handleId = 0;
uint64_t handle0 = 0;
int ret = allocation->peekInternalHandle(this->memoryManager, handleId, handle0);
ASSERT_EQ(ret, 0);
uint64_t handle0 = allocation->peekInternalHandle(this->memoryManager, handleId);
EXPECT_NE(mock->outputFd, static_cast<int32_t>(expectedFd));
uint64_t handle1 = 0;
uint64_t handle2 = 0;
ret = allocation->peekInternalHandle(this->memoryManager, handleId, handle1);
ASSERT_EQ(ret, 0);
ret = allocation->peekInternalHandle(this->memoryManager, handleId, handle2);
ASSERT_EQ(ret, 0);
uint64_t handle1 = allocation->peekInternalHandle(this->memoryManager, handleId);
uint64_t handle2 = allocation->peekInternalHandle(this->memoryManager, handleId);
ASSERT_EQ(handle0, expectedFd);
ASSERT_EQ(handle1, expectedFd);
@ -3197,29 +3163,6 @@ TEST(DrmMemoryManagerWithExplicitExpectationsTest2, whenObtainFdFromHandleIsCall
}
}
TEST(DrmMemoryManagerWithExplicitExpectationsTest2, whenFailingToObtainFdFromHandleThenErrorIsReturned) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(4u);
for (auto i = 0u; i < 4u; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmMockCustom(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
executionEnvironment->rootDeviceEnvironments[i]->initGmm();
}
auto memoryManager = std::make_unique<TestedDrmMemoryManager>(false, false, false, *executionEnvironment);
for (auto i = 0u; i < 4u; i++) {
auto mock = executionEnvironment->rootDeviceEnvironments[i]->osInterface->getDriverModel()->as<DrmMockCustom>();
int boHandle = 3;
mock->outputFd = -1;
mock->ioctl_res = -1;
mock->ioctl_expected.handleToPrimeFd = 1;
auto fdHandle = memoryManager->obtainFdFromHandle(boHandle, i);
EXPECT_EQ(-1, fdHandle);
}
}
TEST_F(DrmMemoryManagerTest, givenSvmCpuAllocationWhenSizeAndAlignmentProvidedThenAllocateMemoryAndReserveGpuVa) {
mock->ioctl_expected.gemUserptr = 1;
mock->ioctl_expected.gemWait = 1;