gpu_fdinfo: divide logic in separate sections

Author: 17314642

src/gpu_fdinfo.cpp

@@ -54,7 +54,7 @@ uint64_t GPU_fdinfo::get_gpu_time()
     return total_val;
 }
 
-float GPU_fdinfo::get_vram_usage()
+float GPU_fdinfo::get_memory_used()
 {
     uint64_t total_val = 0;
 
@@ -108,7 +108,7 @@ void GPU_fdinfo::find_intel_hwmon()
         SPDLOG_DEBUG("Intel hwmon: failed to open {}", hwmon);
 }
 
-float GPU_fdinfo::get_power_usage()
+float GPU_fdinfo::get_current_power()
 {
     if (!energy_stream.is_open())
         return 0.f;
@@ -128,40 +128,51 @@ float GPU_fdinfo::get_power_usage()
     return (float)energy_input / 1'000'000;
 }
 
-void GPU_fdinfo::get_load()
+float GPU_fdinfo::get_power_usage()
 {
-    while (!stop_thread) {
-        std::unique_lock<std::mutex> lock(metrics_mutex);
-        cond_var.wait(lock, [this]() { return !paused || stop_thread; });
+    static float last;
+    float now = get_current_power();
 
-        static uint64_t previous_gpu_time, previous_time, now, gpu_time_now;
-        static float power_usage_now, previous_power_usage;
+    float delta = now - last;
+    delta /= (float)METRICS_UPDATE_PERIOD_MS / 1000;
 
-        now = os_time_get_nano();
-        gpu_time_now = get_gpu_time();
-        power_usage_now = get_power_usage();
+    last = now;
 
-        if (gpu_time_now > previous_gpu_time) {
-            float time_since_last = now - previous_time;
-            float gpu_since_last = gpu_time_now - previous_gpu_time;
-            float power_usage_since_last =
-                (power_usage_now - previous_power_usage) /
-                ((float)METRICS_UPDATE_PERIOD_MS / 1000);
+    return delta;
+}
 
-            auto result = int((gpu_since_last / time_since_last) * 100);
-            if (result > 100)
-                result = 100;
+int GPU_fdinfo::get_gpu_load()
+{
+    static uint64_t previous_gpu_time, previous_time;
 
-            metrics.load = result;
-            metrics.memoryUsed = get_vram_usage();
-            metrics.powerUsage = power_usage_since_last;
+    uint64_t now = os_time_get_nano();
+    uint64_t gpu_time_now = get_gpu_time();
 
-            previous_gpu_time = gpu_time_now;
-            previous_power_usage = power_usage_now;
-        }
+    float delta_time = now - previous_time;
+    float delta_gpu_time = gpu_time_now - previous_gpu_time;
+
+    int result = std::lround(delta_gpu_time / delta_time * 100);
+
+    if (result > 100)
+        result = 100;
+
+    previous_gpu_time = gpu_time_now;
+    previous_time = now;
+
+    return result;
+}
+
+void GPU_fdinfo::main_thread()
+{
+    while (!stop_thread) {
+        std::unique_lock<std::mutex> lock(metrics_mutex);
+        cond_var.wait(lock, [this]() { return !paused || stop_thread; });
+
+        metrics.load = get_gpu_load();
+        metrics.memoryUsed = get_memory_used();
+        metrics.powerUsage = get_power_usage();
 
         std::this_thread::sleep_for(
-            std::chrono::milliseconds(METRICS_UPDATE_PERIOD_MS)
-        );
+            std::chrono::milliseconds(METRICS_UPDATE_PERIOD_MS));
     }
 }

src/gpu_fdinfo.h

@@ -15,24 +15,36 @@
 class GPU_fdinfo {
 private:
     bool init = false;
-    struct gpu_metrics metrics;
-    std::vector<std::ifstream> fdinfo;
+
     const std::string module;
     const std::string pci_dev;
-    void find_fd();
-    void find_intel_hwmon();
-    std::ifstream energy_stream;
+
     std::thread thread;
     std::condition_variable cond_var;
+
     std::atomic<bool> stop_thread { false };
     std::atomic<bool> paused { false };
+
+    struct gpu_metrics metrics;
     mutable std::mutex metrics_mutex;
 
-    uint64_t get_gpu_time();
-    void get_load();
+    std::vector<std::ifstream> fdinfo;
+    std::ifstream energy_stream;
+
     std::string drm_engine_type = "EMPTY";
     std::string drm_memory_type = "EMPTY";
-    float get_vram_usage();
+
+    void main_thread();
+
+    void find_fd();
+    void find_intel_hwmon();
+
+    int get_gpu_load();
+    uint64_t get_gpu_time();
+
+    float get_memory_used();
+
+    float get_current_power();
     float get_power_usage();
 
 public:
@@ -54,7 +66,7 @@ class GPU_fdinfo {
 
         find_fd();
 
-        std::thread thread(&GPU_fdinfo::get_load, this);
+        std::thread thread(&GPU_fdinfo::main_thread, this);
         thread.detach();
     }