use std::process::Command;
use std::sync::OnceLock;
use std::time::Duration;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tier {
Datacenter,
Baseline,
Mid,
Low,
Unknown,
}
impl Tier {
pub fn multiplier(self) -> f64 {
match self {
Tier::Datacenter => 2.0,
Tier::Baseline => 1.0,
Tier::Mid => 0.5,
Tier::Low => 0.25,
Tier::Unknown => 1.0,
}
}
pub fn label(self) -> &'static str {
match self {
Tier::Datacenter => "on a datacenter GPU",
Tier::Baseline => "on a 4090-class GPU",
Tier::Mid => "on a mid-range GPU (3080/4070)",
Tier::Low => "on an entry GPU (3060/laptop)",
Tier::Unknown => "on a 4090-class GPU (no local GPU detected)",
}
}
}
pub fn classify(name: &str) -> Tier {
let n = name.to_ascii_lowercase();
if n.contains("laptop") {
return Tier::Low;
}
if n.contains("a100") || n.contains("h100") || n.contains("h200") || n.contains("l40") {
return Tier::Datacenter;
}
if n.contains("4090") || n.contains("4080") || n.contains("3090") {
return Tier::Baseline;
}
if n.contains("3080") || n.contains("3070") || n.contains("4070") {
return Tier::Mid;
}
if n.contains("3060")
|| n.contains("3050")
|| n.contains("2080")
|| n.contains("2070")
|| n.contains("2060")
|| n.contains("4060")
|| n.contains("4050")
{
return Tier::Low;
}
Tier::Unknown
}
fn probe_nvidia_smi() -> Option<String> {
let mut child = Command::new("nvidia-smi")
.args(["--query-gpu=name", "--format=csv,noheader"])
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null())
.spawn()
.ok()?;
let start = std::time::Instant::now();
loop {
if let Some(status) = child.try_wait().ok().flatten() {
if !status.success() {
return None;
}
let output = child.wait_with_output().ok()?;
let s = String::from_utf8_lossy(&output.stdout).trim().to_string();
return if s.is_empty() { None } else { Some(s) };
}
if start.elapsed() > Duration::from_millis(500) {
let _ = child.kill();
return None;
}
std::thread::sleep(Duration::from_millis(20));
}
}
fn cache_path() -> Option<std::path::PathBuf> {
let base = if cfg!(windows) {
std::env::var_os("LOCALAPPDATA").map(std::path::PathBuf::from)
} else {
std::env::var_os("XDG_CACHE_HOME")
.map(std::path::PathBuf::from)
.or_else(|| {
std::env::var_os("HOME").map(|h| std::path::PathBuf::from(h).join(".cache"))
})
}?;
Some(base.join("hashglass").join("gpu"))
}
fn read_cache() -> Option<Tier> {
let path = cache_path()?;
let content = std::fs::read_to_string(&path).ok()?;
let mut lines = content.lines();
let ts: u64 = lines.next()?.parse().ok()?;
let name = lines.next()?;
let age = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.ok()?
.as_secs()
.saturating_sub(ts);
if age > 86_400 {
return None; }
Some(match name {
"Datacenter" => Tier::Datacenter,
"Baseline" => Tier::Baseline,
"Mid" => Tier::Mid,
"Low" => Tier::Low,
"Unknown" => Tier::Unknown,
_ => return None,
})
}
fn write_cache(tier: Tier) {
let Some(path) = cache_path() else {
return;
};
let Some(parent) = path.parent() else {
return;
};
let _ = std::fs::create_dir_all(parent);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let name = match tier {
Tier::Datacenter => "Datacenter",
Tier::Baseline => "Baseline",
Tier::Mid => "Mid",
Tier::Low => "Low",
Tier::Unknown => "Unknown",
};
let _ = std::fs::write(&path, format!("{now}\n{name}\n"));
}
pub fn tier() -> Tier {
static CACHED: OnceLock<Tier> = OnceLock::new();
*CACHED.get_or_init(|| {
if std::env::var_os("HASHGLASS_GPU").as_deref() == Some(std::ffi::OsStr::new("off")) {
return Tier::Unknown;
}
if let Some(t) = read_cache() {
return t;
}
let t = match probe_nvidia_smi() {
Some(out) => classify(out.lines().next().unwrap_or("")),
None => Tier::Unknown,
};
write_cache(t);
t
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_baseline_gpus() {
assert_eq!(classify("NVIDIA GeForce RTX 4090"), Tier::Baseline);
assert_eq!(classify("GeForce RTX 3090 Ti"), Tier::Baseline);
assert_eq!(classify("NVIDIA GeForce RTX 4080 SUPER"), Tier::Baseline);
}
#[test]
fn classify_datacenter_gpus() {
assert_eq!(classify("NVIDIA A100-SXM4-80GB"), Tier::Datacenter);
assert_eq!(classify("NVIDIA H100 PCIe"), Tier::Datacenter);
}
#[test]
fn classify_mid_gpus() {
assert_eq!(classify("NVIDIA GeForce RTX 3080"), Tier::Mid);
assert_eq!(classify("NVIDIA GeForce RTX 4070"), Tier::Mid);
}
#[test]
fn classify_low_and_laptop_gpus() {
assert_eq!(classify("NVIDIA GeForce RTX 3060"), Tier::Low);
assert_eq!(classify("NVIDIA GeForce RTX 4090 Laptop GPU"), Tier::Low);
assert_eq!(classify("NVIDIA GeForce RTX 2080"), Tier::Low);
}
#[test]
fn classify_unknown_gpus() {
assert_eq!(classify(""), Tier::Unknown);
assert_eq!(classify("Intel Iris Xe"), Tier::Unknown);
assert_eq!(classify("some future card"), Tier::Unknown);
}
#[test]
fn multipliers_are_ordered() {
assert!(Tier::Datacenter.multiplier() > Tier::Baseline.multiplier());
assert!(Tier::Baseline.multiplier() > Tier::Mid.multiplier());
assert!(Tier::Mid.multiplier() > Tier::Low.multiplier());
assert_eq!(Tier::Unknown.multiplier(), Tier::Baseline.multiplier());
}
}