Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio installer (Windows AMD): treat hipinfo output as already mask-filtered when picking the gfx target (#13925)

Daniel Han9c4fd2f02b97
diff --git a/studio/install_llama_prebuilt.py b/studio/install_llama_prebuilt.py
index 0f7acf7658b..462b030a2e0 100644
--- a/studio/install_llama_prebuilt.py
+++ b/studio/install_llama_prebuilt.py
@@ -2776,7 +2776,11 @@ def _list_rocm_gfx_targets(out: str) -> list[str]:
return _tokens
-def _pick_rocm_gfx_target(out: str, rocr_filtered: bool = False) -> str | None:
+def _pick_rocm_gfx_target(
+ out: str,
+ rocr_filtered: bool = False,
+ hip_filtered: bool = False,
+) -> str | None:
"""Choose the gfx target rocminfo / hipinfo report for the active GPU.
A bare first-match picked the wrong device on mixed APU + dGPU hosts (Strix Halo gfx1151
@@ -2789,11 +2793,23 @@ def _pick_rocm_gfx_target(out: str, rocr_filtered: bool = False) -> str | None:
same rule and gfx906 exclusion as _amd_prefer_discrete_gfx in install.sh / studio/setup.sh;
an all-integrated host keeps its own arch. A mask is never second-guessed at ANY value,
including one this cannot resolve: HIP_VISIBLE_DEVICES=N is the #7624 / #7669 workaround.
+
+ hip_filtered: the output came from a HIP application (Windows hipinfo), which HIP_VISIBLE_DEVICES
+ / CUDA_VISIBLE_DEVICES already filtered and renumbered, so the selected device is survivor 0.
"""
_tokens = _list_rocm_gfx_targets(out)
if not _tokens:
return None
+ # hipinfo is already filtered by HIP_VISIBLE_DEVICES / CUDA_VISIBLE_DEVICES (never ROCR on
+ # Windows): with either set, the selected device is survivor 0.
+ if hip_filtered:
+ _hip_vis = os.environ.get("HIP_VISIBLE_DEVICES")
+ if _hip_vis is None:
+ _hip_vis = os.environ.get("CUDA_VISIBLE_DEVICES")
+ if _hip_vis is not None:
+ return None if _hip_vis.strip() in ("", "-1") else _tokens[0]
+
_vis_raw = None
# rocminfo output is already ROCr-filtered and renumbered: only HIP-layer masks index it.
_masks = (
@@ -3171,7 +3187,9 @@ def detect_host(*, probe_rocm_with_nvidia: bool = False) -> HostInfo:
has_rocm = True
# hipinfo reports "gcnArchName: gfx1100" -- extract if present
rocm_gfx_targets = _list_rocm_gfx_targets(_result.stdout)
- rocm_gfx_target = _pick_rocm_gfx_target(_result.stdout)
+ rocm_gfx_target = _pick_rocm_gfx_target(
+ _result.stdout, hip_filtered = _cmd[0] == "hipinfo"
+ )
break
# Note: amdhip64.dll presence alone is NOT treated as GPU evidence
# since the HIP SDK can be installed without an AMD GPU.
diff --git a/tests/studio/install/test_windows_hipinfo_mask_survivor.py b/tests/studio/install/test_windows_hipinfo_mask_survivor.py
new file mode 100644
index 00000000000..2fc853642cb
--- /dev/null
+++ b/tests/studio/install/test_windows_hipinfo_mask_survivor.py
@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+"""Windows hipinfo is a HIP application, so HIP_VISIBLE_DEVICES / CUDA_VISIBLE_DEVICES have
+already filtered and renumbered what it lists. Indexing that list with the mask again picked
+the wrong card: three AMD GPUs with HIP_VISIBLE_DEVICES=1,2 list two devices, and index 1
+named physical GPU 2 instead of GPU 1. amd-smi is not filtered and keeps the mask index."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[3]
+MODULE_PATH = PACKAGE_ROOT / "studio" / "install_llama_prebuilt.py"
+MODULE_NAME = "studio_install_llama_prebuilt"
+if MODULE_NAME in sys.modules:
+ m = sys.modules[MODULE_NAME]
+else:
+ SPEC = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)
+ assert SPEC is not None and SPEC.loader is not None
+ m = importlib.util.module_from_spec(SPEC)
+ sys.modules[MODULE_NAME] = m
+ SPEC.loader.exec_module(m)
+
+PHYSICAL = ["gfx1036", "gfx1201", "gfx1100"]
+
+
+def hipinfo_listing(archs):
+ return "".join(
+ f"device# {i}\nName: AMD GPU\ngcnArchName: {arch}\n"
+ for i, arch in enumerate(archs)
+ )
+
+
+def amd_smi_listing(archs):
+ return "".join(
+ f"GPU: {i}\n TARGET_GRAPHICS_VERSION: {arch}\n" for i, arch in enumerate(archs)
+ )
+
+
+def detect(monkeypatch, probe, stdout, env):
+ monkeypatch.setattr(m.platform, "system", lambda: "Windows")
+ monkeypatch.setattr(m.platform, "machine", lambda: "AMD64")
+ for var in (
+ "CUDA_VISIBLE_DEVICES",
+ "HIP_VISIBLE_DEVICES",
+ "ROCR_VISIBLE_DEVICES",
+ "HIP_PATH",
+ "ROCM_PATH",
+ "UNSLOTH_ENABLE_AMD_SMI",
+ "UNSLOTH_ROCM_GFX_ARCH",
+ ):
+ monkeypatch.delenv(var, raising = False)
+ for var, value in env.items():
+ monkeypatch.setenv(var, value)
+ if probe == "amd-smi":
+ monkeypatch.setenv("UNSLOTH_ENABLE_AMD_SMI", "1")
+ monkeypatch.setattr(m.shutil, "which", lambda name: name if name == probe else None)
+ monkeypatch.setattr(m, "nvidia_library_inventory", lambda *a, **k: None)
+
+ def fake_run_capture(command, **kwargs):
+ if command[0] == probe:
+ return SimpleNamespace(returncode = 0, stdout = stdout, stderr = "")
+ return SimpleNamespace(returncode = 1, stdout = "", stderr = "")
+
+ monkeypatch.setattr(m, "run_capture", fake_run_capture)
+ return m.detect_host()
+
+
+ "env",
+ [{"HIP_VISIBLE_DEVICES": "1,2"}, {"CUDA_VISIBLE_DEVICES": "1,2"}],
+)
+def test_hipinfo_under_a_mask_picks_the_first_listed_device(monkeypatch, env):
+ host = detect(monkeypatch, "hipinfo", hipinfo_listing(PHYSICAL[1:]), env)
+ assert host.has_rocm
+ assert host.rocm_gfx_targets == ["gfx1201", "gfx1100"]
+ assert host.rocm_gfx_target == "gfx1201"
+ # setup.ps1 forwards the same card, so the probe and the forward now agree.
+ routed = m._apply_host_overrides(host, override_rocm_gfx = "gfx1201")
+ assert m._active_rocm_gfx_target(routed) == "gfx1201"
+ # A mask still blocks the automatic Vulkan route.
+ assert m._should_auto_vulkan_for_amd_windows(routed) is False
+ # amd-smi lists every physical device, so the mask index still applies there.
+ unfiltered = detect(monkeypatch, "amd-smi", amd_smi_listing(PHYSICAL), env)
+ assert unfiltered.rocm_gfx_target == "gfx1201"
+
+
+def test_hipinfo_keeps_indexing_a_rocr_mask(monkeypatch):
+ # Windows HIP ignores ROCR_VISIBLE_DEVICES, so hipinfo lists every card and the index applies.
+ host = detect(monkeypatch, "hipinfo", hipinfo_listing(PHYSICAL), {"ROCR_VISIBLE_DEVICES": "1"})
+ assert host.rocm_gfx_target == "gfx1201"
+
+
+def test_hipinfo_under_cuda_and_rocr_masks_takes_the_cuda_survivor(monkeypatch):
+ # hipinfo ignores ROCR but CUDA_VISIBLE_DEVICES=2,0 lists physical [2, 0]: survivor 0 is GPU 2.
+ env = {"CUDA_VISIBLE_DEVICES": "2,0", "ROCR_VISIBLE_DEVICES": "1"}
+ host = detect(monkeypatch, "hipinfo", hipinfo_listing([PHYSICAL[2], PHYSICAL[0]]), env)
+ assert host.rocm_gfx_target == "gfx1100"