128 lines
3.6 KiB
Rust
128 lines
3.6 KiB
Rust
use std::fs;
|
|
use std::io::Write;
|
|
|
|
pub struct GpuInfo {
|
|
pub usage: u32,
|
|
pub vram_used_gb: f64,
|
|
pub vram_total_gb: f64,
|
|
pub temp_c: i32,
|
|
pub vendor: &'static str,
|
|
}
|
|
|
|
pub enum GpuBackend {
|
|
Amd {
|
|
card_path: String,
|
|
hwmon_path: Option<String>,
|
|
},
|
|
Nvidia,
|
|
None,
|
|
}
|
|
|
|
pub fn detect_gpu() -> GpuBackend {
|
|
// AMD: look for gpu_busy_percent exposed by the amdgpu driver
|
|
for i in 0..8 {
|
|
let p = format!("/sys/class/drm/card{i}/device/gpu_busy_percent");
|
|
if fs::read_to_string(&p).is_ok() {
|
|
let card = format!("/sys/class/drm/card{i}/device");
|
|
let hwmon = find_amd_hwmon();
|
|
return GpuBackend::Amd {
|
|
card_path: card,
|
|
hwmon_path: hwmon,
|
|
};
|
|
}
|
|
}
|
|
// NVIDIA: probe nvidia-smi
|
|
let nvidia_ok = std::process::Command::new("nvidia-smi")
|
|
.args(["--query-gpu=name", "--format=csv,noheader"])
|
|
.output()
|
|
.map(|o| o.status.success())
|
|
.unwrap_or(false);
|
|
if nvidia_ok {
|
|
return GpuBackend::Nvidia;
|
|
}
|
|
GpuBackend::None
|
|
}
|
|
|
|
fn find_amd_hwmon() -> Option<String> {
|
|
for i in 0..32 {
|
|
let name = format!("/sys/class/hwmon/hwmon{i}/name");
|
|
if fs::read_to_string(&name).ok()?.trim() == "amdgpu" {
|
|
return Some(format!("/sys/class/hwmon/hwmon{i}"));
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn read_amd(card: &str, hwmon: &Option<String>) -> Option<GpuInfo> {
|
|
let usage: u32 = fs::read_to_string(format!("{card}/gpu_busy_percent"))
|
|
.ok()?
|
|
.trim()
|
|
.parse()
|
|
.ok()?;
|
|
let vram_used: u64 = fs::read_to_string(format!("{card}/mem_info_vram_used"))
|
|
.ok()?
|
|
.trim()
|
|
.parse()
|
|
.ok()?;
|
|
let vram_total: u64 = fs::read_to_string(format!("{card}/mem_info_vram_total"))
|
|
.ok()?
|
|
.trim()
|
|
.parse()
|
|
.ok()?;
|
|
let temp_c = hwmon
|
|
.as_ref()
|
|
.and_then(|h| fs::read_to_string(format!("{h}/temp1_input")).ok())
|
|
.and_then(|s| s.trim().parse::<i32>().ok())
|
|
.map(|mc| mc / 1000)
|
|
.unwrap_or(0);
|
|
Some(GpuInfo {
|
|
usage,
|
|
vram_used_gb: vram_used as f64 / 1_073_741_824.0,
|
|
vram_total_gb: vram_total as f64 / 1_073_741_824.0,
|
|
temp_c,
|
|
vendor: "amd",
|
|
})
|
|
}
|
|
|
|
fn read_nvidia() -> Option<GpuInfo> {
|
|
let out = std::process::Command::new("nvidia-smi")
|
|
.args([
|
|
"--query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu",
|
|
"--format=csv,noheader,nounits",
|
|
])
|
|
.output()
|
|
.ok()?;
|
|
if !out.status.success() {
|
|
return None;
|
|
}
|
|
let s = String::from_utf8_lossy(&out.stdout);
|
|
let p: Vec<&str> = s.trim().split(',').map(str::trim).collect();
|
|
if p.len() < 4 {
|
|
return None;
|
|
}
|
|
Some(GpuInfo {
|
|
usage: p[0].parse().ok()?,
|
|
vram_used_gb: p[1].parse::<f64>().ok()? / 1024.0,
|
|
vram_total_gb: p[2].parse::<f64>().ok()? / 1024.0,
|
|
temp_c: p[3].parse().ok()?,
|
|
vendor: "nvidia",
|
|
})
|
|
}
|
|
|
|
pub fn emit_gpu(out: &mut impl Write, backend: &GpuBackend) {
|
|
let info = match backend {
|
|
GpuBackend::Amd {
|
|
card_path,
|
|
hwmon_path,
|
|
} => read_amd(card_path, hwmon_path),
|
|
GpuBackend::Nvidia => read_nvidia(),
|
|
GpuBackend::None => return,
|
|
};
|
|
if let Some(g) = info {
|
|
let _ = writeln!(
|
|
out,
|
|
"{{\"type\":\"gpu\",\"usage\":{},\"vram_used_gb\":{:.3},\"vram_total_gb\":{:.3},\"temp_c\":{},\"vendor\":\"{}\"}}",
|
|
g.usage, g.vram_used_gb, g.vram_total_gb, g.temp_c, g.vendor
|
|
);
|
|
}
|
|
}
|