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

Extend waitForBind function

Browse Source 
use waitUserFence to wait for fence value
move some tests to shared
- ioctl helper tests
- drm memory info tests
- drm cache info

Related-To: NEO-6591
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-02-11 15:03:58 +00:00
committed by Compute-Runtime-Automation
parent 6a111e41ff
commit 3467bc0994
19 changed files with 123 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
opencl/test/unit_test/os_interface/linux/CMakeLists.txt
View File

@ -22,7 +22,6 @@ set(IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/drm_mapper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_engine_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_memory_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_memory_manager_localmem_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_os_memory_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_residency_handler_tests.cpp
@ -49,27 +48,6 @@ if(NEO__LIBVA_FOUND)
)
endif()
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_tests_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/prelim_helper_func.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_cache_info_tests.cpp
)
if(TESTS_DG1 AND "${BRANCH_TYPE}" STREQUAL "")
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_tests_dg1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_prod_dg1.h
)
endif()
endif()
if("${BRANCH_TYPE}" STREQUAL "")
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_tests_upstream.cpp
)
endif()
if(TESTS_XEHP_AND_LATER)
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream_xehp_and_later_tests.cpp

174
opencl/test/unit_test/os_interface/linux/drm_cache_info_tests.cpp
View File

@ -1,174 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/constants.h"
#include "shared/source/os_interface/linux/cache_info_impl.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/libult/linux/drm_query_mock.h"
#include "shared/test/common/os_interface/linux/drm_mock_cache_info.h"
#include "opencl/test/unit_test/helpers/gtest_helpers.h"
#include "gmock/gmock.h"
using namespace NEO;
TEST(DrmCacheInfoTest, givenCacheRegionsExistsWhenCallingSetUpCacheInfoThenCacheInfoIsCreatedAndReturnsMaxReservationCacheLimits) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
auto &hwHelper = HwHelper::get(drm.context.hwInfo->platform.eRenderCoreFamily);
drm.setupCacheInfo(*defaultHwInfo.get());
EXPECT_NE(nullptr, drm.getCacheInfo());
auto cacheInfo = static_cast<CacheInfoImpl *>(drm.getCacheInfo());
if (hwHelper.getNumCacheRegions() == 0) {
EXPECT_EQ(0u, cacheInfo->getMaxReservationCacheSize());
EXPECT_EQ(0u, cacheInfo->getMaxReservationNumCacheRegions());
EXPECT_EQ(0u, cacheInfo->getMaxReservationNumWays());
} else {
const GT_SYSTEM_INFO *gtSysInfo = &defaultHwInfo->gtSystemInfo;
constexpr uint16_t maxNumWays = 32;
constexpr uint16_t globalReservationLimit = 16;
constexpr uint16_t clientReservationLimit = 8;
constexpr uint16_t maxReservationNumWays = std::min(globalReservationLimit, clientReservationLimit);
const size_t totalCacheSize = gtSysInfo->L3CacheSizeInKb * MemoryConstants::kiloByte;
const size_t maxReservationCacheSize = (totalCacheSize * maxReservationNumWays) / maxNumWays;
const size_t maxReservationNumCacheRegions = hwHelper.getNumCacheRegions() - 1;
EXPECT_EQ(maxReservationCacheSize, cacheInfo->getMaxReservationCacheSize());
EXPECT_EQ(maxReservationNumCacheRegions, cacheInfo->getMaxReservationNumCacheRegions());
EXPECT_EQ(maxReservationNumWays, cacheInfo->getMaxReservationNumWays());
}
}
TEST(DrmCacheInfoTest, givenDebugFlagSetWhenCallingSetUpCacheInfoThenCacheInfoIsCreatedWithoutValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.ClosEnabled.set(0);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
drm.setupCacheInfo(*defaultHwInfo.get());
EXPECT_NE(nullptr, drm.getCacheInfo());
auto cacheInfo = static_cast<CacheInfoImpl *>(drm.getCacheInfo());
EXPECT_EQ(0u, cacheInfo->getMaxReservationCacheSize());
EXPECT_EQ(0u, cacheInfo->getMaxReservationNumCacheRegions());
EXPECT_EQ(0u, cacheInfo->getMaxReservationNumWays());
}
TEST(DrmCacheInfoTest, givenCacheInfoCreatedWhenGetCacheRegionSucceedsToReserveCacheRegionThenReturnTrue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
CacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, 32);
size_t cacheReservationSize = cacheInfo.getMaxReservationCacheSize();
EXPECT_TRUE(cacheInfo.getCacheRegion(cacheReservationSize, CacheRegion::Region1));
EXPECT_EQ(CacheRegion::Region1, cacheInfo.freeCacheRegion(CacheRegion::Region1));
}
TEST(DrmCacheInfoTest, givenCacheInfoCreatedWhenGetCacheRegionFailsToReserveCacheRegionThenReturnFalse) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
CacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, 32);
size_t cacheReservationSize = cacheInfo.getMaxReservationCacheSize();
drm.context.closIndex = 0xFFFF;
EXPECT_FALSE(cacheInfo.getCacheRegion(cacheReservationSize, CacheRegion::Region1));
EXPECT_EQ(CacheRegion::None, cacheInfo.freeCacheRegion(CacheRegion::Region1));
}
TEST(DrmCacheInfoTest, givenCacheInfoWithReservedCacheRegionWhenGetCacheRegionIsCalledForReservedCacheRegionThenReturnTrue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
CacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, 32);
size_t cacheReservationSize = cacheInfo.getMaxReservationCacheSize();
EXPECT_EQ(CacheRegion::Region1, cacheInfo.reserveCacheRegion(cacheReservationSize));
EXPECT_TRUE(cacheInfo.getCacheRegion(cacheReservationSize, CacheRegion::Region1));
EXPECT_EQ(CacheRegion::Region1, cacheInfo.freeCacheRegion(CacheRegion::Region1));
}
TEST(DrmCacheInfoTest, givenCacheInfoCreatedWhenGetCacheRegionIsCalledForReservableRegionsWithRegionSizesInverselyProportionalToNumCacheRegionsThenReturnTrue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
CacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, 32);
size_t regionSize = cacheInfo.getMaxReservationCacheSize() / cacheInfo.getMaxReservationNumCacheRegions();
EXPECT_TRUE(cacheInfo.getCacheRegion(regionSize, CacheRegion::Region1));
EXPECT_TRUE(cacheInfo.getCacheRegion(regionSize, CacheRegion::Region2));
EXPECT_EQ(CacheRegion::Region2, cacheInfo.freeCacheRegion(CacheRegion::Region2));
EXPECT_EQ(CacheRegion::Region1, cacheInfo.freeCacheRegion(CacheRegion::Region1));
}
TEST(DrmCacheInfoTest, givenCacheInfoWhenSpecificNumCacheWaysIsRequestedThenReserveAppropriateCacheSize) {
constexpr uint16_t maxNumCacheWays = 32;
DebugManagerStateRestore restorer;
DebugManager.flags.ClosNumCacheWays.set(maxNumCacheWays / 2);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
MockCacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, maxNumCacheWays);
size_t maxReservationCacheSize = cacheInfo.getMaxReservationCacheSize();
EXPECT_EQ(CacheRegion::Region1, cacheInfo.reserveCacheRegion(maxReservationCacheSize));
EXPECT_TRUE(cacheInfo.isRegionReserved(CacheRegion::Region1, maxReservationCacheSize));
auto cacheRegion = cacheInfo.cacheRegionsReserved.begin();
EXPECT_EQ(CacheRegion::Region1, cacheRegion->first);
EXPECT_EQ(maxReservationCacheSize / 2, cacheRegion->second);
EXPECT_EQ(CacheRegion::Region1, cacheInfo.freeCacheRegion(CacheRegion::Region1));
}
TEST(DrmCacheInfoTest, givenCacheInfoWhenNumCacheWaysIsExceededThenDontReserveCacheRegion) {
constexpr uint16_t maxNumCacheWays = 32;
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
MockCacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, maxNumCacheWays);
size_t maxReservationCacheSize = cacheInfo.getMaxReservationCacheSize();
EXPECT_EQ(CacheRegion::Region1, cacheInfo.reserveCacheRegion(maxReservationCacheSize));
EXPECT_TRUE(cacheInfo.isRegionReserved(CacheRegion::Region1, maxReservationCacheSize));
EXPECT_EQ(CacheRegion::None, cacheInfo.reserveCacheRegion(maxReservationCacheSize));
EXPECT_FALSE(cacheInfo.isRegionReserved(CacheRegion::Region2, maxReservationCacheSize));
}
TEST(DrmCacheInfoTest, givenCacheInfoCreatedWhenFreeCacheRegionIsCalledForNonReservedRegionThenItFails) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
MockCacheInfoImpl cacheInfo(drm, 32 * MemoryConstants::kiloByte, 2, 32);
cacheInfo.cacheRegionsReserved.insert({CacheRegion::Region1, MemoryConstants::kiloByte});
EXPECT_EQ(CacheRegion::None, cacheInfo.freeCacheRegion(CacheRegion::Region1));
}

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

@ -1,253 +0,0 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/memory_manager/memory_banks.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
#include "gtest/gtest.h"
using namespace NEO;
TEST(MemoryInfo, givenMemoryRegionQuerySupportedWhenQueryingMemoryInfoThenMemoryInfoIsCreatedWithRegions) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryMemoryInfo();
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto memoryInfo = drm->getMemoryInfo();
ASSERT_NE(nullptr, memoryInfo);
EXPECT_EQ(2u, memoryInfo->getDrmRegionInfos().size());
}
TEST(MemoryInfo, givenMemoryRegionQueryNotSupportedWhenQueryingMemoryInfoThenMemoryInfoIsNotCreated) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->i915QuerySuccessCount = 0;
drm->queryMemoryInfo();
EXPECT_EQ(nullptr, drm->getMemoryInfo());
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST(MemoryInfo, givenMemoryRegionQueryWhenQueryingFailsThenMemoryInfoIsNotCreated) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryMemoryRegionInfoSuccessCount = 0;
drm->queryMemoryInfo();
EXPECT_EQ(nullptr, drm->getMemoryInfo());
EXPECT_EQ(1u, drm->ioctlCallsCount);
drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->i915QuerySuccessCount = 1;
drm->queryMemoryInfo();
EXPECT_EQ(nullptr, drm->getMemoryInfo());
EXPECT_EQ(2u, drm->ioctlCallsCount);
drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryMemoryRegionInfoSuccessCount = 1;
drm->queryMemoryInfo();
EXPECT_EQ(nullptr, drm->getMemoryInfo());
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenGettingMemoryRegionClassAndInstanceThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
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 regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[0].region.memoryInstance, regionClassAndInstance.memoryInstance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[1].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[1].region.memoryInstance, regionClassAndInstance.memoryInstance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithoutDeviceRegionWhenGettingDeviceRegionSizeThenReturnCorrectSize) {
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);
ASSERT_NE(nullptr, memoryInfo);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(0 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryDisabledWhenGettingMemoryRegionClassAndInstanceThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(0);
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 regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[0].region.memoryInstance, regionClassAndInstance.memoryInstance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[0].region.memoryInstance, regionClassAndInstance.memoryInstance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, whenDebugVariablePrintMemoryRegionSizeIsSetAndGetMemoryRegionSizeIsCalledThenMessagePrintedToStdOutput) {
DebugManagerStateRestore restore;
DebugManager.flags.PrintMemoryRegionSizes.set(true);
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);
ASSERT_NE(nullptr, memoryInfo);
testing::internal::CaptureStdout();
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(16 * GB, regionSize);
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Memory type: 0, memory instance: 1, region size: 17179869184\n");
EXPECT_EQ(expectedOutput, output);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenGettingMemoryRegionClassAndInstanceWhileDebugFlagIsActiveThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
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};
regionInfo[1].probedSize = 16 * GB;
regionInfo[2].region = {I915_MEMORY_CLASS_DEVICE, 1};
regionInfo[2].probedSize = 32 * GB;
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
DebugManager.flags.OverrideDrmRegion.set(1);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[2].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[2].region.memoryInstance, regionClassAndInstance.memoryInstance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
DebugManager.flags.OverrideDrmRegion.set(0);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(1), *defaultHwInfo);
EXPECT_EQ(regionInfo[1].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[1].region.memoryInstance, regionClassAndInstance.memoryInstance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(1));
EXPECT_EQ(32 * GB, regionSize);
DebugManager.flags.OverrideDrmRegion.set(-1);
DebugManager.flags.ForceMemoryBankIndexOverride.set(1);
auto &helper = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(1), *defaultHwInfo);
if (helper.isBankOverrideRequired(*defaultHwInfo)) {
EXPECT_EQ(regionInfo[1].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[1].region.memoryInstance, regionClassAndInstance.memoryInstance);
} else {
EXPECT_EQ(regionInfo[2].region.memoryClass, regionClassAndInstance.memoryClass);
EXPECT_EQ(regionInfo[2].region.memoryInstance, regionClassAndInstance.memoryInstance);
}
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(1));
EXPECT_EQ(32 * GB, regionSize);
}
using MemoryInfoTest = ::testing::Test;
HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtensionsThenReturnCorrectValues, NonDefaultIoctlsSupported) {
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 executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto memoryInfo = std::make_unique<MemoryInfo>(regionInfo);
ASSERT_NE(nullptr, memoryInfo);
uint32_t handle = 0;
MemRegionsVec 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);
EXPECT_EQ(1024u, drm->createExt.size);
}
HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemExtWithSingleRegionThenReturnCorrectValues, NonDefaultIoctlsSupported) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
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<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
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);
EXPECT_EQ(I915_MEMORY_CLASS_DEVICE, drm->memRegions.memory_class);
EXPECT_EQ(1024u, drm->createExt.size);
}

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

@ -17,11 +17,11 @@
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/mocks/mock_gmm.h"
#include "shared/test/common/test_macros/test.h"
#include "shared/test/unit_test/os_interface/linux/drm_mock_impl.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
#include "opencl/test/unit_test/mocks/mock_platform.h"
#include "opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests_impl.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_memory_info.h"
#include "gtest/gtest.h"

130
opencl/test/unit_test/os_interface/linux/drm_mock_impl.h
View File

@ -1,130 +0,0 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "gtest/gtest.h"
#include "test_traits_common.h"
using namespace NEO;
class DrmTipMock : public DrmMock {
public:
DrmTipMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmTipMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmTipMock(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
setupIoctlHelper(inputHwInfo->platform.eProductFamily);
}
uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
uint32_t queryMemoryRegionInfoSuccessCount = std::numeric_limits<uint32_t>::max();
//DRM_IOCTL_I915_GEM_CREATE_EXT
drm_i915_gem_create_ext createExt{};
drm_i915_gem_memory_class_instance memRegions{};
uint32_t numRegions = 0;
int gemCreateExtRetVal = 0;
//DRM_IOCTL_I915_GEM_MMAP_OFFSET
__u64 mmapOffsetFlagsReceived = 0;
__u64 offset = 0;
int mmapOffsetRetVal = 0;
void getPrelimVersion(std::string &prelimVersion) override {
prelimVersion = "";
}
virtual int handleRemainingRequests(unsigned long request, void *arg) override {
if ((request == DRM_IOCTL_I915_QUERY) && (arg != nullptr)) {
if (i915QuerySuccessCount == 0) {
return EINVAL;
}
i915QuerySuccessCount--;
auto query = static_cast<drm_i915_query *>(arg);
if (query->items_ptr == 0) {
return EINVAL;
}
for (auto i = 0u; i < query->num_items; i++) {
handleQueryItem(reinterpret_cast<drm_i915_query_item *>(query->items_ptr) + i);
}
return 0;
} else if (request == DRM_IOCTL_I915_GEM_MMAP_OFFSET) {
auto mmap_arg = static_cast<drm_i915_gem_mmap_offset *>(arg);
mmapOffsetFlagsReceived = mmap_arg->flags;
mmap_arg->offset = offset;
return mmapOffsetRetVal;
}
return handleKernelSpecificRequests(request, arg);
}
virtual void handleQueryItem(drm_i915_query_item *queryItem) {
switch (queryItem->query_id) {
case DRM_I915_QUERY_MEMORY_REGIONS:
if (queryMemoryRegionInfoSuccessCount == 0) {
queryItem->length = -EINVAL;
} else {
queryMemoryRegionInfoSuccessCount--;
auto numberOfLocalMemories = 1u;
auto numberOfRegions = 1u + numberOfLocalMemories;
int regionInfoSize = sizeof(drm_i915_query_memory_regions) + numberOfRegions * sizeof(drm_i915_memory_region_info);
if (queryItem->length == 0) {
queryItem->length = regionInfoSize;
} else {
EXPECT_EQ(regionInfoSize, queryItem->length);
auto queryMemoryRegionInfo = reinterpret_cast<drm_i915_query_memory_regions *>(queryItem->data_ptr);
EXPECT_EQ(0u, queryMemoryRegionInfo->num_regions);
queryMemoryRegionInfo->num_regions = numberOfRegions;
queryMemoryRegionInfo->regions[0].region.memory_class = I915_MEMORY_CLASS_SYSTEM;
queryMemoryRegionInfo->regions[0].region.memory_instance = 1;
queryMemoryRegionInfo->regions[0].probed_size = 2 * MemoryConstants::gigaByte;
queryMemoryRegionInfo->regions[1].region.memory_class = I915_MEMORY_CLASS_DEVICE;
queryMemoryRegionInfo->regions[1].region.memory_instance = 1;
queryMemoryRegionInfo->regions[1].probed_size = 2 * MemoryConstants::gigaByte;
}
}
break;
}
}
virtual int handleKernelSpecificRequests(unsigned long request, void *arg) {
if (request == DRM_IOCTL_I915_GEM_CREATE_EXT) {
auto createExtParams = static_cast<drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;
}
createExtParams->handle = 1u;
this->createExt = *createExtParams;
auto extMemRegions = reinterpret_cast<drm_i915_gem_create_ext_memory_regions *>(createExt.extensions);
if (extMemRegions->base.name != I915_GEM_CREATE_EXT_MEMORY_REGIONS) {
return EINVAL;
}
this->numRegions = extMemRegions->num_regions;
this->memRegions = *reinterpret_cast<drm_i915_gem_memory_class_instance *>(extMemRegions->regions);
if (this->numRegions == 0) {
return EINVAL;
}
if ((this->memRegions.memory_class != I915_MEMORY_CLASS_SYSTEM) && (this->memRegions.memory_class != I915_MEMORY_CLASS_DEVICE)) {
return EINVAL;
}
return gemCreateExtRetVal;
}
return -1;
}
};
struct NonDefaultIoctlsSupported {
template <PRODUCT_FAMILY productFamily>
static constexpr bool isMatched() {
if (productFamily == IGFX_DG1) {
return true;
}
return TestTraits<NEO::ToGfxCoreFamily<productFamily>::get()>::isUsingNonDefaultIoctls;
}
};

78
opencl/test/unit_test/os_interface/linux/drm_mock_prod_dg1.h
View File

@ -1,78 +0,0 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
namespace PROD_DG1 {
#undef DRM_IOCTL_I915_GEM_CREATE_EXT
#undef __I915_EXEC_UNKNOWN_FLAGS
#include "third_party/uapi/dg1/drm/i915_drm.h"
} // namespace PROD_DG1
using namespace NEO;
class DrmMockProdDg1 : public DrmTipMock {
public:
DrmMockProdDg1(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockProdDg1(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmMockProdDg1(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmTipMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
}
void handleQueryItem(drm_i915_query_item *queryItem) override {
switch (queryItem->query_id) {
case DRM_I915_QUERY_MEMORY_REGIONS:
if (queryMemoryRegionInfoSuccessCount == 0) {
queryItem->length = -EINVAL;
} else {
queryMemoryRegionInfoSuccessCount--;
auto numberOfLocalMemories = 1u;
auto numberOfRegions = 1u + numberOfLocalMemories;
int regionInfoSize = sizeof(PROD_DG1::drm_i915_query_memory_regions) + numberOfRegions * sizeof(PROD_DG1::drm_i915_memory_region_info);
if (queryItem->length == 0) {
queryItem->length = regionInfoSize;
} else {
EXPECT_EQ(regionInfoSize, queryItem->length);
auto queryMemoryRegionInfo = reinterpret_cast<PROD_DG1::drm_i915_query_memory_regions *>(queryItem->data_ptr);
EXPECT_EQ(0u, queryMemoryRegionInfo->num_regions);
queryMemoryRegionInfo->num_regions = numberOfRegions;
queryMemoryRegionInfo->regions[0].region.memory_class = I915_MEMORY_CLASS_SYSTEM;
queryMemoryRegionInfo->regions[0].region.memory_instance = 1;
queryMemoryRegionInfo->regions[0].probed_size = 2 * MemoryConstants::gigaByte;
queryMemoryRegionInfo->regions[1].region.memory_class = I915_MEMORY_CLASS_DEVICE;
queryMemoryRegionInfo->regions[1].region.memory_instance = 1;
queryMemoryRegionInfo->regions[1].probed_size = 2 * MemoryConstants::gigaByte;
}
}
break;
}
}
int handleKernelSpecificRequests(unsigned long request, void *arg) override {
if (request == DRM_IOCTL_I915_GEM_CREATE_EXT) {
auto createExtParams = static_cast<drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;
}
createExtParams->handle = 1u;
this->createExt = *createExtParams;
auto setparamRegion = reinterpret_cast<PROD_DG1::drm_i915_gem_create_ext_setparam *>(createExtParams->extensions);
if (setparamRegion->base.name != I915_GEM_CREATE_EXT_SETPARAM) {
return EINVAL;
}
auto regionParam = reinterpret_cast<PROD_DG1::drm_i915_gem_object_param *>(&setparamRegion->param);
if (regionParam->param != (I915_OBJECT_PARAM | I915_PARAM_MEMORY_REGIONS)) {
return EINVAL;
}
numRegions = regionParam->size;
memRegions = *reinterpret_cast<drm_i915_gem_memory_class_instance *>(regionParam->data);
return gemCreateExtRetVal;
}
return -1;
}
};

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

@ -1,96 +0,0 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_prod_dg1.h"
using namespace NEO;
using IoctlHelperTestsDg1 = ::testing::Test;
DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtThenReturnCorrectValue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
EXPECT_EQ(1u, drm->numRegions);
EXPECT_EQ(1024u, drm->createExt.size);
EXPECT_EQ(I915_MEMORY_CLASS_DEVICE, drm->memRegions.memory_class);
}
DG1TEST_F(IoctlHelperTestsDg1, givenDg1WithDrmTipWhenCreateGemExtWithDebugFlagThenPrintDebugInfo) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
testing::internal::CaptureStdout();
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec 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");
EXPECT_EQ(expectedOutput, output);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_EQ(0u, ret);
}
DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtWithDebugFlagThenPrintDebugInfo) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
testing::internal::CaptureStdout();
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec 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: -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);
}
DG1TEST_F(IoctlHelperTestsDg1, givenDg1AndMemoryRegionQuerySupportedWhenQueryingMemoryInfoThenMemoryInfoIsCreatedWithRegions) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryMemoryInfo();
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto memoryInfo = drm->getMemoryInfo();
ASSERT_NE(nullptr, memoryInfo);
EXPECT_EQ(2u, memoryInfo->getDrmRegionInfos().size());
}

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

@ -1,376 +0,0 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/mocks/linux/mock_drm_allocation.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
extern std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines);
class DrmPrelimMock : public DrmMock {
public:
DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmPrelimMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment, HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
rootDeviceEnvironment.getMutableHardwareInfo()->platform.eProductFamily = IGFX_UNKNOWN;
}
int ioctlRetVal = 0;
int queryDistanceIoctlRetVal = 0;
void getPrelimVersion(std::string &prelimVersion) override {
prelimVersion = "2.0";
}
int handleRemainingRequests(unsigned long request, void *arg) override {
return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal);
}
};
class IoctlHelperPrelimFixture : public ::testing::Test {
public:
void SetUp() override {
executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->setupIoctlHelper(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eProductFamily);
}
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
std::unique_ptr<DrmPrelimMock> drm;
};
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);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPrintDebugInfo) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
testing::internal::CaptureStdout();
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec 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");
EXPECT_EQ(expectedOutput, output);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenTranslateToMemoryRegionsThenReturnSameData) {
std::vector<MemoryRegion> expectedMemRegions(2);
expectedMemRegions[0].region.memoryClass = I915_MEMORY_CLASS_SYSTEM;
expectedMemRegions[0].region.memoryInstance = 0;
expectedMemRegions[0].probedSize = 1024;
expectedMemRegions[1].region.memoryClass = I915_MEMORY_CLASS_DEVICE;
expectedMemRegions[1].region.memoryInstance = 0;
expectedMemRegions[1].probedSize = 1024;
auto regionInfo = getRegionInfo(expectedMemRegions);
auto ioctlHelper = drm->getIoctlHelper();
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);
EXPECT_EQ(expectedMemRegions[i].unallocatedSize, memRegions[i].unallocatedSize);
}
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) {
drm_i915_gem_context_create_ext arg{};
auto ret = IoctlHelper::ioctl(drm.get(), DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &arg);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::Region1, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosFreeThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::Region2, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosFreeThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocWaysThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(10u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocWaysThenReturnNone) {
drm->ioctlRetVal = -1;
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(0u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenWaitUserFenceThenCorrectValueReturned) {
uint64_t gpuAddress = 0x1020304000ull;
uint64_t value = 0x98765ull;
auto ioctlHelper = drm->getIoctlHelper();
for (uint32_t i = 0u; i < 4; i++) {
auto ret = ioctlHelper->waitUserFence(drm.get(), 10u, gpuAddress, value, i, -1, 0u);
EXPECT_EQ(0, ret);
}
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetHwConfigIoctlValThenCorrectValueReturned) {
uint32_t ioctlVal = (1 << 16) | 6;
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getHwConfigIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseFailsThenDontUpdateMemAdviceFlags) {
drm->ioctlRetVal = -1;
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
memAdviseFlags.non_atomic = 1;
allocation.setMemAdvise(drm.get(), memAdviseFlags);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_NE(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithNonAtomicIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) {
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
for (auto nonAtomic : {true, false}) {
memAdviseFlags.non_atomic = nonAtomic;
EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags));
EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithDevicePreferredLocationIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) {
MockBufferObject bo(drm.get(), 0, 0, 1);
MockDrmAllocation allocation(AllocationType::BUFFER, MemoryPool::LocalMemory);
allocation.bufferObjects[0] = &bo;
MemAdviseFlags memAdviseFlags{};
for (auto devicePreferredLocation : {true, false}) {
memAdviseFlags.device_preferred_location = devicePreferredLocation;
EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags));
EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags);
}
EXPECT_EQ(2u, drm->ioctlCallsCount);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetDirectSubmissionFlagThenCorrectValueReturned) {
uint32_t ioctlVal = (1u << 31);
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getDirectSubmissionFlag());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenAppendDrmContextFlagsThenCorrectFlagsSet) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.DirectSubmissionDrmContext.set(-1);
uint32_t ioctlVal = (1u << 31);
drm_i915_gem_context_create_ext ctx{};
drm->appendDrmContextFlags(ctx, true);
EXPECT_EQ(ioctlVal, ctx.flags);
ctx.flags = 0u;
DebugManager.flags.DirectSubmissionDrmContext.set(0);
drm->appendDrmContextFlags(ctx, true);
EXPECT_EQ(0u, ctx.flags);
DebugManager.flags.DirectSubmissionDrmContext.set(1);
drm->appendDrmContextFlags(ctx, false);
EXPECT_EQ(ioctlVal, ctx.flags);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectValueReturned) {
int32_t ioctlVal = (1 << 16) | 4;
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getMemRegionsIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
int32_t ioctlVal = (1 << 16) | 13;
EXPECT_EQ(ioctlVal, drm->getIoctlHelper()->getEngineInfoIoctlVal());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenTranslateToEngineCapsThenReturnSameData) {
std::vector<EngineCapabilities> expectedEngines(2);
expectedEngines[0] = {{I915_ENGINE_CLASS_RENDER, 0}, 0};
expectedEngines[1] = {{I915_ENGINE_CLASS_COPY, 1}, 0};
auto engineInfo = getEngineInfo(expectedEngines);
auto ioctlHelper = drm->getIoctlHelper();
auto engines = ioctlHelper->translateToEngineCaps(engineInfo);
EXPECT_EQ(2u, engines.size());
for (uint32_t i = 0; i < engines.size(); i++) {
EXPECT_EQ(expectedEngines[i].engine.engineClass, engines[i].engine.engineClass);
EXPECT_EQ(expectedEngines[i].engine.engineInstance, engines[i].engine.engineInstance);
EXPECT_EQ(expectedEngines[i].capabilities, engines[i].capabilities);
}
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenQueryDistancesThenCorrectDistanceSet) {
std::vector<DistanceInfo> distances(3);
distances[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0};
distances[1].engine = {I915_ENGINE_CLASS_RENDER, 1};
distances[1].region = {I915_MEMORY_CLASS_DEVICE, 1};
distances[2].engine = {I915_ENGINE_CLASS_COPY, 4};
distances[2].region = {I915_MEMORY_CLASS_DEVICE, 2};
std::vector<drm_i915_query_item> queryItems(distances.size());
auto ret = drm->getIoctlHelper()->queryDistances(drm.get(), queryItems, distances);
EXPECT_EQ(0u, ret);
EXPECT_EQ(0, distances[0].distance);
EXPECT_EQ(0, distances[1].distance);
EXPECT_EQ(100, distances[2].distance);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoWithDeviceMemoryThenDistancesUsedAndMultileValuesSet) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto engineInfo = drm->getEngineInfo();
auto &multiTileArchInfo = const_cast<GT_MULTI_TILE_ARCH_INFO &>(hwInfo->gtSystemInfo.MultiTileArchInfo);
EXPECT_TRUE(multiTileArchInfo.IsValid);
EXPECT_EQ(3, multiTileArchInfo.TileCount);
EXPECT_EQ(7, multiTileArchInfo.TileMask);
EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(1));
EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(2));
EXPECT_EQ(0u, drm->memoryInfo->getMemoryRegionSize(4));
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0u, engines);
EXPECT_EQ(3u, engines.size());
engines.clear();
engineInfo->getListOfEnginesOnATile(1u, engines);
EXPECT_EQ(3u, engines.size());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoThenCorrectCCSFlagsSet) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto ccsInfo = hwInfo->gtSystemInfo.CCSInfo;
EXPECT_TRUE(ccsInfo.IsValid);
EXPECT_EQ(1u, ccsInfo.NumberOfCCSEnabled);
EXPECT_EQ(1u, ccsInfo.Instances.CCSEnableMask);
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenSysmanQueryEngineInfoThenAdditionalEnginesUsed) {
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->sysmanQueryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0u, engines);
EXPECT_EQ(5u, engines.size());
engines.clear();
engineInfo->getListOfEnginesOnATile(1u, engines);
EXPECT_EQ(5u, engines.size());
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimWhenQueryEngineInfoAndFailIoctlThenFalseReturned) {
drm->queryDistanceIoctlRetVal = -1;
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_FALSE(drm->queryEngineInfo());
EXPECT_EQ(3u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
EXPECT_EQ(nullptr, engineInfo);
}

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

@ -1,187 +0,0 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
using namespace NEO;
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtThenReturnCorrectValue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
EXPECT_EQ(1u, drm->numRegions);
EXPECT_EQ(1024u, drm->createExt.size);
EXPECT_EQ(I915_MEMORY_CLASS_DEVICE, drm->memRegions.memory_class);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtWithDebugFlagThenPrintDebugInfo) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
testing::internal::CaptureStdout();
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec 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");
EXPECT_EQ(expectedOutput, output);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosAllocThenReturnNoneRegion) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
EXPECT_EQ(CacheRegion::None, cacheRegion);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosFreeThenReturnNoneRegion) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
EXPECT_EQ(CacheRegion::None, cacheRegion);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosAllocWaysThenReturnZeroWays) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
EXPECT_EQ(0, cacheRegion);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetAdviseThenReturnCorrectValue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
EXPECT_EQ(0u, ioctlHelper->getAtomicAdvise(false));
EXPECT_EQ(0u, ioctlHelper->getAtomicAdvise(true));
EXPECT_EQ(0u, ioctlHelper->getPreferredLocationAdvise());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenSetVmBoAdviseThenReturnTrue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
EXPECT_TRUE(ioctlHelper->setVmBoAdvise(drm.get(), 0, 0, nullptr));
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenDirectSubmissionEnabledThenNoFlagsAdded) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.DirectSubmissionDrmContext.set(1);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_gem_context_create_ext ctx{};
drm->appendDrmContextFlags(ctx, false);
EXPECT_EQ(0u, ctx.flags);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetMemRegionsIoctlValThenCorrectValueReturned) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
EXPECT_EQ(DRM_I915_QUERY_MEMORY_REGIONS, drm->getIoctlHelper()->getMemRegionsIoctlVal());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
EXPECT_EQ(DRM_I915_QUERY_ENGINE_INFO, drm->getIoctlHelper()->getEngineInfoIoctlVal());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryDistancesThenReturnEinval) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
std::vector<DistanceInfo> distanceInfos;
std::vector<drm_i915_query_item> queries(4);
auto ret = drm->getIoctlHelper()->queryDistances(drm.get(), queries, distanceInfos);
EXPECT_EQ(0u, ret);
const bool queryUnsupported = std::all_of(queries.begin(), queries.end(),
[](const drm_i915_query_item &item) { return item.length == -EINVAL; });
EXPECT_TRUE(queryUnsupported);
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryEngineInfoWithoutDeviceMemoryThenDontUseMultitile) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0, engines);
auto totalEnginesCount = engineInfo->engines.size();
ASSERT_NE(nullptr, engineInfo);
EXPECT_EQ(totalEnginesCount, engines.size());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryEngineInfoWithDeviceMemoryAndDistancesUnsupportedThenDontUseMultitile) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0},
{{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
EXPECT_TRUE(drm->queryEngineInfo());
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
std::vector<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0, engines);
auto totalEnginesCount = engineInfo->engines.size();
ASSERT_NE(nullptr, engineInfo);
EXPECT_EQ(totalEnginesCount, engines.size());
}

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

@ -1,118 +0,0 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/test/common/test_macros/test.h"
#include "third_party/uapi/prelim/drm/i915_drm.h"
#include <memory>
#include <sys/ioctl.h>
using namespace NEO;
int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal) {
if (request == PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT) {
auto createExtParams = static_cast<prelim_drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;
}
createExtParams->handle = 1u;
auto extensions = reinterpret_cast<prelim_drm_i915_gem_create_ext_setparam *>(createExtParams->extensions);
if (extensions == nullptr) {
return EINVAL;
}
auto setparamRegion = *extensions;
if (setparamRegion.base.name != PRELIM_I915_GEM_CREATE_EXT_SETPARAM) {
return EINVAL;
}
if ((setparamRegion.param.size == 0) ||
(setparamRegion.param.param != (PRELIM_I915_OBJECT_PARAM | PRELIM_I915_PARAM_MEMORY_REGIONS))) {
return EINVAL;
}
auto data = reinterpret_cast<prelim_drm_i915_gem_memory_class_instance *>(setparamRegion.param.data);
if (data == nullptr) {
return EINVAL;
}
if ((data->memory_class != PRELIM_I915_MEMORY_CLASS_SYSTEM) && (data->memory_class != PRELIM_I915_MEMORY_CLASS_DEVICE)) {
return EINVAL;
}
} else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) {
auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
closReserveArg->clos_index = 1u;
} else if (request == DRM_IOCTL_I915_QUERY) {
auto query = static_cast<drm_i915_query *>(arg);
if (query->items_ptr == 0) {
return EINVAL;
}
for (auto i = 0u; i < query->num_items; i++) {
auto queryItemPtr = reinterpret_cast<drm_i915_query_item *>(query->items_ptr) + i;
if (queryItemPtr->query_id == PRELIM_DRM_I915_QUERY_DISTANCE_INFO) {
if (queryDistanceIoctlRetVal != 0) {
return queryDistanceIoctlRetVal;
}
auto distance = reinterpret_cast<prelim_drm_i915_query_distance_info *>(queryItemPtr->data_ptr);
distance->distance = (distance->engine.engine_instance == distance->region.memory_instance) ? 0 : 100;
} else if (queryItemPtr->query_id == PRELIM_DRM_I915_QUERY_ENGINE_INFO) {
auto numberOfTiles = 2u;
uint32_t numberOfEngines = numberOfTiles * 6u;
int engineInfoSize = sizeof(prelim_drm_i915_query_engine_info) + numberOfEngines * sizeof(prelim_drm_i915_engine_info);
if (queryItemPtr->length == 0) {
queryItemPtr->length = engineInfoSize;
} else {
EXPECT_EQ(engineInfoSize, queryItemPtr->length);
auto queryEngineInfo = reinterpret_cast<prelim_drm_i915_query_engine_info *>(queryItemPtr->data_ptr);
EXPECT_EQ(0u, queryEngineInfo->num_engines);
queryEngineInfo->num_engines = numberOfEngines;
auto p = queryEngineInfo->engines;
for (uint16_t tile = 0u; tile < numberOfTiles; tile++) {
p++->engine = {I915_ENGINE_CLASS_RENDER, tile};
p++->engine = {I915_ENGINE_CLASS_COPY, tile};
p++->engine = {I915_ENGINE_CLASS_VIDEO, tile};
p++->engine = {I915_ENGINE_CLASS_VIDEO_ENHANCE, tile};
p++->engine = {PRELIM_I915_ENGINE_CLASS_COMPUTE, tile};
p++->engine = {UINT16_MAX, tile};
}
}
break;
}
}
}
return ioctlRetVal;
}
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 < 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;
memoryRegions->regions[i].unallocated_size = inputRegions[i].unallocatedSize;
}
return data;
}
std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines) {
auto inputSize = static_cast<uint32_t>(inputEngines.size());
int length = sizeof(prelim_drm_i915_query_engine_info) + inputSize * sizeof(prelim_drm_i915_engine_info);
auto data = std::vector<uint8_t>(length);
auto memoryRegions = reinterpret_cast<prelim_drm_i915_query_engine_info *>(data.data());
memoryRegions->num_engines = inputSize;
for (uint32_t i = 0; i < inputSize; i++) {
memoryRegions->engines[i].engine.engine_class = inputEngines[i].engine.engineClass;
memoryRegions->engines[i].engine.engine_instance = inputEngines[i].engine.engineInstance;
memoryRegions->engines[i].capabilities = inputEngines[i].capabilities;
}
return data;
}