use std::path::PathBuf;
use std::process::Command;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, OnceLock};
use crate::error::Error;
#[derive(Debug, Clone)]
pub struct GpuInfo {
pub present: bool,
pub name: String,
pub driver: String,
pub free_bytes: Option<u64>,
pub total_bytes: Option<u64>,
pub count: u32,
pub toolkit: bool,
pub nvcc: Option<String>,
pub cc: Option<String>,
}
struct SmiReading {
present: bool,
name: String,
driver: String,
free_bytes: Option<u64>,
total_bytes: Option<u64>,
count: u32,
}
impl SmiReading {
fn absent() -> Self {
Self {
present: false,
name: String::new(),
driver: String::new(),
free_bytes: None,
total_bytes: None,
count: 0,
}
}
}
pub fn probe_checked(device: u32) -> Result<GpuInfo, Error> {
let info = probe(device);
if let Some(err) = crate::signal::shutdown_error() {
return Err(err);
}
Ok(info)
}
pub fn probe(device: u32) -> GpuInfo {
let toolkit = which::which("nvcc").ok();
let cc = which::which("cc")
.ok()
.or_else(|| which::which("cl").ok())
.or_else(|| which::which("gcc").ok());
let smi = query_smi(device);
GpuInfo {
present: smi.present,
name: smi.name,
driver: smi.driver,
free_bytes: smi.free_bytes,
total_bytes: smi.total_bytes,
count: smi.count,
toolkit: toolkit.is_some(),
nvcc: toolkit.map(|p| p.display().to_string()),
cc: cc.map(|p| p.display().to_string()),
}
}
const DEFAULT_PROBE_POLL_MS: u64 = 25;
static PROBE_POLL_MS: AtomicU64 = AtomicU64::new(DEFAULT_PROBE_POLL_MS);
pub fn publish_probe_poll_ms(ms: u64) {
PROBE_POLL_MS.store(ms, Ordering::SeqCst);
}
fn probe_poll() -> std::time::Duration {
let ms = PROBE_POLL_MS.load(Ordering::SeqCst);
std::time::Duration::from_millis(if ms == 0 { DEFAULT_PROBE_POLL_MS } else { ms })
}
static SMI_PATH: OnceLock<String> = OnceLock::new();
pub fn publish_nvidia_smi_path(path: String) {
let _ = SMI_PATH.set(path);
}
fn run_probe(mut cmd: Command) -> std::io::Result<std::process::Output> {
let (id, child) = crate::signal::spawn_tracked(&mut cmd)?;
loop {
let finished = {
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
guard.try_wait()?.is_some()
};
if finished {
break;
}
if crate::signal::is_shutdown_requested() || crate::signal::deadline_exceeded() {
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
crate::signal::kill_child_tree(&mut guard);
crate::signal::release_child(id);
return Err(std::io::Error::other("probe interrupted"));
}
std::thread::sleep(probe_poll());
}
crate::signal::release_child(id);
let child = Arc::try_unwrap(child)
.map_err(|_| std::io::Error::other("probe handle still shared"))?
.into_inner()
.unwrap_or_else(|e| e.into_inner());
child.wait_with_output()
}
fn query_smi(device: u32) -> SmiReading {
let configured = SMI_PATH
.get()
.map(String::as_str)
.unwrap_or_default()
.trim();
let bin = if configured.is_empty() {
let Ok(found) = which::which("nvidia-smi") else {
return SmiReading::absent();
};
found
} else {
PathBuf::from(configured)
};
let mut cmd = Command::new(&bin);
cmd.args([
"--query-gpu=name,driver_version,memory.free,memory.total",
"--format=csv,noheader,nounits",
])
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null());
let Ok(out) = run_probe(cmd) else {
return SmiReading::absent();
};
if !out.status.success() {
return SmiReading::absent();
}
let text = String::from_utf8_lossy(&out.stdout);
let lines: Vec<&str> = text.lines().filter(|l| !l.trim().is_empty()).collect();
let count = lines.len() as u32;
if count == 0 {
return SmiReading::absent();
}
let idx = (device as usize).min(lines.len() - 1);
let parts: Vec<&str> = lines[idx].split(',').map(str::trim).collect();
if parts.len() < 4 {
return SmiReading {
present: true,
name: lines[idx].to_string(),
driver: String::new(),
free_bytes: None,
total_bytes: None,
count,
};
}
SmiReading {
present: true,
name: parts[0].to_string(),
driver: parts[1].to_string(),
free_bytes: mib_to_bytes(parts[2]),
total_bytes: mib_to_bytes(parts[3]),
count,
}
}
fn mib_to_bytes(raw: &str) -> Option<u64> {
raw.parse::<u64>().ok().map(|mib| mib * 1024 * 1024)
}
pub fn ensure_vram(info: &GpuInfo, need_bytes: u64, concurrency: usize) -> Result<(), Error> {
if !info.present {
return Err(Error::GpuMissing);
}
let Some(free) = info.free_bytes else {
return Err(Error::VramUnknown);
};
let need = need_bytes.saturating_mul(concurrency.max(1) as u64);
if need > free {
return Err(Error::VramInsufficient {
need_bytes: need,
have_bytes: free,
});
}
Ok(())
}
pub fn suggest_model(
free_bytes: Option<u64>,
catalog: &[crate::catalog::ModelEntry],
) -> Option<&str> {
let free = free_bytes?;
catalog
.iter()
.rev()
.find(|m| m.vram_bytes <= free)
.map(|m| m.name.as_str())
}
pub fn ensure_device(info: &GpuInfo, device: u32) -> Result<(), Error> {
if !info.present {
return Err(Error::GpuMissing);
}
if device >= info.count {
return Err(Error::UnknownDevice(device.to_string()));
}
Ok(())
}
pub fn process_rss_bytes() -> Option<u64> {
#[cfg(target_os = "linux")]
{
let raw = std::fs::read_to_string("/proc/self/statm").ok()?;
let pages: u64 = raw.split_whitespace().nth(1)?.parse().ok()?;
let page = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
if page <= 0 {
return None;
}
Some(pages.saturating_mul(page as u64))
}
#[cfg(windows)]
{
use windows_sys::Win32::System::ProcessStatus::{
GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS,
};
use windows_sys::Win32::System::Threading::GetCurrentProcess;
let mut counters = PROCESS_MEMORY_COUNTERS {
cb: std::mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32,
..unsafe { std::mem::zeroed() }
};
let ok = unsafe {
GetProcessMemoryInfo(
GetCurrentProcess(),
&raw mut counters,
std::mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32,
)
};
if ok == 0 {
return None;
}
Some(counters.WorkingSetSize as u64)
}
#[cfg(not(any(target_os = "linux", windows)))]
{
None
}
}
pub fn memory_cap_is_measurable() -> bool {
cfg!(any(target_os = "linux", windows))
}
pub fn memory_cap_source() -> &'static str {
if cfg!(target_os = "linux") {
"procfs"
} else if cfg!(windows) {
"GetProcessMemoryInfo"
} else {
"none"
}
}
pub fn ensure_process_memory(max_bytes: u64) -> Result<(), Error> {
if max_bytes == 0 {
return Ok(());
}
let Some(rss) = process_rss_bytes() else {
return Ok(());
};
if rss > max_bytes {
return Err(Error::MemoryCap);
}
Ok(())
}
static MEMORY_CAP: AtomicU64 = AtomicU64::new(0);
pub fn publish_memory_cap(bytes: u64) {
MEMORY_CAP.store(bytes, Ordering::SeqCst);
}
pub fn memory_cap_exceeded() -> bool {
let cap = MEMORY_CAP.load(Ordering::SeqCst);
if cap == 0 {
return false;
}
process_rss_bytes().is_some_and(|rss| rss > cap)
}
pub fn ensure_headroom(bytes: u64) -> Result<(), Error> {
let cap = MEMORY_CAP.load(Ordering::SeqCst);
if cap == 0 {
return Ok(());
}
let Some(rss) = process_rss_bytes() else {
return Ok(());
};
if rss.saturating_add(bytes) > cap {
return Err(Error::MemoryCap);
}
Ok(())
}
pub fn warn_ignored_cuda_env(ui: crate::i18n::UiLang) {
if std::env::var_os("CUDA_VISIBLE_DEVICES").is_some() {
std::env::remove_var("CUDA_VISIBLE_DEVICES");
eprintln!("{}", crate::i18n::tr(ui, "warn_cuda_env"));
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::catalog::Catalog;
fn info(present: bool, free: Option<u64>, count: u32) -> GpuInfo {
GpuInfo {
present,
name: "test".into(),
driver: "0".into(),
free_bytes: free,
total_bytes: free,
count,
toolkit: true,
nvcc: None,
cc: None,
}
}
#[test]
fn suggest_picks_largest_that_fits() {
let c = Catalog::seeds("https://example.invalid/x");
let name = suggest_model(Some(1300 * 1024 * 1024), &c.models).expect("fits");
assert_eq!(name, "small");
}
#[test]
fn unknown_free_does_not_suggest_largest() {
let c = Catalog::seeds("https://example.invalid/x");
assert_eq!(suggest_model(None, &c.models), None);
}
#[test]
fn unknown_free_does_not_skip_gate() {
let err = ensure_vram(&info(true, None, 1), 1024, 1).expect_err("must refuse");
assert!(matches!(err, Error::VramUnknown));
assert_eq!(err.exit_code(), 70);
}
#[test]
fn tiny_card_refuses_large_batch() {
let one_gib = 1024 * 1024 * 1024;
assert!(ensure_vram(&info(true, Some(one_gib), 1), one_gib / 2, 1).is_ok());
let err = ensure_vram(&info(true, Some(one_gib), 1), one_gib / 2, 8)
.expect_err("batch must not fit");
assert_eq!(err.exit_code(), 70);
}
#[test]
fn missing_card_is_gpu_missing() {
assert!(matches!(
ensure_vram(&info(false, None, 0), 1, 1),
Err(Error::GpuMissing)
));
}
#[test]
fn device_past_the_end_is_unknown_device() {
assert!(ensure_device(&info(true, Some(1), 1), 0).is_ok());
let err = ensure_device(&info(true, Some(1), 1), 3).expect_err("must refuse");
assert!(matches!(err, Error::UnknownDevice(_)));
assert_eq!(err.exit_code(), 78);
}
}