intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-30 09:58:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

L0 Sysman Windows DG2 Readyness Patch.

Browse Source 
Implemented Fan Curve, Moved to OAG Counters, Fixed Frequency Range.
This commit is contained in:
Daniel Enriquez
2021-01-29 02:50:48 -08:00
committed by Compute-Runtime-Automation
parent cfe23873cf
commit 3aff89199d
13 changed files with 129 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp
View File

@@ -12,7 +12,6 @@ namespace L0 {
ze_result_t WddmEngineImp::getActivity(zes_engine_stats_t *pStats) {
uint64_t activeTime = 0;
uint64_t timeStamp = 0;
uint32_t timestampFrequency = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -45,24 +44,8 @@ ze_result_t WddmEngineImp::getActivity(zes_engine_stats_t *pStats) {
memcpy_s(&activeTime, sizeof(uint64_t), response.dataBuffer, sizeof(uint64_t));
memcpy_s(&timeStamp, sizeof(uint64_t), (response.dataBuffer + sizeof(uint64_t)), sizeof(uint64_t));
request.requestId = KmdSysman::Requests::Activity::TimestampFrequency;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&timestampFrequency, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
double timeFactor = 1.0 / static_cast<double>(timestampFrequency);
double elapsedTime = static_cast<double>(activeTime) * timeFactor;
elapsedTime *= static_cast<double>(microFacor);
pStats->activeTime = static_cast<uint64_t>(elapsedTime);
elapsedTime = static_cast<double>(timeStamp) * timeFactor;
elapsedTime *= static_cast<double>(microFacor);
pStats->timestamp = static_cast<uint64_t>(elapsedTime);
pStats->activeTime = activeTime;
pStats->timestamp = timeStamp;
return status;
}

81
level_zero/tools/source/sysman/fan/windows/os_fan_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,10 +9,15 @@
namespace L0 {
void GetOsTimestamp(uint64_t &timestamp) {
std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
}
struct FanPoint {
union {
struct {
int32_t temperatureDegreesCelsius : 16;
int32_t fanSpeedPercent : 16;
};
int32_t data;
};
};
ze_result_t WddmFanImp::getProperties(zes_fan_properties_t *pProperties) {
pProperties->onSubdevice = false;
@@ -45,10 +50,10 @@ ze_result_t WddmFanImp::getProperties(zes_fan_properties_t *pProperties) {
}
memcpy_s(&FanPoints, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->maxPoints = static_cast<int32_t>(FanPoints);
pProperties->maxPoints = maxPoints = static_cast<int32_t>(FanPoints);
pProperties->maxRPM = -1;
pProperties->supportedModes = 1;
pProperties->supportedUnits = 1;
pProperties->supportedModes = zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE;
pProperties->supportedUnits = zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT;
return ZE_RESULT_SUCCESS;
}
@@ -65,7 +70,48 @@ ze_result_t WddmFanImp::setFixedSpeedMode(const zes_fan_speed_t *pSpeed) {
}
ze_result_t WddmFanImp::setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
if (pSpeedTable->numPoints == 0 || pSpeedTable->numPoints >= maxPoints) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
for (int32_t i = 0; i < pSpeedTable->numPoints; i++) {
if (pSpeedTable->table[i].speed.units == zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_RPM) {
return ze_result_t::ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
}
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
uint32_t value = pSpeedTable->numPoints;
request.commandId = KmdSysman::Command::Set;
request.componentId = KmdSysman::Component::FanComponent;
request.requestId = KmdSysman::Requests::Fans::CurrentNumOfControlPoints;
request.dataSize = sizeof(uint32_t);
memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
request.requestId = KmdSysman::Requests::Fans::CurrentFanPoint;
for (int32_t i = 0; i < pSpeedTable->numPoints; i++) {
FanPoint point;
point.fanSpeedPercent = pSpeedTable->table[i].speed.speed;
point.temperatureDegreesCelsius = pSpeedTable->table[i].temperature;
value = point.data;
memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
@@ -73,8 +119,6 @@ ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t status = ZE_RESULT_SUCCESS;
uint64_t currentTS = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -82,7 +126,7 @@ ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
request.componentId = KmdSysman::Component::FanComponent;
request.requestId = KmdSysman::Requests::Fans::CurrentFanSpeed;
status = pKmdSysManager->requestSingle(request, response);
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
@@ -91,18 +135,7 @@ ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
uint32_t value = 0;
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
GetOsTimestamp(currentTS);
uint64_t diffTime = currentTS - prevTS;
uint32_t diffPulses = value - prevPulses;
double pulsesPerTime = static_cast<double>(diffPulses) / static_cast<double>(diffTime);
pulsesPerTime *= 1000000.0;
pulsesPerTime *= 60.0;
prevTS = currentTS;
prevPulses = value;
*pSpeed = static_cast<int32_t>(pulsesPerTime);
*pSpeed = static_cast<int32_t>(value);
return status;
}

3
level_zero/tools/source/sysman/fan/windows/os_fan_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -34,6 +34,7 @@ class WddmFanImp : public OsFan, NEO::NonCopyableOrMovableClass {
private:
uint64_t prevTS = 0;
uint32_t prevPulses = 0;
int32_t maxPoints = 0;
};
} // namespace L0

18
level_zero/tools/source/sysman/frequency/frequency_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -41,16 +41,12 @@ ze_result_t FrequencyImp::frequencyGetRange(zes_freq_range_t *pLimits) {
ze_result_t FrequencyImp::frequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
bool newMinValid = false, newMaxValid = false;
for (unsigned int i = 0; i < numClocks; i++) {
if (newMin == pClocks[i]) {
newMinValid = true;
}
if (newMax == pClocks[i]) {
newMaxValid = true;
}
}
if (newMin > newMax || !newMinValid || !newMaxValid) {
// No need to check if the frequency is inside the clocks array:
// 1. GuC will cap this, GuC has an internal range. Hw too rounds to the next step, no need to do that check.
// 2. For Overclocking, Oc frequency will be higher than the zesFrequencyProperties.max frequency, so it would be outside
// the clocks array too. Pcode at the end will decide the granted frequency, no need for the check.
if (newMin > newMax) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -48,10 +48,19 @@ ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &pr
properties.max = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CanControlFrequency;
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
properties.canControl = false;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
properties.canControl = (value == 1);
}
properties.onSubdevice = false;
properties.subdeviceId = 0;
properties.type = frequencyDomainNumber;
properties.canControl = canControl();
return ZE_RESULT_SUCCESS;
}
@@ -142,15 +151,6 @@ ze_result_t WddmFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool WddmFrequencyImp::canControl() {
double minF = 0.0, maxF = 0.0;
if (getRange(&minF, &maxF) != ZE_RESULT_SUCCESS) {
return false;
}
return (setRange(minF, maxF) == ZE_RESULT_SUCCESS);
}
ze_result_t WddmFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
*pOcCapabilities = ocCapabilities;
return ZE_RESULT_SUCCESS;
@@ -264,39 +264,19 @@ ze_result_t WddmFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
currentVoltageMode = value ? ZES_OC_MODE_OVERRIDE : ZES_OC_MODE_INTERPOLATIVE;
if (currentFixedMode == ZES_OC_MODE_FIXED) {
currentOcMode = ZES_OC_MODE_FIXED;
} else {
currentOcMode = currentVoltageMode;
}
*pCurrentOcMode = currentOcMode;
*pCurrentOcMode = static_cast<zes_oc_mode_t>(currentVoltageMode + currentFixedMode);
return status;
}
ze_result_t WddmFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
if (currentOcMode == ZES_OC_MODE_OFF) {
this->currentFrequencyTarget = ocCapabilities.maxFactoryDefaultFrequency;
this->currentVoltageTarget = ocCapabilities.maxFactoryDefaultVoltage;
this->currentVoltageOffset = 0;
this->currentFixedMode = ZES_OC_MODE_OFF;
this->currentVoltageMode = ZES_OC_MODE_INTERPOLATIVE;
this->currentOcMode = ZES_OC_MODE_OFF;
return applyOcSettings();
}
if (currentOcMode == ZES_OC_MODE_FIXED) {
this->currentOcMode = ZES_OC_MODE_FIXED;
this->currentFixedMode = ZES_OC_MODE_FIXED;
this->currentVoltageMode = ZES_OC_MODE_OVERRIDE;
if (currentOcMode == ZES_OC_MODE_OFF || currentOcMode == ZES_OC_MODE_FIXED) {
this->currentFixedMode = currentOcMode;
return applyOcSettings();
}
if (currentOcMode == ZES_OC_MODE_INTERPOLATIVE || currentOcMode == ZES_OC_MODE_OVERRIDE) {
this->currentVoltageMode = currentOcMode;
this->currentFixedMode = ZES_OC_MODE_OFF;
this->currentOcMode = currentOcMode;
return applyOcSettings();
}
@@ -618,12 +598,6 @@ void WddmFrequencyImp::readOverclockingInfo() {
currentVoltageTarget = ocCapabilities.maxFactoryDefaultVoltage;
}
}
if (currentFixedMode == ZES_OC_MODE_FIXED) {
currentOcMode = ZES_OC_MODE_FIXED;
} else {
currentOcMode = currentVoltageMode;
}
}
WddmFrequencyImp::WddmFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {

4
level_zero/tools/source/sysman/frequency/windows/os_frequency_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -60,12 +60,10 @@ class WddmFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
ze_result_t setRange(double min, double max);
ze_result_t getRange(double *min, double *max);
void readOverclockingInfo();
bool canControl();
ze_result_t applyOcSettings();
double minRangeFreq = -1.0;
double maxRangeFreq = -1.0;
zes_oc_capabilities_t ocCapabilities = {};
zes_oc_mode_t currentOcMode = ZES_OC_MODE_OFF;
zes_oc_mode_t currentFixedMode = ZES_OC_MODE_OFF;
zes_oc_mode_t currentVoltageMode = ZES_OC_MODE_OFF;
double currentFrequencyTarget = -1.0;

3
level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -123,6 +123,7 @@ bool WddmTemperatureImp::isTempModuleSupported() {
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
request.paramInfo = static_cast<uint32_t>(type);
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::TemperatureComponent;
request.requestId = KmdSysman::Requests::Temperature::CurrentTemperature;

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

@@ -22,6 +22,7 @@ struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
uint64_t mockActivityTimeStamps[3] = {4465421, 2566851, 1226621};
uint32_t mockNumSupportedEngineGroups = 3;
uint32_t mockFrequencyTimeStamp = 38400000;
uint32_t mockFrequencyActivity = 1200000;
void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
@@ -56,6 +57,12 @@ struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Activity::ActivityCounterFrequency: {
uint32_t *pValueFrequency = reinterpret_cast<uint32_t *>(pBuffer);
*pValueFrequency = mockFrequencyActivity;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;
default: {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;

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

@@ -104,8 +104,8 @@ TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetAvtivityThenCorrectValuesAr
ze_result_t result = zesEngineGetActivity(handle, &stats);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(stats.activeTime, convertTStoMicroSec(pKmdSysManager->mockActivityCounters[engineGroupIndex], pKmdSysManager->mockFrequencyTimeStamp));
EXPECT_EQ(stats.timestamp, convertTStoMicroSec(pKmdSysManager->mockActivityTimeStamps[engineGroupIndex], pKmdSysManager->mockFrequencyTimeStamp));
EXPECT_EQ(stats.activeTime, pKmdSysManager->mockActivityCounters[engineGroupIndex]);
EXPECT_EQ(stats.timestamp, pKmdSysManager->mockActivityTimeStamps[engineGroupIndex]);
engineGroupIndex++;
}
}

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -101,8 +101,8 @@ TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllo
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(properties.maxPoints, pKmdSysManager->mockFanMaxPoints);
EXPECT_EQ(properties.maxRPM, -1);
EXPECT_EQ(properties.supportedModes, 1);
EXPECT_EQ(properties.supportedUnits, 1);
EXPECT_EQ(properties.supportedModes, zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE);
EXPECT_EQ(properties.supportedUnits, zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT);
}
}
@@ -123,8 +123,8 @@ TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllo
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(properties.maxPoints, pKmdSysManager->mockFanMaxPoints);
EXPECT_EQ(properties.maxRPM, -1);
EXPECT_EQ(properties.supportedModes, 1);
EXPECT_EQ(properties.supportedUnits, 1);
EXPECT_EQ(properties.supportedModes, zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE);
EXPECT_EQ(properties.supportedUnits, zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT);
}
}
@@ -171,7 +171,7 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingTheSpeedTableModeTh
for (auto handle : handles) {
zes_fan_speed_table_t fanSpeedTable = {0};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFanSetSpeedTableMode(handle, &fanSpeedTable));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zesFanSetSpeedTableMode(handle, &fanSpeedTable));
}
}

32
level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -268,36 +268,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest1ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits;
// Verify that Max must be within range.
limits.min = minFreq;
limits.max = clockValue(maxFreq + step);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest2ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits;
// Verify that Min must be within range.
limits.min = clockValue(minFreq - step);
limits.max = maxFreq;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest3ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits;
// Verify that values must be multiples of step.
limits.min = clockValue(minFreq + (step * 0.5));
limits.max = maxFreq;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest4ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits;

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -80,6 +80,12 @@ struct Mock<FrequencyKmdSysManager> : public FrequencyKmdSysManager {
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Frequency::CanControlFrequency: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = allowSetCalls ? mockGPUCanControl[domain] : mockGPUCannotControl[domain];
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Frequency::FixedModeSupported: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockFixedMode[domain];

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -448,29 +448,33 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTru
uint32_t domainIndex = 0;
auto handles = get_frequency_handles(frequencyHandleComponentCount);
for (auto handle : handles) {
zes_oc_mode_t mode = ZES_OC_MODE_OVERRIDE;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
zes_oc_mode_t newmode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(mode, newmode);
mode = ZES_OC_MODE_INTERPOLATIVE;
zes_oc_mode_t mode = ZES_OC_MODE_INTERPOLATIVE;
zes_oc_mode_t newmode;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
newmode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(mode, newmode);
mode = ZES_OC_MODE_FIXED;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
newmode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(mode, newmode);
EXPECT_EQ(mode, ZES_OC_MODE_INTERPOLATIVE);
mode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
newmode = ZES_OC_MODE_OVERRIDE;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(ZES_OC_MODE_INTERPOLATIVE, newmode);
EXPECT_EQ(mode, ZES_OC_MODE_OFF);
mode = ZES_OC_MODE_FIXED;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(mode, ZES_OC_MODE_FIXED);
mode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(mode, ZES_OC_MODE_OFF);
mode = ZES_OC_MODE_OVERRIDE;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
EXPECT_EQ(mode, ZES_OC_MODE_OVERRIDE);
domainIndex++;
}
}