Last commit did not include all the files, oops

Author: nokyan

src/utils/app.rs

@@ -12,12 +12,12 @@ use gtk::{
 };
 use lazy_regex::{Lazy, Regex, lazy_regex};
 use log::{debug, info, trace};
-use process_data::{Containerization, GpuIdentifier, ProcessData};
+use process_data::{Containerization, GpuIdentifier, GpuUsageStats, ProcessData};
 
 use crate::i18n::i18n;
 
 use super::{
-    FiniteOr, boot_time,
+    boot_time,
     process::{Process, ProcessAction},
 };
 
@@ -548,16 +548,8 @@ impl AppsContext {
                 _ => None,
             })
             .map(|(new, old, timestamp, timestamp_last)| {
-                if new.nvidia {
-                    new.gfx as f32 / 100.0
-                } else if old.gfx == 0 {
-                    0.0
-                } else {
-                    ((new.gfx.saturating_sub(old.gfx) as f32)
-                        / (timestamp.saturating_sub(timestamp_last) as f32))
-                        .finite_or_default()
-                        / 1_000_000.0
-                }
+                let time_delta = timestamp.saturating_sub(timestamp_last);
+                new.gfx_fraction(old, time_delta).unwrap_or_default()
             })
             .sum::<f32>()
             .clamp(0.0, 1.0)
@@ -586,16 +578,8 @@ impl AppsContext {
                 _ => None,
             })
             .map(|(new, old, timestamp, timestamp_last)| {
-                if new.nvidia {
-                    new.enc as f32 / 100.0
-                } else if old.enc == 0 {
-                    0.0
-                } else {
-                    ((new.enc.saturating_sub(old.enc) as f32)
-                        / (timestamp.saturating_sub(timestamp_last) as f32))
-                        .finite_or_default()
-                        / 1_000_000.0
-                }
+                let time_delta = timestamp.saturating_sub(timestamp_last);
+                new.enc_fraction(old, time_delta).unwrap_or_default()
             })
             .sum::<f32>()
             .clamp(0.0, 1.0)
@@ -624,16 +608,8 @@ impl AppsContext {
                 _ => None,
             })
             .map(|(new, old, timestamp, timestamp_last)| {
-                if new.nvidia {
-                    new.dec as f32 / 100.0
-                } else if old.dec == 0 {
-                    0.0
-                } else {
-                    ((new.dec.saturating_sub(old.dec) as f32)
-                        / (timestamp.saturating_sub(timestamp_last) as f32))
-                        .finite_or_default()
-                        / 1_000_000.0
-                }
+                let time_delta = timestamp.saturating_sub(timestamp_last);
+                new.dec_fraction(old, time_delta).unwrap_or_default()
             })
             .sum::<f32>()
             .clamp(0.0, 1.0)
@@ -778,16 +754,18 @@ impl AppsContext {
 
             // this is awkward: since AppsContext is the only object around that knows what GPUs have combined media
             // engines, it is here where we have to manipulate the GpuUsageStats objects with PciSlots of those GPUs
-            // whose media engine is combined (e.g. no discrimination between enc and dec stats)
+            // whose media engine is combined (i.e. no discrimination between enc and dec stats)
             process_data
                 .gpu_usage_stats
                 .iter_mut()
                 .filter(|(pci_slot, _)| self.gpus_with_combined_media_engine.contains(pci_slot))
                 .for_each(|(pci_slot, stats)| {
                     trace!("Manually adjusting GPU stats of {} for {pci_slot} due to combined media engine", process_data.pid);
 
-                    stats.dec = u64::max(stats.dec, stats.enc);
-                    stats.enc = u64::max(stats.dec, stats.enc);
+                    if let GpuUsageStats::AmdgpuStats { gfx_ns: _, enc_ns, dec_ns, mem_bytes: _ } = stats {
+                        *enc_ns = u64::max(*enc_ns, *dec_ns);
+                        *dec_ns = u64::max(*enc_ns, *dec_ns);
+                    }
                 });
 
             // refresh our old processes

src/utils/gpu/intel.rs

@@ -1,18 +1,38 @@
 use anyhow::{Result, bail};
 use process_data::GpuIdentifier;
+use strum_macros::{Display, EnumString};
 
-use std::path::PathBuf;
+use std::{path::PathBuf, str::FromStr};
 
 use crate::utils::pci::Device;
 
 use super::GpuImpl;
 
-#[derive(Debug, Clone, Default)]
+pub const DRIVER_NAMES: &[&str] = &["i915", "xe"];
+
+#[derive(Debug, Clone, Display, EnumString, PartialEq, PartialOrd, Eq, Ord)]
+#[strum(ascii_case_insensitive)]
+#[strum(serialize_all = "lowercase")]
+pub enum IntelGpuDriver {
+    I915,
+    Xe,
+    #[strum(transparent)]
+    #[strum(default)]
+    Other(String),
+}
+
+impl Default for IntelGpuDriver {
+    fn default() -> Self {
+        Self::Other(String::new())
+    }
+}
+
+#[derive(Debug, Clone)]
 
 pub struct IntelGpu {
     pub device: Option<&'static Device>,
     pub gpu_identifier: GpuIdentifier,
-    pub driver: String,
+    pub driver: IntelGpuDriver,
     sysfs_path: PathBuf,
     first_hwmon_path: Option<PathBuf>,
 }
@@ -28,7 +48,7 @@ impl IntelGpu {
         Self {
             device,
             gpu_identifier,
-            driver,
+            driver: IntelGpuDriver::from_str(&driver).unwrap_or_default(),
             sysfs_path,
             first_hwmon_path,
         }
@@ -45,7 +65,7 @@ impl GpuImpl for IntelGpu {
     }
 
     fn driver(&self) -> String {
-        self.driver.clone()
+        self.driver.to_string()
     }
 
     fn sysfs_path(&self) -> PathBuf {
@@ -89,11 +109,21 @@ impl GpuImpl for IntelGpu {
     }
 
     fn power_usage(&self) -> Result<f64> {
-        self.hwmon_power_usage()
+        match self.driver {
+            IntelGpuDriver::Xe => {
+                Ok(self.read_sysfs_int("tile0/gt0/freq0/cur_freq")? as f64 * 1_000_000.0)
+            }
+            _ => Ok(self.read_sysfs_int("gt_cur_freq_mhz")? as f64 * 1_000_000.0),
+        }
     }
 
     fn core_frequency(&self) -> Result<f64> {
-        Ok(self.read_sysfs_int("gt_cur_freq_mhz")? as f64 * 1_000_000.0)
+        match self.driver {
+            IntelGpuDriver::Xe => {
+                Ok(self.read_sysfs_int("tile0/gt0/freq0/cur_freq")? as f64 * 1_000_000.0)
+            }
+            _ => Ok(self.read_sysfs_int("gt_cur_freq_mhz")? as f64 * 1_000_000.0),
+        }
     }
 
     fn vram_frequency(&self) -> Result<f64> {
@@ -108,3 +138,54 @@ impl GpuImpl for IntelGpu {
         self.hwmon_power_cap_max()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use super::IntelGpuDriver;
+    use pretty_assertions::assert_eq;
+
+    const I915_NAME: &str = "i915";
+    const XE_NAME: &str = "xe";
+    const OTHER_NAME: &str = "other_driver";
+
+    #[test]
+    fn i915_driver_from_str() {
+        let driver = IntelGpuDriver::from_str(I915_NAME).unwrap();
+
+        assert_eq!(driver, IntelGpuDriver::I915);
+    }
+
+    #[test]
+    fn xe_driver_from_str() {
+        let driver = IntelGpuDriver::from_str(XE_NAME).unwrap();
+
+        assert_eq!(driver, IntelGpuDriver::Xe);
+    }
+
+    #[test]
+    fn other_driver_from_str() {
+        let driver = IntelGpuDriver::from_str(OTHER_NAME).unwrap();
+
+        assert_eq!(driver, IntelGpuDriver::Other(OTHER_NAME.to_string()));
+    }
+
+    #[test]
+    fn i915_driver_to_str() {
+        assert_eq!(IntelGpuDriver::I915.to_string(), I915_NAME);
+    }
+
+    #[test]
+    fn xe_driver_to_str() {
+        assert_eq!(IntelGpuDriver::Xe.to_string(), XE_NAME);
+    }
+
+    #[test]
+    fn other_driver_to_str() {
+        assert_eq!(
+            IntelGpuDriver::Other(OTHER_NAME.to_string()).to_string(),
+            OTHER_NAME
+        );
+    }
+}

src/utils/gpu/mod.rs

@@ -202,7 +202,8 @@ pub trait GpuImpl {
     fn hwmon_power_usage(&self) -> Result<f64> {
         Ok(self
             .read_hwmon_int("power1_average")
-            .or_else(|_| self.read_hwmon_int("power1_input"))? as f64
+            .or_else(|_| self.read_hwmon_int("power1_input"))
+            .or_else(|_| self.read_hwmon_int("power1"))? as f64
             / 1_000_000.0)
     }
 
@@ -311,7 +312,7 @@ impl Gpu {
                 )),
                 "AMD",
             )
-        } else if vid == VID_INTEL || driver == "i915" {
+        } else if vid == VID_INTEL || intel::DRIVER_NAMES.contains(&driver.as_str()) {
             (
                 Gpu::Intel(IntelGpu::new(
                     device,

src/utils/process.rs

@@ -399,20 +399,10 @@ impl Process {
         let mut returned_gpu_usage = 0.0;
         for (gpu, usage) in &self.data.gpu_usage_stats {
             if let Some(old_usage) = self.gpu_usage_stats_last.get(gpu) {
-                let this_gpu_usage = if usage.nvidia {
-                    usage.gfx as f32 / 100.0
-                } else if old_usage.gfx == 0 {
-                    0.0
-                } else {
-                    ((usage.gfx.saturating_sub(old_usage.gfx) as f32)
-                        / (self.data.timestamp.saturating_sub(self.timestamp_last) as f32)
-                            .finite_or_default())
-                        / 1_000_000.0
-                };
-
-                if this_gpu_usage > returned_gpu_usage {
-                    returned_gpu_usage = this_gpu_usage;
-                }
+                let time_delta = self.data.timestamp.saturating_sub(self.timestamp_last);
+                returned_gpu_usage += usage
+                    .gfx_fraction(old_usage, time_delta)
+                    .unwrap_or_default();
             }
         }
 
@@ -424,20 +414,10 @@ impl Process {
         let mut returned_gpu_usage = 0.0;
         for (gpu, usage) in &self.data.gpu_usage_stats {
             if let Some(old_usage) = self.gpu_usage_stats_last.get(gpu) {
-                let this_gpu_usage = if usage.nvidia {
-                    usage.enc as f32 / 100.0
-                } else if old_usage.enc == 0 {
-                    0.0
-                } else {
-                    ((usage.enc.saturating_sub(old_usage.enc) as f32)
-                        / (self.data.timestamp.saturating_sub(self.timestamp_last) as f32)
-                            .finite_or_default())
-                        / 1_000_000.0
-                };
-
-                if this_gpu_usage > returned_gpu_usage {
-                    returned_gpu_usage = this_gpu_usage;
-                }
+                let time_delta = self.data.timestamp.saturating_sub(self.timestamp_last);
+                returned_gpu_usage += usage
+                    .enc_fraction(old_usage, time_delta)
+                    .unwrap_or_default();
             }
         }
 
@@ -449,20 +429,10 @@ impl Process {
         let mut returned_gpu_usage = 0.0;
         for (gpu, usage) in &self.data.gpu_usage_stats {
             if let Some(old_usage) = self.gpu_usage_stats_last.get(gpu) {
-                let this_gpu_usage = if usage.nvidia {
-                    usage.dec as f32 / 100.0
-                } else if old_usage.dec == 0 {
-                    0.0
-                } else {
-                    ((usage.dec.saturating_sub(old_usage.dec) as f32)
-                        / (self.data.timestamp.saturating_sub(self.timestamp_last) as f32)
-                            .finite_or_default())
-                        / 1_000_000.0
-                };
-
-                if this_gpu_usage > returned_gpu_usage {
-                    returned_gpu_usage = this_gpu_usage;
-                }
+                let time_delta = self.data.timestamp.saturating_sub(self.timestamp_last);
+                returned_gpu_usage += usage
+                    .dec_fraction(old_usage, time_delta)
+                    .unwrap_or_default();
             }
         }
 
@@ -474,7 +444,7 @@ impl Process {
         self.data
             .gpu_usage_stats
             .values()
-            .map(|stats| stats.mem)
+            .map(|stats| stats.mem().unwrap_or_default())
             .sum()
     }