Problem / Background

all-smi exposes its device readers as an in-process Rust library (the all_smi crate). Consumers call get_gpu_info() as their single source of truth for host GPU detection — for example, to recommend the optimal inference accelerator.

Inspecting src/device/readers/ in 0.21.0, the available readers cover:

• NVIDIA — nvidia.rs (NVML), plus nvidia_hardware.rs, nvidia_jetson.rs, nvidia_mig.rs, nvidia_vgpu.rs
• AMD — amd.rs, amd_windows.rs
• Apple Silicon — apple_silicon_native.rs
• NPUs / TPUs — gaudi.rs, furiosa.rs, rebellions.rs, tenstorrent.rs, google_tpu.rs, tpu_*.rs

There is no reader for Intel client GPUs — neither discrete Intel Arc (A-series / B-series "Battlemage") nor integrated graphics (Iris Xe, Xe-LPG, Arc iGPU on Core Ultra). The only "Intel" device covered today is Gaudi, which is a datacenter HPU enumerated via hl-smi and is unrelated to client GPUs.

As a result, on an Intel-GPU host get_gpu_info() returns no GPU. This blocks any consumer that relies on all-smi as its sole GPU-detection source: Intel client GPUs are the target for the SYCL / oneAPI inference backend (e.g. the llama.cpp SYCL build), so a host with an Intel Arc/Iris/Xe GPU is mis-detected as having no GPU and inference falls back to CPU.

Related: #73 ("feat: add Intel Arc and Arc Pro GPU support") already requests discrete Arc / Arc Pro (A-series) detection. This issue overlaps with it but extends the scope in three ways that #73 does not cover, and reframes the motivation around library-level get_gpu_info() detection:

1. Integrated graphics (Iris Xe, Xe-LPG, Arc iGPU on Core Ultra) — a distinct enumeration/metrics surface (shared memory, no dedicated VRAM, different sysfs paths) vs. discrete Arc.
2. Newer discrete Arc B-series "Battlemage", not just the A-series listed in feat: add Intel Arc and Arc Pro GPU support #73.
3. The library-consumer angle: get_gpu_info() returning nothing on Intel hosts, which breaks SYCL/oneAPI accelerator selection downstream.

Maintainers may prefer to fold this into #73 or treat it as the iGPU + Battlemage + library-detection complement. Cross-linking for triage.

Proposed Solution

Add a new device reader that enumerates Intel client GPUs on Windows and Linux:

• Discrete: Intel Arc A-series and B-series ("Battlemage")
• Integrated: Iris Xe, Xe-LPG, and Arc iGPU on Core Ultra

The reader must implement the existing GpuReader trait and populate the existing GpuInfo struct so that current consumers work unchanged. At minimum it should report:

• Device name
• Total / used memory (dedicated VRAM for discrete; shared/system memory for integrated)
• Utilization
• Temperature where available

Requirements:

• Vendor must be classifiable as Intel, and device_type set appropriately (e.g. "gpu").
• The reader must be feature/platform-gated so non-Intel hosts and other operating systems are unaffected and the crate still compiles cleanly — matching the gating pattern of the existing readers.
• Add a mock template under src/mock/templates/ and unit tests consistent with the existing readers.

Suggested Implementation Directions

(Non-binding guidance — implementer's discretion.)

Linux

• Intel Level Zero (libze_intel_gpu / ze_* API) for compute-capable enumeration and metrics.
• And/or sysfs /sys/class/drm/card*/device with the i915 / xe kernel driver for enumeration, plus intel_gpu_top (perf / i915 PMU) for utilization.
• For datacenter Flex / Max, xpu-smi / XPU Manager.

Windows

• DXGI / SetupAPI / WMI (Win32_VideoController) for enumeration — see src/device/readers/amd_windows.rs for the existing WMI pattern.
• Level Zero for compute metrics.
• PDH / D3DKMT for utilization.

Reference readers to mirror

• src/device/readers/nvidia.rs — NVML library pattern.
• src/device/readers/amd_windows.rs — Windows WMI pattern.

Acceptance Criteria

• Intel discrete (Arc A-series / B-series) and integrated (Iris Xe / Xe-LPG / Arc iGPU) GPUs are enumerated by get_gpu_info() on Windows and Linux.
• Reported GpuInfo carries a usable name and memory, and vendor resolves to Intel with an appropriate device_type.
• Reader is gated so it is a no-op and compiles cleanly on platforms and hosts without Intel GPUs.
• Mock template + unit tests added following existing reader conventions.

Technical Considerations

• Discrete vs. integrated differ materially: integrated GPUs report shared/system memory rather than dedicated VRAM, and their sysfs/driver enumeration paths differ from discrete cards. The reader should handle both without conflating their memory semantics.
• Keep GpuInfo semantics identical to existing vendors so downstream consumers (e.g. accelerator auto-resolution) need no changes.