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

Use drm tip kernel headers as default 2/2

Browse Source 
Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2021-10-27 12:43:46 +00:00
committed by Compute-Runtime-Automation
parent 75a5aed81d
commit 3cf2e2e395
31 changed files with 2952 additions and 7832 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -23,6 +23,8 @@ set(IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}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
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_system_info_tests.cpp
@@ -32,7 +34,7 @@ set(IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_linux_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_linux_tests.h
${CMAKE_CURRENT_SOURCE_DIR}/linux_create_command_queue_with_properties_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/local_memory_helper_default_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}local_memory_helper_default_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_os_time_linux.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_performance_counters_linux.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_performance_counters_linux.h
@@ -42,17 +44,7 @@ set(IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/performance_counters_linux_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/self_lib_lin.cpp
)
if(I915_LOCAL_MEM_EXP)
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_info_tests_exp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager_localmem_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/local_memory_helper_default_tests_exp.cpp
)
else()
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_memory_info_tests.cpp
)
endif()
if(NEO__LIBVA_FOUND)
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}/drm_va_sharing_tests.cpp

26
opencl/test/unit_test/os_interface/linux/device_command_stream_fixture_exp.h → opencl/test/unit_test/os_interface/linux/device_command_stream_fixture_impl.h
View File

@@ -8,11 +8,11 @@
#pragma once
#include "shared/test/common/os_interface/linux/device_command_stream_fixture.h"
class DrmMockCustomExp : public DrmMockCustom {
class DrmMockCustomImpl : public DrmMockCustom {
public:
using Drm::memoryInfo;
class IoctlsExp {
class Ioctls {
public:
void reset() {
gemCreateExt = 0;
@@ -22,13 +22,13 @@ class DrmMockCustomExp : public DrmMockCustom {
std::atomic<int32_t> gemMmapOffset;
};
IoctlsExp ioctlExp_cnt;
IoctlsExp ioctlExp_expected;
Ioctls ioctlImpl_cnt;
Ioctls ioctlImpl_expected;
void testIoctlsExp() {
#define NEO_IOCTL_EXPECT_EQ(PARAM) \
if (this->ioctlExp_expected.PARAM >= 0) { \
EXPECT_EQ(this->ioctlExp_expected.PARAM, this->ioctlExp_cnt.PARAM); \
void testIoctls() {
#define NEO_IOCTL_EXPECT_EQ(PARAM) \
if (this->ioctlImpl_expected.PARAM >= 0) { \
EXPECT_EQ(this->ioctlImpl_expected.PARAM, this->ioctlImpl_cnt.PARAM); \
}
NEO_IOCTL_EXPECT_EQ(gemMmapOffset);
#undef NEO_IOCTL_EXPECT_EQ
@@ -54,7 +54,7 @@ class DrmMockCustomExp : public DrmMockCustom {
createExtSize = createExtParams->size;
createExtHandle = createExtParams->handle;
createExtExtensions = createExtParams->extensions;
ioctlExp_cnt.gemCreateExt++;
ioctlImpl_cnt.gemCreateExt++;
} break;
case DRM_IOCTL_I915_GEM_MMAP_OFFSET: {
auto mmapOffsetParams = reinterpret_cast<drm_i915_gem_mmap_offset *>(arg);
@@ -62,7 +62,7 @@ class DrmMockCustomExp : public DrmMockCustom {
mmapOffsetPad = mmapOffsetParams->pad;
mmapOffsetOffset = mmapOffsetParams->offset;
mmapOffsetFlags = mmapOffsetParams->flags;
ioctlExp_cnt.gemMmapOffset++;
ioctlImpl_cnt.gemMmapOffset++;
if (failOnMmapOffset == true) {
return -1;
}
@@ -75,8 +75,8 @@ class DrmMockCustomExp : public DrmMockCustom {
return 0;
}
DrmMockCustomExp(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockCustom(rootDeviceEnvironment) {
ioctlExp_cnt.reset();
ioctlExp_expected.reset();
DrmMockCustomImpl(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockCustom(rootDeviceEnvironment) {
ioctlImpl_cnt.reset();
ioctlImpl_expected.reset();
}
};

2
opencl/test/unit_test/os_interface/linux/drm_command_stream_fixture.h
View File

@@ -242,4 +242,4 @@ class DrmCommandStreamEnhancedWithFailingExecTemplate : public ::testing::Test {
}
};
using DrmCommandStreamEnhancedWithFailingExec = DrmCommandStreamEnhancedWithFailingExecTemplate<DrmMockCustom>;
using DrmCommandStreamEnhancedWithFailingExec = DrmCommandStreamEnhancedWithFailingExecTemplate<DrmMockCustom>;

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

@@ -5,50 +5,290 @@
*
*/
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/memory_manager/memory_banks.h"
#include "shared/source/os_interface/linux/memory_info_impl.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
#include "test.h"
#include "gtest/gtest.h"
using namespace NEO;
struct MemoryInfoImpl : public NEO::MemoryInfo {
MemoryInfoImpl() {}
~MemoryInfoImpl() override{};
size_t getMemoryRegionSize(uint32_t memoryBank) override {
return 0u;
}
uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override {
return 0u;
}
uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) override {
return 0u;
}
};
TEST(DrmTest, whenQueryingMemoryInfoThenMemoryInfoIsNotCreatedAndNoIoctlsAreCalled) {
TEST(MemoryInfo, givenNotSupportedLocalMemoryQueryingMemoryInfoThenMemoryInfoIsNotCreated) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(0);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>(*executionEnvironment->rootDeviceEnvironments[0]);
EXPECT_NE(nullptr, drm);
EXPECT_TRUE(drm->queryMemoryInfo());
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
auto ret = drm->queryMemoryInfo();
auto memoryInfo = drm->getMemoryInfo();
EXPECT_EQ(nullptr, drm->memoryInfo.get());
EXPECT_EQ(0u, drm->ioctlCallsCount);
EXPECT_TRUE(ret);
EXPECT_EQ(nullptr, memoryInfo);
}
TEST(DrmTest, givenMemoryInfoWhenGetMemoryInfoIsCalledThenValidPtrIsReturned) {
TEST(MemoryInfo, givenMemoryRegionQuerySupportedWhenQueryingMemoryInfoThenMemoryInfoIsCreatedWithRegions) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>(*executionEnvironment->rootDeviceEnvironments[0]);
EXPECT_NE(nullptr, drm);
drm->memoryInfo.reset(new MemoryInfoImpl);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
EXPECT_EQ(drm->memoryInfo.get(), drm->getMemoryInfo());
drm->queryMemoryInfo();
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto memoryInfo = static_cast<MemoryInfoImpl *>(drm->getMemoryInfo());
ASSERT_NE(nullptr, memoryInfo);
EXPECT_EQ(2u, memoryInfo->getDrmRegionInfos().size());
}
TEST(MemoryInfo, givenMemoryInfoImplementationWhenDestructingThenDestructorIsCalled) {
MemoryInfoImpl memoryInfoImpl;
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);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[1].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenAssignRegionsFromDistancesThenRegionsNotChanged) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
memoryInfo->assignRegionsFromDistances(&regionInfo, 2);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[1].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithoutDeviceRegionWhenGettingDeviceRegionSizeThenReturnCorrectSize) {
drm_i915_memory_region_info regionInfo[1] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 1);
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);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, whenDebugVariablePrintMemoryRegionSizeIsSetAndGetMemoryRegionSizeIsCalledThenMessagePrintedToStdOutput) {
DebugManagerStateRestore restore;
DebugManager.flags.PrintMemoryRegionSizes.set(true);
drm_i915_memory_region_info regionInfo[1] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 1};
regionInfo[0].probed_size = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 1);
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);
drm_i915_memory_region_info regionInfo[3] = {};
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;
regionInfo[2].region = {I915_MEMORY_CLASS_DEVICE, 1};
regionInfo[2].probed_size = 32 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 3);
ASSERT_NE(nullptr, memoryInfo);
DebugManager.flags.OverrideDrmRegion.set(1);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[2].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[2].region.memory_instance, regionClassAndInstance.memory_instance);
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.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
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.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
} else {
EXPECT_EQ(regionInfo[2].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[2].region.memory_instance, regionClassAndInstance.memory_instance);
}
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(1));
EXPECT_EQ(32 * GB, regionSize);
}
using MemoryInfoTest = ::testing::Test;
HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtensionsThenReturnCorrectValues, NonDefaultIoctlsSupported) {
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 executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExt(drm.get(), &regionInfo, 2, 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);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
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);
}

277
opencl/test/unit_test/os_interface/linux/drm_memory_info_tests_exp.cpp
View File

@@ -1,277 +0,0 @@
/*
* Copyright (C) 2020-2021 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_impl.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_exp.h"
#include "test.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<DrmMockExp>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryMemoryInfo();
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto memoryInfo = static_cast<MemoryInfoImpl *>(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<DrmMockExp>(*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<DrmMockExp>(*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<DrmMockExp>(*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<DrmMockExp>(*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);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[1].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsAndLocalMemoryEnabledWhenAssignRegionsFromDistancesThenRegionsNotChanged) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
memoryInfo->assignRegionsFromDistances(&regionInfo, 2);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[1].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithoutDeviceRegionWhenGettingDeviceRegionSizeThenReturnCorrectSize) {
drm_i915_memory_region_info regionInfo[1] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 1);
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);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::MainBank, *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
auto regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::MainBank);
EXPECT_EQ(8 * GB, regionSize);
regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[0].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[0].region.memory_instance, regionClassAndInstance.memory_instance);
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0));
EXPECT_EQ(16 * GB, regionSize);
}
TEST(MemoryInfo, whenDebugVariablePrintMemoryRegionSizeIsSetAndGetMemoryRegionSizeIsCalledThenMessagePrintedToStdOutput) {
DebugManagerStateRestore restore;
DebugManager.flags.PrintMemoryRegionSizes.set(true);
drm_i915_memory_region_info regionInfo[1] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 1};
regionInfo[0].probed_size = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 1);
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);
drm_i915_memory_region_info regionInfo[3] = {};
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;
regionInfo[2].region = {I915_MEMORY_CLASS_DEVICE, 1};
regionInfo[2].probed_size = 32 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 3);
ASSERT_NE(nullptr, memoryInfo);
DebugManager.flags.OverrideDrmRegion.set(1);
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(MemoryBanks::getBankForLocalMemory(0), *defaultHwInfo);
EXPECT_EQ(regionInfo[2].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[2].region.memory_instance, regionClassAndInstance.memory_instance);
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.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
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.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[1].region.memory_instance, regionClassAndInstance.memory_instance);
} else {
EXPECT_EQ(regionInfo[2].region.memory_class, regionClassAndInstance.memory_class);
EXPECT_EQ(regionInfo[2].region.memory_instance, regionClassAndInstance.memory_instance);
}
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(1));
EXPECT_EQ(32 * GB, regionSize);
}
using MemoryInfoTest = ::testing::Test;
HWTEST2_F(MemoryInfoTest, givenMemoryInfoWithRegionsWhenCreatingGemWithExtensionsThenReturnCorrectValues, NonDefaultIoctlsSupported) {
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 executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockExp>(*executionEnvironment->rootDeviceEnvironments[0]);
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExt(drm.get(), &regionInfo, 2, 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);
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 memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockExp>(*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);
}

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

@@ -19,8 +19,8 @@
#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_exp.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_exp.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 "test.h"
@@ -32,14 +32,14 @@ BufferObject *createBufferObjectInMemoryRegion(Drm *drm, uint64_t gpuAddress, si
class DrmMemoryManagerLocalMemoryTest : public ::testing::Test {
public:
DrmMockExp *mock;
DrmTipMock *mock;
void SetUp() override {
const bool localMemoryEnabled = true;
executionEnvironment = new ExecutionEnvironment;
executionEnvironment->prepareRootDeviceEnvironments(1);
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->setHwInfo(defaultHwInfo.get());
mock = new DrmMockExp(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
mock->memoryInfo.reset(new MockMemoryInfo());
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
@@ -67,14 +67,14 @@ class DrmMemoryManagerLocalMemoryTest : public ::testing::Test {
class DrmMemoryManagerLocalMemoryWithCustomMockTest : public ::testing::Test {
public:
DrmMockCustomExp *mock;
DrmMockCustomImpl *mock;
void SetUp() override {
const bool localMemoryEnabled = true;
executionEnvironment = new ExecutionEnvironment;
executionEnvironment->prepareRootDeviceEnvironments(1);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
mock = new DrmMockCustomExp(*executionEnvironment->rootDeviceEnvironments[0]);
mock = new DrmMockCustomImpl(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
@@ -171,7 +171,7 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMem
executionEnvironment->prepareRootDeviceEnvironments(rootDevicesNumber);
for (uint32_t i = 0; i < rootDevicesNumber; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmMockExp(*executionEnvironment->rootDeviceEnvironments[i]);
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[i]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
@@ -190,7 +190,7 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMem
size_t size = 4096u;
AllocationProperties properties(rootDeviceIndex, true, size, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY, false, {});
static_cast<DrmMockExp *>(executionEnvironment->rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Drm>())->outputFd = 7;
static_cast<DrmTipMock *>(executionEnvironment->rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Drm>())->outputFd = 7;
auto ptr = memoryManager->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndices, properties, multiGraphics);
@@ -198,7 +198,7 @@ HWTEST2_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMem
EXPECT_NE(static_cast<DrmAllocation *>(multiGraphics.getDefaultGraphicsAllocation())->getMmapPtr(), nullptr);
for (uint32_t i = 0; i < rootDevicesNumber; i++) {
if (i != 0) {
EXPECT_EQ(static_cast<DrmMockExp *>(executionEnvironment->rootDeviceEnvironments[i]->osInterface->getDriverModel()->as<Drm>())->inputFd, 7);
EXPECT_EQ(static_cast<DrmTipMock *>(executionEnvironment->rootDeviceEnvironments[i]->osInterface->getDriverModel()->as<Drm>())->inputFd, 7);
}
EXPECT_NE(multiGraphics.getGraphicsAllocation(i), nullptr);
memoryManager->freeGraphicsMemory(multiGraphics.getGraphicsAllocation(i));
@@ -216,7 +216,7 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMemory
executionEnvironment->prepareRootDeviceEnvironments(rootDevicesNumber);
for (uint32_t i = 0; i < rootDevicesNumber; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmMockExp(*executionEnvironment->rootDeviceEnvironments[i]);
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[i]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
@@ -275,7 +275,7 @@ TEST_F(DrmMemoryManagerUsmSharedHandleTest, givenMultiRootDeviceEnvironmentAndMe
executionEnvironment->prepareRootDeviceEnvironments(rootDevicesNumber);
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmMockExp(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
@@ -311,7 +311,7 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndNoMemo
executionEnvironment->prepareRootDeviceEnvironments(rootDevicesNumber);
for (uint32_t i = 0; i < rootDevicesNumber; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
auto mock = new DrmMockExp(*executionEnvironment->rootDeviceEnvironments[i]);
auto mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[i]);
mock->memoryInfo.reset(nullptr);
mock->ioctlCallsCount = 0;
@@ -472,14 +472,14 @@ class DrmMemoryManagerLocalMemoryMemoryBankMock : public TestedDrmMemoryManager
class DrmMemoryManagerLocalMemoryMemoryBankTest : public ::testing::Test {
public:
DrmMockExp *mock;
DrmTipMock *mock;
void SetUp() override {
const bool localMemoryEnabled = true;
executionEnvironment = new ExecutionEnvironment;
executionEnvironment->prepareRootDeviceEnvironments(1);
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->setHwInfo(defaultHwInfo.get());
mock = new DrmMockExp(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
mock = new DrmTipMock(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]);
mock->memoryInfo.reset(new MockMemoryInfo());
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
@@ -668,7 +668,7 @@ TEST_F(DrmMemoryManagerLocalMemoryWithCustomMockTest, givenDrmMemoryManagerWithL
EXPECT_EQ(nullptr, bo.peekLockedAddress());
}
using DrmMemoryManagerFailInjectionTest = Test<DrmMemoryManagerFixtureExp>;
using DrmMemoryManagerFailInjectionTest = Test<DrmMemoryManagerFixtureImpl>;
HWTEST2_F(DrmMemoryManagerFailInjectionTest, givenEnabledLocalMemoryWhenNewFailsThenAllocateInDevicePoolReturnsStatusErrorAndNullallocation, NonDefaultIoctlsSupported) {
mock->ioctl_expected.total = -1; //don't care
@@ -816,13 +816,13 @@ TEST_F(DrmMemoryManagerCopyMemoryToAllocationTest, givenDrmMemoryManagerWhenCopy
drmMemoryManger.freeGraphicsMemory(allocation);
}
using DrmMemoryManagerTestExp = Test<DrmMemoryManagerFixtureExp>;
using DrmMemoryManagerTestImpl = Test<DrmMemoryManagerFixtureImpl>;
HWTEST2_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryThenCallIoctlGemMapOffsetAndReturnLockedPtr, NonDefaultIoctlsSupported) {
mockExp->ioctlExp_expected.gemCreateExt = 1;
HWTEST2_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryThenCallIoctlGemMapOffsetAndReturnLockedPtr, NonDefaultIoctlsSupported) {
mockExp->ioctlImpl_expected.gemCreateExt = 1;
mockExp->ioctl_expected.gemWait = 1;
mockExp->ioctl_expected.gemClose = 1;
mockExp->ioctlExp_expected.gemMmapOffset = 1;
mockExp->ioctlImpl_expected.gemMmapOffset = 1;
mockExp->memoryInfo.reset(new MockMemoryInfo());
AllocationData allocData;
@@ -854,8 +854,8 @@ HWTEST2_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOn
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryButFailsOnMmapThenReturnNullPtr) {
mockExp->ioctlExp_expected.gemMmapOffset = 2;
TEST_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryButFailsOnMmapThenReturnNullPtr) {
mockExp->ioctlImpl_expected.gemMmapOffset = 2;
this->ioctlResExt = {mockExp->ioctl_cnt.total, -1};
mockExp->ioctl_res_ext = &ioctlResExt;
@@ -870,8 +870,8 @@ TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAll
mockExp->ioctl_res_ext = &mockExp->NONE;
}
TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryButFailsOnIoctlMmapFunctionOffsetThenReturnNullPtr) {
mockExp->ioctlExp_expected.gemMmapOffset = 2;
TEST_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryButFailsOnIoctlMmapFunctionOffsetThenReturnNullPtr) {
mockExp->ioctlImpl_expected.gemMmapOffset = 2;
mockExp->returnIoctlExtraErrorValue = true;
mockExp->failOnMmapOffset = true;
@@ -886,7 +886,7 @@ TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAll
mockExp->ioctl_res_ext = &mockExp->NONE;
}
TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryButBufferObjectIsNullThenReturnNullPtr) {
TEST_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAllocationInLocalMemoryButBufferObjectIsNullThenReturnNullPtr) {
DrmAllocation drmAllocation(0, GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 0u, 0u, MemoryPool::LocalMemory);
auto ptr = memoryManager->lockResource(&drmAllocation);
@@ -895,7 +895,7 @@ TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenLockUnlockIsCalledOnAll
memoryManager->unlockResource(&drmAllocation);
}
TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCalledForMemoryInfoThenReturnMemoryRegionSize) {
TEST_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCalledForMemoryInfoThenReturnMemoryRegionSize) {
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto drm = new DrmMock(*executionEnvironment.rootDeviceEnvironments[0]);
@@ -908,7 +908,7 @@ TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCal
EXPECT_EQ(memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(0)), memoryManager.getLocalMemorySize(0u, 0xF));
}
TEST_F(DrmMemoryManagerTestExp, givenLocalMemoryDisabledWhenQueryMemoryInfoThenReturnTrueAndDontCreateMemoryInfo) {
TEST_F(DrmMemoryManagerTestImpl, givenLocalMemoryDisabledWhenQueryMemoryInfoThenReturnTrueAndDontCreateMemoryInfo) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(0);
MockExecutionEnvironment executionEnvironment;
@@ -919,7 +919,7 @@ TEST_F(DrmMemoryManagerTestExp, givenLocalMemoryDisabledWhenQueryMemoryInfoThenR
EXPECT_EQ(nullptr, drm->memoryInfo);
}
TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCalledForMemoryInfoAndInvalidDeviceBitfieldThenReturnZero) {
TEST_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCalledForMemoryInfoAndInvalidDeviceBitfieldThenReturnZero) {
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto drm = new DrmMock(*executionEnvironment.rootDeviceEnvironments[0]);
@@ -932,7 +932,7 @@ TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCal
EXPECT_EQ(0u, memoryManager.getLocalMemorySize(0u, 0u));
}
TEST_F(DrmMemoryManagerTestExp, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCalledButMemoryInfoIsNotAvailableThenSizeZeroIsReturned) {
TEST_F(DrmMemoryManagerTestImpl, givenDrmMemoryManagerWhenGetLocalMemorySizeIsCalledButMemoryInfoIsNotAvailableThenSizeZeroIsReturned) {
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto drm = new DrmMock(*executionEnvironment.rootDeviceEnvironments[0]);

10
opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests_exp.h → opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests_impl.h
View File

@@ -10,13 +10,13 @@
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
#include "opencl/test/unit_test/os_interface/linux/device_command_stream_fixture_exp.h"
#include "opencl/test/unit_test/os_interface/linux/device_command_stream_fixture_impl.h"
namespace NEO {
class DrmMemoryManagerFixtureExp : public DrmMemoryManagerFixture {
class DrmMemoryManagerFixtureImpl : public DrmMemoryManagerFixture {
public:
DrmMockCustomExp *mockExp;
DrmMockCustomImpl *mockExp;
void SetUp() override {
backup = std::make_unique<VariableBackup<UltHwConfig>>(&ultHwConfig);
@@ -24,12 +24,12 @@ class DrmMemoryManagerFixtureExp : public DrmMemoryManagerFixture {
MemoryManagementFixture::SetUp();
executionEnvironment = MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), numRootDevices - 1);
mockExp = new DrmMockCustomExp(*executionEnvironment->rootDeviceEnvironments[0]);
mockExp = new DrmMockCustomImpl(*executionEnvironment->rootDeviceEnvironments[0]);
DrmMemoryManagerFixture::SetUp(mockExp, true);
}
void TearDown() override {
mockExp->testIoctlsExp();
mockExp->testIoctls();
DrmMemoryManagerFixture::TearDown();
}
std::unique_ptr<VariableBackup<UltHwConfig>> backup;

6
opencl/test/unit_test/os_interface/linux/drm_mock_exp.h → opencl/test/unit_test/os_interface/linux/drm_mock_impl.h
View File

@@ -15,10 +15,10 @@
using namespace NEO;
class DrmMockExp : public DrmMock {
class DrmTipMock : public DrmMock {
public:
DrmMockExp(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockExp(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmMockExp(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
DrmTipMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmTipMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmTipMock(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
}

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

@@ -7,7 +7,7 @@
#pragma once
#include "opencl/test/unit_test/os_interface/linux/drm_mock_exp.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
namespace PROD_DG1 {
#undef DRM_IOCTL_I915_GEM_CREATE_EXT
@@ -17,10 +17,10 @@ namespace PROD_DG1 {
using namespace NEO;
class DrmMockProdDg1 : public DrmMockExp {
class DrmMockProdDg1 : public DrmTipMock {
public:
DrmMockProdDg1(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockProdDg1(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmMockProdDg1(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMockExp(rootDeviceEnvironment) {
DrmMockProdDg1(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmTipMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
}

21
opencl/test/unit_test/os_interface/linux/local_memory_helper_default_tests.cpp
View File

@@ -5,12 +5,33 @@
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/local_memory_helper.h"
#include "shared/source/os_interface/linux/memory_info_impl.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "test.h"
using namespace NEO;
TEST(LocalMemoryHelperTestsDefault, givenUnsupportedPlatformWhenCreateGemExtThenReturnErrorNumber) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMock>(*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 localMemHelper = LocalMemoryHelper::get(IGFX_UNKNOWN);
uint32_t handle = 0;
auto ret = localMemHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
EXPECT_EQ(-1u, ret);
}
TEST(LocalMemoryHelperTestsDefault, givenUnsupportedPlatformWhenTranslateIfRequiredReturnSameData) {
auto *data = new uint8_t{};
auto localMemHelper = LocalMemoryHelper::get(IGFX_UNKNOWN);

33
opencl/test/unit_test/os_interface/linux/local_memory_helper_default_tests_exp.cpp
View File

@@ -1,33 +0,0 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/linux/local_memory_helper.h"
#include "shared/source/os_interface/linux/memory_info_impl.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "test.h"
using namespace NEO;
TEST(LocalMemoryHelperTestsDefault, givenUnsupportedPlatformWhenCreateGemExtThenReturnErrorNumber) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMock>(*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 localMemHelper = LocalMemoryHelper::get(IGFX_UNKNOWN);
uint32_t handle = 0;
auto ret = localMemHelper->createGemExt(drm.get(), &regionInfo[1], 1, 1024, handle);
EXPECT_EQ(-1u, ret);
}

6
opencl/test/unit_test/os_interface/linux/local_memory_helper_tests_dg1.cpp
View File

@@ -11,7 +11,7 @@
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_exp.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"
#include "test.h"
@@ -22,7 +22,7 @@ using LocalMemoryHelperTestsDg1 = ::testing::Test;
DG1TEST_F(LocalMemoryHelperTestsDg1, givenDg1WhenCreateGemExtThenReturnCorrectValue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockExp>(*executionEnvironment->rootDeviceEnvironments[0]);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
@@ -47,7 +47,7 @@ DG1TEST_F(LocalMemoryHelperTestsDg1, givenDg1WithDrmTipWhenCreateGemExtWithDebug
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockExp>(*executionEnvironment->rootDeviceEnvironments[0]);
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};

8
opencl/test/unit_test/os_interface/linux/local_memory_helper_tests_xe_hp_sdv.cpp
View File

@@ -10,7 +10,7 @@
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_exp.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock_impl.h"
#include "test.h"
using namespace NEO;
@@ -20,7 +20,7 @@ using LocalMemoryHelperTestsXeHpSdv = ::testing::Test;
XEHPTEST_F(LocalMemoryHelperTestsXeHpSdv, givenXeHpSdvWhenCreateGemExtThenReturnCorrectValue) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockExp>(*executionEnvironment->rootDeviceEnvironments[0]);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
@@ -45,7 +45,7 @@ XEHPTEST_F(LocalMemoryHelperTestsXeHpSdv, givenXeHpSdvWhenCreateGemExtWithDebugF
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockExp>(*executionEnvironment->rootDeviceEnvironments[0]);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
@@ -59,4 +59,4 @@ XEHPTEST_F(LocalMemoryHelperTestsXeHpSdv, givenXeHpSdvWhenCreateGemExtWithDebugF
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);
}
}