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

Add support for gem create extension to create VM_PRIVATE BOs

Browse Source 
Add support for PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE extension
to create VM_PRIVATE BOs.

Related-to: NEO-6730
Signed-off-by: Naklicki, Mateusz <mateusz.naklicki@intel.com>
This commit is contained in:
Naklicki, Mateusz
2022-04-27 11:21:53 +00:00
committed by Compute-Runtime-Automation
parent dc2e1dfdb0
commit 58ec879c46
18 changed files with 165 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
shared/source/debug_settings/debug_variables_base.inl
View File

@@ -332,6 +332,7 @@ DECLARE_DEBUG_VARIABLE(bool, EnableFreeMemory, false, "Enable freeMemory in memo
DECLARE_DEBUG_VARIABLE(bool, ForceSamplerLowFilteringPrecision, false, "Force Low Filtering Precision Sampler mode")
DECLARE_DEBUG_VARIABLE(bool, EngineInstancedSubDevices, false, "Create subdevices assigned to specific engine")
DECLARE_DEBUG_VARIABLE(bool, AllowSingleTileEngineInstancedSubDevices, false, "Create subdevices assigned to specific engine on single tile config")
DECLARE_DEBUG_VARIABLE(bool, EnablePrivateBO, false, "Enable PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE extension creating VM_PRIVATE BOs")
DECLARE_DEBUG_VARIABLE(int32_t, ReturnSubDevicesAsApiDevices, -1, "Expose each subdevice as a separate device during clGetDeviceIDs or zeDeviceGet API call")
DECLARE_DEBUG_VARIABLE(int32_t, ForceRunAloneContext, -1, "Control creation of run-alone HW context, -1:default, 0:disable, 1:enable")
DECLARE_DEBUG_VARIABLE(int32_t, AddClGlSharing, -1, "Add cl-gl extension")

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

@@ -1839,7 +1839,7 @@ GraphicsAllocation *DrmMemoryManager::createSharedUnifiedMemoryAllocation(const
createMemoryRegionsForSharedAllocation(*pHwInfo, *memoryInfo, allocationData, memRegions);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExt(&drm, memRegions, size, handle);
auto ret = memoryInfo->createGemExt(&drm, memRegions, size, handle, std::numeric_limits<uint32_t>::max());
if (ret) {
return nullptr;

8
shared/source/os_interface/linux/ioctl_helper.h
View File

@@ -71,7 +71,7 @@ class IoctlHelper {
virtual IoctlHelper *clone() = 0;
virtual bool isVmBindAvailable(Drm *drm) = 0;
virtual uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) = 0;
virtual uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) = 0;
virtual std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) = 0;
virtual CacheRegion closAlloc(Drm *drm) = 0;
virtual uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) = 0;
@@ -131,7 +131,7 @@ class IoctlHelperUpstream : public IoctlHelper {
IoctlHelper *clone() override;
bool isVmBindAvailable(Drm *drm) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) override;
std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
CacheRegion closAlloc(Drm *drm) override;
uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
@@ -187,7 +187,7 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
}
IoctlHelper *clone() override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) override;
std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
};
@@ -197,7 +197,7 @@ class IoctlHelperPrelim20 : public IoctlHelper {
IoctlHelper *clone() override;
bool isVmBindAvailable(Drm *drm) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) override;
std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
CacheRegion closAlloc(Drm *drm) override;
uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;

9
shared/source/os_interface/linux/ioctl_helper_prelim.cpp
View File

@@ -40,7 +40,7 @@ bool IoctlHelperPrelim20::isVmBindAvailable(Drm *drm) {
return vmBindSupported;
}
uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) {
uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) {
uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
std::vector<prelim_drm_i915_gem_memory_class_instance> regions(regionsSize);
for (uint32_t i = 0; i < regionsSize; i++) {
@@ -56,6 +56,13 @@ uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memCla
setparamRegion.base.name = PRELIM_I915_GEM_CREATE_EXT_SETPARAM;
setparamRegion.param = regionParam;
prelim_drm_i915_gem_create_ext_vm_private vmPrivate{};
if (vmId != std::numeric_limits<uint32_t>::max()) {
vmPrivate.base.name = PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE;
vmPrivate.vm_id = vmId;
setparamRegion.base.next_extension = reinterpret_cast<uintptr_t>(&vmPrivate);
}
prelim_drm_i915_gem_create_ext createExt{};
createExt.size = allocSize;
createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);

2
shared/source/os_interface/linux/ioctl_helper_upstream.cpp
View File

@@ -23,7 +23,7 @@ bool IoctlHelperUpstream::isVmBindAvailable(Drm *drm) {
return false;
}
uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) {
uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) {
uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
std::vector<drm_i915_gem_memory_class_instance> regions(regionsSize);
for (uint32_t i = 0; i < regionsSize; i++) {

4
shared/source/os_interface/linux/local/dg1/ioctl_helper_dg1.cpp
View File

@@ -23,8 +23,8 @@ IoctlHelper *IoctlHelperImpl<gfxProduct>::clone() {
}
template <>
uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) {
auto ret = IoctlHelperUpstream::createGemExt(drm, memClassInstances, allocSize, handle);
uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) {
auto ret = IoctlHelperUpstream::createGemExt(drm, memClassInstances, allocSize, handle, vmId);
if (ret == 0) {
return ret;
}

31
shared/source/os_interface/linux/memory_info.cpp
View File

@@ -53,8 +53,18 @@ void MemoryInfo::assignRegionsFromDistances(const std::vector<DistanceInfo> &dis
}
}
uint32_t MemoryInfo::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) {
return drm->getIoctlHelper()->createGemExt(drm, memClassInstances, allocSize, handle);
uint32_t MemoryInfo::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) {
return drm->getIoctlHelper()->createGemExt(drm, memClassInstances, allocSize, handle, vmId);
}
uint32_t MemoryInfo::getTileIndex(uint32_t memoryBank, const HardwareInfo &hwInfo) {
auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
auto tileIndex = Math::log2(memoryBank);
tileIndex = hwHelper.isBankOverrideRequired(hwInfo) ? 0 : tileIndex;
if (DebugManager.flags.OverrideDrmRegion.get() != -1) {
tileIndex = DebugManager.flags.OverrideDrmRegion.get();
}
return tileIndex;
}
MemoryClassInstance MemoryInfo::getMemoryRegionClassAndInstance(uint32_t memoryBank, const HardwareInfo &hwInfo) {
@@ -63,13 +73,7 @@ MemoryClassInstance MemoryInfo::getMemoryRegionClassAndInstance(uint32_t memoryB
return systemMemoryRegion.region;
}
auto index = Math::log2(memoryBank);
index = hwHelper.isBankOverrideRequired(hwInfo) ? 0 : index;
if (DebugManager.flags.OverrideDrmRegion.get() != -1) {
index = DebugManager.flags.OverrideDrmRegion.get();
}
auto index = getTileIndex(memoryBank, hwInfo);
UNRECOVERABLE_IF(index >= localMemoryRegions.size());
@@ -105,7 +109,14 @@ uint32_t MemoryInfo::createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks
auto pHwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto regionClassAndInstance = getMemoryRegionClassAndInstance(memoryBanks, *pHwInfo);
MemRegionsVec region = {regionClassAndInstance};
auto ret = createGemExt(drm, region, allocSize, handle);
uint32_t vmId = std::numeric_limits<uint32_t>::max();
if (!drm->isPerContextVMRequired()) {
if (memoryBanks != 0 && DebugManager.flags.EnablePrivateBO.get()) {
auto tileIndex = getTileIndex(memoryBanks, *pHwInfo);
vmId = drm->getVirtualMemoryAddressSpace(tileIndex);
}
}
auto ret = createGemExt(drm, region, allocSize, handle, vmId);
return ret;
}

4
shared/source/os_interface/linux/memory_info.h
View File

@@ -26,7 +26,7 @@ class MemoryInfo {
void assignRegionsFromDistances(const std::vector<DistanceInfo> &distances);
MOCKABLE_VIRTUAL uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle);
MOCKABLE_VIRTUAL uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId);
MemoryClassInstance getMemoryRegionClassAndInstance(uint32_t memoryBank, const HardwareInfo &hwInfo);
@@ -34,6 +34,8 @@ class MemoryInfo {
void printRegionSizes();
uint32_t getTileIndex(uint32_t memoryBank, const HardwareInfo &hwInfo);
MOCKABLE_VIRTUAL uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle);
const RegionContainer &getDrmRegionInfos() const { return drmQueryRegions; }

11
shared/test/common/libult/linux/drm_mock_prelim_context.cpp
View File

@@ -156,6 +156,14 @@ int DrmMockPrelimContext::handlePrelimRequest(DrmIoctl request, void *arg) {
return EINVAL;
}
prelim_drm_i915_gem_create_ext_vm_private *vmPrivateExt = nullptr;
if (extension->base.next_extension != 0) {
vmPrivateExt = reinterpret_cast<prelim_drm_i915_gem_create_ext_vm_private *>(extension->base.next_extension);
if (vmPrivateExt->base.name != PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE) {
return EINVAL;
}
}
auto data = reinterpret_cast<MemoryClassInstance *>(extension->param.data);
if (!data) {
return EINVAL;
@@ -165,6 +173,9 @@ int DrmMockPrelimContext::handlePrelimRequest(DrmIoctl request, void *arg) {
createExt->handle = createExtHandle;
receivedCreateGemExt = CreateGemExt{createExt->size, createExtHandle};
receivedCreateGemExt->setParamExt = CreateGemExt::SetParam{extension->param.handle, extension->param.size, extension->param.param};
if (vmPrivateExt != nullptr) {
receivedCreateGemExt->vmPrivateExt = CreateGemExt::VmPrivate{vmPrivateExt->vm_id};
}
receivedCreateGemExt->memoryRegions.clear();
for (uint32_t i = 0; i < extension->param.size; i++) {

5
shared/test/common/libult/linux/drm_mock_prelim_context.h
View File

@@ -43,6 +43,11 @@ struct CreateGemExt {
uint16_t memoryInstance{0};
};
std::vector<MemoryClassInstance> memoryRegions{};
struct VmPrivate {
uint32_t vmId{std::numeric_limits<uint32_t>::max()};
};
VmPrivate vmPrivateExt{};
};
struct GemContextParamAcc {

2
shared/test/common/os_interface/linux/drm_memory_manager_tests.h
View File

@@ -156,7 +156,7 @@ struct MockedMemoryInfo : public NEO::MemoryInfo {
size_t getMemoryRegionSize(uint32_t memoryBank) override {
return 1024u;
}
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override {
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, uint32_t vmId) override {
if (allocSize == 0) {
return EINVAL;
}

1
shared/test/common/test_files/igdrcl.config
View File

@@ -427,3 +427,4 @@ EnableDebuggerMmapMemoryAccess = 0
FailBuildProgramWithStatefulAccess = -1
ForceUncachedGmmUsageType = 0
OverrideDeviceName = unk
EnablePrivateBO = 0

93
shared/test/unit_test/os_interface/linux/drm_memory_info_prelim_tests.cpp
View File

@@ -373,7 +373,7 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenCreatingGemWithExtensionsThenRetu
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
uint32_t handle = 0;
MemRegionsVec memClassInstance = {regionInfo[0].region, regionInfo[1].region};
auto ret = memoryInfo->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = memoryInfo->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -409,3 +409,94 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenCreatingGemExtWithSingleRegionThe
EXPECT_EQ(I915_MEMORY_CLASS_DEVICE, createExt->memoryRegions[0].memoryClass);
EXPECT_EQ(1024u, drm->context.receivedCreateGemExt->size);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndPrivateBOSupportWhenCreatingGemExtWithSingleRegionThenValidVmIdIsSet) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
DebugManager.flags.EnablePrivateBO.set(true);
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probedSize = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probedSize = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setPerContextVMRequired(false);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExtWithSingleRegion(drm.get(), 1, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
const auto &createExt = drm->context.receivedCreateGemExt;
ASSERT_TRUE(createExt);
auto validVmId = drm->getVirtualMemoryAddressSpace(0);
EXPECT_EQ(validVmId, createExt->vmPrivateExt.vmId);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndNoPrivateBOSupportWhenCreatingGemExtWithSingleRegionThenVmIdIsNotSet) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
DebugManager.flags.EnablePrivateBO.set(false);
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probedSize = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probedSize = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setPerContextVMRequired(false);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExtWithSingleRegion(drm.get(), 1, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
const auto &createExt = drm->context.receivedCreateGemExt;
ASSERT_TRUE(createExt);
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), createExt->vmPrivateExt.vmId);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndPrivateBOSupportedAndIsPerContextVMRequiredIsTrueWhenCreatingGemExtWithSingleRegionThenVmIdIsNotSet) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
DebugManager.flags.EnablePrivateBO.set(true);
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probedSize = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probedSize = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setPerContextVMRequired(true);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExtWithSingleRegion(drm.get(), 1, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
const auto &createExt = drm->context.receivedCreateGemExt;
ASSERT_TRUE(createExt);
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), createExt->vmPrivateExt.vmId);
}

2
shared/test/unit_test/os_interface/linux/drm_memory_info_tests.cpp
View File

@@ -226,7 +226,7 @@ HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtension
uint32_t handle = 0;
MemRegionsVec memClassInstance = {regionInfo[0].region, regionInfo[1].region};
auto ret = memoryInfo->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = memoryInfo->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);

4
shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp
View File

@@ -112,7 +112,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtThenReturnSuccess)
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
@@ -127,7 +127,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPr
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, param: 0x1000000010001, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT has returned: 0 BO-1 with size: 1024\n");

6
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_dg1.cpp
View File

@@ -25,7 +25,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtThenReturnCorrectValue) {
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
@@ -47,7 +47,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WithDrmTipWhenCreateGemExtWithDebugFlagTh
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: 0 BO-1 with size: 1024\n");
@@ -68,7 +68,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtWithDebugFlagThenPrintDeb
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: -1 BO-0 with size: 1024\nGEM_CREATE_EXT with EXT_SETPARAM has returned: 0 BO-1 with size: 1024\n");

4
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@@ -112,7 +112,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtThenReturnCorrectVal
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
@@ -133,7 +133,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtWithDebugFlagThenPri
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, std::numeric_limits<uint32_t>::max());
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: 0 BO-1 with size: 1024\n");

6
shared/test/unit_test/os_interface/linux/prelim_helper_func.cpp
View File

@@ -35,6 +35,12 @@ int handlePrelimRequests(DrmIoctl request, void *arg, int ioctlRetVal, int query
(setparamRegion.param.param != (PRELIM_I915_OBJECT_PARAM | PRELIM_I915_PARAM_MEMORY_REGIONS))) {
return EINVAL;
}
if (setparamRegion.base.next_extension != 0) {
auto vmPrivate = reinterpret_cast<prelim_drm_i915_gem_create_ext_vm_private *>(setparamRegion.base.next_extension);
if (vmPrivate->base.name != PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE) {
return EINVAL;
}
}
auto data = reinterpret_cast<MemoryClassInstance *>(setparamRegion.param.data);
if (data == nullptr) {
return EINVAL;