Function oneapi_host 

pub fn oneapi_host() -> Option<OneApiHost>

The host’s Intel oneAPI installation, or None when it is not installed.

Read from the component layout under $ONEAPI_ROOT, falling back to /opt/intel/oneapi. Nothing is linked or executed.

Narrower than it looks: this reports the toolkit, not the GPU runtime. A host running compute through a distro-packaged Level Zero driver with no toolkit installed reports None, because reading that runtime’s version requires linking it rather than reading a file. So Some proves the toolkit is present, while None is the weakest negative of the three probes — it does not rule out a usable Level Zero runtime.

use gpu_probe::OneApiVersion;

if let Some(oneapi) = gpu_probe::oneapi_host()
    && oneapi.version >= OneApiVersion::new(2024, 0, 0)
{
    // pick a oneAPI 2024-or-newer build
}

Examples found in repository

examples/watch.rs (line 85)

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