ceos/unsloth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Keep probing for nvidia-smi after an unusable one on PATH

Browse source 
_has_usable_nvidia_gpu gated its Windows fixed-location fallback on the
PATH lookup missing, not on the GPU check failing. A stale or driverless
nvidia-smi exits non-zero listing nothing, so the search stopped there
and the function reported no NVIDIA GPU even with a working driver
binary under NVSMI or System32.

That answer routes a mixed AMD iGPU plus NVIDIA dGPU Windows host into
_ensure_rocm_torch() and replaces its CUDA stack with ROCm wheels.

install.ps1 and studio/setup.ps1 already do the right thing: both call
Test-NvidiaSmiHasGpu on the PATH result and fall through to the two fixed
paths when it fails, with the same reasoning recorded at install.ps1:1708
("a stale/driverless nvidia-smi can exit 0 while listing no GPU"). This
brings the Python helper to the same rule: collect the candidates, then
take the first that lists a GPU.

Reproduced with real stub executables through the real subprocess call,
before and after:

    PATH exe   fixed-location exe   before   after
    absent     working              True     True
    stale      working              False    True
    working    -                    True     True
    none       none                 False    False

Only the stale row changes. An AMD-only host with a leftover nvidia-smi
still gets False, so it is not denied the ROCm wheels.

tests/studio/install/test_nvidia_smi_candidate_probing.py pins all four
rows plus the CUDA_VISIBLE_DEVICES cases: 1 failed / 8 passed before,
9 passed after.
This commit is contained in:
Daniel Han 2026-07-27 23:17:58 +00:00
commit 10bc8aa538
2 changed files with 151 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

52
studio/install_python_stack.py
View file

@ -1175,9 +1175,32 @@ def _has_usable_nvidia_gpu() -> bool:
cvd = os.environ.get("CUDA_VISIBLE_DEVICES")
if cvd is not None and cvd.strip() in ("", "-1"):
return False
exe = shutil.which("nvidia-smi")
if not exe and IS_WINDOWS:
for _candidate in (
def _lists_a_gpu(exe: str) -> bool:
try:
result = subprocess.run(
[exe, "-L"],
stdout = subprocess.PIPE,
stderr = subprocess.DEVNULL,
text = True,
timeout = 10,
)
except Exception:
return False
return result.returncode == 0 and "GPU " in result.stdout
# Try every candidate until one lists a GPU, rather than committing to the
# first executable found. A stale or driverless nvidia-smi on PATH exits
# non-zero listing nothing; stopping there would report the host as
# NVIDIA-free and route it into _ensure_rocm_torch() even though a working
# driver binary sits at a fixed location. install.ps1 and setup.ps1 both
# gate their fallback on the GPU check failing, not on the PATH lookup
# missing, so mirror that.
candidates = []
_path_exe = shutil.which("nvidia-smi")
if _path_exe:
candidates.append(_path_exe)
if IS_WINDOWS:
candidates.extend((
os.path.join(
os.environ.get("ProgramFiles", r"C:\Program Files"),
"NVIDIA Corporation",
@ -1189,23 +1212,12 @@ def _has_usable_nvidia_gpu() -> bool:
"System32",
"nvidia-smi.exe",
),
):
if os.path.isfile(_candidate):
exe = _candidate
break
if exe:
try:
result = subprocess.run(
[exe, "-L"],
stdout = subprocess.PIPE,
stderr = subprocess.DEVNULL,
text = True,
timeout = 10,
)
if result.returncode == 0 and "GPU " in result.stdout:
return True
except Exception:
pass
))
for _candidate in candidates:
if _candidate != _path_exe and not os.path.isfile(_candidate):
continue
if _lists_a_gpu(_candidate):
return True
# Fallback: the NVIDIA driver exposes one subdirectory per GPU under
# /proc/driver/nvidia/gpus/ on Linux regardless of nvidia-smi state.
if sys.platform != "win32":

119
tests/studio/install/test_nvidia_smi_candidate_probing.py Normal file
View file

@ -0,0 +1,119 @@
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
"""_has_usable_nvidia_gpu must keep probing after an unusable nvidia-smi.
A stale or driverless nvidia-smi on PATH exits non-zero and lists no GPU.
Treating the first executable found as the answer reports a mixed AMD+NVIDIA
Windows host as NVIDIA-free, which routes it into _ensure_rocm_torch() and
replaces a working CUDA stack with ROCm wheels. install.ps1 and setup.ps1 both
gate their fixed-location fallback on the GPU check failing rather than on the
PATH lookup missing; this pins the Python helper to the same rule.
The stubs are real executables run through the real subprocess call, so the
test exercises the actual control flow rather than a mocked return value.
"""
import importlib.util
import os
import pathlib
import sys
import types
import pytest
_REPO_ROOT = pathlib.Path(__file__).resolve().parents[3]
_STUDIO = _REPO_ROOT / "studio"
_SRC = _STUDIO / "install_python_stack.py"
_STALE = 'echo "No devices were found"; exit 9'
_WORKING = 'echo "GPU 0: NVIDIA H100 (UUID: GPU-abc)"; exit 0'
def _load_module():
# install_python_stack imports backend.utils.wheel_utils, which resolves
# only with studio/ on sys.path. That is how the installer invokes it.
if str(_STUDIO) not in sys.path:
sys.path.insert(0, str(_STUDIO))
spec = importlib.util.spec_from_file_location("_ips_probe_under_test", _SRC)
module = importlib.util.module_from_spec(spec)
sys.modules["_ips_probe_under_test"] = module
spec.loader.exec_module(module)
return module
def _write_stub(path: pathlib.Path, body: str) -> None:
path.parent.mkdir(parents = True, exist_ok = True)
# Not /usr/bin/env: PATH is narrowed to the stub directory below, so env
# would not find an interpreter.
path.write_text("#!/bin/bash\n" + body + "\n")
path.chmod(0o755)
@pytest.fixture
def probe(tmp_path, monkeypatch):
"""Run _has_usable_nvidia_gpu as if on Windows, with stubbed nvidia-smi."""
def _run(
path_smi: str | None,
fixed_smi: str | None,
cuda_visible_devices: str | None = None,
) -> bool:
path_dir = tmp_path / "pathbin"
path_dir.mkdir(exist_ok = True)
if path_smi is not None:
_write_stub(path_dir / "nvidia-smi", path_smi)
program_files = tmp_path / "ProgramFiles"
if fixed_smi is not None:
_write_stub(
program_files / "NVIDIA Corporation" / "NVSMI" / "nvidia-smi.exe",
fixed_smi,
)
monkeypatch.setenv("PATH", str(path_dir))
monkeypatch.setenv("ProgramFiles", str(program_files))
monkeypatch.setenv("SystemRoot", str(tmp_path / "Windows"))
if cuda_visible_devices is None:
monkeypatch.delenv("CUDA_VISIBLE_DEVICES", raising = False)
else:
monkeypatch.setenv("CUDA_VISIBLE_DEVICES", cuda_visible_devices)
module = _load_module()
monkeypatch.setattr(module, "IS_WINDOWS", True)
# A real NVIDIA host has /proc/driver/nvidia/gpus, and the helper's
# Linux-only fallback would then answer True for every case and mask
# what the Windows path did. Present as win32 to isolate it.
monkeypatch.setattr(module, "sys", types.SimpleNamespace(platform = "win32"))
return module._has_usable_nvidia_gpu()
return _run
def test_stale_path_nvidia_smi_still_reaches_the_fixed_locations(probe):
# The regression: a driverless nvidia-smi on PATH used to end the search.
assert probe(_STALE, _WORKING) is True
def test_absent_path_nvidia_smi_reaches_the_fixed_locations(probe):
assert probe(None, _WORKING) is True
def test_working_path_nvidia_smi_is_enough(probe):
assert probe(_WORKING, None) is True
def test_no_nvidia_smi_anywhere_reports_no_gpu(probe):
assert probe(None, None) is False
def test_stale_everywhere_reports_no_gpu(probe):
# Every candidate answering "no GPU" must stay False, or an AMD-only host
# with a leftover nvidia-smi would be denied the ROCm wheels.
assert probe(_STALE, _STALE) is False
@pytest.mark.parametrize("hidden", ["", "-1", " "])
def test_cuda_visible_devices_hidden_wins_over_a_working_probe(probe, hidden):
assert probe(_WORKING, _WORKING, cuda_visible_devices = hidden) is False
def test_cuda_visible_devices_listing_a_device_does_not_block_detection(probe):
assert probe(_WORKING, None, cuda_visible_devices = "0") is True