Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feature: check peak power support using escape call 

Related-To: NEO-12836

Signed-off-by: shubham kumar <shubham.kumar@intel.com>
This commit is contained in:
shubham kumar 2024-10-10 10:35:14 +00:00 committed by Compute-Runtime-Automation
parent ce9f03c548
commit 5ed81a1b9e
5 changed files with 45 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
level_zero/sysman/source/api/power/windows/sysman_os_power_imp.cpp
View File

@ -325,7 +325,7 @@ ze_result_t WddmPowerImp::setEnergyThreshold(double threshold) {
bool WddmPowerImp::isPowerModuleSupported() {
powerLimitCount = 0;
std::vector<KmdSysman::RequestProperty> vRequests(4);
std::vector<KmdSysman::RequestProperty> vRequests(3);
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
@ -338,10 +338,8 @@ bool WddmPowerImp::isPowerModuleSupported() {
request.requestId = KmdSysman::Requests::Power::PowerLimit2Enabled;
vRequests[1] = request;
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit4Ac;
request.requestId = KmdSysman::Requests::Power::PowerLimit4Enabled;
vRequests[2] = request;
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit4Dc;
vRequests[3] = request;
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
@ -349,8 +347,9 @@ bool WddmPowerImp::isPowerModuleSupported() {
return status;
}
for (uint32_t i = 0; i < vResponses.size() - 2; i++) {
ze_bool_t enabled = false;
ze_bool_t enabled;
for (uint32_t i = 0; i < vResponses.size() - 1; i++) {
enabled = false;
if (vResponses[i].returnCode == KmdSysman::Success) {
memcpy_s(&enabled, sizeof(ze_bool_t), vResponses[i].dataBuffer, sizeof(ze_bool_t));
}
@ -359,13 +358,13 @@ bool WddmPowerImp::isPowerModuleSupported() {
}
}
// CurrentPowerLimit4Ac is not a bool hence check for it individually
enabled = false;
if (vResponses[2].returnCode == KmdSysman::Success) {
powerLimitCount++;
}
if (vResponses[3].returnCode == KmdSysman::Success) {
powerLimitCount++;
memcpy_s(&enabled, sizeof(ze_bool_t), vResponses[2].dataBuffer, sizeof(ze_bool_t));
if (enabled) {
// PowerLimit4Enabled controls AC and DC peak limit, hence increment the count by 2.
powerLimitCount += 2;
}
}
if (powerLimitCount > 0) {
@ -386,7 +385,7 @@ ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
*pCount = std::min(*pCount, powerLimitCount);
std::vector<KmdSysman::RequestProperty> vRequests(7);
std::vector<KmdSysman::RequestProperty> vRequests(8);
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
@ -408,12 +407,15 @@ ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit2;
vRequests[4] = request;
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit4Ac;
request.requestId = KmdSysman::Requests::Power::PowerLimit4Enabled;
vRequests[5] = request;
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit4Dc;
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit4Ac;
vRequests[6] = request;
request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit4Dc;
vRequests[7] = request;
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
@ -474,11 +476,16 @@ ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
}
}
// Peak AC
if (count < *pCount) {
if (vResponses[5].returnCode == KmdSysman::Success) {
enabled = false;
if (vResponses[5].returnCode == KmdSysman::Success) {
memcpy_s(&enabled, sizeof(ze_bool_t), vResponses[5].dataBuffer, sizeof(ze_bool_t));
}
if (count < *pCount && enabled) {
if (vResponses[6].returnCode == KmdSysman::Success) {
uint32_t powerAC = 0;
memset(&pSustained[count], 0, sizeof(zes_power_limit_ext_desc_t));
memcpy_s(&powerAC, sizeof(uint32_t), vResponses[5].dataBuffer, sizeof(uint32_t));
memcpy_s(&powerAC, sizeof(uint32_t), vResponses[6].dataBuffer, sizeof(uint32_t));
pSustained[count].enabled = true;
pSustained[count].limit = powerAC;
pSustained[count].enabledStateLocked = true;
@ -492,11 +499,11 @@ ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
}
}
// Peak DC
if (count < *pCount) {
if (vResponses[6].returnCode == KmdSysman::Success) {
if (count < *pCount && enabled) {
if (vResponses[7].returnCode == KmdSysman::Success) {
uint32_t powerDC = 0;
memset(&pSustained[count], 0, sizeof(zes_power_limit_ext_desc_t));
memcpy_s(&powerDC, sizeof(uint32_t), vResponses[6].dataBuffer, sizeof(uint32_t));
memcpy_s(&powerDC, sizeof(uint32_t), vResponses[7].dataBuffer, sizeof(uint32_t));
pSustained[count].enabled = true;
pSustained[count].limit = powerDC;
pSustained[count].enabledStateLocked = true;

2
level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp
View File

@ -564,7 +564,7 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryBandWidth(zes_mem_bandwi
// PMT reports maxBandwidth in units of 100 MBps (decimal). Need to convert it into Bytes/sec, unit to be returned by sysman.
pBandwidth->maxBandwidth = static_cast<uint64_t>(maxBandwidth) * megaBytesToBytes * 100;
// timestamp calcuation
// timestamp calculation
uint32_t timeStampL = 0;
uint32_t timeStampH = 0;

2
level_zero/sysman/source/shared/windows/sysman_kmd_sys.h
View File

@ -131,6 +131,8 @@ enum Power {
DisableEnergyThreshold,
CurrentEnergyCounter,
CurrentEnergyCounter64Bit,
PowerSupportedSubDevices,
PowerLimit4Enabled,
MaxPowerRequests,
};

7
level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h
View File

@ -19,6 +19,7 @@ struct PowerKmdSysManager : public MockKmdSysManager {
uint32_t mockPowerDomainCount = 2;
uint32_t mockPowerLimit1Enabled = 1;
uint32_t mockPowerLimit2Enabled = 1;
uint32_t mockPowerLimit4Enabled = 1;
int32_t mockPowerLimit1 = 25000;
int32_t mockPowerLimit2 = 41000;
int32_t mockTauPowerLimit1 = 20800;
@ -162,6 +163,12 @@ struct PowerKmdSysManager : public MockKmdSysManager {
pResponse->outReturnCode = getReturnCode(pRequest->inRequestId);
pResponse->outDataSize = sizeof(uint64_t) + sizeof(uint64_t);
} break;
case KmdSysman::Requests::Power::PowerLimit4Enabled: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockPowerLimit4Enabled;
pResponse->outReturnCode = getReturnCode(pRequest->inRequestId);
pResponse->outDataSize = sizeof(uint32_t);
} break;
default: {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;

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

@ -428,7 +428,7 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandlesWhenCallingSetAndGetPower
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenCallingGetAnsSetPowerLimitsExtThenProperValuesAreReturnedCoveringMutlipleBranches) {
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenCallingGetAndSetPowerLimitsExtThenProperValuesAreReturnedCoveringMutlipleBranches) {
// Setting allow set calls or not
init(true);
auto handles = getPowerHandles(powerHandleComponentCount);
@ -442,7 +442,7 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenCallingGetAnsSetPowerL
std::vector<zes_power_limit_ext_desc_t> allLimits(limitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
std::vector<uint32_t> requestId = {KmdSysman::Requests::Power::PowerLimit1Enabled, KmdSysman::Requests::Power::CurrentPowerLimit1, KmdSysman::Requests::Power::CurrentPowerLimit1Tau, KmdSysman::Requests::Power::PowerLimit2Enabled, KmdSysman::Requests::Power::CurrentPowerLimit2, KmdSysman::Requests::Power::CurrentPowerLimit4Ac, KmdSysman::Requests::Power::CurrentPowerLimit4Dc};
std::vector<uint32_t> requestId = {KmdSysman::Requests::Power::PowerLimit1Enabled, KmdSysman::Requests::Power::CurrentPowerLimit1, KmdSysman::Requests::Power::CurrentPowerLimit1Tau, KmdSysman::Requests::Power::PowerLimit2Enabled, KmdSysman::Requests::Power::CurrentPowerLimit2, KmdSysman::Requests::Power::PowerLimit4Enabled, KmdSysman::Requests::Power::CurrentPowerLimit4Ac, KmdSysman::Requests::Power::CurrentPowerLimit4Dc};
for (auto it = requestId.begin(); it != requestId.end(); it++) {
pKmdSysManager->mockPowerFailure[*it] = 1;
uint32_t count = limitCount;
@ -477,6 +477,11 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenCallingGetAnsSetPowerL
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
pKmdSysManager->mockPowerLimit1Enabled = 1;
pKmdSysManager->mockPowerLimit4Enabled = 0;
count = mockLimitCount;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
pKmdSysManager->mockPowerLimit4Enabled = 1;
allLimits[0].level = ZES_POWER_LEVEL_UNKNOWN;
count = mockLimitCount;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));