Function rocm_host 

pub fn rocm_host() -> Option<RocmHost>

The host’s ROCm installation, or None when ROCm is not installed.

Read from $ROCM_PATH/.info/version, falling back to /opt/rocm — the plain text file the rocm-core package writes. Nothing is linked or executed, so this costs one file read.

Some is the signal that ROCm is installed and the host can run its builds. None is weaker: the install was not found at the prefixes above, which a distro shipping ROCm into /usr — or a container carrying only the runtime libraries — will trigger despite working. Treat Some as proof and None as “probably not, worth confirming”.

None does not mean the GPU is unusable for compute: the kernel side is a separate component, and what a build has to target is GpuInfo::arch_target, reported with no ROCm installed at all.

use gpu_probe::RocmVersion;

if let Some(rocm) = gpu_probe::rocm_host()
    && rocm.version >= RocmVersion::new(6, 0, 0)
{
    // pick a `ROCm` 6 build
}

Examples found in repository

examples/watch.rs (line 89)

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"),
    }
}