AMDXDNA support

lib/process_data/Cargo.toml

@@ -21,9 +21,11 @@ anyhow = "1.0.94"
 glob = "0.3.1"
 lazy-regex = "3.3.0"
 libc = "0.2.167"
+log = "0.4.22"
 num_cpus = "1.16.0"
 nutype = { version = "0.5.0", features = ["serde"] }
 nvml-wrapper = "0.10.0"
+pretty_env_logger = "0.5"
 serde = { version = "1.0.215", features = ["serde_derive"] }
 syscalls = { version = "0.6.18", features = ["all"] }
 sysconf = "0.3.4"

src/bin/resources-processes.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use log::{info, trace};
 use process_data::ProcessData;
 use ron::ser::PrettyConfig;
 use std::io::{Read, Write};
@@ -18,6 +19,11 @@ struct Args {
 }
 
 fn main() -> Result<()> {
+    // Initialize logger
+    pretty_env_logger::init();
+
+    info!("Starting resources-processes…");
+
     let args = Args::parse();
 
     if args.once {
@@ -29,12 +35,14 @@ fn main() -> Result<()> {
         let mut buffer = [0; 1];
 
         std::io::stdin().read_exact(&mut buffer)?;
+        trace!("Received character");
 
         output(args.ron)?;
     }
 }
 
 fn output(ron: bool) -> Result<()> {
+    trace!("Gathering process data…");
     let data = ProcessData::all_process_data()?;
 
     let encoded = if ron {
@@ -50,10 +58,13 @@ fn output(ron: bool) -> Result<()> {
     let stdout = std::io::stdout();
     let mut handle = stdout.lock();
 
+    trace!("Sending content length ({})…", encoded.len());
     handle.write_all(&len_byte_array)?;
 
+    trace!("Sending content…");
     handle.write_all(&encoded)?;
 
+    trace!("Flushing…");
     handle.flush()?;
     Ok(())
 }

src/ui/window.rs

@@ -598,17 +598,32 @@ impl MainWindow {
             page.refresh_page(&gpu_data);
         }
 
-        std::mem::drop(apps_context);
-
         /*
          * Npu
          */
         let npu_pages = imp.npu_pages.borrow();
-        for ((_, page), npu_data) in npu_pages.values().zip(npu_data) {
+        for ((_, page), mut npu_data) in npu_pages.values().zip(npu_data) {
             let page = page.content().and_downcast::<ResNPU>().unwrap();
+
+            let processes_npu_fraction = apps_context.npu_fraction(npu_data.pci_slot);
+            npu_data.usage_fraction = Some(f64::max(
+                npu_data.usage_fraction.unwrap_or(0.0),
+                processes_npu_fraction.into(),
+            ));
+
+            if npu_data.total_memory.is_some() {
+                let processes_npu_memory_fraction = apps_context.npu_mem(npu_data.pci_slot);
+                npu_data.used_memory = Some(usize::max(
+                    npu_data.used_memory.unwrap_or(0),
+                    processes_npu_memory_fraction as usize,
+                ));
+            }
+
             page.refresh_page(&npu_data);
         }
 
+        std::mem::drop(apps_context);
+
         /*
          * Cpu
          */

src/utils/app.rs

@@ -12,7 +12,7 @@ use gtk::{
 };
 use lazy_regex::{lazy_regex, Lazy, Regex};
 use log::{debug, info, trace};
-use process_data::{Containerization, GpuIdentifier, ProcessData};
+use process_data::{pci_slot::PciSlot, Containerization, GpuIdentifier, ProcessData};
 
 use crate::i18n::i18n;
 
@@ -640,6 +640,52 @@ impl AppsContext {
             .clamp(0.0, 1.0)
     }
 
+    pub fn npu_fraction(&self, pci_slot: PciSlot) -> f32 {
+        self.processes_iter()
+            .map(|process| {
+                (
+                    &process.data.npu_usage_stats,
+                    &process.npu_usage_stats_last,
+                    process.data.timestamp,
+                    process.timestamp_last,
+                )
+            })
+            .map(|(new, old, timestamp, timestamp_last)| {
+                (
+                    new.get(&pci_slot),
+                    old.get(&pci_slot),
+                    timestamp,
+                    timestamp_last,
+                )
+            })
+            .filter_map(|(new, old, timestamp, timestamp_last)| match (new, old) {
+                (Some(new), Some(old)) => Some((new, old, timestamp, timestamp_last)),
+                _ => None,
+            })
+            .map(|(new, old, timestamp, timestamp_last)| {
+                if old.usage == 0 {
+                    0.0
+                } else {
+                    ((new.usage.saturating_sub(old.usage) as f32)
+                        / (timestamp.saturating_sub(timestamp_last) as f32))
+                        .finite_or_default()
+                        / 1_000_000.0
+                }
+            })
+            .sum::<f32>()
+            .clamp(0.0, 1.0)
+    }
+
+    pub fn npu_mem(&self, pci_slot: PciSlot) -> u64 {
+        self.processes_iter()
+            .map(|process| process.data.npu_usage_stats.get(&pci_slot))
+            .map(|stats| match stats {
+                Some(stats) => stats.mem,
+                None => 0,
+            })
+            .sum()
+    }
+
     fn app_associated_with_process(&self, process: &Process) -> Option<String> {
         // TODO: tidy this up
         // ↓ look for whether we can find an ID in the cgroup
@@ -797,6 +843,7 @@ impl AppsContext {
                 old_process.read_bytes_last = old_process.data.read_bytes;
                 old_process.write_bytes_last = old_process.data.write_bytes;
                 old_process.gpu_usage_stats_last = old_process.data.gpu_usage_stats.clone();
+                old_process.npu_usage_stats_last = old_process.data.npu_usage_stats.clone();
 
                 old_process.data = process_data.clone();
             } else {

src/utils/gpu/nvidia.rs

@@ -10,20 +10,16 @@ use process_data::GpuIdentifier;
 use std::{path::PathBuf, sync::LazyLock};
 
 static NVML: LazyLock<Result<Nvml, NvmlError>> = LazyLock::new(|| {
-    let nvml = Nvml::init();
-
-    if let Err(error) = nvml.as_ref() {
-        warn!("Connection to NVML failed, reason: {error}");
-        if *IS_FLATPAK {
-            warn!("This can occur when the version of the NVIDIA Flatpak runtime (org.freedesktop.Platform.GL.nvidia) \
-            and the version of the natively installed NVIDIA driver do not match. Consider updating both your system \
-            and Flatpak packages before opening an issue.")
-        }
-    } else {
-        debug!("Successfully connected to NVML");
-    }
-
-    nvml
+    Nvml::init()
+        .inspect_err(|err| {
+            warn!("Unable to connect to NVML: {err}"); 
+            if *IS_FLATPAK {
+                warn!("This can occur when the version of the NVIDIA Flatpak runtime \
+                (org.freedesktop.Platform.GL.nvidia) and the version of the natively installed NVIDIA driver do not \
+                match. Consider updating both your system and Flatpak packages before opening an issue.");
+            }
+        })
+        .inspect(|_| debug!("Successfully connected to NVML"))
 });
 
 use crate::utils::{pci::Device, IS_FLATPAK};

src/utils/npu/amd.rs

@@ -0,0 +1,98 @@
+use anyhow::Result;
+use process_data::pci_slot::PciSlot;
+
+use std::path::PathBuf;
+
+use crate::utils::pci::Device;
+
+use super::NpuImpl;
+
+#[derive(Debug, Clone, Default)]
+
+pub struct AmdNpu {
+    pub device: Option<&'static Device>,
+    pub pci_slot: PciSlot,
+    pub driver: String,
+    sysfs_path: PathBuf,
+    first_hwmon_path: Option<PathBuf>,
+}
+
+impl AmdNpu {
+    pub fn new(
+        device: Option<&'static Device>,
+        pci_slot: PciSlot,
+        driver: String,
+        sysfs_path: PathBuf,
+        first_hwmon_path: Option<PathBuf>,
+    ) -> Self {
+        Self {
+            device,
+            pci_slot,
+            driver,
+            sysfs_path,
+            first_hwmon_path,
+        }
+    }
+}
+
+impl NpuImpl for AmdNpu {
+    fn device(&self) -> Option<&'static Device> {
+        self.device
+    }
+
+    fn pci_slot(&self) -> PciSlot {
+        self.pci_slot
+    }
+
+    fn driver(&self) -> String {
+        self.driver.clone()
+    }
+
+    fn sysfs_path(&self) -> PathBuf {
+        self.sysfs_path.clone()
+    }
+
+    fn first_hwmon(&self) -> Option<PathBuf> {
+        self.first_hwmon_path.clone()
+    }
+
+    fn name(&self) -> Result<String> {
+        self.drm_name()
+    }
+
+    fn usage(&self) -> Result<f64> {
+        self.drm_usage().map(|usage| usage as f64 / 100.0)
+    }
+
+    fn used_memory(&self) -> Result<usize> {
+        self.drm_used_memory().map(|usage| usage as usize)
+    }
+
+    fn total_memory(&self) -> Result<usize> {
+        self.drm_total_memory().map(|usage| usage as usize)
+    }
+
+    fn temperature(&self) -> Result<f64> {
+        self.hwmon_temperature()
+    }
+
+    fn power_usage(&self) -> Result<f64> {
+        self.hwmon_power_usage()
+    }
+
+    fn core_frequency(&self) -> Result<f64> {
+        self.hwmon_core_frequency()
+    }
+
+    fn memory_frequency(&self) -> Result<f64> {
+        self.hwmon_vram_frequency()
+    }
+
+    fn power_cap(&self) -> Result<f64> {
+        self.hwmon_power_cap()
+    }
+
+    fn power_cap_max(&self) -> Result<f64> {
+        self.hwmon_power_cap_max()
+    }
+}

src/utils/npu/intel.rs

@@ -82,12 +82,12 @@ impl NpuImpl for IntelNpu {
         Ok((delta_busy_time / delta_timestamp) / 1000.0)
     }
 
-    fn used_vram(&self) -> Result<usize> {
-        self.drm_used_vram().map(|usage| usage as usize)
+    fn used_memory(&self) -> Result<usize> {
+        self.drm_used_memory().map(|usage| usage as usize)
     }
 
-    fn total_vram(&self) -> Result<usize> {
-        self.drm_total_vram().map(|usage| usage as usize)
+    fn total_memory(&self) -> Result<usize> {
+        self.drm_total_memory().map(|usage| usage as usize)
     }
 
     fn temperature(&self) -> Result<f64> {