Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Change return type from unique_ptr to vector

Browse Source 
In some of the drm functions there is a pattern
to store array in unique_ptr and pass it's length
as an argument. This commit simplifies this.

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2021-12-22 14:25:53 +00:00
committed by Compute-Runtime-Automation
parent 9be5efe4f7
commit d9f6757378
25 changed files with 187 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
opencl/test/unit_test/os_interface/linux/drm_memory_info_tests.cpp
View File

@ -81,13 +81,13 @@ TEST(MemoryInfo, givenMemoryRegionQueryWhenQueryingFailsThenMemoryInfoIsNotCreat
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenGettingMemoryRegionClassAndInstanceThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
MemoryRegion regionInfo[2] = {};
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, 2);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
@ -106,13 +106,13 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenGettingMemor
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenAssignRegionsFromDistancesThenRegionsNotChanged) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
MemoryRegion regionInfo[2] = {};
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, 2);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
memoryInfo->assignRegionsFromDistances(&regionInfo, 2);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
@ -129,10 +129,10 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenAssignRegion
}
TEST(MemoryInfo, givenMemoryInfoWithoutDeviceRegionWhenGettingDeviceRegionSizeThenReturnCorrectSize) {
MemoryRegion regionInfo[1] = {};
std::vector<MemoryRegion> regionInfo(1);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probedSize = 8 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo, 1);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(0 * GB, regionSize);
@ -141,13 +141,13 @@ TEST(MemoryInfo, givenMemoryInfoWithoutDeviceRegionWhenGettingDeviceRegionSizeTh
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryDisabledWhenGettingMemoryRegionClassAndInstanceThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(0);
MemoryRegion regionInfo[2] = {};
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, 2);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
@ -167,11 +167,11 @@ TEST(MemoryInfo, whenDebugVariablePrintMemoryRegionSizeIsSetAndGetMemoryRegionSi
DebugManagerStateRestore restore;
DebugManager.flags.PrintMemoryRegionSizes.set(true);
MemoryRegion regionInfo[1] = {};
std::vector<MemoryRegion> regionInfo(1);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 1};
regionInfo[0].probedSize = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo, 1);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
testing::internal::CaptureStdout();
@ -186,7 +186,7 @@ TEST(MemoryInfo, whenDebugVariablePrintMemoryRegionSizeIsSetAndGetMemoryRegionSi
TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenGettingMemoryRegionClassAndInstanceWhileDebugFlagIsActiveThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
MemoryRegion regionInfo[3] = {};
std::vector<MemoryRegion> regionInfo(3);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probedSize = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
@ -194,7 +194,7 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenGettingMemoryRegionClassAndInstan
regionInfo[2].region = {I915_MEMORY_CLASS_DEVICE, 1};
regionInfo[2].probedSize = 32 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo, 3);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
DebugManager.flags.OverrideDrmRegion.set(1);
@ -232,7 +232,7 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenGettingMemoryRegionClassAndInstan
using MemoryInfoTest = ::testing::Test;
HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtensionsThenReturnCorrectValues, NonDefaultIoctlsSupported) {
MemoryRegion regionInfo[2] = {};
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};
@ -241,11 +241,12 @@ HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtension
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo, 2);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExt(drm.get(), &regionInfo, 2, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {regionInfo[0].region, regionInfo[1].region};
auto ret = memoryInfo->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@ -255,13 +256,13 @@ HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtension
HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemExtWithSingleRegionThenReturnCorrectValues, NonDefaultIoctlsSupported) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
MemoryRegion regionInfo[2] = {};
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, 2);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();

44
opencl/test/unit_test/os_interface/linux/drm_memory_manager_localmem_tests.cpp
View File

@ -91,11 +91,11 @@ class DrmMemoryManagerLocalMemoryWithCustomMockTest : public ::testing::Test {
HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenDrmMemoryManagerWhenCreateBufferObjectInMemoryRegionIsCalledThenBufferObjectWithAGivenGpuAddressAndSizeIsCreatedAndAllocatedInASpecifiedMemoryRegion, NonDefaultIoctlsSupported) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
auto gpuAddress = 0x1234u;
@ -131,11 +131,11 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMem
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[i]);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
executionEnvironment->rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
@ -176,11 +176,11 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMemory
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[i]);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
mock->fdToHandleRetVal = -1;
executionEnvironment->rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();
@ -235,11 +235,11 @@ TEST_F(DrmMemoryManagerUsmSharedHandleTest, givenMultiRootDeviceEnvironmentAndMe
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
mock->fdToHandleRetVal = -1;
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface = std::make_unique<OSInterface>();
@ -302,11 +302,11 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenMemoryInfoWhenAllocateWithAlignm
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(-1);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
AllocationData allocationData;
@ -327,11 +327,11 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMemoryInfoAndNotUseObjectMmapProper
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(0);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->mmapOffsetRetVal = -1;
AllocationData allocationData;
@ -350,11 +350,11 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMemoryInfoAndFailedMmapOffsetWhenAl
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(-1);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->mmapOffsetRetVal = -1;
AllocationData allocationData;
@ -370,11 +370,11 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMemoryInfoAndDisabledMmapBOCreation
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(0);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->mmapOffsetRetVal = -1;
AllocationData allocationData;
@ -392,11 +392,11 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMemoryInfoAndFailedGemCreateExtWhen
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(-1);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->gemCreateExtRetVal = -1;
AllocationData allocationData;
@ -936,11 +936,11 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenAlignmentAndSizeWhenMmapReturnsU
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(-1);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
AllocationData allocationData;
@ -973,11 +973,11 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenAlignmentAndSizeWhenMmapReturnsA
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBOMmapCreate.set(-1);
MemoryRegion regionInfo[2] = {};
std::vector<MemoryRegion> regionInfo(2);
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfo(regionInfo, 2));
mock->memoryInfo.reset(new MemoryInfo(regionInfo));
mock->ioctlCallsCount = 0;
AllocationData allocationData;

4
opencl/test/unit_test/os_interface/linux/drm_mock_memory_info.h
View File

@ -9,11 +9,11 @@
#include "shared/source/os_interface/linux/memory_info.h"
constexpr MemoryRegion memoryRegions[2] = {
const std::vector<MemoryRegion> memoryRegions = {
{{I915_MEMORY_CLASS_SYSTEM, 0}, 64 * GB, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 8 * GB, 0}};
struct MockMemoryInfo : public MemoryInfo {
MockMemoryInfo() : MemoryInfo(memoryRegions, 2) {}
MockMemoryInfo() : MemoryInfo(memoryRegions) {}
~MockMemoryInfo() override{};
};

5
opencl/test/unit_test/os_interface/linux/drm_system_info_tests.cpp
View File

@ -29,7 +29,8 @@ TEST(DrmSystemInfoTest, whenQueryingSystemInfoThenSystemInfoIsNotCreatedAndIoctl
}
TEST(DrmSystemInfoTest, givenSystemInfoCreatedWhenQueryingSpecificAtrributesThenReturnZero) {
SystemInfo systemInfo(nullptr, 0);
std::vector<uint8_t> inputData{};
SystemInfo systemInfo(inputData);
EXPECT_EQ(0u, systemInfo.getL3CacheSizeInKb());
EXPECT_EQ(0u, systemInfo.getL3BankCount());
@ -105,7 +106,7 @@ TEST(DrmSystemInfoTest, whenQueryingSystemInfoThenSystemInfoIsCreatedAndReturnsN
}
TEST(DrmSystemInfoTest, givenSystemInfoCreatedFromDeviceBlobWhenQueryingSpecificAtrributesThenReturnCorrectValues) {
SystemInfo systemInfo(dummyDeviceBlobData, sizeof(dummyDeviceBlobData));
SystemInfo systemInfo(inputBlobData);
EXPECT_EQ(0x0Au, systemInfo.getMaxMemoryChannels());
EXPECT_EQ(0x0Bu, systemInfo.getMemoryType());

25
opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_dg1.cpp
View File

@ -23,15 +23,10 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtThenReturnCorrectValue) {
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probed_size = 16 * GB;
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
auto ret = ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
@ -47,15 +42,12 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WithDrmTipWhenCreateGemExtWithDebugFlagTh
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
testing::internal::CaptureStdout();
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
auto ret = ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
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");
@ -71,18 +63,15 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtWithDebugFlagThenPrintDeb
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
testing::internal::CaptureStdout();
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
auto ret = ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
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_SETPARAM has returned: 0 BO-1 with size: 1024\n");
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");
EXPECT_EQ(expectedOutput, output);
EXPECT_EQ(2u, drm->ioctlCallsCount);
EXPECT_EQ(0u, ret);

29
opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp
View File

@ -16,7 +16,7 @@
using namespace NEO;
extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal);
extern std::unique_ptr<uint8_t[]> getRegionInfo(const MemoryRegion *inputRegions, uint32_t size);
extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
class DrmPrelimMock : public DrmMock {
public:
@ -42,15 +42,10 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenCreateGemExtThenReturnSuccess) {
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probed_size = 16 * GB;
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
auto ret = ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
@ -65,14 +60,11 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenCreateGemExtWithDebugFlagThenPrintD
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
testing::internal::CaptureStdout();
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
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");
@ -83,7 +75,7 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenTranslateToMemoryRegionsThenReturnS
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
MemoryRegion expectedMemRegions[2] = {};
std::vector<MemoryRegion> expectedMemRegions(2);
expectedMemRegions[0].region.memoryClass = I915_MEMORY_CLASS_SYSTEM;
expectedMemRegions[0].region.memoryInstance = 0;
expectedMemRegions[0].probedSize = 1024;
@ -91,13 +83,12 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenTranslateToMemoryRegionsThenReturnS
expectedMemRegions[1].region.memoryInstance = 0;
expectedMemRegions[1].probedSize = 1024;
auto regionInfo = getRegionInfo(expectedMemRegions, 2);
auto regionInfo = getRegionInfo(expectedMemRegions);
auto numRegions = 0u;
auto ioctlHelper = IoctlHelper::get(drm.get());
auto memRegions = ioctlHelper->translateToMemoryRegions(reinterpret_cast<uint8_t *>(regionInfo.get()), 0, numRegions);
EXPECT_EQ(2u, numRegions);
for (uint32_t i = 0; i < numRegions; i++) {
auto memRegions = ioctlHelper->translateToMemoryRegions(regionInfo);
EXPECT_EQ(2u, memRegions.size());
for (uint32_t i = 0; i < memRegions.size(); i++) {
EXPECT_EQ(expectedMemRegions[i].region.memoryClass, memRegions[i].region.memoryClass);
EXPECT_EQ(expectedMemRegions[i].region.memoryInstance, memRegions[i].region.memoryInstance);
EXPECT_EQ(expectedMemRegions[i].probedSize, memRegions[i].probedSize);

16
opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@ -20,15 +20,10 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtThenReturnCorrectVal
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probed_size = 16 * GB;
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
auto ret = ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
@ -45,14 +40,11 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtWithDebugFlagThenPri
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
testing::internal::CaptureStdout();
auto ioctlHelper = IoctlHelper::get(drm.get());
uint32_t handle = 0;
ioctlHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
std::vector<MemoryClassInstance> memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
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");

13
opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp
View File

@ -49,13 +49,14 @@ int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal) {
return ioctlRetVal;
}
std::unique_ptr<uint8_t[]> getRegionInfo(const MemoryRegion *inputRegions, uint32_t size) {
int length = sizeof(prelim_drm_i915_query_memory_regions) + size * sizeof(prelim_drm_i915_memory_region_info);
auto data = std::make_unique<uint8_t[]>(length);
auto memoryRegions = reinterpret_cast<prelim_drm_i915_query_memory_regions *>(data.get());
memoryRegions->num_regions = size;
std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions) {
auto inputSize = static_cast<uint32_t>(inputRegions.size());
int length = sizeof(prelim_drm_i915_query_memory_regions) + inputSize * sizeof(prelim_drm_i915_memory_region_info);
auto data = std::vector<uint8_t>(length);
auto memoryRegions = reinterpret_cast<prelim_drm_i915_query_memory_regions *>(data.data());
memoryRegions->num_regions = inputSize;
for (uint32_t i = 0; i < size; i++) {
for (uint32_t i = 0; i < inputSize; i++) {
memoryRegions->regions[i].region.memory_class = inputRegions[i].region.memoryClass;
memoryRegions->regions[i].region.memory_instance = inputRegions[i].region.memoryInstance;
memoryRegions->regions[i].probed_size = inputRegions[i].probedSize;