Sysman for Windows: Multiple fixes and optimizations

Signed-off-by: Daniel Enriquez <[email protected]>

Author: Daniel Enriquez

level_zero/tools/source/sysman/events/windows/os_events_imp.cpp

@@ -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
+    ResetEvent(exitHandle);
+    // Was a timeout, exit event loop.
     if (signaledEvent == WAIT_TIMEOUT) {
-        return false;
+        return true;
     }
 
-    // Was the exit event
-    if (signaledEvent >= eventList.size()) {
-        ResetEvent(exitHandle);
-        return false;
+    // Was the exit event and exit event loop.
+    if (signaledEvent == eventList.size()) {
+        pEvent = ZES_EVENT_TYPE_FLAG_FORCE_UINT32;
+    } else {
+        pEvent = eventList[signaledEvent].id;
     }
 
-    pEvent = eventList[signaledEvent].id;
-
+    // Whatever reason exit the loop, WaitForMultipleObjects exited, exit from the loop must follow.
     return true;
 }
 

level_zero/tools/source/sysman/fan/windows/os_fan_imp.cpp

@@ -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->maxPoints = maxPoints = static_cast<int32_t>(FanPoints);
+    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) {