use crate::{
collector::gpu::GpuMetricsCollector,
model::gpu::{GpuDevice, GpuMetrics, GpuVendor},
};
use anyhow::Result;
use nvml_wrapper::{Nvml, enum_wrappers::device::TemperatureSensor, enums::device::UsedGpuMemory};
pub struct NvidiaNvmlCollector {
nvml: Option<Nvml>,
}
impl Default for NvidiaNvmlCollector {
fn default() -> Self {
Self::new()
}
}
impl NvidiaNvmlCollector {
pub fn new() -> Self {
Self {
nvml: Nvml::init().ok(),
}
}
}
impl GpuMetricsCollector for NvidiaNvmlCollector {
fn collect(&mut self, devices: &[GpuDevice]) -> Result<Vec<GpuMetrics>> {
let Some(nvml) = &self.nvml else {
return Ok(Vec::new());
};
let nvidia_devices = devices
.iter()
.filter(|device| device.vendor == GpuVendor::Nvidia)
.collect::<Vec<_>>();
let count = nvml.device_count().unwrap_or_default() as usize;
let mut metrics = Vec::with_capacity(count.min(nvidia_devices.len()));
for (index, device_info) in nvidia_devices.into_iter().take(count).enumerate() {
let Ok(device) = nvml.device_by_index(index as u32) else {
continue;
};
let utilization_percent = device.utilization_rates().ok().map(|value| value.gpu);
let memory = device.memory_info().ok();
let temperature_celsius = device.temperature(TemperatureSensor::Gpu).ok();
let power_draw_milliwatts = device.power_usage().ok();
let power_limit_milliwatts = device.enforced_power_limit().ok();
let processes = device
.running_compute_processes()
.unwrap_or_default()
.into_iter()
.map(|process| crate::model::gpu::GpuProcess {
pid: process.pid,
name: String::new(),
used_memory_bytes: match process.used_gpu_memory {
UsedGpuMemory::Used(value) => value,
UsedGpuMemory::Unavailable => 0,
},
})
.collect();
metrics.push(GpuMetrics {
device_key: device_info.card_name.clone(),
name: device.name().ok(),
utilization_percent,
used_memory_bytes: memory.as_ref().map(|value| value.used),
total_memory_bytes: memory.map(|value| value.total),
temperature_celsius,
power_draw_milliwatts,
power_limit_milliwatts,
processes,
});
}
Ok(metrics)
}
}