amd-smi-wsl 0.2.0__tar.gz

amd_smi_wsl-0.2.0/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0] - 2026-06-11
+
+### Fixed
+- **Critical:** infinite recursion / `RecursionError` when used with a real
+  PyTorch ROCm build. torch's ROCm device enumeration resolves the device count
+  *through* `amdsmi` (`amdsmi_init` + `amdsmi_get_processor_handles`), which this
+  package shadows, so `amdsmi_init()` -> backend probe -> `torch.cuda` ->
+  `amdsmi_init()` looped forever. A thread-local re-entrancy guard now makes the
+  re-entrant `amdsmi_init()` raise so torch falls back to its native HIP device
+  count. This was the blocker that prevented the package (and vLLM through it)
+  from working at all on the target WSL2 + torch-ROCm environment.
+- `amdsmi_get_clock_info` / `amdsmi_get_temp_metric` / `amdsmi_get_power_info`
+  could leak `AMDSMI_STATUS_NOT_FOUND` (and risk re-entrancy) when torch routed
+  the sensor query back through amdsmi; they now degrade cleanly to
+  `AMDSMI_STATUS_NOT_SUPPORTED`.
+
+### Changed
+- `amdsmi_get_gpu_asic_info` now returns `device_id`, `vendor_id`,
+  `subvendor_id`, `subsystem_id` and `rev_id` as lowercase, zero-padded hex
+  strings (e.g. `"0x1586"`, `"0xc1"`), matching the upstream contract. This lets
+  vLLM resolve the canonical device name from its hex-keyed
+  `_ROCM_DEVICE_ID_NAME_MAP` (e.g. `AMD_Radeon_8060S`) instead of falling back
+  to the raw marketing string. `amdsmi_get_gpu_subsystem_id` /
+  `amdsmi_get_gpu_revision` likewise return hex strings.
+- `driver_date` from the Windows probe is parsed from the raw WMI
+  `/Date(ms)/` serialization into a readable `YYYY-MM-DD` string.
+- The Windows interop probe is cached persistently (PCI metadata is static), so
+  vLLM's `with_amdsmi_context` no longer re-spawns `powershell.exe` on every
+  call.
+- Degenerate placeholder UUIDs reported by torch on WSL2 (e.g.
+  `66666666-...`) are detected and replaced with a stable synthesized id, kept
+  consistent across `device_uuid`, `asic_serial`, and board `product_serial`.
+
+### Tested
+- Verified end-to-end on WSL2 + AMD Radeon 8060S (Strix Halo, gfx1151) +
+  ROCm 7.2.4 + PyTorch 2.9.1: `import amdsmi` works, vLLM ROCm platform
+  detection succeeds, and `RocmPlatform.get_device_name(0)` returns
+  `AMD_Radeon_8060S`.
+
+## [0.1.0] - 2026-06-04
+
+### Added
+- Initial release: a drop-in replacement for the `amdsmi` Python package that
+  works on WSL2 / Windows, where the native AMD SMI library cannot run because
+  the KFD interface (`/dev/kfd`, `/sys/class/kfd`) is unavailable.
+- Full API parity with upstream `amdsmi`: all 189 `amdsmi_*` functions, 37
+  `AmdSmi*` enums, the complete exception hierarchy, and `AmdSmiEventReader`.
+- Real implementations for the queryable subset, backed by:
+  - the HIP runtime via `torch.cuda` (device count, name, gfx arch, VRAM, compute
+    units, live memory usage), and
+  - Windows interop (`powershell.exe Get-CimInstance Win32_VideoController`) to
+    recover the real PCI device id, subsystem id, and driver version.
+  - a static `gfx -> metadata` fallback table.
+- Faithful degradation: capabilities that genuinely do not exist on WSL2 raise
+  `AmdSmiLibraryException(AMDSMI_STATUS_NOT_SUPPORTED)`, matching native behavior.
+- `AMDSMI_WSL_DISABLE` environment variable to disable the shim.
+
+[Unreleased]: https://github.com/JoursBleu/amd-smi-wsl/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/JoursBleu/amd-smi-wsl/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/JoursBleu/amd-smi-wsl/releases/tag/v0.1.0

amd_smi_wsl-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,39 @@
+# Contributing
+
+Thanks for your interest in improving `amd-smi-wsl`.
+
+## Scope
+
+This package is a **drop-in replacement** for the upstream `amdsmi` Python
+binding, targeted at WSL2 / Windows environments where the native AMD SMI
+library cannot run. The guiding principle is **API fidelity**: the public
+surface (function names, signatures, return shapes, enums, exceptions) must
+match upstream `amdsmi`. Where a capability cannot be supported on WSL2, the
+corresponding function should raise
+`AmdSmiLibraryException(AMDSMI_STATUS_NOT_SUPPORTED)` rather than returning
+fabricated data.
+
+## Development setup
+
+```bash
+git clone git@github.com:JoursBleu/amd-smi-wsl.git
+cd amd-smi-wsl
+python -m venv .venv && . .venv/bin/activate
+pip install -e ".[test]"
+pytest
+```
+
+## Guidelines
+
+- Keep full parity with upstream `amdsmi` — do not rename or drop public symbols.
+- Constants and enums are extracted verbatim from upstream; do not edit their
+  values by hand.
+- New real implementations must degrade gracefully when no GPU / no torch is
+  present.
+- Add or update tests in `tests/` for any behavior change.
+- Run `pytest` before opening a pull request.
+
+## Reporting issues
+
+Please include: OS (Windows version + WSL distro), ROCm version, GPU model,
+`python -c "import torch; print(torch.version.hip)"`, and the full traceback.

amd_smi_wsl-0.2.0/LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2026 JoursBleu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Portions of this project (the AMDSMI_* status constants, the AmdSmi* enum
+value definitions, and the exception classes) are derived from the ROCm/amdsmi
+project, which is also distributed under the MIT License:
+
+    Copyright (C) Advanced Micro Devices. All rights reserved.

amd_smi_wsl-0.2.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include CHANGELOG.md
+include CONTRIBUTING.md
+include src/amdsmi/py.typed

amd_smi_wsl-0.2.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: amd-smi-wsl
+Version: 0.2.0
+Summary: Drop-in amdsmi replacement for WSL2 / Windows (HIP + Windows interop backed).
+Author: JoursBleu
+License: MIT
+Project-URL: Homepage, https://joursbleu.github.io/amd-smi-wsl/
+Project-URL: Documentation, https://joursbleu.github.io/amd-smi-wsl/
+Project-URL: Repository, https://github.com/JoursBleu/amd-smi-wsl
+Project-URL: Issues, https://github.com/JoursBleu/amd-smi-wsl/issues
+Project-URL: Changelog, https://github.com/JoursBleu/amd-smi-wsl/blob/main/CHANGELOG.md
+Keywords: amdsmi,amd-smi,rocm,wsl2,wsl,hip,gpu,vllm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: GPU
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# amd-smi-wsl
+
+A **drop-in replacement for the `amdsmi` Python package** that works inside
+**WSL2 / Windows**, where the native AMD SMI library cannot run.
+
+This is a property of the WSL2 GPU stack rather than of any single card, so it
+applies broadly to AMD GPUs used with ROCm under WSL2 — across RDNA
+generations (e.g. RDNA3 / RDNA3.5 / RDNA4 desktop Radeon and Radeon PRO cards,
+as well as Ryzen AI APUs). The data sources it builds on (the HIP runtime and
+Windows interop) are GPU-agnostic; only the per-device details (PCI id, market
+name, gfx arch) differ from card to card.
+
+```python
+import amdsmi            # this package, not the native one
+amdsmi.amdsmi_init()
+h = amdsmi.amdsmi_get_processor_handles()[0]
+print(amdsmi.amdsmi_get_gpu_asic_info(h)["market_name"])
+```
+
+## Why
+
+On WSL2 **any** AMD GPU is exposed through DirectX para-virtualisation
+(`/dev/dxg` + `dxgkrnl`), **not** the native `amdgpu` KFD driver. The Linux
+`/dev/kfd` device and its sysfs topology simply do not exist, so — regardless
+of which Radeon / Ryzen GPU you have:
+
+- `import amdsmi` (native) fails / `amdsmi_init()` raises, and
+- downstream code such as **vLLM** then fails ROCm platform detection and
+  device-name / topology queries at startup,
+
+even though the HIP runtime itself works perfectly via `/dev/dxg`.
+
+This package restores the `amdsmi` import surface and re-implements the
+*queryable* subset on top of data sources that **do** work in WSL2:
+
+| Source | Provides |
+| --- | --- |
+| `torch.cuda` (HIP runtime) | device count, name, GCN arch, total VRAM, compute units, UUID, live mem usage |
+| Windows interop (`Get-CimInstance Win32_VideoController`) | real PCI device id, subsystem id, revision, driver version/date |
+| Static `gfx -> metadata` table | marketing name / VRAM type / device id fallbacks |
+
+> **Note on `torch` re-entrancy.** PyTorch's ROCm build resolves its device
+> count *through* `amdsmi` itself. Since this package replaces `amdsmi`, a
+> naive probe would recurse (`amdsmi_init` -> `torch.cuda` -> `amdsmi_init` ...).
+> A thread-local re-entrancy guard breaks that cycle so `torch` falls back to
+> its native HIP device count. See the v0.2.0 entry in the changelog.
+
+## API coverage
+
+The package exposes **every** public symbol of the upstream binding —
+all 189 `amdsmi_*` functions, all 37 `AmdSmi*` enums, and the full
+exception hierarchy — so `import amdsmi` is binary-compatible at the
+Python level.
+
+- **Implemented for real** (read-only queries that map cleanly to HIP /
+  Windows data): init / shutdown, processor & socket handle enumeration,
+  `asic_info`, `board_info`, `vram_info`, `vram_usage`, `memory_total`,
+  `memory_usage`, `device_uuid`, `device_bdf`, `driver_info`, `gpu_id`,
+  `subsystem_id`/`name`, `revision`, `vendor_name`, `topo_get_link_type`,
+  `topo_get_numa_node_number`, `lib_version`, `rocm_version`,
+  `status_code_to_string`, and best-effort `activity` / `clock_info` /
+  `temp_metric` / `power_info` (when the running `torch` build exposes them).
+- **Faithful `NOT_SUPPORTED` stubs** for everything the platform genuinely
+  lacks under WSL2: the entire CPU/HSMP/EPYC surface, performance counters,
+  RAS/ECC, compute/memory partitioning, every `set_*` mutator, GPU reset,
+  KFD info, XGMI status, and event notification. These raise
+  `AmdSmiLibraryException(AMDSMI_STATUS_NOT_SUPPORTED)` — exactly what the
+  native library does for unsupported features.
+
+## Install
+
+```bash
+pip install amd-smi-wsl
+```
+
+`torch` (ROCm build) is expected to already be present in your environment and
+is therefore **not** declared as a hard dependency.
+
+> Only install this where the real `amdsmi` cannot be used. In a normal
+> native-Linux ROCm install you should keep the official `amdsmi`.
+
+## Environment variables
+
+- `AMDSMI_WSL_DISABLE=1` — make `amdsmi_init()` raise `NOT_SUPPORTED`, useful
+  to test a caller's fallback path.
+
+## Relationship to vLLM
+
+This package makes the native-`amdsmi` code paths in vLLM's
+`vllm/platforms/rocm.py` and `vllm/platforms/__init__.py` work unchanged on
+WSL2, as an alternative to patching vLLM with `torch.cuda` fallbacks
+(cf. vLLM PR #37189).
+
+With this package installed, vLLM resolves the **canonical** device name from
+its hex-keyed `_ROCM_DEVICE_ID_NAME_MAP` (because `asic_info["device_id"]` is
+returned as a lowercase hex string such as `"0x1586"`), e.g.:
+
+```python
+from vllm.platforms import rocm_platform_plugin
+import vllm.platforms.rocm as rocm
+rocm_platform_plugin()              # -> 'vllm.platforms.rocm.RocmPlatform'
+rocm.RocmPlatform.get_device_name(0)  # -> 'AMD_Radeon_8060S'
+rocm._GCN_ARCH                      # -> 'gfx1151'
+```
+
+## Verified environment
+
+The mechanism is GPU-agnostic (it only relies on the HIP runtime + Windows
+interop, which behave the same for any Radeon / Ryzen GPU under WSL2). The
+numbers below are from one fully validated end-to-end setup — **WSL2 + AMD
+Radeon 8060S (Strix Halo, gfx1151) + ROCm 7.2.4 + PyTorch 2.9.1** — and the
+device-specific values (name, `device_id`, gfx arch) will naturally differ on
+other cards:
+
+| Check | Result |
+| --- | --- |
+| `import amdsmi` + `amdsmi_init()` | OK (no recursion) |
+| `amdsmi_get_gpu_asic_info()["market_name"]` | `AMD Radeon(TM) 8060S Graphics` |
+| `amdsmi_get_gpu_asic_info()["device_id"]` | `0x1586` (hex string) |
+| `target_graphics_version` | `gfx1151` |
+| test suite (`pytest`) | **16 passed** |
+| vLLM `rocm_platform_plugin()` | `vllm.platforms.rocm.RocmPlatform` |
+| vLLM `RocmPlatform.get_device_name(0)` | `AMD_Radeon_8060S` |
+| vLLM `is_fully_connected([0])` | `True` |
+
+Telemetry that the platform does not expose (`clock_info`, `temp_metric`,
+`power_info`, `gpu_activity`) raises `AMDSMI_STATUS_NOT_SUPPORTED`, as expected.
+
+## License
+
+MIT. Status constants, enum values and exception classes are derived from the
+MIT-licensed [ROCm/amdsmi](https://github.com/ROCm/amdsmi) project.

amd_smi_wsl-0.2.0/README.md

@@ -0,0 +1,132 @@
+# amd-smi-wsl
+
+A **drop-in replacement for the `amdsmi` Python package** that works inside
+**WSL2 / Windows**, where the native AMD SMI library cannot run.
+
+This is a property of the WSL2 GPU stack rather than of any single card, so it
+applies broadly to AMD GPUs used with ROCm under WSL2 — across RDNA
+generations (e.g. RDNA3 / RDNA3.5 / RDNA4 desktop Radeon and Radeon PRO cards,
+as well as Ryzen AI APUs). The data sources it builds on (the HIP runtime and
+Windows interop) are GPU-agnostic; only the per-device details (PCI id, market
+name, gfx arch) differ from card to card.
+
+```python
+import amdsmi            # this package, not the native one
+amdsmi.amdsmi_init()
+h = amdsmi.amdsmi_get_processor_handles()[0]
+print(amdsmi.amdsmi_get_gpu_asic_info(h)["market_name"])
+```
+
+## Why
+
+On WSL2 **any** AMD GPU is exposed through DirectX para-virtualisation
+(`/dev/dxg` + `dxgkrnl`), **not** the native `amdgpu` KFD driver. The Linux
+`/dev/kfd` device and its sysfs topology simply do not exist, so — regardless
+of which Radeon / Ryzen GPU you have:
+
+- `import amdsmi` (native) fails / `amdsmi_init()` raises, and
+- downstream code such as **vLLM** then fails ROCm platform detection and
+  device-name / topology queries at startup,
+
+even though the HIP runtime itself works perfectly via `/dev/dxg`.
+
+This package restores the `amdsmi` import surface and re-implements the
+*queryable* subset on top of data sources that **do** work in WSL2:
+
+| Source | Provides |
+| --- | --- |
+| `torch.cuda` (HIP runtime) | device count, name, GCN arch, total VRAM, compute units, UUID, live mem usage |
+| Windows interop (`Get-CimInstance Win32_VideoController`) | real PCI device id, subsystem id, revision, driver version/date |
+| Static `gfx -> metadata` table | marketing name / VRAM type / device id fallbacks |
+
+> **Note on `torch` re-entrancy.** PyTorch's ROCm build resolves its device
+> count *through* `amdsmi` itself. Since this package replaces `amdsmi`, a
+> naive probe would recurse (`amdsmi_init` -> `torch.cuda` -> `amdsmi_init` ...).
+> A thread-local re-entrancy guard breaks that cycle so `torch` falls back to
+> its native HIP device count. See the v0.2.0 entry in the changelog.
+
+## API coverage
+
+The package exposes **every** public symbol of the upstream binding —
+all 189 `amdsmi_*` functions, all 37 `AmdSmi*` enums, and the full
+exception hierarchy — so `import amdsmi` is binary-compatible at the
+Python level.
+
+- **Implemented for real** (read-only queries that map cleanly to HIP /
+  Windows data): init / shutdown, processor & socket handle enumeration,
+  `asic_info`, `board_info`, `vram_info`, `vram_usage`, `memory_total`,
+  `memory_usage`, `device_uuid`, `device_bdf`, `driver_info`, `gpu_id`,
+  `subsystem_id`/`name`, `revision`, `vendor_name`, `topo_get_link_type`,
+  `topo_get_numa_node_number`, `lib_version`, `rocm_version`,
+  `status_code_to_string`, and best-effort `activity` / `clock_info` /
+  `temp_metric` / `power_info` (when the running `torch` build exposes them).
+- **Faithful `NOT_SUPPORTED` stubs** for everything the platform genuinely
+  lacks under WSL2: the entire CPU/HSMP/EPYC surface, performance counters,
+  RAS/ECC, compute/memory partitioning, every `set_*` mutator, GPU reset,
+  KFD info, XGMI status, and event notification. These raise
+  `AmdSmiLibraryException(AMDSMI_STATUS_NOT_SUPPORTED)` — exactly what the
+  native library does for unsupported features.
+
+## Install
+
+```bash
+pip install amd-smi-wsl
+```
+
+`torch` (ROCm build) is expected to already be present in your environment and
+is therefore **not** declared as a hard dependency.
+
+> Only install this where the real `amdsmi` cannot be used. In a normal
+> native-Linux ROCm install you should keep the official `amdsmi`.
+
+## Environment variables
+
+- `AMDSMI_WSL_DISABLE=1` — make `amdsmi_init()` raise `NOT_SUPPORTED`, useful
+  to test a caller's fallback path.
+
+## Relationship to vLLM
+
+This package makes the native-`amdsmi` code paths in vLLM's
+`vllm/platforms/rocm.py` and `vllm/platforms/__init__.py` work unchanged on
+WSL2, as an alternative to patching vLLM with `torch.cuda` fallbacks
+(cf. vLLM PR #37189).
+
+With this package installed, vLLM resolves the **canonical** device name from
+its hex-keyed `_ROCM_DEVICE_ID_NAME_MAP` (because `asic_info["device_id"]` is
+returned as a lowercase hex string such as `"0x1586"`), e.g.:
+
+```python
+from vllm.platforms import rocm_platform_plugin
+import vllm.platforms.rocm as rocm
+rocm_platform_plugin()              # -> 'vllm.platforms.rocm.RocmPlatform'
+rocm.RocmPlatform.get_device_name(0)  # -> 'AMD_Radeon_8060S'
+rocm._GCN_ARCH                      # -> 'gfx1151'
+```
+
+## Verified environment
+
+The mechanism is GPU-agnostic (it only relies on the HIP runtime + Windows
+interop, which behave the same for any Radeon / Ryzen GPU under WSL2). The
+numbers below are from one fully validated end-to-end setup — **WSL2 + AMD
+Radeon 8060S (Strix Halo, gfx1151) + ROCm 7.2.4 + PyTorch 2.9.1** — and the
+device-specific values (name, `device_id`, gfx arch) will naturally differ on
+other cards:
+
+| Check | Result |
+| --- | --- |
+| `import amdsmi` + `amdsmi_init()` | OK (no recursion) |
+| `amdsmi_get_gpu_asic_info()["market_name"]` | `AMD Radeon(TM) 8060S Graphics` |
+| `amdsmi_get_gpu_asic_info()["device_id"]` | `0x1586` (hex string) |
+| `target_graphics_version` | `gfx1151` |
+| test suite (`pytest`) | **16 passed** |
+| vLLM `rocm_platform_plugin()` | `vllm.platforms.rocm.RocmPlatform` |
+| vLLM `RocmPlatform.get_device_name(0)` | `AMD_Radeon_8060S` |
+| vLLM `is_fully_connected([0])` | `True` |
+
+Telemetry that the platform does not expose (`clock_info`, `temp_metric`,
+`power_info`, `gpu_activity`) raises `AMDSMI_STATUS_NOT_SUPPORTED`, as expected.
+
+## License
+
+MIT. Status constants, enum values and exception classes are derived from the
+MIT-licensed [ROCm/amdsmi](https://github.com/ROCm/amdsmi) project.

amd_smi_wsl-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "amd-smi-wsl"
+version = "0.2.0"
+description = "Drop-in amdsmi replacement for WSL2 / Windows (HIP + Windows interop backed)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "JoursBleu" }]
+keywords = ["amdsmi", "amd-smi", "rocm", "wsl2", "wsl", "hip", "gpu", "vllm"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: GPU",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Hardware",
+    "Topic :: System :: Monitoring",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+# torch is the runtime data source but is intentionally NOT a hard dependency:
+# it is already present in any ROCm/vLLM environment and pinning it here would
+# fight the user's existing install.
+test = ["pytest"]
+
+[project.urls]
+Homepage = "https://joursbleu.github.io/amd-smi-wsl/"
+Documentation = "https://joursbleu.github.io/amd-smi-wsl/"
+Repository = "https://github.com/JoursBleu/amd-smi-wsl"
+Issues = "https://github.com/JoursBleu/amd-smi-wsl/issues"
+Changelog = "https://github.com/JoursBleu/amd-smi-wsl/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+amdsmi = ["py.typed"]

amd_smi_wsl-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

amd_smi_wsl-0.2.0/src/amd_smi_wsl.egg-info/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: amd-smi-wsl
+Version: 0.2.0
+Summary: Drop-in amdsmi replacement for WSL2 / Windows (HIP + Windows interop backed).
+Author: JoursBleu
+License: MIT
+Project-URL: Homepage, https://joursbleu.github.io/amd-smi-wsl/
+Project-URL: Documentation, https://joursbleu.github.io/amd-smi-wsl/
+Project-URL: Repository, https://github.com/JoursBleu/amd-smi-wsl
+Project-URL: Issues, https://github.com/JoursBleu/amd-smi-wsl/issues
+Project-URL: Changelog, https://github.com/JoursBleu/amd-smi-wsl/blob/main/CHANGELOG.md
+Keywords: amdsmi,amd-smi,rocm,wsl2,wsl,hip,gpu,vllm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: GPU
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# amd-smi-wsl
+
+A **drop-in replacement for the `amdsmi` Python package** that works inside
+**WSL2 / Windows**, where the native AMD SMI library cannot run.
+
+This is a property of the WSL2 GPU stack rather than of any single card, so it
+applies broadly to AMD GPUs used with ROCm under WSL2 — across RDNA
+generations (e.g. RDNA3 / RDNA3.5 / RDNA4 desktop Radeon and Radeon PRO cards,
+as well as Ryzen AI APUs). The data sources it builds on (the HIP runtime and
+Windows interop) are GPU-agnostic; only the per-device details (PCI id, market
+name, gfx arch) differ from card to card.
+
+```python
+import amdsmi            # this package, not the native one
+amdsmi.amdsmi_init()
+h = amdsmi.amdsmi_get_processor_handles()[0]
+print(amdsmi.amdsmi_get_gpu_asic_info(h)["market_name"])
+```
+
+## Why
+
+On WSL2 **any** AMD GPU is exposed through DirectX para-virtualisation
+(`/dev/dxg` + `dxgkrnl`), **not** the native `amdgpu` KFD driver. The Linux
+`/dev/kfd` device and its sysfs topology simply do not exist, so — regardless
+of which Radeon / Ryzen GPU you have:
+
+- `import amdsmi` (native) fails / `amdsmi_init()` raises, and
+- downstream code such as **vLLM** then fails ROCm platform detection and
+  device-name / topology queries at startup,
+
+even though the HIP runtime itself works perfectly via `/dev/dxg`.
+
+This package restores the `amdsmi` import surface and re-implements the
+*queryable* subset on top of data sources that **do** work in WSL2:
+
+| Source | Provides |
+| --- | --- |
+| `torch.cuda` (HIP runtime) | device count, name, GCN arch, total VRAM, compute units, UUID, live mem usage |
+| Windows interop (`Get-CimInstance Win32_VideoController`) | real PCI device id, subsystem id, revision, driver version/date |
+| Static `gfx -> metadata` table | marketing name / VRAM type / device id fallbacks |
+
+> **Note on `torch` re-entrancy.** PyTorch's ROCm build resolves its device
+> count *through* `amdsmi` itself. Since this package replaces `amdsmi`, a
+> naive probe would recurse (`amdsmi_init` -> `torch.cuda` -> `amdsmi_init` ...).
+> A thread-local re-entrancy guard breaks that cycle so `torch` falls back to
+> its native HIP device count. See the v0.2.0 entry in the changelog.
+
+## API coverage
+
+The package exposes **every** public symbol of the upstream binding —
+all 189 `amdsmi_*` functions, all 37 `AmdSmi*` enums, and the full
+exception hierarchy — so `import amdsmi` is binary-compatible at the
+Python level.
+
+- **Implemented for real** (read-only queries that map cleanly to HIP /
+  Windows data): init / shutdown, processor & socket handle enumeration,
+  `asic_info`, `board_info`, `vram_info`, `vram_usage`, `memory_total`,
+  `memory_usage`, `device_uuid`, `device_bdf`, `driver_info`, `gpu_id`,
+  `subsystem_id`/`name`, `revision`, `vendor_name`, `topo_get_link_type`,
+  `topo_get_numa_node_number`, `lib_version`, `rocm_version`,
+  `status_code_to_string`, and best-effort `activity` / `clock_info` /
+  `temp_metric` / `power_info` (when the running `torch` build exposes them).
+- **Faithful `NOT_SUPPORTED` stubs** for everything the platform genuinely
+  lacks under WSL2: the entire CPU/HSMP/EPYC surface, performance counters,
+  RAS/ECC, compute/memory partitioning, every `set_*` mutator, GPU reset,
+  KFD info, XGMI status, and event notification. These raise
+  `AmdSmiLibraryException(AMDSMI_STATUS_NOT_SUPPORTED)` — exactly what the
+  native library does for unsupported features.
+
+## Install
+
+```bash
+pip install amd-smi-wsl
+```
+
+`torch` (ROCm build) is expected to already be present in your environment and
+is therefore **not** declared as a hard dependency.
+
+> Only install this where the real `amdsmi` cannot be used. In a normal
+> native-Linux ROCm install you should keep the official `amdsmi`.
+
+## Environment variables
+
+- `AMDSMI_WSL_DISABLE=1` — make `amdsmi_init()` raise `NOT_SUPPORTED`, useful
+  to test a caller's fallback path.
+
+## Relationship to vLLM
+
+This package makes the native-`amdsmi` code paths in vLLM's
+`vllm/platforms/rocm.py` and `vllm/platforms/__init__.py` work unchanged on
+WSL2, as an alternative to patching vLLM with `torch.cuda` fallbacks
+(cf. vLLM PR #37189).
+
+With this package installed, vLLM resolves the **canonical** device name from
+its hex-keyed `_ROCM_DEVICE_ID_NAME_MAP` (because `asic_info["device_id"]` is
+returned as a lowercase hex string such as `"0x1586"`), e.g.:
+
+```python
+from vllm.platforms import rocm_platform_plugin
+import vllm.platforms.rocm as rocm
+rocm_platform_plugin()              # -> 'vllm.platforms.rocm.RocmPlatform'
+rocm.RocmPlatform.get_device_name(0)  # -> 'AMD_Radeon_8060S'
+rocm._GCN_ARCH                      # -> 'gfx1151'
+```
+
+## Verified environment
+
+The mechanism is GPU-agnostic (it only relies on the HIP runtime + Windows
+interop, which behave the same for any Radeon / Ryzen GPU under WSL2). The
+numbers below are from one fully validated end-to-end setup — **WSL2 + AMD
+Radeon 8060S (Strix Halo, gfx1151) + ROCm 7.2.4 + PyTorch 2.9.1** — and the
+device-specific values (name, `device_id`, gfx arch) will naturally differ on
+other cards:
+
+| Check | Result |
+| --- | --- |
+| `import amdsmi` + `amdsmi_init()` | OK (no recursion) |
+| `amdsmi_get_gpu_asic_info()["market_name"]` | `AMD Radeon(TM) 8060S Graphics` |
+| `amdsmi_get_gpu_asic_info()["device_id"]` | `0x1586` (hex string) |
+| `target_graphics_version` | `gfx1151` |
+| test suite (`pytest`) | **16 passed** |
+| vLLM `rocm_platform_plugin()` | `vllm.platforms.rocm.RocmPlatform` |
+| vLLM `RocmPlatform.get_device_name(0)` | `AMD_Radeon_8060S` |
+| vLLM `is_fully_connected([0])` | `True` |
+
+Telemetry that the platform does not expose (`clock_info`, `temp_metric`,
+`power_info`, `gpu_activity`) raises `AMDSMI_STATUS_NOT_SUPPORTED`, as expected.
+
+## License
+
+MIT. Status constants, enum values and exception classes are derived from the
+MIT-licensed [ROCm/amdsmi](https://github.com/ROCm/amdsmi) project.