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

refactor: Merge prelim and non-prelim files for engine

Browse Source 
Related-To: NEO-11203

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2024-05-03 12:23:43 +00:00
committed by Compute-Runtime-Automation
parent 4c43ca518b
commit 4320be4593
11 changed files with 103 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
level_zero/sysman/source/api/engine/linux/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2020-2023 Intel Corporation
# Copyright (C) 2020-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -7,18 +7,9 @@
set(L0_SRCS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_engine_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_engine_imp.cpp
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_SRCS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_engine_imp_prelim.cpp
)
else()
list(APPEND L0_SRCS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_engine_imp.cpp
)
endif()
if(UNIX)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE

142
level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp_prelim.cpp
View File

@@ -1,142 +0,0 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/linux/engine_info.h"
#include "shared/source/os_interface/linux/i915_prelim.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_hw_device_id_linux.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
namespace L0 {
namespace Sysman {
using NEO::PrelimI915::I915_SAMPLE_BUSY;
zes_engine_group_t LinuxEngineImp::getGroupFromEngineType(zes_engine_group_t type) {
if (type == ZES_ENGINE_GROUP_RENDER_SINGLE) {
return ZES_ENGINE_GROUP_RENDER_ALL;
}
if (type == ZES_ENGINE_GROUP_COMPUTE_SINGLE) {
return ZES_ENGINE_GROUP_COMPUTE_ALL;
}
if (type == ZES_ENGINE_GROUP_COPY_SINGLE) {
return ZES_ENGINE_GROUP_COPY_ALL;
}
if (type == ZES_ENGINE_GROUP_MEDIA_DECODE_SINGLE || type == ZES_ENGINE_GROUP_MEDIA_ENCODE_SINGLE || type == ZES_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE) {
return ZES_ENGINE_GROUP_MEDIA_ALL;
}
return ZES_ENGINE_GROUP_ALL;
}
ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine_group_t, EngineInstanceSubDeviceId>> &engineGroupInstance, OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
NEO::Drm *pDrm = pLinuxSysmanImp->getDrm();
bool status = false;
{
auto hwDeviceId = pLinuxSysmanImp->getSysmanHwDeviceIdInstance();
if (hwDeviceId.getFileDescriptor() < 0) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
status = pDrm->sysmanQueryEngineInfo();
}
if (status == false) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():sysmanQueryEngineInfo is returning false and error message:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto engineInfo = pDrm->getEngineInfo();
auto engineTileMap = engineInfo->getEngineTileInfo();
for (auto itr = engineTileMap.begin(); itr != engineTileMap.end(); ++itr) {
uint32_t subDeviceId = itr->first;
auto engineGroupRange = engineClassToEngineGroup.equal_range(static_cast<__u16>(itr->second.engineClass));
for (auto l0EngineEntryInMap = engineGroupRange.first; l0EngineEntryInMap != engineGroupRange.second; l0EngineEntryInMap++) {
auto l0EngineType = l0EngineEntryInMap->second;
engineGroupInstance.insert({l0EngineType, {static_cast<uint32_t>(itr->second.engineInstance), subDeviceId}});
engineGroupInstance.insert({LinuxEngineImp::getGroupFromEngineType(l0EngineType), {0u, subDeviceId}});
engineGroupInstance.insert({ZES_ENGINE_GROUP_ALL, {0u, subDeviceId}});
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxEngineImp::getActivity(zes_engine_stats_t *pStats) {
if (fd < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): as fileDescriptor value = %d it's returning error:0x%x \n", __FUNCTION__, fd, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
uint64_t data[2] = {};
auto ret = pPmuInterface->pmuRead(static_cast<int>(fd), data, sizeof(data));
if (ret < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():pmuRead is returning value:%d and error:0x%x \n", __FUNCTION__, ret, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
// In data[], First u64 is "active time", And second u64 is "timestamp". Both in nanoseconds
pStats->activeTime = data[0] / microSecondsToNanoSeconds;
pStats->timestamp = data[1] / microSecondsToNanoSeconds;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxEngineImp::getProperties(zes_engine_properties_t &properties) {
properties.subdeviceId = subDeviceId;
properties.onSubdevice = onSubDevice;
properties.type = engineGroup;
return ZE_RESULT_SUCCESS;
}
void LinuxEngineImp::init() {
uint64_t config = UINT64_MAX;
switch (engineGroup) {
case ZES_ENGINE_GROUP_ALL:
config = __PRELIM_I915_PMU_ANY_ENGINE_GROUP_BUSY(subDeviceId);
break;
case ZES_ENGINE_GROUP_COMPUTE_ALL:
case ZES_ENGINE_GROUP_RENDER_ALL:
config = __PRELIM_I915_PMU_RENDER_GROUP_BUSY(subDeviceId);
break;
case ZES_ENGINE_GROUP_COPY_ALL:
config = __PRELIM_I915_PMU_COPY_GROUP_BUSY(subDeviceId);
break;
case ZES_ENGINE_GROUP_MEDIA_ALL:
config = __PRELIM_I915_PMU_MEDIA_GROUP_BUSY(subDeviceId);
break;
default:
auto engineClass = engineGroupToEngineClass.find(engineGroup);
config = I915_PMU_ENGINE_BUSY(engineClass->second, engineInstance);
break;
}
fd = pPmuInterface->pmuInterfaceOpen(config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED);
}
bool LinuxEngineImp::isEngineModuleSupported() {
if (fd < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): as fileDescriptor value = %d Engine Module is not supported \n", __FUNCTION__, fd);
return false;
}
return true;
}
LinuxEngineImp::LinuxEngineImp(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t subDeviceId, ze_bool_t onSubDevice) : engineGroup(type), engineInstance(engineInstance), subDeviceId(subDeviceId), onSubDevice(onSubDevice) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pDrm = pLinuxSysmanImp->getDrm();
pDevice = pLinuxSysmanImp->getSysmanDeviceImp();
pPmuInterface = pLinuxSysmanImp->getPmuInterface();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
init();
}
std::unique_ptr<OsEngine> OsEngine::create(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t subDeviceId, ze_bool_t onSubDevice) {
std::unique_ptr<LinuxEngineImp> pLinuxEngineImp = std::make_unique<LinuxEngineImp>(pOsSysman, type, engineInstance, subDeviceId, onSubDevice);
return pLinuxEngineImp;
}
} // namespace Sysman
} // namespace L0

2
level_zero/sysman/source/shared/linux/sysman_kmd_interface.h
View File

@@ -221,7 +221,7 @@ class SysmanKmdInterfaceI915Prelim : public SysmanKmdInterface, SysmanKmdInterfa
std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const override;
bool isStandbyModeControlAvailable() const override { return true; }
bool clientInfoAvailableInFdInfo() const override { return false; }
bool isGroupEngineInterfaceAvailable() const override { return false; }
bool isGroupEngineInterfaceAvailable() const override { return true; }
std::string getEngineBasePath(uint32_t subDeviceId) const override;
bool useDefaultMaximumWatchdogTimeoutForExclusiveMode() override { return false; };
ze_result_t getNumEngineTypeAndInstances(std::map<zes_engine_type_flag_t, std::vector<std::string>> &mapOfEngines,

23
level_zero/sysman/source/shared/linux/sysman_kmd_interface_i915_prelim.cpp
View File

@@ -8,6 +8,7 @@
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/os_interface/linux/i915_prelim.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
@@ -84,7 +85,27 @@ std::string SysmanKmdInterfaceI915Prelim::getSysfsFilePathForPhysicalMemorySize(
}
int64_t SysmanKmdInterfaceI915Prelim::getEngineActivityFd(zes_engine_group_t engineGroup, uint32_t engineInstance, uint32_t subDeviceId, PmuInterface *const &pPmuInterface) {
return -1;
uint64_t config = UINT64_MAX;
switch (engineGroup) {
case ZES_ENGINE_GROUP_ALL:
config = __PRELIM_I915_PMU_ANY_ENGINE_GROUP_BUSY(subDeviceId);
break;
case ZES_ENGINE_GROUP_COMPUTE_ALL:
case ZES_ENGINE_GROUP_RENDER_ALL:
config = __PRELIM_I915_PMU_RENDER_GROUP_BUSY(subDeviceId);
break;
case ZES_ENGINE_GROUP_COPY_ALL:
config = __PRELIM_I915_PMU_COPY_GROUP_BUSY(subDeviceId);
break;
case ZES_ENGINE_GROUP_MEDIA_ALL:
config = __PRELIM_I915_PMU_MEDIA_GROUP_BUSY(subDeviceId);
break;
default:
auto engineClass = engineGroupToEngineClass.find(engineGroup);
config = I915_PMU_ENGINE_BUSY(engineClass->second, engineInstance);
break;
}
return pPmuInterface->pmuInterfaceOpen(config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED);
}
std::string SysmanKmdInterfaceI915Prelim::getHwmonName(uint32_t subDeviceId, bool isSubdevice) const {

17
level_zero/sysman/test/unit_tests/sources/engine/linux/CMakeLists.txt
View File

@@ -8,21 +8,12 @@ set(L0_TESTS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine_xe.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine_xe.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine_prelim.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine_prelim.h
)
else()
list(APPEND L0_TESTS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine.h
)
endif()
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE

1
level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine.h
View File

@@ -72,6 +72,7 @@ struct MockEngineNeoDrm : public Drm {
struct MockEnginePmuInterfaceImp : public L0::Sysman::PmuInterfaceImp {
using PmuInterfaceImp::perfEventOpen;
using PmuInterfaceImp::pSysmanKmdInterface;
int64_t mockPmuFd = 0;
uint64_t mockTimestamp = 0;
uint64_t mockActiveTime = 0;

65
level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h
View File

@@ -48,12 +48,12 @@ class MockEngineSysmanHwDeviceIdDrm : public MockSysmanHwDeviceIdDrm {
}
};
struct MockEngineNeoDrm : public Drm {
struct MockEngineNeoDrmPrelim : public Drm {
using Drm::engineInfo;
using Drm::setupIoctlHelper;
const int mockFd = 0;
MockEngineNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<MockSysmanHwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
MockEngineNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment, int mockFileDescriptor) : Drm(std::make_unique<MockEngineSysmanHwDeviceIdDrm>(mockFileDescriptor, ""), rootDeviceEnvironment) {}
MockEngineNeoDrmPrelim(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<MockSysmanHwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
MockEngineNeoDrmPrelim(RootDeviceEnvironment &rootDeviceEnvironment, int mockFileDescriptor) : Drm(std::make_unique<MockEngineSysmanHwDeviceIdDrm>(mockFileDescriptor, ""), rootDeviceEnvironment) {}
bool mockReadSysmanQueryEngineInfo = false;
bool mockReadSysmanQueryEngineInfoMultiDevice = false;
@@ -118,9 +118,10 @@ struct MockEngineNeoDrm : public Drm {
}
};
struct MockEnginePmuInterfaceImp : public L0::Sysman::PmuInterfaceImp {
struct MockEnginePmuInterfaceImpPrelim : public L0::Sysman::PmuInterfaceImp {
using PmuInterfaceImp::perfEventOpen;
MockEnginePmuInterfaceImp(L0::Sysman::LinuxSysmanImp *pLinuxSysmanImp) : PmuInterfaceImp(pLinuxSysmanImp) {}
using PmuInterfaceImp::pSysmanKmdInterface;
MockEnginePmuInterfaceImpPrelim(L0::Sysman::LinuxSysmanImp *pLinuxSysmanImp) : PmuInterfaceImp(pLinuxSysmanImp) {}
bool mockPmuRead = false;
bool mockPerfEventOpenRead = false;
@@ -154,60 +155,6 @@ struct MockEnginePmuInterfaceImp : public L0::Sysman::PmuInterfaceImp {
}
};
struct MockEngineFsAccess : public L0::Sysman::FsAccessInterface {
bool mockReadVal = false;
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadVal == true) {
return readValFailure(file, val);
}
val = 23;
return ZE_RESULT_SUCCESS;
}
ze_result_t readValFailure(const std::string file, uint32_t &val) {
val = 0;
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
};
struct MockEngineSysfsAccess : public L0::Sysman::SysFsAccessInterface {
bool mockReadSymLinkFailure = false;
bool mockReadSymLinkSuccess = false;
ze_result_t readSymLink(const std::string file, std::string &val) override {
if (mockReadSymLinkFailure == true) {
return getValStringSymLinkFailure(file, val);
}
if (mockReadSymLinkSuccess == true) {
return getValStringSymLinkSuccess(file, val);
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getValStringSymLinkSuccess(const std::string file, std::string &val) {
if (file.compare(deviceDir) == 0) {
val = "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0";
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getValStringSymLinkFailure(const std::string file, std::string &val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
MockEngineSysfsAccess() = default;
};
} // namespace ult
} // namespace Sysman
} // namespace L0

30
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine.cpp
View File

@@ -27,19 +27,29 @@ class ZesEngineFixture : public SysmanDeviceFixture {
class ZesEngineFixtureI915 : public ZesEngineFixture {
protected:
std::unique_ptr<MockEnginePmuInterfaceImp> pPmuInterface;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
std::string str = "../../devices/pci0000:37/0000:37:01.0/0000:38:00.0/0000:39:01.0/0000:3a:00.0/drm/renderD128";
std::memcpy(buf, str.c_str(), str.size());
return static_cast<int>(str.size());
});
MockEngineNeoDrm *pDrm = new MockEngineNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrm>(pDrm));
pLinuxSysmanImp->pSysmanKmdInterface.reset(new SysmanKmdInterfaceI915Upstream(pLinuxSysmanImp->getProductFamily()));
pLinuxSysmanImp->pSysmanKmdInterface->initFsAccessInterface(*pDrm);
pPmuInterface = std::make_unique<MockEnginePmuInterfaceImp>(pLinuxSysmanImp);
pPmuInterface->mockPmuFd = 10;
pPmuInterface->mockActiveTime = 987654321;
pPmuInterface->mockTimestamp = 87654321;
VariableBackup<L0::Sysman::PmuInterface *> pmuBackup(&pLinuxSysmanImp->pPmuInterface);
pOriginalPmuInterface = pLinuxSysmanImp->pPmuInterface;
pPmuInterface->pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
@@ -49,6 +59,7 @@ class ZesEngineFixtureI915 : public ZesEngineFixture {
}
void TearDown() override {
pLinuxSysmanImp->pPmuInterface = pOriginalPmuInterface;
SysmanDeviceFixture::TearDown();
}
@@ -69,23 +80,6 @@ class ZesEngineFixtureI915 : public ZesEngineFixture {
}
};
TEST_F(SysmanDeviceFixture, GivenComponentCountZeroAndOpenCallFailsWhenCallingZesDeviceEnumEngineGroupsThenErrorIsReturned) {
MockEngineNeoDrm *pDrm = nullptr;
int mockFd = -1;
pDrm = new MockEngineNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()), mockFd);
pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrm>(pDrm));
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = true;
L0::Sysman::SysmanDevice *device = pSysmanDevice;
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL));
}
TEST_F(ZesEngineFixtureI915, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
uint32_t count = 0;

120
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp
View File

@@ -18,37 +18,34 @@ namespace ult {
constexpr uint32_t handleComponentCount = 13u;
constexpr uint32_t handleCountForMultiDeviceFixture = 7u;
class ZesEngineFixture : public SysmanDeviceFixture {
class ZesEngineFixturePrelim : public SysmanDeviceFixture {
protected:
MockEngineNeoDrm *pDrm = nullptr;
std::unique_ptr<MockEnginePmuInterfaceImp> pPmuInterface;
MockEngineNeoDrmPrelim *pDrm = nullptr;
std::unique_ptr<MockEnginePmuInterfaceImpPrelim> pPmuInterface;
Drm *pOriginalDrm = nullptr;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
std::unique_ptr<MockEngineSysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
std::unique_ptr<MockEngineFsAccess> pFsAccess;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
std::string str = "../../devices/pci0000:37/0000:37:01.0/0000:38:00.0/0000:39:01.0/0000:3a:00.0/drm/renderD128";
std::memcpy(buf, str.c_str(), str.size());
return static_cast<int>(str.size());
});
pSysfsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockEngineSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pFsAccess = std::make_unique<MockEngineFsAccess>();
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
pDrm = new MockEngineNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
pDrm = new MockEngineNeoDrmPrelim(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrm>(pDrm));
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrmPrelim>(pDrm));
pPmuInterface = std::make_unique<MockEnginePmuInterfaceImp>(pLinuxSysmanImp);
pLinuxSysmanImp->pSysmanKmdInterface.reset(new SysmanKmdInterfaceI915Prelim(pLinuxSysmanImp->getProductFamily()));
pLinuxSysmanImp->pSysmanKmdInterface->initFsAccessInterface(*pDrm);
pPmuInterface = std::make_unique<MockEnginePmuInterfaceImpPrelim>(pLinuxSysmanImp);
pOriginalPmuInterface = pLinuxSysmanImp->pPmuInterface;
pPmuInterface->pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
@@ -59,8 +56,6 @@ class ZesEngineFixture : public SysmanDeviceFixture {
void TearDown() override {
pLinuxSysmanImp->pPmuInterface = pOriginalPmuInterface;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOriginal;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
SysmanDeviceFixture::TearDown();
}
@@ -82,12 +77,12 @@ class ZesEngineFixture : public SysmanDeviceFixture {
TEST_F(SysmanDeviceFixture, GivenComponentCountZeroAndOpenCallFailsWhenCallingZesDeviceEnumEngineGroupsThenErrorIsReturned) {
MockEngineNeoDrm *pDrm = nullptr;
MockEngineNeoDrmPrelim *pDrm = nullptr;
int mockFd = -1;
pDrm = new MockEngineNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()), mockFd);
pDrm = new MockEngineNeoDrmPrelim(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()), mockFd);
pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrm>(pDrm));
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrmPrelim>(pDrm));
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = true;
@@ -97,7 +92,7 @@ TEST_F(SysmanDeviceFixture, GivenComponentCountZeroAndOpenCallFailsWhenCallingZe
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL));
}
TEST_F(ZesEngineFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
TEST_F(ZesEngineFixturePrelim, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL));
EXPECT_EQ(count, handleComponentCount);
@@ -112,7 +107,7 @@ TEST_F(ZesEngineFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGr
EXPECT_EQ(count, handleComponentCount);
}
TEST_F(ZesEngineFixture, GivenValidEngineHandlesWhenCallingZesEngineGetPropertiesThenVerifyCallSucceeds) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandlesWhenCallingZesEngineGetPropertiesThenVerifyCallSucceeds) {
zes_engine_properties_t properties;
auto handles = getEngineHandles(handleComponentCount);
for (auto handle : handles) {
@@ -172,7 +167,7 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandlesWhenCallingZesEngineGetPropertie
EXPECT_FALSE(properties.onSubdevice);
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZesEngineGetActivityThenVerifyCallReturnsSuccess) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZesEngineGetActivityThenVerifyCallReturnsSuccess) {
zes_engine_stats_t stats = {};
auto handles = getEngineHandles(handleComponentCount);
EXPECT_EQ(handleComponentCount, handles.size());
@@ -185,7 +180,7 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZes
}
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleAndDiscreteDeviceWhenCallingZesEngineGetActivityThenVerifyCallReturnsSuccess) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleAndDiscreteDeviceWhenCallingZesEngineGetActivityThenVerifyCallReturnsSuccess) {
pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = false;
zes_engine_stats_t stats = {};
@@ -200,38 +195,32 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleAndDiscreteDeviceWhenCallingZesEn
}
}
TEST_F(ZesEngineFixture, GivenTestDiscreteDevicesAndValidEngineHandleWhenCallingZesEngineGetActivityAndPMUGetEventTypeFailsThenVerifyEngineGetActivityReturnsFailure) {
TEST_F(ZesEngineFixturePrelim, GivenTestDiscreteDevicesAndValidEngineHandleWhenCallingZesEngineGetActivityAndPMUGetEventTypeFailsThenVerifyEngineGetActivityReturnsFailure) {
pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = false;
pSysfsAccess->mockReadSymLinkFailure = true;
auto pOsEngineTest1 = L0::Sysman::OsEngine::create(pOsSysman, ZES_ENGINE_GROUP_RENDER_SINGLE, 0u, 0u, false);
zes_engine_stats_t stats = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsEngineTest1->getActivity(&stats));
pSysfsAccess->mockReadSymLinkSuccess = true;
pFsAccess->mockReadVal = true;
auto pOsEngineTest2 = L0::Sysman::OsEngine::create(pOsSysman, ZES_ENGINE_GROUP_RENDER_SINGLE, 0u, 0u, false);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsEngineTest2->getActivity(&stats));
}
TEST_F(ZesEngineFixture, GivenUnknownEngineTypeThengetEngineGroupFromTypeReturnsGroupAllEngineGroup) {
TEST_F(ZesEngineFixturePrelim, GivenUnknownEngineTypeThengetEngineGroupFromTypeReturnsGroupAllEngineGroup) {
auto group = L0::Sysman::LinuxEngineImp::getGroupFromEngineType(ZES_ENGINE_GROUP_3D_SINGLE);
EXPECT_EQ(group, ZES_ENGINE_GROUP_ALL);
}
TEST_F(ZesEngineFixture, GivenTestIntegratedDevicesAndValidEngineHandleWhenCallingZesEngineGetActivityAndPMUGetEventTypeFailsThenVerifyEngineGetActivityReturnsFailure) {
TEST_F(ZesEngineFixturePrelim, GivenTestIntegratedDevicesAndValidEngineHandleWhenCallingZesEngineGetActivityAndPMUGetEventTypeFailsThenVerifyEngineGetActivityReturnsFailure) {
zes_engine_stats_t stats = {};
pFsAccess->mockReadVal = true;
auto pOsEngineTest1 = L0::Sysman::OsEngine::create(pOsSysman, ZES_ENGINE_GROUP_RENDER_SINGLE, 0u, 0u, false);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsEngineTest1->getActivity(&stats));
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleWhenCallingZesEngineGetActivityAndPmuReadFailsThenVerifyEngineGetActivityReturnsFailure) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleWhenCallingZesEngineGetActivityAndPmuReadFailsThenVerifyEngineGetActivityReturnsFailure) {
pPmuInterface->mockPmuRead = true;
@@ -245,7 +234,7 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleWhenCallingZesEngineGetActivityAn
}
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZesEngineGetActivityExtThenUnsupportedFeatureErrorIsReturned) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZesEngineGetActivityExtThenUnsupportedFeatureErrorIsReturned) {
zes_engine_stats_t stats = {};
auto handles = getEngineHandles(handleComponentCount);
EXPECT_EQ(handleComponentCount, handles.size());
@@ -256,7 +245,7 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZes
}
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleWhenCallingZesEngineGetActivityAndperfEventOpenFailsThenVerifyEngineGetActivityReturnsFailure) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleWhenCallingZesEngineGetActivityAndperfEventOpenFailsThenVerifyEngineGetActivityReturnsFailure) {
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::ostringstream oStream;
@@ -270,7 +259,7 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleWhenCallingZesEngineGetActivityAn
EXPECT_EQ(-1, pPmuInterface->pmuInterfaceOpen(0, -1, 0));
}
TEST_F(ZesEngineFixture, GivenValidOsSysmanPointerWhenRetrievingEngineTypeAndInstancesAndIfEngineInfoQueryFailsThenErrorIsReturned) {
TEST_F(ZesEngineFixturePrelim, GivenValidOsSysmanPointerWhenRetrievingEngineTypeAndInstancesAndIfEngineInfoQueryFailsThenErrorIsReturned) {
std::set<std::pair<zes_engine_group_t, std::pair<uint32_t, uint32_t>>> engineGroupInstance;
pDrm->mockReadSysmanQueryEngineInfo = true;
@@ -278,7 +267,7 @@ TEST_F(ZesEngineFixture, GivenValidOsSysmanPointerWhenRetrievingEngineTypeAndIns
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, L0::Sysman::OsEngine::getNumEngineTypeAndInstances(engineGroupInstance, pOsSysman));
}
TEST_F(ZesEngineFixture, GivenHandleQueryItemCalledWithInvalidEngineTypeThenzesDeviceEnumEngineGroupsSucceeds) {
TEST_F(ZesEngineFixturePrelim, GivenHandleQueryItemCalledWithInvalidEngineTypeThenzesDeviceEnumEngineGroupsSucceeds) {
uint32_t count = 0;
uint32_t mockHandleCount = 13u;
@@ -286,9 +275,7 @@ TEST_F(ZesEngineFixture, GivenHandleQueryItemCalledWithInvalidEngineTypeThenzesD
EXPECT_EQ(count, mockHandleCount);
}
TEST_F(ZesEngineFixture, GivenHandleQueryItemCalledWhenPmuInterfaceOpenFailsThenzesDeviceEnumEngineGroupsSucceedsAndHandleCountIsZero) {
pFsAccess->mockReadVal = true;
TEST_F(ZesEngineFixturePrelim, GivenHandleQueryItemCalledWhenPmuInterfaceOpenFailsThenzesDeviceEnumEngineGroupsSucceedsAndHandleCountIsZero) {
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->init(pOsSysman->getSubDeviceCount());
@@ -298,7 +285,7 @@ TEST_F(ZesEngineFixture, GivenHandleQueryItemCalledWhenPmuInterfaceOpenFailsThen
EXPECT_EQ(count, mockHandleCount);
}
TEST_F(ZesEngineFixture, GivenValidDrmObjectWhenCallingsysmanQueryEngineInfoMethodThenSuccessIsReturned) {
TEST_F(ZesEngineFixturePrelim, GivenValidDrmObjectWhenCallingsysmanQueryEngineInfoMethodThenSuccessIsReturned) {
auto drm = std::make_unique<DrmMockEngine>(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
ASSERT_NE(nullptr, drm);
EXPECT_TRUE(drm->sysmanQueryEngineInfo());
@@ -306,7 +293,7 @@ TEST_F(ZesEngineFixture, GivenValidDrmObjectWhenCallingsysmanQueryEngineInfoMeth
ASSERT_NE(nullptr, engineInfo);
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleAndHandleCountZeroWhenCallingReInitThenValidCountIsReturnedAndVerifyzesDeviceEnumEngineGroupsSucceeds) {
TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleAndHandleCountZeroWhenCallingReInitThenValidCountIsReturnedAndVerifyzesDeviceEnumEngineGroupsSucceeds) {
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::ostringstream oStream;
@@ -328,37 +315,34 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleAndHandleCountZeroWhenCallingReIn
EXPECT_EQ(count, handleComponentCount);
}
class ZesEngineMultiFixture : public SysmanMultiDeviceFixture {
class ZesEngineMultiFixturePrelim : public SysmanMultiDeviceFixture {
protected:
std::unique_ptr<MockEnginePmuInterfaceImp> pPmuInterface;
std::unique_ptr<MockEnginePmuInterfaceImpPrelim> pPmuInterface;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
std::unique_ptr<MockEngineSysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
std::unique_ptr<MockEngineFsAccess> pFsAccess;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
pSysfsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockEngineSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
std::string str = "../../devices/pci0000:37/0000:37:01.0/0000:38:00.0/0000:39:01.0/0000:3a:00.0/drm/renderD128";
std::memcpy(buf, str.c_str(), str.size());
return static_cast<int>(str.size());
});
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pFsAccess = std::make_unique<MockEngineFsAccess>();
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
MockEngineNeoDrm *pDrm = new MockEngineNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
MockEngineNeoDrmPrelim *pDrm = new MockEngineNeoDrmPrelim(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrm>(pDrm));
osInterface->setDriverModel(std::unique_ptr<MockEngineNeoDrmPrelim>(pDrm));
pPmuInterface = std::make_unique<MockEnginePmuInterfaceImp>(pLinuxSysmanImp);
pLinuxSysmanImp->pSysmanKmdInterface.reset(new SysmanKmdInterfaceI915Prelim(pLinuxSysmanImp->getProductFamily()));
pLinuxSysmanImp->pSysmanKmdInterface->initFsAccessInterface(*pDrm);
pPmuInterface = std::make_unique<MockEnginePmuInterfaceImpPrelim>(pLinuxSysmanImp);
pOriginalPmuInterface = pLinuxSysmanImp->pPmuInterface;
pPmuInterface->pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
pDrm->mockReadSysmanQueryEngineInfoMultiDevice = true;
pSysfsAccess->mockReadSymLinkSuccess = true;
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = true;
@@ -369,8 +353,6 @@ class ZesEngineMultiFixture : public SysmanMultiDeviceFixture {
void TearDown() override {
SysmanMultiDeviceFixture::TearDown();
pLinuxSysmanImp->pPmuInterface = pOriginalPmuInterface;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOriginal;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
}
std::vector<zes_engine_handle_t> getEngineHandles(uint32_t count) {
@@ -389,7 +371,7 @@ class ZesEngineMultiFixture : public SysmanMultiDeviceFixture {
}
};
TEST_F(ZesEngineMultiFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
TEST_F(ZesEngineMultiFixturePrelim, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL));
EXPECT_EQ(count, handleCountForMultiDeviceFixture);
@@ -404,7 +386,7 @@ TEST_F(ZesEngineMultiFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEng
EXPECT_EQ(count, handleCountForMultiDeviceFixture);
}
TEST_F(ZesEngineMultiFixture, GivenValidEngineHandlesWhenCallingZesEngineGetPropertiesThenVerifyCallSucceeds) {
TEST_F(ZesEngineMultiFixturePrelim, GivenValidEngineHandlesWhenCallingZesEngineGetPropertiesThenVerifyCallSucceeds) {
zes_engine_properties_t properties;
auto handles = getEngineHandles(handleCountForMultiDeviceFixture);
for (auto handle : handles) {
@@ -446,9 +428,7 @@ TEST_F(ZesEngineMultiFixture, GivenValidEngineHandlesWhenCallingZesEngineGetProp
EXPECT_EQ(properties.subdeviceId, 0u);
}
TEST_F(ZesEngineMultiFixture, GivenHandleQueryItemCalledWhenPmuInterfaceOpenFailsThenzesDeviceEnumEngineGroupsSucceedsAndHandleCountIsZero) {
pFsAccess->mockReadVal = true;
TEST_F(ZesEngineMultiFixturePrelim, GivenHandleQueryItemCalledWhenPmuInterfaceOpenFailsThenzesDeviceEnumEngineGroupsSucceedsAndHandleCountIsZero) {
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->init(pOsSysman->getSubDeviceCount());

6
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_xe.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -24,6 +24,7 @@ class ZesEngineFixtureXe : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockPmuInterfaceImp> pPmuInterface;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
@@ -45,7 +46,7 @@ class ZesEngineFixtureXe : public SysmanDeviceFixture {
pPmuInterface->mockActiveTime = 987654321;
pPmuInterface->mockTimestamp = 87654321;
pPmuInterface->pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
VariableBackup<L0::Sysman::PmuInterface *> pmuBackup(&pLinuxSysmanImp->pPmuInterface);
pOriginalPmuInterface = pLinuxSysmanImp->pPmuInterface;
pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
@@ -55,6 +56,7 @@ class ZesEngineFixtureXe : public SysmanDeviceFixture {
}
void TearDown() override {
pLinuxSysmanImp->pPmuInterface = pOriginalPmuInterface;
SysmanDeviceFixture::TearDown();
}

8
level_zero/sysman/test/unit_tests/sources/shared/linux/sysman_kmd_interface_tests_i915_prelim.cpp
View File

@@ -123,16 +123,10 @@ TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceWhenCalling
EXPECT_EQ(SysmanKmdInterface::SysfsValueUnit::micro, pSysmanKmdInterface->getNativeUnit(SysfsName::sysfsNameDefaultPowerLimit));
}
TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceWhenCallingGetEngineActivityFdThenInvalidFdisReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
auto pPmuInterface = std::make_unique<MockPmuInterfaceImp>(pLinuxSysmanImp);
EXPECT_EQ(-1, pSysmanKmdInterface->getEngineActivityFd(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get()));
}
TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceWhenCheckingSupportForI915DriverThenProperStatusIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
EXPECT_FALSE(pSysmanKmdInterface->clientInfoAvailableInFdInfo());
EXPECT_FALSE(pSysmanKmdInterface->isGroupEngineInterfaceAvailable());
EXPECT_TRUE(pSysmanKmdInterface->isGroupEngineInterfaceAvailable());
EXPECT_FALSE(pSysmanKmdInterface->useDefaultMaximumWatchdogTimeoutForExclusiveMode());
}