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

Sysman for Windows: Multiple fixes and optimizations

Browse Source 
Signed-off-by: Daniel Enriquez <daniel.enriquez.montanez@intel.com>
This commit is contained in:
Daniel Enriquez
2021-11-03 22:31:25 -07:00
committed by Compute-Runtime-Automation
parent 0418c12c77
commit dbe0ba2a0f
16 changed files with 636 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
level_zero/tools/source/sysman/events/windows/os_events_imp.cpp
View File

@@ -82,8 +82,12 @@ ze_result_t WddmEventsImp::eventRegister(zes_event_type_flags_t events) {
registerEvents(ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_EXIT, KmdSysman::Events::EnterD0);
}
if (events & ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED) {
registerEvents(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED, KmdSysman::Events::EnterTDR);
if (events & ZES_EVENT_TYPE_FLAG_DEVICE_DETACH) {
registerEvents(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH, KmdSysman::Events::EnterTDR);
}
if (events & ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH) {
registerEvents(ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH, KmdSysman::Events::ExitTDR);
}
return (eventList.size() == 0) ? ZE_RESULT_ERROR_UNSUPPORTED_FEATURE : ZE_RESULT_SUCCESS;
@@ -93,32 +97,39 @@ bool WddmEventsImp::eventListen(zes_event_type_flags_t &pEvent, uint64_t timeout
HANDLE events[MAXIMUM_WAIT_OBJECTS];
pEvent = 0;
if (eventList.size() == 0) {
return false;
// Note: whatever happens on this function, it should return true. If that's not the case, the upper loop in sysman.cpp will
// cause an infinite loop for the case of "Infinite timeout". This may work on Linux since the implementation is poll based,
// windows uses WaitForMultipleObjects, which is a blocking call.
// no events no listen. Less than MAXIMUM_WAIT_OBJECTS - 2 to left space for the exit handle.
if (eventList.size() == 0 || (eventList.size() >= (MAXIMUM_WAIT_OBJECTS - 2))) {
pEvent = ZES_EVENT_TYPE_FLAG_FORCE_UINT32;
return true;
}
// set every handle from pos 1 onwards...
for (uint32_t i = 0; i < eventList.size(); i++) {
events[i] = eventList[i].windowsHandle;
}
events[eventList.size()] = exitHandle;
// Setting the last handle for the exit handle, then the exit handle is signaled, it breaks from the wait.
uint32_t signaledEvent = WaitForMultipleObjects(static_cast<uint32_t>(eventList.size() + 1), events, FALSE, static_cast<uint32_t>(timeout));
// Was a timeout
if (signaledEvent == WAIT_TIMEOUT) {
return false;
}
// Was the exit event
if (signaledEvent >= eventList.size()) {
ResetEvent(exitHandle);
return false;
// Was a timeout, exit event loop.
if (signaledEvent == WAIT_TIMEOUT) {
return true;
}
// Was the exit event and exit event loop.
if (signaledEvent == eventList.size()) {
pEvent = ZES_EVENT_TYPE_FLAG_FORCE_UINT32;
} else {
pEvent = eventList[signaledEvent].id;
}
// Whatever reason exit the loop, WaitForMultipleObjects exited, exit from the loop must follow.
return true;
}

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

@@ -23,8 +23,9 @@ ze_result_t WddmFanImp::getProperties(zes_fan_properties_t *pProperties) {
pProperties->onSubdevice = false;
pProperties->subdeviceId = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Set;
request.componentId = KmdSysman::Component::FanComponent;
@@ -34,23 +35,27 @@ ze_result_t WddmFanImp::getProperties(zes_fan_properties_t *pProperties) {
uint32_t FanPoints = 2;
memcpy_s(request.dataBuffer, sizeof(uint32_t), &FanPoints, sizeof(uint32_t));
ze_result_t status = pKmdSysManager->requestSingle(request, response);
vRequests.push_back(request);
pProperties->canControl = (status == ZE_RESULT_SUCCESS);
request.dataSize = 0;
memset(request.dataBuffer, request.dataSize, sizeof(request.dataBuffer));
request.commandId = KmdSysman::Command::Get;
request.requestId = KmdSysman::Requests::Fans::MaxFanControlPointsSupported;
status = pKmdSysManager->requestSingle(request, response);
vRequests.push_back(request);
if (status != ZE_RESULT_SUCCESS) {
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&FanPoints, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->canControl = (vResponses[0].returnCode == KmdSysman::Success);
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&FanPoints, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
pProperties->maxPoints = maxPoints = static_cast<int32_t>(FanPoints);
}
pProperties->maxRPM = -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;
@@ -80,38 +85,31 @@ ze_result_t WddmFanImp::setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTab
}
}
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
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;
}
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Fans::CurrentFanPoint;
for (int32_t i = 0; i < pSpeedTable->numPoints; i++) {
FanPoint point;
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;
}
vRequests.push_back(request);
}
return ZE_RESULT_SUCCESS;
return pKmdSysManager->requestMultiple(vRequests, vResponses);
;
}
ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
@@ -141,7 +139,14 @@ ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
}
bool WddmFanImp::isFanModuleSupported() {
return true;
KmdSysman::RequestProperty request = {};
KmdSysman::ResponseProperty response = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::FanComponent;
request.requestId = KmdSysman::Requests::Fans::CurrentFanSpeed;
return (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS);
}
WddmFanImp::WddmFanImp(OsSysman *pOsSysman) {

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

@@ -14,47 +14,59 @@ namespace L0 {
ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
readOverclockingInfo();
uint32_t value = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::FrequencyComponent;
request.requestId = KmdSysman::Requests::Frequency::FrequencyThrottledEventSupported;
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
properties.isThrottleEventSupported = false;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
properties.isThrottleEventSupported = static_cast<ze_bool_t>(value);
}
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::FrequencyRangeMinDefault;
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
properties.min = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
properties.min = static_cast<double>(value);
}
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::FrequencyRangeMaxDefault;
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
properties.max = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
properties.max = static_cast<double>(value);
}
vRequests.push_back(request);
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 (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
if (vResponses[3].returnCode == ZE_RESULT_SUCCESS) {
value = 0;
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
memcpy_s(&value, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
properties.canControl = (value == 1);
}
@@ -79,71 +91,83 @@ ze_result_t WddmFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimit
ze_result_t WddmFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
uint32_t value = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::FrequencyComponent;
request.requestId = KmdSysman::Requests::Frequency::CurrentRequestedFrequency;
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentTdpFrequency;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentResolvedFrequency;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentEfficientFrequency;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltage;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentThrottleReasons;
vRequests.push_back(request);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
pState->request = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
pState->request = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentTdpFrequency;
pState->tdp = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
pState->tdp = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentResolvedFrequency;
pState->actual = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
pState->actual = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentEfficientFrequency;
pState->efficient = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
pState->efficient = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltage;
pState->currentVoltage = unsupportedProperty;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[4].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[4].dataBuffer, sizeof(uint32_t));
pState->currentVoltage = static_cast<double>(value);
pState->currentVoltage /= milliVoltsFactor;
}
request.requestId = KmdSysman::Requests::Frequency::CurrentThrottleReasons;
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
if (vResponses[5].returnCode == KmdSysman::Success) {
KmdThrottleReasons value = {0};
pState->throttleReasons = {0};
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
memcpy_s(&value, sizeof(uint32_t), vResponses[5].dataBuffer, sizeof(uint32_t));
if (value.powerlimit1) {
if (value.power3) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP;
}
if (value.powerlimit2) {
if (value.power4) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP;
}
if (value.powerlimit4) {
if (value.current1) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT;
}
if (value.thermal) {
if (value.thermal1 || value.thermal2 || value.thermal3 || value.thermal4) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT;
}
}
@@ -184,59 +208,51 @@ ze_result_t WddmFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency)
}
ze_result_t WddmFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
if (currentFrequencyTarget != currentOcFrequency) {
currentFrequencyTarget = currentOcFrequency;
this->currentFrequencyTarget = currentOcFrequency;
return applyOcSettings();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
ze_result_t status = ZE_RESULT_SUCCESS;
uint32_t unsignedValue = 0;
int32_t signedValue = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::FrequencyComponent;
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&unsignedValue, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
*pCurrentVoltageTarget = currentVoltageTarget = static_cast<double>(unsignedValue);
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if (status != ZE_RESULT_SUCCESS) {
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&signedValue, sizeof(int32_t), response.dataBuffer, sizeof(int32_t));
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&unsignedValue, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
*pCurrentVoltageTarget = currentVoltageTarget = static_cast<double>(unsignedValue);
}
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&signedValue, sizeof(int32_t), vResponses[1].dataBuffer, sizeof(int32_t));
*pCurrentVoltageOffset = currentVoltageOffset = static_cast<double>(signedValue);
return status;
}
ze_result_t WddmFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
if (this->currentVoltageTarget != currentVoltageTarget || this->currentVoltageOffset != currentVoltageOffset) {
this->currentVoltageTarget = currentVoltageTarget;
this->currentVoltageOffset = currentVoltageOffset;
return applyOcSettings();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
this->currentVoltageTarget = currentVoltageTarget;
this->currentVoltageOffset = currentVoltageOffset;
return applyOcSettings();
}
ze_result_t WddmFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
ze_result_t status = ZE_RESULT_SUCCESS;
@@ -352,7 +368,7 @@ ze_result_t WddmFrequencyImp::setOcTjMax(double ocTjMax) {
request.commandId = KmdSysman::Command::Set;
request.componentId = KmdSysman::Component::FrequencyComponent;
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
request.requestId = KmdSysman::Requests::Frequency::CurrentTjMax;
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
request.dataSize = sizeof(uint32_t);
@@ -407,190 +423,192 @@ ze_result_t WddmFrequencyImp::getRange(double *min, double *max) {
}
ze_result_t WddmFrequencyImp::applyOcSettings() {
ze_result_t status = ZE_RESULT_SUCCESS;
int32_t value = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Set;
request.componentId = KmdSysman::Component::FrequencyComponent;
request.requestId = KmdSysman::Requests::Frequency::CurrentFixedMode;
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
request.dataSize = sizeof(int32_t);
// Fixed mode not supported.
request.requestId = KmdSysman::Requests::Frequency::CurrentFixedMode;
value = 0;
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageMode;
value = (currentVoltageMode == ZES_OC_MODE_OVERRIDE) ? 1 : 0;
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
value = static_cast<int32_t>(currentVoltageOffset);
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
value = static_cast<int32_t>(currentVoltageTarget);
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
value = static_cast<int32_t>(currentFrequencyTarget);
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
vRequests.push_back(request);
if (status != ZE_RESULT_SUCCESS) {
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
for (uint32_t i = 0; i < vResponses.size(); i++) {
if (vResponses[i].returnCode != KmdSysman::ReturnCodes::Success) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
}
value = static_cast<int32_t>(currentFrequencyTarget);
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
return pKmdSysManager->requestSingle(request, response);
return status;
}
void WddmFrequencyImp::readOverclockingInfo() {
uint32_t value = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::FrequencyComponent;
request.requestId = KmdSysman::Requests::Frequency::ExtendedOcSupported;
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
request.requestId = KmdSysman::Requests::Frequency::ExtendedOcSupported;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::FixedModeSupported;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::HighVoltageModeSupported;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::HighVoltageEnabled;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::FrequencyOcSupported;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentTjMax;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::MaxNonOcFrequencyDefault;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::MaxNonOcVoltageDefault;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::MaxOcFrequencyDefault;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::MaxOcVoltageDefault;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageMode;
vRequests.push_back(request);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return;
}
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
ocCapabilities.isExtendedModeSupported = static_cast<ze_bool_t>(value);
}
request.requestId = KmdSysman::Requests::Frequency::FixedModeSupported;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
ocCapabilities.isFixedModeSupported = static_cast<ze_bool_t>(value);
}
request.requestId = KmdSysman::Requests::Frequency::HighVoltageModeSupported;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
ocCapabilities.isHighVoltModeCapable = static_cast<ze_bool_t>(value);
}
request.requestId = KmdSysman::Requests::Frequency::HighVoltageEnabled;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
ocCapabilities.isHighVoltModeEnabled = static_cast<ze_bool_t>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[4].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[4].dataBuffer, sizeof(uint32_t));
ocCapabilities.isIccMaxSupported = static_cast<ze_bool_t>(value > 0);
}
request.requestId = KmdSysman::Requests::Frequency::FrequencyOcSupported;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[5].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[5].dataBuffer, sizeof(uint32_t));
ocCapabilities.isOcSupported = static_cast<ze_bool_t>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentTjMax;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[6].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[6].dataBuffer, sizeof(uint32_t));
ocCapabilities.isTjMaxSupported = static_cast<ze_bool_t>(value > 0);
}
request.requestId = KmdSysman::Requests::Frequency::MaxNonOcFrequencyDefault;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[7].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[7].dataBuffer, sizeof(uint32_t));
ocCapabilities.maxFactoryDefaultFrequency = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::MaxNonOcVoltageDefault;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[8].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[8].dataBuffer, sizeof(uint32_t));
ocCapabilities.maxFactoryDefaultVoltage = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::MaxOcFrequencyDefault;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[9].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[9].dataBuffer, sizeof(uint32_t));
ocCapabilities.maxOcFrequency = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::MaxOcVoltageDefault;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[10].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[10].dataBuffer, sizeof(uint32_t));
ocCapabilities.maxOcVoltage = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[11].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[11].dataBuffer, sizeof(uint32_t));
currentFrequencyTarget = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[12].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[12].dataBuffer, sizeof(uint32_t));
currentVoltageTarget = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[13].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[13].dataBuffer, sizeof(uint32_t));
currentVoltageOffset = static_cast<double>(value);
}
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageMode;
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[14].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[14].dataBuffer, sizeof(uint32_t));
currentVoltageMode = value ? ZES_OC_MODE_OVERRIDE : ZES_OC_MODE_INTERPOLATIVE;
}
if (currentFrequencyTarget == 0.0 || currentVoltageTarget == 0.0) {
if (currentFrequencyTarget == 0.0) {
currentFrequencyTarget = ocCapabilities.maxFactoryDefaultFrequency;
}
if (currentVoltageTarget == 0.0) {
currentVoltageTarget = ocCapabilities.maxFactoryDefaultVoltage;
}
}
}
WddmFrequencyImp::WddmFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {

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

@@ -19,14 +19,21 @@ struct KmdThrottleReasons {
union {
uint32_t bitfield;
struct {
uint32_t reserved1 : KMD_BIT_RANGE(16, 0);
uint32_t thermal : KMD_BIT_RANGE(17, 17);
uint32_t reserved2 : KMD_BIT_RANGE(23, 18);
uint32_t powerlimit4 : KMD_BIT_RANGE(24, 24);
uint32_t reserved3 : KMD_BIT_RANGE(25, 25);
uint32_t powerlimit1 : KMD_BIT_RANGE(26, 26);
uint32_t powerlimit2 : KMD_BIT_RANGE(27, 27);
uint32_t reserved4 : KMD_BIT_RANGE(31, 28);
uint32_t thermal1 : KMD_BIT_RANGE(0, 0);
uint32_t thermal2 : KMD_BIT_RANGE(1, 1);
uint32_t reserved1 : KMD_BIT_RANGE(3, 2);
uint32_t power1 : KMD_BIT_RANGE(4, 4);
uint32_t power2 : KMD_BIT_RANGE(5, 5);
uint32_t thermal3 : KMD_BIT_RANGE(6, 6);
uint32_t thermal4 : KMD_BIT_RANGE(7, 7);
uint32_t current1 : KMD_BIT_RANGE(8, 8);
uint32_t reserved2 : KMD_BIT_RANGE(9, 9);
uint32_t power3 : KMD_BIT_RANGE(10, 10);
uint32_t power4 : KMD_BIT_RANGE(11, 11);
uint32_t inefficient1 : KMD_BIT_RANGE(12, 12);
uint32_t reserved3 : KMD_BIT_RANGE(13, 13);
uint32_t inefficient2 : KMD_BIT_RANGE(14, 14);
uint32_t reserved4 : KMD_BIT_RANGE(31, 15);
};
};
};

123
level_zero/tools/source/sysman/memory/windows/os_memory_imp.cpp
View File

@@ -55,26 +55,42 @@ bool WddmMemoryImp::isMemoryModuleSupported() {
return (value > 0);
}
ze_result_t WddmMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
ze_result_t status = ZE_RESULT_SUCCESS;
uint32_t valueSmall = 0;
uint64_t valueLarge = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
pProperties->onSubdevice = isSubdevice;
pProperties->subdeviceId = subdeviceId;
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::MemoryComponent;
request.requestId = KmdSysman::Requests::Memory::MemoryType;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
request.requestId = KmdSysman::Requests::Memory::PhysicalSize;
vRequests.push_back(request);
if (status != ZE_RESULT_SUCCESS) {
request.requestId = KmdSysman::Requests::Memory::NumChannels;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Memory::MemoryLocation;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Memory::MemoryWidth;
vRequests.push_back(request);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->type = ZES_MEM_TYPE_FORCE_UINT32;
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
switch (valueSmall) {
case KmdSysman::MemoryType::DDR4: {
pProperties->type = ZES_MEM_TYPE_DDR4;
@@ -98,85 +114,80 @@ ze_result_t WddmMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
pProperties->type = ZES_MEM_TYPE_FORCE_UINT32;
} break;
}
request.requestId = KmdSysman::Requests::Memory::PhysicalSize;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueLarge, sizeof(uint64_t), response.dataBuffer, sizeof(uint64_t));
pProperties->physicalSize = 0;
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&valueLarge, sizeof(uint64_t), vResponses[1].dataBuffer, sizeof(uint64_t));
pProperties->physicalSize = valueLarge;
request.requestId = KmdSysman::Requests::Memory::NumChannels;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->numChannels = -1;
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
pProperties->numChannels = valueSmall;
request.requestId = KmdSysman::Requests::Memory::MemoryLocation;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->location = ZES_MEM_LOC_FORCE_UINT32;
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
pProperties->location = static_cast<zes_mem_loc_t>(valueSmall);
request.requestId = KmdSysman::Requests::Memory::MemoryWidth;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->busWidth = -1;
if (vResponses[4].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[4].dataBuffer, sizeof(uint32_t));
pProperties->busWidth = valueSmall;
}
pProperties->subdeviceId = 0;
pProperties->onSubdevice = false;
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) {
ze_result_t status = ZE_RESULT_SUCCESS;
uint32_t valueSmall = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
pBandwidth->writeCounter = 0;
uint64_t valueLarge = 0;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::MemoryComponent;
request.requestId = KmdSysman::Requests::Memory::MaxBandwidth;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pBandwidth->maxBandwidth = valueSmall;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthRead;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthWrite;
vRequests.push_back(request);
if (status != ZE_RESULT_SUCCESS) {
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pBandwidth->readCounter = valueSmall * MbpsToBytesPerSecond;
pBandwidth->maxBandwidth = 0;
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
pBandwidth->maxBandwidth = valueSmall * MbpsToBytesPerSecond;
}
pBandwidth->readCounter = 0;
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&valueLarge, sizeof(uint64_t), vResponses[1].dataBuffer, sizeof(uint64_t));
pBandwidth->readCounter = valueLarge;
}
pBandwidth->writeCounter = 0;
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&valueLarge, sizeof(uint64_t), vResponses[2].dataBuffer, sizeof(uint64_t));
pBandwidth->writeCounter = valueLarge;
}
std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
pBandwidth->timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();

120
level_zero/tools/source/sysman/pci/windows/os_pci_imp.cpp
View File

@@ -19,64 +19,55 @@ ze_result_t WddmPciImp::getProperties(zes_pci_properties_t *properties) {
ze_result_t WddmPciImp::getPciBdf(std::string &bdf) {
uint32_t valueSmall = 0;
uint32_t domain = 0, bus = 0, dev = 0, func = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PciComponent;
request.paramInfo = (isLmemSupported) ? KmdSysman::PciDomainsType::PciRootPort : KmdSysman::PciDomainsType::PciCurrentDevice;
request.requestId = KmdSysman::Requests::Pci::Bus;
if (isLmemSupported) {
request.paramInfo = KmdSysman::PciDomainsType::PciRootPort;
} else {
request.paramInfo = KmdSysman::PciDomainsType::PciCurrentDevice;
}
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
bus = valueSmall;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Pci::Domain;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
domain = valueSmall;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Pci::Device;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
dev = valueSmall;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Pci::Function;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if (status != ZE_RESULT_SUCCESS) {
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
bus = valueSmall;
}
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
domain = valueSmall;
}
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
dev = valueSmall;
}
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
func = valueSmall;
}
bdf = std::to_string(domain) + std::string(":") + std::to_string(bus) + std::string(":") + std::to_string(dev) + std::string(".") + std::to_string(func);
return status;
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmPciImp::getMaxLinkSpeed(double &maxLinkSpeed) {
@@ -87,12 +78,7 @@ ze_result_t WddmPciImp::getMaxLinkSpeed(double &maxLinkSpeed) {
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PciComponent;
request.requestId = KmdSysman::Requests::Pci::MaxLinkSpeed;
if (isLmemSupported) {
request.paramInfo = KmdSysman::PciDomainsType::PciRootPort;
} else {
request.paramInfo = KmdSysman::PciDomainsType::PciCurrentDevice;
}
request.paramInfo = (isLmemSupported) ? KmdSysman::PciDomainsType::PciRootPort : KmdSysman::PciDomainsType::PciCurrentDevice;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
@@ -114,12 +100,7 @@ ze_result_t WddmPciImp::getMaxLinkWidth(int32_t &maxLinkwidth) {
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PciComponent;
request.requestId = KmdSysman::Requests::Pci::MaxLinkWidth;
if (isLmemSupported) {
request.paramInfo = KmdSysman::PciDomainsType::PciRootPort;
} else {
request.paramInfo = KmdSysman::PciDomainsType::PciCurrentDevice;
}
request.paramInfo = (isLmemSupported) ? KmdSysman::PciDomainsType::PciRootPort : KmdSysman::PciDomainsType::PciCurrentDevice;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
@@ -135,8 +116,9 @@ ze_result_t WddmPciImp::getMaxLinkWidth(int32_t &maxLinkwidth) {
ze_result_t WddmPciImp::getState(zes_pci_state_t *state) {
uint32_t valueSmall = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
state->qualityIssues = ZES_PCI_LINK_QUAL_ISSUE_FLAG_FORCE_UINT32;
state->stabilityIssues = ZES_PCI_LINK_STAB_ISSUE_FLAG_FORCE_UINT32;
@@ -144,31 +126,31 @@ ze_result_t WddmPciImp::getState(zes_pci_state_t *state) {
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PciComponent;
request.requestId = KmdSysman::Requests::Pci::CurrentLinkSpeed;
request.paramInfo = (isLmemSupported) ? KmdSysman::PciDomainsType::PciRootPort : KmdSysman::PciDomainsType::PciCurrentDevice;
if (isLmemSupported) {
request.paramInfo = KmdSysman::PciDomainsType::PciRootPort;
} else {
request.paramInfo = KmdSysman::PciDomainsType::PciCurrentDevice;
request.requestId = KmdSysman::Requests::Pci::CurrentLinkSpeed;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Pci::CurrentLinkWidth;
vRequests.push_back(request);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status == ZE_RESULT_SUCCESS) {
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
state->speed.gen = static_cast<int32_t>(valueSmall);
}
request.requestId = KmdSysman::Requests::Pci::CurrentLinkWidth;
status = pKmdSysManager->requestSingle(request, response);
if (status == ZE_RESULT_SUCCESS) {
memcpy_s(&valueSmall, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&valueSmall, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
state->speed.width = static_cast<int32_t>(valueSmall);
}
return status;
return ZE_RESULT_SUCCESS;
}
bool WddmPciImp::resizableBarSupported() {

117
level_zero/tools/source/sysman/power/windows/os_power_imp.cpp
View File

@@ -13,107 +13,104 @@ ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
pProperties->onSubdevice = false;
pProperties->subdeviceId = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.requestId = KmdSysman::Requests::Power::EnergyThresholdSupported;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&pProperties->canControl, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t));
memcpy_s(&pProperties->isEnergyThresholdSupported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::TdpDefault;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&pProperties->defaultLimit, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::MinPowerLimitDefault;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&pProperties->minLimit, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::MaxPowerLimitDefault;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if (status != ZE_RESULT_SUCCESS) {
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&pProperties->maxLimit, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->canControl, sizeof(ze_bool_t), vResponses[0].dataBuffer, sizeof(ze_bool_t));
memcpy_s(&pProperties->isEnergyThresholdSupported, sizeof(ze_bool_t), vResponses[0].dataBuffer, sizeof(ze_bool_t));
}
return status;
pProperties->defaultLimit = -1;
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->defaultLimit, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
}
pProperties->minLimit = -1;
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->minLimit, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
}
pProperties->maxLimit = -1;
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->maxLimit, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
uint32_t energyUnits = 0;
uint32_t timestampFrequency = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.requestId = KmdSysman::Requests::Power::EnergyCounterUnits;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&energyUnits, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::CurrentEnergyCounter;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
uint32_t valueCounter = 0;
uint64_t valueTimeStamp = 0;
memcpy_s(&valueCounter, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
uint32_t conversionUnit = (1 << energyUnits);
double valueConverted = static_cast<double>(valueCounter) / static_cast<double>(conversionUnit);
valueConverted *= static_cast<double>(convertJouleToMicroJoule);
pEnergy->energy = static_cast<uint64_t>(valueConverted);
memcpy_s(&valueTimeStamp, sizeof(uint64_t), (response.dataBuffer + sizeof(uint32_t)), sizeof(uint64_t));
vRequests.push_back(request);
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::ActivityComponent;
request.requestId = KmdSysman::Requests::Activity::TimestampFrequency;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if (status != ZE_RESULT_SUCCESS) {
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&timestampFrequency, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&energyUnits, sizeof(uint32_t), vResponses[0].dataBuffer, sizeof(uint32_t));
}
uint32_t valueCounter = 0;
uint64_t valueTimeStamp = 0;
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&valueCounter, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
uint32_t conversionUnit = (1 << energyUnits);
double valueConverted = static_cast<double>(valueCounter) / static_cast<double>(conversionUnit);
valueConverted *= static_cast<double>(convertJouleToMicroJoule);
pEnergy->energy = static_cast<uint64_t>(valueConverted);
memcpy_s(&valueTimeStamp, sizeof(uint64_t), (vResponses[1].dataBuffer + sizeof(uint32_t)), sizeof(uint64_t));
}
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&timestampFrequency, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
double timeFactor = 1.0 / static_cast<double>(timestampFrequency);
timeFactor = static_cast<double>(valueTimeStamp) * timeFactor;
timeFactor *= static_cast<double>(microFacor);
pEnergy->timestamp = static_cast<uint64_t>(timeFactor);
}
return status;
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) {

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

@@ -10,10 +10,10 @@
namespace L0 {
ze_result_t WddmTemperatureImp::getProperties(zes_temp_properties_t *pProperties) {
ze_result_t status = ZE_RESULT_SUCCESS;
uint32_t value = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
pProperties->type = this->type;
pProperties->onSubdevice = false;
@@ -38,47 +38,41 @@ ze_result_t WddmTemperatureImp::getProperties(zes_temp_properties_t *pProperties
}
request.requestId = KmdSysman::Requests::Temperature::TempCriticalEventSupported;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&pProperties->isCriticalTempSupported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Temperature::TempThreshold1EventSupported;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&pProperties->isThreshold1Supported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Temperature::TempThreshold2EventSupported;
status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
memcpy_s(&pProperties->isThreshold2Supported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t));
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Temperature::MaxTempSupported;
vRequests.push_back(request);
status = pKmdSysManager->requestSingle(request, response);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if (status != ZE_RESULT_SUCCESS) {
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
pProperties->maxTemperature = static_cast<double>(value);
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->isCriticalTempSupported, sizeof(ze_bool_t), vResponses[0].dataBuffer, sizeof(ze_bool_t));
}
return status;
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->isThreshold1Supported, sizeof(ze_bool_t), vResponses[1].dataBuffer, sizeof(ze_bool_t));
}
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->isThreshold2Supported, sizeof(ze_bool_t), vResponses[2].dataBuffer, sizeof(ze_bool_t));
}
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&value, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
pProperties->maxTemperature = static_cast<double>(value);
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmTemperatureImp::getSensorTemperature(double *pTemperature) {

41
level_zero/tools/source/sysman/windows/kmd_sys.h
View File

@@ -365,6 +365,12 @@ enum MemoryType {
LPDDR4,
DDR3,
LPDDR3,
GDDR4,
GDDR5,
GDDR5X,
GDDR6,
GDDR6X,
GDDR7,
UknownMemType,
MaxMemoryTypes,
@@ -410,6 +416,41 @@ enum PciLinkSpeedType {
MaxPciLinkSpeedTypes,
};
enum ReturnCodes {
Success = 0,
PcuError,
IllegalCommand,
TimeOut,
IllegalData,
IllegalSubCommand,
OverclockingLocked,
DomainServiceNotSupported,
FrequencyExceedsMax,
VoltageExceedsMax,
OverclockingNotSupported,
InvalidVr,
InvalidIccMax,
VoltageOverrideDisabled,
ServiceNotAvailable,
InvalidRequestType,
InvalidComponent,
BufferNotLargeEnough,
GetNotSupported,
SetNotSupported,
MissingProperties,
InvalidEvent,
CreateEventError,
ErrorVersion,
ErrorSize,
ErrorNoElements,
ErrorBufferCorrupted,
VTNotSupported,
NotInitialized,
PropertyNotSet,
InvalidFlipType,
};
enum PciLinkWidthType {
PciLinkWidth1x = 0,
PciLinkWidth2x,

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

@@ -64,26 +64,26 @@ class SysmanEventsFixture : public SysmanDeviceFixture {
TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterTimingOutWithNoEvent) {
init(true);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
zes_device_handle_t *phDevices = new zes_device_handle_t[1];
phDevices[0] = device->toHandle();
uint32_t numDeviceEvents = 0;
zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 100u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
EXPECT_EQ(0u, numDeviceEvents);
EXPECT_EQ(1u, numDeviceEvents);
delete[] phDevices;
delete[] pDeviceEvents;
}
TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWait) {
init(true);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
zes_device_handle_t *phDevices = new zes_device_handle_t[1];
phDevices[0] = device->toHandle();
uint32_t numDeviceEvents = 0;
zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
pKmdSysManager->signalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED);
pKmdSysManager->signalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), INFINITE, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
EXPECT_EQ(1u, numDeviceEvents);
@@ -93,18 +93,18 @@ TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredE
TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWaitMultipleTimes) {
init(true);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
zes_device_handle_t *phDevices = new zes_device_handle_t[1];
phDevices[0] = device->toHandle();
uint32_t numDeviceEvents = 0;
zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
pKmdSysManager->signalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED);
pKmdSysManager->signalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), INFINITE, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
EXPECT_EQ(1u, numDeviceEvents);
pKmdSysManager->signalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED);
pKmdSysManager->signalEvent(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), INFINITE, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
EXPECT_EQ(1u, numDeviceEvents);

7
level_zero/tools/test/unit_tests/sources/sysman/fan/windows/mock_fan.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -35,10 +35,15 @@ struct Mock<FanKmdSysManager> : public FanKmdSysManager {
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Fans::CurrentFanSpeed: {
if (fanSupported) {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockFanCurrentPulses;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} else {
pResponse->outDataSize = 0;
pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
}
} break;
default: {
pResponse->outDataSize = 0;

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

@@ -22,10 +22,11 @@ class SysmanDeviceFanFixture : public SysmanDeviceFixture {
SysmanDeviceFixture::SetUp();
}
void init(bool allowSetCalls) {
void init(bool allowSetCalls, bool fanSupported) {
pKmdSysManager.reset(new Mock<FanKmdSysManager>);
pKmdSysManager->allowSetCalls = allowSetCalls;
pKmdSysManager->fanSupported = fanSupported;
EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
.WillRepeatedly(::testing::Invoke(pKmdSysManager.get(), &Mock<FanKmdSysManager>::mock_escape));
@@ -45,7 +46,9 @@ class SysmanDeviceFanFixture : public SysmanDeviceFixture {
pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
}
std::vector<zes_fan_handle_t> get_fan_handles(uint32_t count) {
std::vector<zes_fan_handle_t> get_fan_handles() {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFans(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
std::vector<zes_fan_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFans(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
@@ -53,7 +56,7 @@ class SysmanDeviceFanFixture : public SysmanDeviceFixture {
};
TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
init(true);
init(true, true);
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFans(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
@@ -61,7 +64,7 @@ TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenVal
}
TEST_F(SysmanDeviceFanFixture, GivenInvalidComponentCountWhenEnumeratingFansThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
init(true);
init(true, true);
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFans(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
@@ -72,8 +75,8 @@ TEST_F(SysmanDeviceFanFixture, GivenInvalidComponentCountWhenEnumeratingFansThen
EXPECT_EQ(count, fanHandleComponentCount);
}
TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenValidPowerHandlesIsReturned) {
init(true);
TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenValidFanHandlesIsReturned) {
init(true, true);
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFans(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
@@ -86,11 +89,11 @@ TEST_F(SysmanDeviceFanFixture, GivenComponentCountZeroWhenEnumeratingFansThenVal
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllowSetToTrueThenCallSucceeds) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowSetToTrueThenCallSucceeds) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_properties_t properties;
@@ -108,11 +111,34 @@ TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllo
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllowSetToFalseThenCallSucceeds) {
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowSetToFalseThenControlToFalse) {
// Setting allow set calls or not
init(false);
init(false, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_properties_t properties = {};
ze_result_t result = zesFanGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(properties.canControl);
}
}
TEST_F(SysmanDeviceFanFixture, GivenValidNoSupportForFanCheckFanHandleCountIsZero) {
// Setting allow set calls or not
init(false, false);
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumFans(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, 0u);
}
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowSetToFalseThenCallSucceeds) {
// Setting allow set calls or not
init(true, true);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_properties_t properties;
@@ -122,7 +148,7 @@ TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllo
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0);
EXPECT_FALSE(properties.canControl);
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(properties.maxPoints, pKmdSysManager->mockFanMaxPoints);
EXPECT_EQ(properties.maxRPM, -1);
EXPECT_EQ(properties.supportedModes, zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE);
@@ -132,9 +158,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidPowerHandleWhenGettingFanPropertiesAllo
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanConfigThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_config_t fanConfig;
@@ -144,9 +170,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanConfigThenUnsupp
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingDefaultModeThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFanSetDefaultMode(handle));
@@ -155,9 +181,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingDefaultModeThenUnsu
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingFixedSpeedModeThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_speed_t fanSpeed = {0};
@@ -167,9 +193,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingFixedSpeedModeThenU
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingTheSpeedTableModeThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_speed_table_t fanSpeedTable = {0};
@@ -179,9 +205,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenSettingTheSpeedTableModeTh
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanSpeedWithRPMUnitThenValidFanSpeedReadingsRetrieved) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_speed_units_t unit = zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_RPM;
@@ -195,9 +221,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanSpeedWithRPMUnit
TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanSpeedWithPercentUnitThenUnsupportedIsReturned) {
// Setting allow set calls or not
init(true);
init(true, true);
auto handles = get_fan_handles(fanHandleComponentCount);
auto handles = get_fan_handles();
for (auto handle : handles) {
zes_fan_speed_units_t unit = zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT;

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

@@ -425,7 +425,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTru
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetFrequencyTarget(handle, freqTarget));
double newFreqTarget = 0.0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetFrequencyTarget(handle, &newFreqTarget));
EXPECT_DOUBLE_EQ(freqTarget, newFreqTarget);
EXPECT_DOUBLE_EQ(newFreqTarget, freqTarget);
domainIndex++;
}
}

11
level_zero/tools/test/unit_tests/sources/sysman/memory/windows/mock_memory.h
View File

@@ -34,7 +34,8 @@ struct Mock<MemoryKmdSysManager> : public MemoryKmdSysManager {
uint32_t mockMemoryBus = 256;
uint32_t mockMemoryChannels = 2;
uint32_t mockMemoryMaxBandwidth = 4256000000;
uint32_t mockMemoryCurrentBandwidth = 561321;
uint32_t mockMemoryCurrentBandwidthRead = 561321;
uint32_t mockMemoryCurrentBandwidthWrite = 664521;
uint32_t mockMemoryDomains = 1;
void getMemoryProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
@@ -110,7 +111,13 @@ struct Mock<MemoryKmdSysManager> : public MemoryKmdSysManager {
} break;
case KmdSysman::Requests::Memory::CurrentBandwidthRead: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockMemoryCurrentBandwidth;
*pValue = mockMemoryCurrentBandwidthRead;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;
case KmdSysman::Requests::Memory::CurrentBandwidthWrite: {
uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
*pValue = mockMemoryCurrentBandwidthWrite;
pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
pResponse->outDataSize = sizeof(uint32_t);
} break;

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

@@ -189,9 +189,9 @@ TEST_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenGettingBandwidthThen
ze_result_t result = zesMemoryGetBandwidth(handle, &bandwidth);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(bandwidth.maxBandwidth, pKmdSysManager->mockMemoryMaxBandwidth);
EXPECT_EQ(bandwidth.readCounter, pKmdSysManager->mockMemoryCurrentBandwidth * MbpsToBytesPerSecond);
EXPECT_EQ(bandwidth.writeCounter, 0u);
EXPECT_EQ(bandwidth.maxBandwidth, pKmdSysManager->mockMemoryMaxBandwidth * MbpsToBytesPerSecond);
EXPECT_EQ(bandwidth.readCounter, pKmdSysManager->mockMemoryCurrentBandwidthRead);
EXPECT_EQ(bandwidth.writeCounter, pKmdSysManager->mockMemoryCurrentBandwidthWrite);
EXPECT_GT(bandwidth.timestamp, 0u);
}
}

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

@@ -33,7 +33,7 @@ template <>
struct Mock<MockKmdSysManager> : public MockKmdSysManager {
ze_bool_t allowSetCalls = false;
ze_bool_t fanSupported = false;
uint32_t mockPowerLimit1 = 2500;
MockEventHandle handles[KmdSysman::Events::MaxEvents][mockKmdMaxHandlesPerEvent];
@@ -278,10 +278,14 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
arrayID = KmdSysman::Events::EnterD0;
}
if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED) {
if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_DETACH) {
arrayID = KmdSysman::Events::EnterTDR;
}
if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH) {
arrayID = KmdSysman::Events::ExitTDR;
}
for (uint32_t i = 0; i < mockKmdMaxHandlesPerEvent; i++) {
if (handles[arrayID][i].inited) {
SetEvent(handles[arrayID][i].eventHandle);