corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
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)
    }
}