Function cuda_host 

pub fn cuda_host() -> Option<CudaHost>

Host-wide CUDA properties, or None when NVML is unavailable — no NVIDIA driver, the nvidia feature disabled, no device, or a driver reporting values that aren’t usable.

Shares the one process-wide NVML handle with detect, so calling this on a timer does not accumulate resources.

use gpu_probe::ComputeCapability;

if let Some(cuda) = gpu_probe::cuda_host() {
    println!("sm_{}{} on CUDA {}",
        cuda.compute_capability.major,
        cuda.compute_capability.minor,
        cuda.driver_version);

    if cuda.compute_capability >= ComputeCapability::new(8, 0) {
        // pick an Ampere-or-newer build
    }
}

Examples found in repository

examples/watch.rs (line 93)

fn main() {
    let gpus = gpu_probe::detect();

    println!("gpu-probe · {} GPU(s)", gpus.len());
    println!();

    if gpus.is_empty() {
        println!("  no GPUs detected");
    }

    for (index, gpu) in gpus.iter().enumerate() {
        println!("[{index}] {} · {}", gpu.name, gpu.vendor);
        // The artifact-selection target, whichever form this vendor reports:
        // `gfx1013` for ROCm/HIP, `sm_89` for CUDA.
        match gpu.arch_target {
            Some(arch) => println!("     arch   {:>10}", arch.to_string()),
            None => println!("     arch      unavailable"),
        }
        println!("     total  {:>10}", gib(gpu.total_bytes));
        match gpu.used_bytes {
            Some(used) => println!("     used   {:>10}", gib(used)),
            None => println!("     used      unknown"),
        }
        match gpu.free_bytes {
            Some(free) => println!("     free   {:>10}", gib(free)),
            None => println!("     free      unknown"),
        }
        println!("     {}", bar(gpu.used_bytes, gpu.total_bytes));
        println!();
    }

    // Host-wide toolchains, unlike the per-GPU fields above. Every row always
    // prints, including when absent: "we looked and found nothing" is the point
    // of a probe tool, and a lone row for one vendor reads like it describes
    // the GPU above it rather than the host.
    //
    // They are not the same measurement. `cuda` is the driver version from
    // NVML; `rocm` and `oneapi` are userspace installs, because neither AMD nor
    // Intel exposes a driver version anywhere. The architecture each build
    // targets is the per-GPU `arch` row, which needs none of them installed.
    println!("host");
    match gpu_probe::oneapi_host() {
        Some(oneapi) => println!("     oneapi {:>10}", oneapi.version.to_string()),
        None => println!("     oneapi    unavailable"),
    }
    match gpu_probe::rocm_host() {
        Some(rocm) => println!("     rocm   {:>10}", rocm.version.to_string()),
        None => println!("     rocm      unavailable"),
    }
    match gpu_probe::cuda_host() {
        Some(cuda) => println!("     cuda   {:>10}", cuda.driver_version.to_string()),
        None => println!("     cuda      unavailable"),
    }
    match gpu_probe::vulkan_host() {
        Some(vulkan) => println!("     vulkan {:>10}", vulkan.api_version.to_string()),
        None => println!("     vulkan    unavailable"),
    }
}