intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Enable sysman windows ults

Browse Source 
Related-To: LOCI-3205

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>
This commit is contained in:
Mayank Raghuwanshi
2022-09-06 13:28:56 +00:00
committed by Compute-Runtime-Automation
parent 88b7a4f82d
commit a9bc4de8cf
18 changed files with 400 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
level_zero/tools/source/sysman/frequency/windows/os_frequency_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,6 +14,14 @@ namespace L0 {
ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
readOverclockingInfo();
uint32_t value = 0;
properties.onSubdevice = false;
properties.subdeviceId = 0;
properties.type = frequencyDomainNumber;
properties.isThrottleEventSupported = false;
properties.min = unsupportedProperty;
properties.max = unsupportedProperty;
properties.max = unsupportedProperty;
properties.canControl = false;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
@@ -36,44 +44,35 @@ ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &pr
request.requestId = KmdSysman::Requests::Frequency::CanControlFrequency;
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
vRequests.push_back(request);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
properties.isThrottleEventSupported = false;
if (vResponses[0].returnCode == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
properties.isThrottleEventSupported = static_cast<ze_bool_t>(value);
}
properties.min = unsupportedProperty;
if (vResponses[1].returnCode == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
properties.min = static_cast<double>(value);
}
properties.max = unsupportedProperty;
if (vResponses[2].returnCode == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
properties.max = static_cast<double>(value);
}
properties.canControl = false;
if (vResponses[3].returnCode == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
properties.canControl = (value == 1);
}
properties.onSubdevice = false;
properties.subdeviceId = 0;
properties.type = frequencyDomainNumber;
return ZE_RESULT_SUCCESS;
}

10
level_zero/tools/source/sysman/windows/kmd_sys_manager.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -22,14 +22,14 @@ class KmdSysManager {
public:
static KmdSysManager *create(NEO::Wddm *pWddm);
KmdSysManager() = default;
~KmdSysManager() = default;
virtual ~KmdSysManager() = default;
MOCKABLE_VIRTUAL ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out);
ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut);
virtual ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out);
virtual ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut);
NEO::Wddm *GetWddmAccess() { return pWddmAccess; }
private:
MOCKABLE_VIRTUAL bool escape(uint32_t escapeOp, uint64_t pDataIn, uint32_t dataInSize, uint64_t pDataOut, uint32_t dataOutSize);
virtual bool escape(uint32_t escapeOp, uint64_t pDataIn, uint32_t dataInSize, uint64_t pDataOut, uint32_t dataOutSize);
bool parseBufferIn(KmdSysman::GfxSysmanMainHeaderIn *pIn, std::vector<KmdSysman::RequestProperty> &vIn);
bool parseBufferOut(KmdSysman::GfxSysmanMainHeaderOut *pOut, std::vector<KmdSysman::ResponseProperty> &vOut);

4
level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -79,7 +79,7 @@ struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
}
Mock() = default;
~Mock() = default;
~Mock() override = default;
};
} // namespace ult

58
level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_zes_engine.cpp
View File

@@ -17,7 +17,7 @@ namespace ult {
constexpr uint32_t engineHandleComponentCount = 3u;
class SysmanDeviceEngineFixture : public SysmanDeviceFixture {
protected:
Mock<EngineKmdSysManager> *pKmdSysManager = nullptr;
std::unique_ptr<Mock<EngineKmdSysManager>> pKmdSysManager = nullptr;
KmdSysManager *pOriginalKmdSysManager = nullptr;
void SetUp() override {
if (!sysmanUltsEnable) {
@@ -25,32 +25,24 @@ class SysmanDeviceEngineFixture : public SysmanDeviceFixture {
}
SysmanDeviceFixture::SetUp();
pKmdSysManager = new Mock<EngineKmdSysManager>;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<EngineKmdSysManager>::mock_escape));
pKmdSysManager.reset(new Mock<EngineKmdSysManager>);
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
for (auto handle : pSysmanDeviceImp->pEngineHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
get_engine_handles(0);
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
if (pKmdSysManager != nullptr) {
delete pKmdSysManager;
pKmdSysManager = nullptr;
}
SysmanDeviceFixture::TearDown();
}
std::vector<zes_engine_handle_t> get_engine_handles(uint32_t count) {
@@ -60,13 +52,13 @@ class SysmanDeviceEngineFixture : public SysmanDeviceFixture {
}
};
TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingEngineGroupsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, engineHandleComponentCount);
}
TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenInvalidComponentCountWhenEnumeratingEngineGroupsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
TEST_F(SysmanDeviceEngineFixture, GivenInvalidComponentCountWhenEnumeratingEngineGroupsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, engineHandleComponentCount);
@@ -76,7 +68,7 @@ TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenInvalidComponentCountWhenEnumera
EXPECT_EQ(count, engineHandleComponentCount);
}
TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingEngineGroupsThenValidPowerHandlesIsReturned) {
TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsThenValidPowerHandlesIsReturned) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, engineHandleComponentCount);
@@ -88,7 +80,29 @@ TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenComponentCountZeroWhenEnumeratin
}
}
TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenValidHandleGetPropertiesThenCorrectEngineGroupIsReturned) {
TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsAndRequestSingleFailsThenZeroHandlesAreReturned) {
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, 0);
}
TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsIfEngineSupportIsAbsentThenZeroHandlesAreReturned) {
pKmdSysManager->mockNumSupportedEngineGroups = 0;
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, 0);
}
TEST_F(SysmanDeviceEngineFixture, GivenUnsupportedEngineHandleWhenGettingEngineActivityThenFailureIsReturned) {
WddmEngineImp *pEngineImp = new WddmEngineImp(pOsSysman, ZES_ENGINE_GROUP_3D_ALL, 0, 0);
zes_engine_stats_t pStats = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pEngineImp->getActivity(&pStats));
delete pEngineImp;
}
TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetPropertiesThenCorrectEngineGroupIsReturned) {
auto handles = get_engine_handles(engineHandleComponentCount);
uint32_t engineGroupIndex = 0;
for (auto handle : handles) {
@@ -103,7 +117,7 @@ TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenValidHandleGetPropertiesThenCorr
}
}
TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenValidHandleGetAvtivityThenCorrectValuesAreReturned) {
TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetAvtivityThenCorrectValuesAreReturned) {
auto handles = get_engine_handles(engineHandleComponentCount);
uint32_t engineGroupIndex = 0;
for (auto handle : handles) {
@@ -118,5 +132,15 @@ TEST_F(SysmanDeviceEngineFixture, DISABLED_GivenValidHandleGetAvtivityThenCorrec
}
}
TEST_F(SysmanDeviceEngineFixture, GivenValidHandleWhenGettingEngineActivityAndRequestSingleFailsThenFailureIsReturned) {
auto handles = get_engine_handles(engineHandleComponentCount);
for (auto handle : handles) {
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_engine_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesEngineGetActivity(handle, &stats));
}
}
} // namespace ult
} // namespace L0

3
level_zero/tools/test/unit_tests/sources/sysman/events/windows/test_zes_events.cpp
View File

@@ -39,9 +39,6 @@ class SysmanEventsFixture : public SysmanDeviceFixture {
pKmdSysManager->allowSetCalls = allowSetCalls;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager.get(), &Mock<MockKmdSysManager>::mock_escape));
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();

33
level_zero/tools/test/unit_tests/sources/sysman/fan/windows/test_zes_sysman_fan.cpp
View File

@@ -33,9 +33,6 @@ class SysmanDeviceFanFixture : public SysmanDeviceFixture {
pKmdSysManager->allowSetCalls = allowSetCalls;
pKmdSysManager->fanSupported = fanSupported;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager.get(), &Mock<FanKmdSysManager>::mock_escape));
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
@@ -49,8 +46,8 @@ class SysmanDeviceFanFixture : public SysmanDeviceFixture {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
SysmanDeviceFixture::TearDown();
}
std::vector<zes_fan_handle_t> getFanHandles() {
@@ -62,7 +59,7 @@ class SysmanDeviceFanFixture : public SysmanDeviceFixture {
}
};
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingFansThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
init(true, true);
uint32_t count = 0;
@@ -70,7 +67,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingFa
EXPECT_EQ(count, fanHandleComponentCount);
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenInvalidComponentCountWhenEnumeratingFansThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
TEST_F(SysmanDeviceFanFixture, GivenInvalidComponentCountWhenEnumeratingFansThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
init(true, true);
uint32_t count = 0;
@@ -82,7 +79,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenInvalidComponentCountWhenEnumeratin
EXPECT_EQ(count, fanHandleComponentCount);
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingFansThenValidFanHandlesIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenValidFanHandlesIsReturned) {
init(true, true);
uint32_t count = 0;
@@ -96,7 +93,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingFa
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanPropertiesAllowSetToTrueThenCallSucceeds) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowSetToTrueThenCallSucceeds) {
// Setting allow set calls or not
init(true, true);
@@ -118,7 +115,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanPropert
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanPropertiesAllowSetToFalseThenControlToFalse) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowSetToFalseThenControlToFalse) {
// Setting allow set calls or not
init(false, true);
@@ -132,7 +129,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanPropert
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidNoSupportForFanCheckFanHandleCountIsZero) {
TEST_F(SysmanDeviceFanFixture, GivenValidNoSupportForFanCheckFanHandleCountIsZero) {
// Setting allow set calls or not
init(false, false);
@@ -141,7 +138,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidNoSupportForFanCheckFanHandleC
EXPECT_EQ(count, 0u);
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanPropertiesAllowSetToFalseThenCallSucceeds) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowSetToFalseThenCallSucceeds) {
// Setting allow set calls or not
init(true, true);
@@ -163,7 +160,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanPropert
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanConfigThenUnsupportedIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanConfigThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true, true);
@@ -175,7 +172,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanConfigT
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingDefaultModeThenSupportedIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingDefaultModeThenSupportedIsReturned) {
// Setting allow set calls or not
init(true, true);
@@ -186,7 +183,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingDefaultMod
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingFixedSpeedModeThenUnsupportedIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingFixedSpeedModeThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true, true);
@@ -198,7 +195,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingFixedSpeed
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingTheSpeedTableModeWithNumberOfPointsZeroThenUnsupportedIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingTheSpeedTableModeWithNumberOfPointsZeroThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true, true);
@@ -210,7 +207,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingTheSpeedTa
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingTheSpeedTableModeWithGreaterThanMaxNumberOfPointsThenUnsupportedIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingTheSpeedTableModeWithGreaterThanMaxNumberOfPointsThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true, true);
@@ -223,7 +220,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenSettingTheSpeedTa
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanSpeedWithRPMUnitThenValidFanSpeedReadingsRetrieved) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanSpeedWithRPMUnitThenValidFanSpeedReadingsRetrieved) {
// Setting allow set calls or not
init(true, true);
@@ -239,7 +236,7 @@ TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanSpeedWi
}
}
TEST_F(SysmanDeviceFanFixture, DISABLED_GivenValidFanHandleWhenGettingFanSpeedWithPercentUnitThenUnsupportedIsReturned) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanSpeedWithPercentUnitThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true, true);

10
level_zero/tools/test/unit_tests/sources/sysman/firmware_util/test_fw_util_helper.cpp
View File

@@ -52,7 +52,7 @@ static inline int mockEccConfigSetFailure(struct igsc_device_handle *handle, uin
return -1;
}
TEST(LinuxFwStatusExtTest, GivenIFRWasSetWhenFirmwareUtilChecksIFRThenIFRStatusIsUpdated) {
TEST(FwStatusExtTest, GivenIFRWasSetWhenFirmwareUtilChecksIFRThenIFRStatusIsUpdated) {
if (!sysmanUltsEnable) {
GTEST_SKIP();
@@ -74,7 +74,7 @@ TEST(LinuxFwStatusExtTest, GivenIFRWasSetWhenFirmwareUtilChecksIFRThenIFRStatusI
delete pFwUtilImp;
}
TEST(LinuxFwStatusExtTest, GivenStatusCallFailsWhenFirmwareUtilChecksIFRThenStatusCallFails) {
TEST(FwStatusExtTest, GivenStatusCallFailsWhenFirmwareUtilChecksIFRThenStatusCallFails) {
if (!sysmanUltsEnable) {
GTEST_SKIP();
@@ -95,7 +95,7 @@ TEST(LinuxFwStatusExtTest, GivenStatusCallFailsWhenFirmwareUtilChecksIFRThenStat
delete pFwUtilImp;
}
TEST(LinuxFwRunDiagTest, GivenValidSupportedDiagnosticsTestsParamWhenFirmwareUtilSupportedTestsAreRequestedThenSupportedTestsAreRun) {
TEST(FwRunDiagTest, GivenValidSupportedDiagnosticsTestsParamWhenFirmwareUtilSupportedTestsAreRequestedThenSupportedTestsAreRun) {
if (!sysmanUltsEnable) {
GTEST_SKIP();
@@ -136,7 +136,7 @@ TEST(LinuxFwRunDiagTest, GivenValidSupportedDiagnosticsTestsParamWhenFirmwareUti
delete pFwUtilImp;
}
TEST(LinuxFwGetProcAddressTest, GivenValidFwUtilMethodNameWhenFirmwareUtilIsInitalizedThenCorrectMethodsAreLoaded) {
TEST(FwGetProcAddressTest, GivenValidFwUtilMethodNameWhenFirmwareUtilIsInitalizedThenCorrectMethodsAreLoaded) {
struct IFRmockOsLibrary : OsLibrary {
public:
~IFRmockOsLibrary() override = default;
@@ -168,7 +168,7 @@ TEST(LinuxFwGetProcAddressTest, GivenValidFwUtilMethodNameWhenFirmwareUtilIsInit
delete pFwUtilImp;
}
TEST(LinuxFwEccTest, GivenFwEccConfigCallFailsWhenCallingFirmwareUtilSetAndGetEccThenCorrespondingCallFails) {
TEST(FwEccTest, GivenFwEccConfigCallFailsWhenCallingFirmwareUtilSetAndGetEccThenCorrespondingCallFails) {
if (!sysmanUltsEnable) {
GTEST_SKIP();

16
level_zero/tools/test/unit_tests/sources/sysman/frequency/windows/mock_frequency.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -335,6 +335,18 @@ struct Mock<FrequencyKmdSysManager> : public FrequencyKmdSysManager {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
} break;
case KmdSysman::Requests::Frequency::CurrentIccMax: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
mockIccMax = *pValue;
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
} break;
case KmdSysman::Requests::Frequency::CurrentTjMax: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
mockTjMax = *pValue;
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
} break;
default: {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
@@ -343,7 +355,7 @@ struct Mock<FrequencyKmdSysManager> : public FrequencyKmdSysManager {
}
Mock() = default;
~Mock() = default;
~Mock() override = default;
};
} // namespace ult

204
level_zero/tools/test/unit_tests/sources/sysman/frequency/windows/test_zes_frequency.cpp
View File

@@ -22,27 +22,20 @@ constexpr double step = 50.0 / 3;
constexpr uint32_t numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
Mock<FrequencyKmdSysManager> *pKmdSysManager = nullptr;
std::unique_ptr<Mock<FrequencyKmdSysManager>> pKmdSysManager;
KmdSysManager *pOriginalKmdSysManager = nullptr;
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
}
pKmdSysManager.reset(new Mock<FrequencyKmdSysManager>);
void init(bool allowSetCalls) {
pKmdSysManager = new Mock<FrequencyKmdSysManager>;
pKmdSysManager->allowSetCalls = allowSetCalls;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<FrequencyKmdSysManager>::mock_escape));
pKmdSysManager->allowSetCalls = true;
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
@@ -57,19 +50,14 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
deviceHandles.resize(subDeviceCount, nullptr);
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
}
get_frequency_handles(0);
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
if (pKmdSysManager != nullptr) {
delete pKmdSysManager;
pKmdSysManager = nullptr;
}
SysmanDeviceFixture::TearDown();
}
double clockValue(const double calculatedClock) {
@@ -88,17 +76,13 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
}
};
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, frequencyHandleComponentCount);
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenInvalidComponentCountWhenEnumeratingFrequencyDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidComponentCountWhenEnumeratingFrequencyDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, frequencyHandleComponentCount);
@@ -108,9 +92,15 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenInvalidComponentCountWhenEnum
EXPECT_EQ(count, frequencyHandleComponentCount);
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidPowerHandlesIsReturned) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsAndRequestSingleFailsThenZeroHandlesAreCreated) {
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNKNOWN;
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, 0);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidPowerHandlesIsReturned) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, frequencyHandleComponentCount);
@@ -122,9 +112,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenComponentCountZeroWhenEnumera
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
for (auto handle : handles) {
@@ -145,9 +133,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesAllowSetCallsToFalseFrequencyGetPropertiesThenSuccessIsReturned) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesAllowSetCallsToFalseFrequencyGetPropertiesThenSuccessIsReturned) {
pKmdSysManager->allowSetCalls = false;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
for (auto handle : handles) {
@@ -168,9 +155,33 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyPropertiesAndRequestMultipleFailsThenInvalidPropertiesAreReturned) {
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->requestMultipleSizeDiff = false;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
zes_freq_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
EXPECT_EQ(-1.0, properties.min);
EXPECT_EQ(-1.0, properties.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyPropertiesAndRequestMultipleReturnsInvalidSizeThenInvalidpropertiesAreReturned) {
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->requestMultipleSizeDiff = true;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_SUCCESS;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
zes_freq_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
EXPECT_EQ(-1.0, properties.min);
EXPECT_EQ(-1.0, properties.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
@@ -189,9 +200,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAndZeroCo
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
@@ -214,9 +223,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAndCorrec
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
@@ -234,9 +241,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
@@ -262,9 +267,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
@@ -291,9 +294,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyCallSucceeds) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyCallSucceeds) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
uint32_t domainIndex = 0;
@@ -321,8 +322,28 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyGetThrottleTimeThenVerifyCallFails) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyStateAndRequestMultipleFailsThenFailureIsReturned) {
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state = {};
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zesFrequencyGetState(handle, &state));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyStateAndRequestMultipleReturnsInvalidSizeThenFailureIsReturned) {
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->requestMultipleSizeDiff = true;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state = {};
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zesFrequencyGetState(handle, &state));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetThrottleTimeThenVerifyCallFails) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
zes_freq_throttle_time_t throttletime = {};
@@ -330,8 +351,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetCapabilitiesThenVerifyCallSucceeds) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetCapabilitiesThenVerifyCallSucceeds) {
pKmdSysManager->allowSetCalls = false;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -354,8 +375,7 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetThenVerifyCallSucceeds) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetThenVerifyCallSucceeds) {
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -366,8 +386,17 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetThenVerifyCallSucceeds) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetAndRequestSingleFailsThenFailureIsReturned) {
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNKNOWN;
double freqTarget = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zesFrequencyOcGetFrequencyTarget(handle, &freqTarget));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetThenVerifyCallSucceeds) {
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -379,8 +408,19 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetModeThenVerifyCallSucceeds) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetAndRequestMultipleFailsThenFailureIsReturned) {
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->requestMultipleSizeDiff = false;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
double voltageTarget = 0.0, voltageOffset = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zesFrequencyOcGetVoltageTarget(handle, &voltageTarget, &voltageOffset));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetModeThenVerifyCallSucceeds) {
pKmdSysManager->allowSetCalls = false;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -391,8 +431,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleWhenCalli
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallFails) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallFails) {
pKmdSysManager->allowSetCalls = false;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -402,8 +442,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetC
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallFails) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallFails) {
pKmdSysManager->allowSetCalls = false;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -413,8 +453,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetC
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetModeThenVerifyCallFails) {
init(false);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetModeThenVerifyCallFails) {
pKmdSysManager->allowSetCalls = false;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -424,8 +464,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetC
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallSucceed) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallSucceed) {
pKmdSysManager->allowSetCalls = true;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -438,8 +478,8 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetC
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallSucceed) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallSucceed) {
pKmdSysManager->allowSetCalls = true;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
@@ -453,8 +493,32 @@ TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetC
}
}
TEST_F(SysmanDeviceFrequencyFixture, DISABLED_GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetModeThenVerifyCallSucceed) {
init(true);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetIccMaxTargetThenVerifyCallSucceed) {
pKmdSysManager->allowSetCalls = true;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
double setIccMax = 1050.0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetIccMax(handle, setIccMax));
double newSetIccMax = 0.0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetIccMax(handle, &newSetIccMax));
EXPECT_DOUBLE_EQ(setIccMax, newSetIccMax);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetTjMaxTargetThenVerifyCallSucceed) {
pKmdSysManager->allowSetCalls = true;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
double setTjMax = 1050.0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetTjMax(handle, setTjMax));
double newSetTjMax = 0.0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetTjMax(handle, &newSetTjMax));
EXPECT_DOUBLE_EQ(newSetTjMax, setTjMax);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetModeThenVerifyCallSucceed) {
pKmdSysManager->allowSetCalls = true;
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {

4
level_zero/tools/test/unit_tests/sources/sysman/global_operations/windows/mock_global_operations.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -36,7 +36,7 @@ struct Mock<GlobalOpsKmdSysManager> : public GlobalOpsKmdSysManager {
}
}
Mock() = default;
~Mock() = default;
~Mock() override = default;
};
} // namespace ult

31
level_zero/tools/test/unit_tests/sources/sysman/global_operations/windows/test_zes_global_operations.cpp
View File

@@ -20,7 +20,7 @@ class SysmanGlobalOperationsFixture : public SysmanDeviceFixture {
L0::GlobalOperations *pGlobalOperationsPrev = nullptr;
L0::GlobalOperationsImp *pGlobalOperationsImp;
Mock<GlobalOpsKmdSysManager> *pKmdSysManager = nullptr;
std::unique_ptr<Mock<GlobalOpsKmdSysManager>> pKmdSysManager = nullptr;
KmdSysManager *pOriginalKmdSysManager = nullptr;
void SetUp() override {
if (!sysmanUltsEnable) {
@@ -30,15 +30,12 @@ class SysmanGlobalOperationsFixture : public SysmanDeviceFixture {
}
void init(bool allowSetCalls) {
pKmdSysManager = new Mock<GlobalOpsKmdSysManager>;
pKmdSysManager.reset(new Mock<GlobalOpsKmdSysManager>);
pKmdSysManager->allowSetCalls = allowSetCalls;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<GlobalOpsKmdSysManager>::mock_escape));
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
pGlobalOperationsImp = static_cast<L0::GlobalOperationsImp *>(pSysmanDeviceImp->pGlobalOperations);
pOsGlobalOperationsPrev = pGlobalOperationsImp->pOsGlobalOperations;
@@ -54,22 +51,30 @@ class SysmanGlobalOperationsFixture : public SysmanDeviceFixture {
}
pGlobalOperationsImp->pOsGlobalOperations = pOsGlobalOperationsPrev;
pGlobalOperationsImp = nullptr;
SysmanDeviceFixture::TearDown();
pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
if (pKmdSysManager != nullptr) {
delete pKmdSysManager;
pKmdSysManager = nullptr;
}
SysmanDeviceFixture::TearDown();
}
};
TEST_F(SysmanGlobalOperationsFixture, DISABLED_GivenForceTrueAndDeviceInUseWhenCallingResetThenSuccessIsReturned) {
TEST_F(SysmanGlobalOperationsFixture, GivenForceTrueAndDeviceInUseWhenCallingResetThenSuccessIsReturned) {
init(true);
ze_result_t result = zesDeviceReset(device, true);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(SysmanGlobalOperationsFixture, DISABLED_GivenProcessStartsMidResetWhenCallingResetThenSuccessIsReturned) {
TEST_F(SysmanGlobalOperationsFixture, GivenValidDeviceHandleWhenCallingzesDeviceGetStateThenFailureIsReturned) {
init(true);
zes_device_state_t pState = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDeviceGetState(device, &pState));
}
TEST_F(SysmanGlobalOperationsFixture, GivenValidDeviceHandleWhenCallingzesDeviceProcessesGetStateThenFailureIsReturned) {
init(true);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDeviceProcessesGetState(device, &count, nullptr));
}
TEST_F(SysmanGlobalOperationsFixture, GivenProcessStartsMidResetWhenCallingResetThenSuccessIsReturned) {
init(false);
ze_result_t result = zesDeviceReset(device, true);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);

3
level_zero/tools/test/unit_tests/sources/sysman/memory/windows/test_zes_memory.cpp
View File

@@ -35,9 +35,6 @@ class SysmanDeviceMemoryFixture : public SysmanDeviceFixture {
pKmdSysManager = new Mock<MemoryKmdSysManager>;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<MemoryKmdSysManager>::mock_escape));
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager;

32
level_zero/tools/test/unit_tests/sources/sysman/pci/windows/mock_pci.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -34,6 +34,16 @@ struct Mock<PciKmdSysManager> : public PciKmdSysManager {
uint32_t mockCurrentLinkWidth[3] = {1, 0, 1};
uint32_t mockResizableBarSupported[3] = {1, 1, 1};
uint32_t mockResizableBarEnabled[3] = {1, 1, 1};
uint32_t pciBusReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciDomainReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciDeviceReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciFunctionReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciMaxLinkSpeedReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciMaxLinkWidthReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciCurrentLinkSpeedReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciCurrentLinkWidthReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciResizableBarSupportedReturnCode = KmdSysman::KmdSysmanSuccess;
uint32_t pciResizableBarEnabledReturnCode = KmdSysman::KmdSysmanSuccess;
void getPciProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
@@ -45,61 +55,61 @@ struct Mock<PciKmdSysManager> : public PciKmdSysManager {
case KmdSysman::Requests::Pci::Domain: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockDomain[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciDomainReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::Bus: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockBus[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciBusReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::Device: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockDevice[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciDeviceReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::Function: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockFunction[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciFunctionReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::MaxLinkSpeed: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockMaxLinkSpeed[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciMaxLinkSpeedReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::MaxLinkWidth: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockMaxLinkWidth[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciMaxLinkWidthReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::CurrentLinkSpeed: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockCurrentLinkSpeed[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciCurrentLinkSpeedReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::CurrentLinkWidth: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockCurrentLinkWidth[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciCurrentLinkWidthReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::ResizableBarSupported: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockResizableBarSupported[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciResizableBarSupportedReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Pci::ResizableBarEnabled: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockResizableBarEnabled[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outReturnCode = pciResizableBarEnabledReturnCode;
pResponse->outDataSize = sizeof(uint32_t);
} break;
default: {

129
level_zero/tools/test/unit_tests/sources/sysman/pci/windows/test_zes_pci.cpp
View File

@@ -17,7 +17,7 @@ namespace ult {
class SysmanDevicePciFixture : public SysmanDeviceFixture {
protected:
Mock<PciKmdSysManager> *pKmdSysManager = nullptr;
std::unique_ptr<Mock<PciKmdSysManager>> pKmdSysManager = nullptr;
KmdSysManager *pOriginalKmdSysManager = nullptr;
void SetUp() override {
if (!sysmanUltsEnable) {
@@ -33,13 +33,10 @@ class SysmanDevicePciFixture : public SysmanDeviceFixture {
device->getDriverHandle()->setMemoryManager(pMemoryManager);
pKmdSysManager = new Mock<PciKmdSysManager>;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<PciKmdSysManager>::mock_escape));
pKmdSysManager.reset(new Mock<PciKmdSysManager>);
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
delete pSysmanDeviceImp->pPci;
@@ -55,12 +52,8 @@ class SysmanDevicePciFixture : public SysmanDeviceFixture {
GTEST_SKIP();
}
device->getDriverHandle()->setMemoryManager(pMemoryManagerOld);
SysmanDeviceFixture::TearDown();
pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
if (pKmdSysManager != nullptr) {
delete pKmdSysManager;
pKmdSysManager = nullptr;
}
SysmanDeviceFixture::TearDown();
if (pMemoryManager != nullptr) {
delete pMemoryManager;
pMemoryManager = nullptr;
@@ -83,7 +76,7 @@ class SysmanDevicePciFixture : public SysmanDeviceFixture {
MemoryManager *pMemoryManagerOld;
};
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropertiesWithLocalMemoryThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropertiesWithLocalMemoryThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
setLocalMemorySupportedAndReinit(true);
zes_pci_properties_t properties;
@@ -99,28 +92,67 @@ TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysm
EXPECT_EQ(properties.maxSpeed.width, pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropertiesWithNoLocalMemoryThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
setLocalMemorySupportedAndReinit(false);
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallinggetPciBdfAndkmdSysmanCallFailsThenUnknownValuesArereturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->pciBusReturnCode = KmdSysman::KmdSysmanFail;
pKmdSysManager->pciDomainReturnCode = KmdSysman::KmdSysmanFail;
pKmdSysManager->pciDeviceReturnCode = KmdSysman::KmdSysmanFail;
pKmdSysManager->pciFunctionReturnCode = KmdSysman::KmdSysmanFail;
zes_pci_properties_t properties = {};
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPciImp->getPciBdf(properties));
EXPECT_EQ(0, properties.address.domain);
EXPECT_EQ(0, properties.address.bus);
EXPECT_EQ(0, properties.address.device);
EXPECT_EQ(0, properties.address.function);
delete pPciImp;
}
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetProLocalMemoryThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
setLocalMemorySupportedAndReinit(true);
zes_pci_properties_t properties;
ze_result_t result = zesDevicePciGetProperties(device, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(properties.address.domain, pKmdSysManager->mockDomain[KmdSysman::PciDomainsType::PciCurrentDevice]);
EXPECT_EQ(properties.address.bus, pKmdSysManager->mockBus[KmdSysman::PciDomainsType::PciCurrentDevice]);
EXPECT_EQ(properties.address.device, pKmdSysManager->mockDevice[KmdSysman::PciDomainsType::PciCurrentDevice]);
EXPECT_EQ(properties.address.function, pKmdSysManager->mockFunction[KmdSysman::PciDomainsType::PciCurrentDevice]);
EXPECT_EQ(properties.maxSpeed.gen, pKmdSysManager->mockMaxLinkSpeed[KmdSysman::PciDomainsType::PciCurrentDevice]);
EXPECT_EQ(properties.maxSpeed.width, pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciCurrentDevice]);
EXPECT_EQ(properties.address.domain, pKmdSysManager->mockDomain[KmdSysman::PciDomainsType::PciRootPort]);
EXPECT_EQ(properties.address.bus, pKmdSysManager->mockBus[KmdSysman::PciDomainsType::PciRootPort]);
EXPECT_EQ(properties.address.device, pKmdSysManager->mockDevice[KmdSysman::PciDomainsType::PciRootPort]);
EXPECT_EQ(properties.address.function, pKmdSysManager->mockFunction[KmdSysman::PciDomainsType::PciRootPort]);
EXPECT_EQ(properties.maxSpeed.gen, pKmdSysManager->mockMaxLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
EXPECT_EQ(properties.maxSpeed.width, pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceeds) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingGetPciBdfAndRequestMultpileFailsThenFailureIsReturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_pci_properties_t properties = {};
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPciImp->getPciBdf(properties));
delete pPciImp;
}
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenGettingMaxLinkSpeedAndMaxLinkWidthAndRequestSingleFailsThenUnknownValuesAreReturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double maxLinkSpeed;
int32_t maxLinkWidth;
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
pPciImp->getMaxLinkCaps(maxLinkSpeed, maxLinkWidth);
EXPECT_DOUBLE_EQ(0.0, maxLinkSpeed);
EXPECT_EQ(-1, maxLinkWidth);
delete pPciImp;
}
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDevicePciGetBars(device, &count, nullptr));
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceedsWith1_2Extension) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceedsWith1_2Extension) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDevicePciGetBars(device, &count, nullptr));
EXPECT_NE(count, 0u);
@@ -144,7 +176,7 @@ TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysm
}
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingPciGetBarsThenVerifyAPICallSucceedsWith1_2ExtensionWithNullPtr) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingPciGetBarsThenVerifyAPICallSucceedsWith1_2ExtensionWithNullPtr) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDevicePciGetBars(device, &count, nullptr));
EXPECT_NE(count, 0u);
@@ -162,7 +194,7 @@ TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingPciGetB
pBarProps = nullptr;
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceedsWith1_2ExtensionWrongType) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceedsWith1_2ExtensionWrongType) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDevicePciGetBars(device, &count, nullptr));
EXPECT_NE(count, 0u);
@@ -185,7 +217,7 @@ TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysm
}
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetStatsWithLocalMemoryThenVerifyzetSysmanPciGetBarsCallSucceeds) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStatsWithLocalMemoryThenVerifyzetSysmanPciGetBarsCallSucceeds) {
setLocalMemorySupportedAndReinit(true);
zes_pci_state_t state;
@@ -195,7 +227,7 @@ TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysm
EXPECT_EQ(state.speed.width, pKmdSysManager->mockCurrentLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
}
TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysmanPciGetStatsWithNoLocalMemoryThenVerifyzetSysmanPciGetBarsCallSucceeds) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStatsWithNoLocalMemoryThenVerifyzetSysmanPciGetBarsCallSucceeds) {
setLocalMemorySupportedAndReinit(false);
zes_pci_state_t state;
@@ -205,7 +237,31 @@ TEST_F(SysmanDevicePciFixture, DISABLED_GivenValidSysmanHandleWhenCallingzetSysm
EXPECT_EQ(state.speed.width, pKmdSysManager->mockCurrentLinkWidth[KmdSysman::PciDomainsType::PciCurrentDevice]);
}
TEST_F(SysmanDevicePciFixture, DISABLED_WhenConvertingLinkSpeedThenResultIsCorrect) {
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingGetPciStateAndRequestMultipleFailsThenFailureIsReturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->mockRequestMultiple = true;
pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_pci_state_t pState = {};
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPciImp->getState(&pState));
delete pPciImp;
}
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingGetPciStateAndKmdSysmanCallFailsThenUnknownValuesAreReturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->pciCurrentLinkSpeedReturnCode = KmdSysman::KmdSysmanFail;
pKmdSysManager->pciCurrentLinkWidthReturnCode = KmdSysman::KmdSysmanFail;
zes_pci_state_t pState = {};
pState.speed.gen = -1;
pState.speed.width = -1;
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPciImp->getState(&pState));
EXPECT_EQ(pState.speed.gen, -1);
EXPECT_EQ(pState.speed.gen, -1);
delete pPciImp;
}
TEST_F(SysmanDevicePciFixture, WhenConvertingLinkSpeedThenResultIsCorrect) {
for (int32_t i = PciGenerations::PciGen1; i <= PciGenerations::PciGen5; i++) {
double speed = convertPciGenToLinkSpeed(i);
int32_t gen = convertLinkSpeedToPciGen(speed);
@@ -216,5 +272,24 @@ TEST_F(SysmanDevicePciFixture, DISABLED_WhenConvertingLinkSpeedThenResultIsCorre
EXPECT_EQ(0.0, convertPciGenToLinkSpeed(0));
}
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenGettingResizableBarSupportAndRequestSingleFailsThenUnknownValuesAreReturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
EXPECT_EQ(false, pPciImp->resizableBarSupported());
delete pPciImp;
}
TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenGettingResizableBarEnabledAndRequestSingleFailsThenUnknownValuesAreReturned) {
setLocalMemorySupportedAndReinit(true);
pKmdSysManager->mockRequestSingle = true;
pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint32_t barIndex = 1;
WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
EXPECT_EQ(false, pPciImp->resizableBarEnabled(barIndex));
delete pPciImp;
}
} // namespace ult
} // namespace L0

3
level_zero/tools/test/unit_tests/sources/sysman/power/windows/test_zes_sysman_power.cpp
View File

@@ -32,9 +32,6 @@ class SysmanDevicePowerFixture : public SysmanDeviceFixture {
pKmdSysManager->allowSetCalls = allowSetCalls;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager.get(), &Mock<PowerKmdSysManager>::mock_escape));
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();

3
level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp
View File

@@ -29,9 +29,6 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
pKmdSysManager = new Mock<TemperatureKmdSysManager>;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<TemperatureKmdSysManager>::mock_escape));
pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
pWddmSysmanImp->pKmdSysManager = pKmdSysManager;

37
level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -35,11 +35,15 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
ze_bool_t allowSetCalls = false;
ze_bool_t fanSupported = false;
uint32_t mockPowerLimit1 = 2500;
bool mockEscapeResult = true;
bool mockRequestSingle = false;
bool mockRequestMultiple = false;
bool requestMultipleSizeDiff = false;
ze_result_t mockRequestSingleResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
ze_result_t mockRequestMultipleResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
MockEventHandle handles[KmdSysman::Events::MaxEvents][mockKmdMaxHandlesPerEvent];
MOCK_METHOD(bool, escape, (uint32_t escapeOp, uint64_t pDataIn, uint32_t dataInSize, uint64_t pDataOut, uint32_t dataOutSize));
MOCKABLE_VIRTUAL void getInterfaceProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
@@ -293,6 +297,26 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
}
}
ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out) {
if (mockRequestSingle == false) {
return KmdSysManager::requestSingle(In, Out);
}
return mockRequestSingleResult;
}
ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut) {
if (mockRequestMultiple == false) {
return KmdSysManager::requestMultiple(vIn, vOut);
} else {
if (requestMultipleSizeDiff == true) {
KmdSysman::ResponseProperty temp;
vOut.push_back(temp);
}
return mockRequestMultipleResult;
}
return ZE_RESULT_SUCCESS;
}
void setProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
if (!allowSetCalls) {
pResponse->outDataSize = 0;
@@ -383,7 +407,10 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
}
}
bool mock_escape(uint32_t escapeOp, uint64_t pInPtr, uint32_t dataInSize, uint64_t pOutPtr, uint32_t dataOutSize) {
bool escape(uint32_t escapeOp, uint64_t pInPtr, uint32_t dataInSize, uint64_t pOutPtr, uint32_t dataOutSize) {
if (mockEscapeResult == false) {
return mockEscapeResult;
}
void *pDataIn = reinterpret_cast<void *>(pInPtr);
void *pDataOut = reinterpret_cast<void *>(pOutPtr);
@@ -473,7 +500,7 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
}
Mock() = default;
~Mock() = default;
~Mock() override = default;
};
} // namespace ult

3
level_zero/tools/test/unit_tests/sources/sysman/windows/test_sysman_manager.cpp
View File

@@ -42,9 +42,6 @@ class SysmanKmdManagerFixture : public ::testing::Test {
GTEST_SKIP();
}
pKmdSysManager = new Mock<MockKmdSysManager>;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<MockKmdSysManager>::mock_escape));
}
void TearDown() override {
if (!sysmanUltsEnable) {