feat(rocm): upgrade GPU base images to ROCm 10.0

.github/build-config.json

@@ -1,10 +1,19 @@
 {
   "gpu_targets": [
-    {"name": "gfx110x", "pytorch_whl": "gfx110X-all", "rocm_sdk": "gfx110x"},
-    {"name": "gfx1150", "pytorch_whl": "gfx1150", "rocm_sdk": "gfx1150"},
-    {"name": "gfx1151", "pytorch_whl": "gfx1151", "rocm_sdk": "gfx1151"},
-    {"name": "gfx1152", "pytorch_whl": "gfx1152", "rocm_sdk": "gfx1152"},
-    {"name": "gfx120x", "pytorch_whl": "gfx120X-all", "rocm_sdk": "gfx120x"}
+    {
+      "name": "gfx110x",
+      "rocm_sdk": ["gfx1100", "gfx1101", "gfx1102", "gfx1103"],
+      "pytorch_devices": ["gfx1100", "gfx1101", "gfx1102", "gfx1103"]
+    },
+    {"name": "gfx1150", "rocm_sdk": ["gfx1150"], "pytorch_devices": ["gfx1150"]},
+    {"name": "gfx1151", "rocm_sdk": ["gfx1151"], "pytorch_devices": ["gfx1151"]},
+    {"name": "gfx1152", "rocm_sdk": ["gfx1152"], "pytorch_devices": ["gfx1152"]},
+    {"name": "gfx1153", "rocm_sdk": ["gfx1153"], "pytorch_devices": ["gfx1153"]},
+    {
+      "name": "gfx120x",
+      "rocm_sdk": ["gfx1200", "gfx1201"],
+      "pytorch_devices": ["gfx1200", "gfx1201"]
+    }
   ],
   "default_gpu_target": "gfx1151",
   "courses": ["CV", "DL", "LLM", "PhySim"]

.github/workflows/docker-build.yml

@@ -74,6 +74,7 @@ on:
           - gfx1150
           - gfx1151
           - gfx1152
+          - gfx1153
           - gfx120x
 
 # Build matrix is defined in .github/build-config.json
@@ -633,9 +634,19 @@ jobs:
         run: |
           echo "tag_suffix=${{ matrix.gpu_target }}" >> "$GITHUB_OUTPUT"
           # Look up target-specific build metadata; fall back to gpu_target if not found
-          WHL=$(echo '${{ needs.changes.outputs.gpu-map }}' | jq -r --arg t "${{ matrix.gpu_target }}" '.[] | select(.name == $t) | .pytorch_whl // .name')
-          SDK=$(echo '${{ needs.changes.outputs.gpu-map }}' | jq -r --arg t "${{ matrix.gpu_target }}" '.[] | select(.name == $t) | .rocm_sdk // .name')
-          echo "pytorch_whl=${WHL}" >> "$GITHUB_OUTPUT"
+          GPU_MAP='${{ needs.changes.outputs.gpu-map }}'
+          TARGET='${{ matrix.gpu_target }}'
+          WHL=$(echo "$GPU_MAP" | jq -r --arg t "$TARGET" '
+            .[] | select(.name == $t) |
+            (.pytorch_devices // .pytorch_whl // .name) |
+            if type == "array" then join(" ") else . end
+          ')
+          SDK=$(echo "$GPU_MAP" | jq -r --arg t "$TARGET" '
+            .[] | select(.name == $t) |
+            (.rocm_sdk // .name) |
+            if type == "array" then join(" ") else . end
+          ')
+          echo "pytorch_devices=${WHL}" >> "$GITHUB_OUTPUT"
           echo "rocm_sdk=${SDK}" >> "$GITHUB_OUTPUT"
 
       - name: Docker metadata (target-suffixed tags)
@@ -700,7 +711,7 @@ jobs:
           build-args: |
             GPU_TARGET=${{ matrix.gpu_target }}
             ROCM_SDK_TARGET=${{ steps.suffix.outputs.rocm_sdk }}
-            PYTORCH_WHL_TARGET=${{ steps.suffix.outputs.pytorch_whl }}
+            PYTORCH_DEVICES=${{ steps.suffix.outputs.pytorch_devices }}
           cache-from: type=gha,scope=base-gpu-${{ matrix.gpu_target }}
           cache-to: type=gha,mode=max,scope=base-gpu-${{ matrix.gpu_target }}
           provenance: false

README.md

@@ -60,7 +60,7 @@ sudo apt install build-essential
 sudo apt install python3-questionary python3-prompt-toolkit
 ```
 
-> **Kernel note** (Ryzen AI APU only): The OEM kernel package follows AMD ROCm's Ryzen APU installation guidance for Ubuntu 24.04. See the [ROCm 7.13.0 preview installation guide for Ryzen APUs](https://rocm.docs.amd.com/en/7.13.0-preview/install/rocm.html?fam=ryzen&w=compute&os=ubuntu&ubuntu-ver=24.04&i=pkgman&gpu=max-pro-395&gfx=gfx1151) for details. Radeon dGPU systems typically use the stock Ubuntu kernel—check ROCm docs for your GPU.
+> **Kernel note** (Ryzen AI APU only): The OEM kernel package follows AMD ROCm's Ryzen APU installation guidance for Ubuntu 24.04. See the [ROCm 10.0.0 installation guide for Ryzen APUs](https://rocm.docs.amd.com/en/latest/install/rocm.html?fam=ryzen&w=compute&os=ubuntu&ubuntu-ver=24.04.4&i=pkgman&gpu=amd-ryzen-ai-max-pro-395&gfx=gfx1151) for details. Radeon dGPU systems typically use the stock Ubuntu kernel—check ROCm docs for your GPU.
 >
 > **Docker note**: See [Docker Post-installation Steps](https://docs.docker.com/engine/install/linux-postinstall/) and [Install Docker Engine on Ubuntu](https://docs.docker.com/engine/install/ubuntu/) for details.
 >

auplc_installer/gpu.py

@@ -76,6 +76,8 @@ def is_curated_sku(key: str) -> bool:
     "gfx1150": ("strix", "gfx1150", "", 2, ""),
     "strix-halo": ("strix-halo", "gfx1151", "", 3, ""),
     "gfx1151": ("strix-halo", "gfx1151", "", 3, ""),
+    "gfx1152": ("gfx1152", "gfx1152", "", 2, ""),
+    "gfx1153": ("gfx1153", "gfx1153", "", 2, ""),
     "rdna4": ("r9700", "gfx120x", "", 4, ""),
     "dgpu": ("r9700", "gfx120x", "", 4, ""),
     "gfx1200": ("r9700", "gfx120x", "", 4, ""),
@@ -106,6 +108,7 @@ def resolve_gpu_config(input_key: str) -> SkuRow:
         raise InstallerError(
             f"Unsupported GPU type: {input_key}\n"
             "  Supported: phx (gfx1100-1103), strix (gfx1150), strix-halo (gfx1151), "
+            "gfx1152, gfx1153, "
             "RDNA4 SKUs (9070xt | r9700 | 9600gre | dgpu fallback)"
         )
     return row

dockerfiles/Base/Dockerfile.rocm

@@ -74,26 +74,32 @@ ARG NB_GID=100
 
 # GPU target and ROCm baseline
 #
+# GPU_TARGET is the public image-tag bucket (latest-<GPU_TARGET>). ROCm 10
+# no longer ships gfx110x / gfx120x apt or wheel buckets, so those names are
+# expanded to concrete ISAs below. CI passes the expanded lists via
+# ROCM_SDK_TARGET and PYTORCH_DEVICES (see .github/build-config.json).
+#
 # Supported GPU_TARGET values:
-#   gfx110x       RDNA 3   — gfx1100/1101/1102/1103 (dGPU)
+#   gfx110x       RDNA 3   — gfx1100/1101/1102/1103
 #   gfx1150       RDNA 3.5 — Radeon 890M (Strix Point iGPU)
 #   gfx1151       RDNA 3.5 — Radeon 8060S (Strix Halo iGPU)
 #   gfx1152       RDNA 3.5 — Ryzen AI 300-series iGPU
-#   gfx120x       RDNA 4   — Radeon 9x series (dGPU)
+#   gfx1153       RDNA 3.5 — Ryzen AI 300/400-series iGPU
+#   gfx120x       RDNA 4   — gfx1200/gfx1201 (Radeon 9x series)
 #
-# ROCm 7.13 ships TheRock Core SDK packages in the Ubuntu apt repo.
-# GPU_TARGET selects the image tag and PyTorch wheel bucket; ROCM_SDK_TARGET
-# selects the concrete apt SDK package for size-conscious installs.
+# ROCm 10.0 ships TheRock Core SDK packages from stable.repo.amd.com.
+# GPU_TARGET selects the image tag; ROCM_SDK_TARGET selects one or more
+# concrete apt SDK packages (space-separated) for size-conscious installs.
 ARG GPU_TARGET=gfx1151
-ARG ROCM_SDK_TARGET=gfx1151
-ARG ROCM_VERSION=7.13.0
-ARG PYTORCH_VERSION=2.9.1
-ARG TORCHVISION_VERSION=0.24.0
-ARG TORCHAUDIO_VERSION=2.9.0
-# PyTorch wheel target — only differs from GPU_TARGET for the generic
-# buckets (gfx110x → gfx110X-all, gfx120x → gfx120X-all). Specific targets
-# like gfx1150/gfx1151/gfx1152 use the same name in both apt and wheel repos.
-# See https://repo.amd.com/rocm/whl/ for available targets.
+ARG ROCM_SDK_TARGET=
+ARG ROCM_VERSION=10.0.0
+ARG PYTORCH_VERSION=2.13.0
+ARG TORCHVISION_VERSION=0.28.0
+ARG TORCHAUDIO_VERSION=2.11.0.2
+# Space-separated concrete ISAs for torch[device-*] extras. Empty means
+# derive from GPU_TARGET (gfx110x / gfx120x expand to their ISA lists).
+# PYTORCH_WHL_TARGET is kept as a legacy alias for PYTORCH_DEVICES.
+ARG PYTORCH_DEVICES=
 ARG PYTORCH_WHL_TARGET=
 ARG PYTORCH_INDEX_URL=
 
@@ -135,19 +141,44 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 # Download and install GPG key for AMD ROCm repo
 RUN mkdir -p /etc/apt/keyrings && \
-    wget -q https://repo.amd.com/rocm/packages/gpg/rocm.gpg -O - | \
+    wget -q https://stable.repo.amd.com/rocm/gpg/packages.gpg -O - | \
     gpg --dearmor -o /etc/apt/keyrings/amdrocm.gpg
 
 # Add AMD ROCm apt repository (Ubuntu 24.04)
-RUN echo 'deb [arch=amd64 signed-by=/etc/apt/keyrings/amdrocm.gpg] https://repo.amd.com/rocm/packages/ubuntu2404 stable main' \
-    > /etc/apt/sources.list.d/rocm.list
-
-# Install ROCm from apt.
-# After install, create standard /opt/rocm/{bin,lib,include} symlinks — the amdrocm
-# packages install into /opt/rocm/core-<ver>/ without the standard top-level layout,
-# so hipcc and device bitcode are not found via PATH / LD_LIBRARY_PATH otherwise.
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends amdrocm-core-sdk${ROCM_VERSION%.*}-${ROCM_SDK_TARGET} && \
+RUN printf '%s\n' \
+    'Types: deb' \
+    'URIs: https://stable.repo.amd.com/rocm/core/packages/ubuntu2404/' \
+    'Suites: stable' \
+    'Components: main' \
+    'Architectures: amd64' \
+    'Signed-By: /etc/apt/keyrings/amdrocm.gpg' \
+    > /etc/apt/sources.list.d/amdrocm-stable.sources
+
+# After install, create standard /opt/rocm/{bin,lib,include} symlinks — the
+# amdrocm packages install into /opt/rocm/core-<ver>/ without the standard
+# top-level layout, so hipcc and device bitcode are not found via PATH /
+# LD_LIBRARY_PATH otherwise.
+# Expand family buckets (gfx110x / gfx120x) to the concrete ISAs ROCm 10
+# packages actually ship. Concrete names (gfx1151, gfx1201, …) pass through.
+# Also accept the ROCm 7.x wheel aliases gfx110X-all / gfx120X-all.
+RUN expand_rocm_isas() { \
+        for tok in $1; do \
+            case "${tok}" in \
+                gfx110x|gfx110X-all) echo gfx1100 gfx1101 gfx1102 gfx1103 ;; \
+                gfx120x|gfx120X-all) echo gfx1200 gfx1201 ;; \
+                *) echo "${tok}" ;; \
+            esac; \
+        done; \
+    }; \
+    SDK_ISAS=$(expand_rocm_isas "${ROCM_SDK_TARGET:-${GPU_TARGET}}"); \
+    SDK_VER="${ROCM_VERSION%.*}"; \
+    PKGS=""; \
+    for isa in ${SDK_ISAS}; do \
+        PKGS="${PKGS} amdrocm-core-sdk${SDK_VER}-${isa}"; \
+    done; \
+    echo "Installing ROCm Core SDK packages:${PKGS}"; \
+    apt-get update && \
+    apt-get install -y --no-install-recommends ${PKGS} && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/* && \
     CORE_BASE=$(ls -d /opt/rocm/core-[0-9]*.[0-9]* 2>/dev/null | sort -V | tail -1) && \
@@ -159,34 +190,41 @@ RUN apt-get update && \
         done; \
     fi
 
-# Install ROCm PyTorch.
+# Install ROCm PyTorch from the ROCm 10 multi-arch extra index.
 #
-# The SDK apt packages accept the same generic RDNA bucket names as GPU_TARGET,
-# such as `gfx110x` and `gfx120x`. The pip wheel index at
-# https://repo.amd.com/rocm/whl/ uses the "long" `gfx110X-all` /
-# `gfx120X-all` paths for those buckets (the short lowercase paths return 403),
-# so image targets still map to wheel targets below.
+# Wheels are selected with extras such as torch[device-gfx1151], not the
+# older per-arch https://repo.amd.com/rocm/whl/<arch>/ paths. Generic image
+# buckets install every ISA in the family so one tag still covers the SKUs
+# that previously used gfx110X-all / gfx120X-all.
 #
-# CI passes PYTORCH_WHL_TARGET explicitly via .github/build-config.json. For
-# local builds driven by dockerfiles/Makefile or auplc-installer — which only
-# set GPU_TARGET — we derive the wheel target here so ad-hoc
+# CI passes PYTORCH_DEVICES explicitly via .github/build-config.json. For
+# local builds driven by dockerfiles/Makefile or auplc-installer — which
+# only set GPU_TARGET — we derive the extras here so ad-hoc
 # `docker build --build-arg GPU_TARGET=gfx120x` and `make base-rocm
 # GPU_TARGET=gfx120x` both Just Work.
-RUN WHL_TARGET="${PYTORCH_WHL_TARGET}" && \
-    if [ -z "${WHL_TARGET}" ]; then \
-        case "${GPU_TARGET}" in \
-            gfx110x) WHL_TARGET="gfx110X-all" ;; \
-            gfx120x) WHL_TARGET="gfx120X-all" ;; \
-            *)       WHL_TARGET="${GPU_TARGET}" ;; \
-        esac; \
-    fi && \
-    INDEX_URL="${PYTORCH_INDEX_URL:-https://repo.amd.com/rocm/whl/${WHL_TARGET}/}" && \
-    TORCH_SUFFIX="+rocm${ROCM_VERSION}" && \
-    echo "Installing ROCm PyTorch from ${INDEX_URL} (GPU_TARGET=${GPU_TARGET}, WHL_TARGET=${WHL_TARGET})" && \
+RUN expand_rocm_isas() { \
+        for tok in $1; do \
+            case "${tok}" in \
+                gfx110x|gfx110X-all) echo gfx1100 gfx1101 gfx1102 gfx1103 ;; \
+                gfx120x|gfx120X-all) echo gfx1200 gfx1201 ;; \
+                *) echo "${tok}" ;; \
+            esac; \
+        done; \
+    }; \
+    DEVICE_ISAS=$(expand_rocm_isas "${PYTORCH_DEVICES:-${PYTORCH_WHL_TARGET:-${GPU_TARGET}}}"); \
+    EXTRAS=""; \
+    for isa in ${DEVICE_ISAS}; do \
+        EXTRAS="${EXTRAS},device-${isa}"; \
+    done; \
+    EXTRAS="${EXTRAS#,}"; \
+    INDEX_URL="${PYTORCH_INDEX_URL:-https://stable.repo.amd.com/rocm/whl-next/}"; \
+    TORCH_SUFFIX="+rocm${ROCM_VERSION}"; \
+    echo "Installing ROCm PyTorch from ${INDEX_URL} (GPU_TARGET=${GPU_TARGET}, extras=${EXTRAS})"; \
     python3 -m pip install --no-cache-dir \
     --index-url "${INDEX_URL}" \
-    "torch==${PYTORCH_VERSION}${TORCH_SUFFIX}" \
-    "torchvision==${TORCHVISION_VERSION}${TORCH_SUFFIX}" \
+    --extra-index-url https://pypi.org/simple \
+    "torch[${EXTRAS}]==${PYTORCH_VERSION}${TORCH_SUFFIX}" \
+    "torchvision[${EXTRAS}]==${TORCHVISION_VERSION}${TORCH_SUFFIX}" \
     "torchaudio==${TORCHAUDIO_VERSION}${TORCH_SUFFIX}" && \
     SDK_INC=$(python3 -c "import _rocm_sdk_core, os; print(os.path.join(os.path.dirname(_rocm_sdk_core.__file__), 'include'))" 2>/dev/null) && \
     if [ -n "$SDK_INC" ] && [ ! -e /opt/rocm/include/hip ]; then \

dockerfiles/Base/README.md

@@ -24,33 +24,30 @@ SOFTWARE.
 ## GPU Base Image (`Dockerfile.rocm`)
 
 Multi-target ROCm GPU base image. Set `GPU_TARGET` to build for any supported architecture.
-`Dockerfile.rocm` tracks the current course-image baseline: ROCm 7.13.0 Core SDK
+`Dockerfile.rocm` tracks the current course-image baseline: ROCm 10.0.0 Core SDK
 from AMD's Ubuntu 24.04 apt repository, plus ROCm-enabled PyTorch wheels.
 
 ### Supported Targets
 
-| GPU_TARGET    | Arch     | GPUs                            | Pip wheel path (derived) |
-|---------------|----------|---------------------------------|--------------------------|
-| gfx110x       | RDNA 3   | gfx1100/1101/1102/1103 (dGPU)   | gfx110X-all              |
-| gfx1150       | RDNA 3.5 | Strix (Radeon 890M)             | gfx1150                  |
-| gfx1151       | RDNA 3.5 | Strix Halo (Radeon 8060S)       | gfx1151                  |
-| gfx1152       | RDNA 3.5 | Ryzen AI 300-series iGPU        | gfx1152                  |
-| gfx120x       | RDNA 4   | gfx1201 (dGPU: RX 9070 XT, R9700, RX 9600 GRE, …) | gfx120X-all |
-
-The `GPU_TARGET` value selects the PyTorch wheel bucket and becomes the
-image-tag suffix. The ROCm SDK is installed from the matching arch-specific
-`amdrocm-core-sdk7.13-<ROCM_SDK_TARGET>` apt package to avoid pulling every
-supported architecture into each image. Generic image buckets use the matching
-generic SDK target, for example `gfx110x` and `gfx120x`.
-
-The pip wheel index at <https://repo.amd.com/rocm/whl/> uses the "long"
-`gfxNNNX-all` path for the generic RDNA 3 / RDNA 4 buckets; `Dockerfile.rocm`
-maps short → long automatically. CI passes `PYTORCH_WHL_TARGET` and
-`ROCM_SDK_TARGET` explicitly (see `.github/build-config.json`).
-
-The baseline PyTorch stack follows AMD's ROCm 7.13.0 wheel set while keeping
-the existing course-facing framework versions: `torch==2.9.1+rocm7.13.0`,
-`torchvision==0.24.0+rocm7.13.0`, and `torchaudio==2.9.0+rocm7.13.0`.
+| GPU_TARGET    | Arch     | GPUs                            | ROCm 10 ISAs (apt + `torch[device-*]`) |
+|---------------|----------|---------------------------------|----------------------------------------|
+| gfx110x       | RDNA 3   | gfx1100/1101/1102/1103          | gfx1100 gfx1101 gfx1102 gfx1103        |
+| gfx1150       | RDNA 3.5 | Strix (Radeon 890M)             | gfx1150                                |
+| gfx1151       | RDNA 3.5 | Strix Halo (Radeon 8060S)      | gfx1151                                |
+| gfx1152       | RDNA 3.5 | Ryzen AI 300-series iGPU        | gfx1152                                |
+| gfx1153       | RDNA 3.5 | Ryzen AI 300/400-series iGPU     | gfx1153                                |
+| gfx120x       | RDNA 4   | gfx1200/gfx1201 (RX 9x, R9700)  | gfx1200 gfx1201                        |
+
+The `GPU_TARGET` value is the image-tag suffix. ROCm 10 does not ship
+`gfx110x` / `gfx120x` apt or wheel buckets, so those family tags expand to
+the concrete ISAs above. Specific targets such as `gfx1151` stay 1:1.
+CI passes `PYTORCH_DEVICES` and `ROCM_SDK_TARGET` as space-separated ISA
+lists (see `.github/build-config.json`).
+
+The pip extra index is <https://stable.repo.amd.com/rocm/whl-next/>.
+The baseline PyTorch stack follows AMD's ROCm 10.0.0 wheel set:
+`torch==2.13.0+rocm10.0.0`, `torchvision==0.28.0+rocm10.0.0`, and
+`torchaudio==2.11.0.2+rocm10.0.0`.
 
 ### Build
 
@@ -61,13 +58,15 @@ docker build -t ghcr.io/amdresearch/auplc-base:latest --file Dockerfile.rocm .
 # Specific target
 docker build --build-arg GPU_TARGET=gfx120x \
   --build-arg ROCM_SDK_TARGET=gfx1201 \
+  --build-arg PYTORCH_DEVICES=gfx1201 \
   -t ghcr.io/amdresearch/auplc-base:latest-gfx120x --file Dockerfile.rocm .
 
 # Using make (from dockerfiles/ directory)
 make base-rocm                         # default target
 make base-rocm GPU_TARGET=gfx120x      # RDNA 4 desktop GPUs
 make base-rocm GPU_TARGET=gfx110x      # RDNA 3 desktop GPUs
 make base-rocm GPU_TARGET=gfx1152      # Ryzen AI 300-series iGPU
+make base-rocm GPU_TARGET=gfx1153      # Ryzen AI 300/400-series iGPU
 ```
 
 ### Override PyTorch Wheel URL

dockerfiles/Makefile

@@ -16,9 +16,9 @@ MIRROR_PREFIX ?=
 MIRROR_PIP ?=
 MIRROR_NPM ?=
 
-# GPU target architecture (short AMD apt-repo name; e.g. gfx110x, gfx1150,
-# gfx1151, gfx1152, gfx120x). Dockerfile.rocm maps this to the corresponding pip
-# wheel path (gfx110X-all / gfx120X-all for the RDNA 3 / RDNA 4 buckets).
+# GPU target architecture (image-tag bucket; e.g. gfx110x, gfx1150, gfx1151,
+# gfx1152, gfx1153, gfx120x). Dockerfile.rocm expands gfx110x / gfx120x to the
+# concrete ROCm 10 ISAs (gfx1100..1103 and gfx1200/gfx1201).
 GPU_TARGET ?= gfx1151
 
 ROCM_SDK_TARGET ?= $(GPU_TARGET)

runtime/values-multi-nodes.yaml.example

@@ -155,10 +155,9 @@ custom:
       nodeSelector:
         amd.com/gpu.product-name: "AMD_Radeon_780M_Graphics"
       env:
-        # Phoenix hw (gfx1100/1101/1102/1103) shares a single gfx110x ROCm
-        # build — we do not ship dedicated images for gfx1102/gfx1103 — so
-        # force every Phoenix GPU to report as gfx1100 at runtime so it
-        # accepts the shared kernels.
+        # Phoenix hw (gfx1103) shares the gfx110x image, which now ships
+        # per-ISA ROCm 10 kernels (gfx1100/1101/1102/1103). Keep Phoenix on
+        # the gfx1100 kernel path until the native gfx1103 route is validated.
         HSA_OVERRIDE_GFX_VERSION: "11.0.0"
       quotaRate: 2
     strix:

runtime/values.yaml

@@ -226,10 +226,9 @@ custom:
       nodeSelector:
         amd.com/gpu.product-name: "AMD_Radeon_780M_Graphics"
       env:
-        # Phoenix hw (gfx1100/1101/1102/1103) shares a single gfx110x ROCm
-        # build — we do not ship dedicated images for gfx1102/gfx1103 — so
-        # force every Phoenix GPU to report as gfx1100 at runtime so it
-        # accepts the shared kernels.
+        # Phoenix hw (gfx1103) shares the gfx110x image, which now ships
+        # per-ISA ROCm 10 kernels (gfx1100/1101/1102/1103). Keep Phoenix on
+        # the gfx1100 kernel path until the native gfx1103 route is validated.
         HSA_OVERRIDE_GFX_VERSION: "11.0.0"
       quotaRate: 2
     strix:

tests/installer/test_gpu.py

@@ -154,6 +154,11 @@ def test_resolve_gpu_config_known_gfx_alias() -> None:
     assert (accel_key, gpu_target) == ("strix-halo", "gfx1151")
 
 
+def test_resolve_gpu_config_gfx1152_and_gfx1153_image_targets() -> None:
+    assert resolve_gpu_config("gfx1152")[:2] == ("gfx1152", "gfx1152")
+    assert resolve_gpu_config("gfx1153")[:2] == ("gfx1153", "gfx1153")
+
+
 def test_resolve_gpu_config_hyphenated_gfx_alias() -> None:
     accel_key, gpu_target, _, _, _ = resolve_gpu_config("gfx-1150")
     assert (accel_key, gpu_target) == ("strix", "gfx1150")