gpu_fdinfo: add driver-agnostic hwmon support

This commit removes the hardcoding of specific hwmon sensor IDs to that
of i915 and Xe KMD, thus making `find_intel_hwmon` vendor-independent.

Instead, it iterates through available hwmon sensors and selects the
first available sensor. This should allow fan speed and temp monitoring
to work out of the box on Xe DRM in the future as well, once Xe DRM
exposes the necessary interfaces via hwmon.

Co-authored-by: Ibrahim Ansari <ansari.ibrahim1@gmail.com>

Author: 17314642

src/gpu_fdinfo.cpp

@@ -39,8 +39,10 @@ void GPU_fdinfo::find_fd()
         if (!driver.empty() && driver == module) {
             total++;
             SPDLOG_DEBUG(
-                "driver = \"{}\", pdev = \"{}\", client_id = \"{}\", client_id_exists = \"{}\"",
-                driver, pdev, client_id, client_ids.find(client_id) != client_ids.end()
+                "driver = \"{}\", pdev = \"{}\", "
+                "client_id = \"{}\", client_id_exists = \"{}\"",
+                driver, pdev,
+                client_id, client_ids.find(client_id) != client_ids.end()
             );
         }
 
@@ -55,7 +57,11 @@ void GPU_fdinfo::find_fd()
         open_fdinfo_fd(fd_path);
     }
 
-    SPDLOG_DEBUG("Found {} total fds. Opened {} unique fds.", total, fdinfo.size());
+    SPDLOG_DEBUG(
+        "Found {} total fds. Opened {} unique fds.",
+        total,
+        fdinfo.size()
+    );
 }
 
 void GPU_fdinfo::open_fdinfo_fd(std::string path) {
@@ -109,73 +115,108 @@ float GPU_fdinfo::get_memory_used()
     return (float)total / 1024 / 1024;
 }
 
-void GPU_fdinfo::find_intel_hwmon()
+void GPU_fdinfo::find_hwmon()
 {
-    std::string device = "/sys/bus/pci/devices/";
-    device += pci_dev;
-    device += "/hwmon";
+    std::string device = "/sys/bus/pci/devices/" + pci_dev + "/hwmon";
 
     if (!fs::exists(device)) {
-        SPDLOG_DEBUG("Intel hwmon directory {} doesn't exist.", device);
+        SPDLOG_DEBUG("hwmon: hwmon directory {} doesn't exist.", device);
         return;
     }
 
     auto dir_iterator = fs::directory_iterator(device);
     auto hwmon = dir_iterator->path().string();
 
     if (hwmon.empty()) {
-        SPDLOG_DEBUG("Intel hwmon directory is empty.");
+        SPDLOG_DEBUG("hwmon: hwmon directory is empty.");
         return;
     }
 
-    hwmon += module == "i915" ? "/energy1_input" : "/energy2_input";
+    for (const auto &entry : fs::directory_iterator(hwmon)) {
+        auto filename = entry.path().filename().string();
 
-    if (!fs::exists(hwmon)) {
-        SPDLOG_DEBUG("Intel hwmon: file {} doesn't exist.", hwmon);
-        return;
+        for (auto& hs : hwmon_sensors) {
+            auto key = hs.first;
+            auto sensor = &hs.second;
+            std::smatch matches;
+
+            if (
+                !std::regex_match(filename, matches, sensor->rx) ||
+                matches.size() != 2
+            )
+                continue;
+
+            auto cur_id = std::stoull(matches[1].str());
+
+            if (sensor->filename.empty() || cur_id < sensor->id) {
+                sensor->filename = entry.path().string();
+                sensor->id = cur_id;
+            }
+        }
     }
 
-    SPDLOG_DEBUG("Intel hwmon found: hwmon = {}", hwmon);
+    for (auto& hs : hwmon_sensors) {
+        auto key = hs.first;
+        auto sensor = &hs.second;
+
+        if (sensor->filename.empty()) {
+            SPDLOG_DEBUG("hwmon: {} reading not found at {}", key, hwmon);
+            continue;
+        }
 
-    energy_stream.open(hwmon);
+        SPDLOG_DEBUG("hwmon: {} reading found at {}", key, sensor->filename);
 
-    if (!energy_stream.good())
-        SPDLOG_DEBUG("Intel hwmon: failed to open {}", hwmon);
+        sensor->stream.open(sensor->filename);
 
-    // Initialize value for the first time, otherwise delta will be very large
-    // and your gpu power usage will be like 1 million watts for a second.
-    this->last_power = get_current_power();
+        if (!sensor->stream.good()) {
+            SPDLOG_DEBUG(
+                "hwmon: failed to open {} reading {}",
+                key, sensor->filename
+            );
+            continue;
+        }
+    }
 }
 
-float GPU_fdinfo::get_current_power()
+void GPU_fdinfo::get_current_hwmon_readings()
 {
-    if (!energy_stream.is_open())
-        return 0.f;
+    for (auto& hs : hwmon_sensors) {
+        auto key = hs.first;
+        auto sensor = &hs.second;
 
-    std::string energy_input_str;
-    uint64_t energy_input;
-
-    energy_stream.seekg(0);
+        if (!sensor->stream.is_open())
+            continue;
 
-    std::getline(energy_stream, energy_input_str);
+        sensor->stream.seekg(0);
 
-    if (energy_input_str.empty())
-        return 0.f;
+        std::stringstream ss;
+        ss << sensor->stream.rdbuf();
 
-    energy_input = std::stoull(energy_input_str);
+        if (ss.str().empty())
+            continue;
 
-    return (float)energy_input / 1'000'000;
+        sensor->val = std::stoull(ss.str());
+    }
 }
 
 float GPU_fdinfo::get_power_usage()
 {
-    float now = get_current_power();
+    if (!hwmon_sensors["power"].filename.empty())
+        return (float)hwmon_sensors["power"].val / 1'000'000;
+
+    float now = hwmon_sensors["energy"].val;
+
+    // Initialize value for the first time, otherwise delta will be very large
+    // and your gpu power usage will be like 1 million watts for a second.
+    if (this->last_power == 0.f)
+        this->last_power = now;
+
     float delta = now - this->last_power;
     delta /= (float)METRICS_UPDATE_PERIOD_MS / 1000;
 
     this->last_power = now;
 
-    return delta;
+    return delta / 1'000'000;
 }
 
 int GPU_fdinfo::get_xe_load()
@@ -349,15 +390,26 @@ void GPU_fdinfo::main_thread()
         cond_var.wait(lock, [this]() { return !paused || stop_thread; });
 
         gather_fdinfo_data();
+        get_current_hwmon_readings();
 
         metrics.load = get_gpu_load();
         metrics.memoryUsed = get_memory_used();
         metrics.powerUsage = get_power_usage();
         metrics.CoreClock = get_gpu_clock();
+        metrics.temp = hwmon_sensors["temp"].val / 1000;
+        metrics.fan_speed = hwmon_sensors["fan_speed"].val;
+        metrics.voltage = hwmon_sensors["voltage"].val;
+        metrics.fan_rpm = true; // Fan data is pulled from hwmon
 
         SPDLOG_DEBUG(
-            "pci_dev = {}, pid = {}, module = {}, load = {}, mem = {}, power = {}",
-            pci_dev, pid, module, metrics.load, metrics.memoryUsed, metrics.powerUsage
+            "pci_dev = {}, pid = {}, module = {}, "
+            "load = {}, mem = {}, power = {}, "
+            "core = {}, temp = {}, fan = {}, "
+            "voltage = {}",
+            pci_dev, pid, module,
+            metrics.load, metrics.memoryUsed, metrics.powerUsage,
+            metrics.CoreClock, metrics.temp, metrics.fan_speed,
+            metrics.voltage
         );
 
         std::this_thread::sleep_for(

src/gpu_fdinfo.h

@@ -1,19 +1,32 @@
 #pragma once
+#include <cstdint>
 #include <filesystem.h>
 #include <inttypes.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
 #include <thread>
+
 #ifdef TEST_ONLY
 #include <../src/mesa/util/os_time.h>
 #else
 #include <mesa/util/os_time.h>
 #endif
+
 #include "gpu_metrics_util.h"
 #include <atomic>
 #include <spdlog/spdlog.h>
 #include <map>
 #include <set>
+#include <regex>
+
+struct hwmon_sensor {
+    std::regex rx;
+    std::ifstream stream;
+    std::string filename;
+    unsigned char id = 0;
+    uint64_t val = 0;
+};
 
 class GPU_fdinfo {
 private:
@@ -33,7 +46,8 @@ class GPU_fdinfo {
     mutable std::mutex metrics_mutex;
 
     std::vector<std::ifstream> fdinfo;
-    std::ifstream energy_stream;
+
+    std::map<std::string, hwmon_sensor> hwmon_sensors;
 
     std::string drm_engine_type = "EMPTY";
     std::string drm_memory_type = "EMPTY";
@@ -56,8 +70,9 @@ class GPU_fdinfo {
 
     float get_memory_used();
 
-    void find_intel_hwmon();
-    float get_current_power();
+    void find_hwmon();
+    void get_current_hwmon_readings();
+
     float get_power_usage();
     float last_power = 0;
 
@@ -106,8 +121,13 @@ class GPU_fdinfo {
             drm_engine_type, drm_memory_type
         );
 
-        if (module == "i915" || module == "xe")
-            find_intel_hwmon();
+        hwmon_sensors["voltage"]   = { .rx = std::regex("in(\\d+)_input") };
+        hwmon_sensors["fan_speed"] = { .rx = std::regex("fan(\\d+)_input") };
+        hwmon_sensors["temp"]      = { .rx = std::regex("temp(\\d+)_input") };
+        hwmon_sensors["power"]     = { .rx = std::regex("power(\\d+)_input") };
+        hwmon_sensors["energy"]    = { .rx = std::regex("energy(\\d+)_input") };
+
+        find_hwmon();
 
         if (module == "i915")
             find_i915_gt_dir();