[ci] Rework test_runs_on plumbing for release workflows. (#1100)

Progress on #589 and
#1097.

This changes `configure_target_run.py` to look for the target family in
either the "inner family" or the "outer key", so it correctly chooses
runners for gfx1151 instead of skipping that test configuration since
`gfx115X` and `gfx1151` do not match. I also considered explicit data
flow of `test_runs_on` through the workflows, but we preferred to keep
some automatic detection so developers triggering workflows do not need
to manually line up test families with test runners.

Recent test runs:
* "Build Windows PyTorch Wheels" with default inputs and ROCm version
`7.0.0rc20250804`:
https://github.com/ROCm/TheRock/actions/runs/16787740857
* "Build Portable Linux PyTorch Wheels" with default inputs and ROCm
version `7.0.0rc20250805`:
https://github.com/ROCm/TheRock/actions/runs/16787747432
* "Build Portable Linux PyTorch Wheels" with gfx110X-dgpu and ROCm
version `7.0.0rc20250805`:
https://github.com/ROCm/TheRock/actions/runs/16787789191

Author: ScottTodd

.github/workflows/build_portable_linux_pytorch_wheels.yml

@@ -35,8 +35,14 @@ on:
   workflow_dispatch:
     inputs:
       amdgpu_family:
-        required: true
-        type: string
+        type: choice
+        options:
+          - gfx110X-dgpu
+          - gfx1151
+          - gfx120X-all
+          - gfx94X-dcgpu
+          - gfx950-dcgpu
+        default: gfx94X-dcgpu
       python_version:
         required: true
         type: string
@@ -190,9 +196,9 @@ jobs:
         run: python ./build_tools/github_actions/configure_target_run.py
 
   test_pytorch_wheels:
+    name: Test | ${{ inputs.amdgpu_family }} | ${{ needs.generate_target_to_run.outputs.test_runs_on }}
     if: ${{ needs.generate_target_to_run.outputs.test_runs_on != '' }}
     needs: [build_pytorch_wheels, generate_target_to_run]
-
     uses: ./.github/workflows/test_pytorch_wheels.yml
     with:
       amdgpu_family: ${{ inputs.amdgpu_family }}

.github/workflows/build_windows_pytorch_wheels.yml

@@ -27,12 +27,18 @@ on:
   workflow_dispatch:
     inputs:
       amdgpu_family:
-        required: true
-        type: string
+        type: choice
+        options:
+          - gfx110X-dgpu
+          - gfx1151
+          - gfx120X-all
+          - gfx94X-dcgpu
+          - gfx950-dcgpu
+        default: gfx1151
       python_version:
         required: true
         type: string
-        default:
+        default: "3.12"
       release_type:
         description: The type of release to build ("nightly", or "dev")
         type: string
@@ -180,6 +186,7 @@ jobs:
         run: python ./build_tools/github_actions/configure_target_run.py
 
   test_pytorch_wheels:
+    name: Test | ${{ inputs.amdgpu_family }} | ${{ needs.generate_target_to_run.outputs.test_runs_on }}
     if: ${{ needs.generate_target_to_run.outputs.test_runs_on != '' }}
     needs: [build_pytorch_wheels, generate_target_to_run]
     uses: ./.github/workflows/test_pytorch_wheels.yml

.github/workflows/release_portable_linux_packages.yml

@@ -198,7 +198,12 @@ jobs:
         uses: benc-uk/workflow-dispatch@e2e5e9a103e331dad343f381a29e654aea3cf8fc # v1.2.4
         with:
           workflow: test_release_packages.yml
-          inputs: '{ "version": "${{ needs.setup_metadata.outputs.version }}", "tag": "nightly-tarball", "file_name": "${{ env.FILE_NAME }}", "target": "${{ matrix.target_bundle.amdgpu_family }}" }'
+          inputs: |
+            { "version": "${{ needs.setup_metadata.outputs.version }}",
+              "tag": "nightly-tarball",
+              "file_name": "${{ env.FILE_NAME }}",
+              "target": "${{ matrix.target_bundle.amdgpu_family }}",
+            }
 
       - name: Trigger building PyTorch wheels
         if: ${{ github.repository_owner == 'ROCm' }}

.github/workflows/release_portable_linux_pytorch_wheels.yml

@@ -24,8 +24,14 @@ on:
   workflow_dispatch:
     inputs:
       amdgpu_family:
-        required: true
-        type: string
+        type: choice
+        options:
+          - gfx110X-dgpu
+          - gfx1151
+          - gfx120X-all
+          - gfx94X-dcgpu
+          - gfx950-dcgpu
+        default: gfx94X-dcgpu
       release_type:
         description: The type of release to build ("nightly", or "dev")
         type: string
@@ -48,8 +54,8 @@ permissions:
   contents: read
 
 jobs:
-  build:
-    name: PyTorch Wheels | ${{ inputs.amdgpu_family }} | Python ${{ matrix.python_version }}
+  release:
+    name: Release PyTorch | ${{ inputs.amdgpu_family }} | Python ${{ matrix.python_version }}
     strategy:
       fail-fast: false
       matrix:

.github/workflows/release_windows_pytorch_wheels.yml

@@ -24,8 +24,14 @@ on:
   workflow_dispatch:
     inputs:
       amdgpu_family:
-        required: true
-        type: string
+        type: choice
+        options:
+          - gfx110X-dgpu
+          - gfx1151
+          - gfx120X-all
+          - gfx94X-dcgpu
+          - gfx950-dcgpu
+        default: gfx1151
       release_type:
         description: The type of release to build ("nightly", or "dev")
         type: string
@@ -47,7 +53,8 @@ permissions:
   contents: read
 
 jobs:
-  build:
+  release:
+    name: Release PyTorch | ${{ inputs.amdgpu_family }} | Python ${{ matrix.python_version }}
     strategy:
       fail-fast: false
       matrix:

.github/workflows/test_release_packages.yml

@@ -17,6 +17,7 @@ permissions:
 
 jobs:
   generate_target_to_run:
+    name: Generate target_to_run
     runs-on: ubuntu-24.04
     outputs:
       test_runs_on: ${{ steps.configure.outputs.test-runs-on }}
@@ -27,10 +28,10 @@ jobs:
       - name: Generating target to run
         id: configure
         env:
-          TARGET: ${{ inputs.target }}
+          TARGET: ${{ inputs.amdgpu_family }}
+          PLATFORM: "linux"
         run: python ./build_tools/github_actions/configure_target_run.py
 
-
   test_release_packages:
     # If there is a test machine available
     if: ${{ needs.generate_target_to_run.outputs.test_runs_on != '' }}

build_tools/github_actions/CMakeLists.txt

@@ -4,6 +4,12 @@ add_test(
         "${CMAKE_CURRENT_SOURCE_DIR}/tests/configure_ci_test.py"
 )
 
+add_test(
+    NAME build_tools_github_actions_configure_target_run_test
+    COMMAND "${Python3_EXECUTABLE}"
+        "${CMAKE_CURRENT_SOURCE_DIR}/tests/configure_target_run_test.py"
+)
+
 add_test(
     NAME build_tools_github_actions_determine_version_test
     COMMAND "${Python3_EXECUTABLE}"

build_tools/github_actions/configure_target_run.py

@@ -1,3 +1,11 @@
+"""This file looks up the test-runs-on runner label for a given GPU family.
+
+Environment variable inputs:
+    * 'TARGET': A GPU family like 'gfx95X-dcgpu' or 'gfx1151', corresponding
+                to a release index.
+    * 'PLATFORM': "linux" or "windows"
+"""
+
 import os
 from amdgpu_family_matrix import (
     amdgpu_family_info_matrix_presubmit,
@@ -6,32 +14,46 @@
 
 from github_actions_utils import *
 
-# This file helps configure which target to run
-
-# TODO (geomin12): this is very hard-coded to a very specific use-case.
-# Once portable_linux_package_matrix.yml matures, this will mature as well
-# Some logic is duplicated with fetch_package_targets.py
-
 
-def main(target: str, platform: str):
+def get_runner_label(target: str, platform: str) -> str:
+    print(f"Searching for a runner for target '{target}' on platform '{platform}'")
     amdgpu_family_info_matrix = (
         amdgpu_family_info_matrix_presubmit | amdgpu_family_info_matrix_postsubmit
     )
     for key, info_for_key in amdgpu_family_info_matrix.items():
-        # Only consider items containing the amdgpu_family (ex: gfx94X in gfx94X-dcgpu)
-        if key not in target.lower():
-            continue
-
+        print(f"Cheecking key '{key}' with info:\n  {info_for_key}")
         platform_for_key = info_for_key.get(platform)
 
         if not platform_for_key:
             # Some AMDGPU families are only supported on certain platforms.
+            print(f"  Skipping since this entry has no platform '{platform}'")
+            continue
+
+        # Check against both the inner "family" and the outer "key". If neither
+        # match then skip. Workflows are expected to use the inner "family"
+        # but manually triggered runs may use the outer "key" instead, so we'll
+        # be a bit lenient here.
+        # This needs a rework, see https://github.com/ROCm/TheRock/issues/1097.
+        family_for_platform = platform_for_key.get("family")
+        if target != family_for_platform and key not in target.lower():
+            print(
+                f"  Skipping since the target '{target}' does not match the family '{family_for_platform}'"
+            )
             continue
 
         # If there is a test machine available for this target, run on it.
         test_runs_on_machine = platform_for_key.get("test-runs-on")
         if test_runs_on_machine:
-            gha_set_output({"test-runs-on": test_runs_on_machine})
+            print(f"  Found runner: '{test_runs_on_machine}'")
+            return test_runs_on_machine
+
+    return ""
+
+
+def main(target: str, platform: str):
+    runner_label = get_runner_label(target, platform)
+    if runner_label:
+        gha_set_output({"test-runs-on": runner_label})
 
 
 if __name__ == "__main__":

build_tools/github_actions/fetch_package_targets.py

@@ -1,3 +1,50 @@
+"""This file helps generate a package target matrix for workflows.
+
+Environment variable inputs:
+    * 'AMDGPU_FAMILIES': A comma separated list of AMD GPU families, e.g.
+                    `gfx94X,gfx103x`, or empty for the default list
+    * 'THEROCK_PACKAGE_PLATFORM': "linux" or "windows"
+
+Outputs written to GITHUB_OUTPUT:
+    * 'package_targets': JSON list of the form
+        [
+            {
+                "amdgpu_family": "gfx94X-dcgpu",
+                "test_machine": "linux-mi300-1gpu-ossci-rocm"
+            },
+            {
+                "amdgpu_family": "gfx110X-dgpu",
+                "test_machine": ""
+            }
+        ]
+
+Example usage:
+
+```yml
+jobs:
+  setup_metadata:
+    runs-on: ubuntu-24.04
+    outputs:
+      package_targets: ${{ steps.configure.outputs.package_targets }}
+
+    steps:
+      - name: Generating package target matrix
+        id: configure
+        env:
+          AMDGPU_FAMILIES: ${{ inputs.families }}
+          THEROCK_PACKAGE_PLATFORM: "windows"
+        run: python ./build_tools/github_actions/fetch_package_targets.py
+
+  windows_packages:
+    name: ${{ matrix.target_bundle.amdgpu_family }}::Build Windows
+    runs-on: 'windows-2022'
+    needs: [setup_metadata]
+    strategy:
+      matrix:
+        target_bundle: ${{ fromJSON(needs.setup_metadata.outputs.package_targets) }}
+```
+"""
+
 import os
 import json
 from amdgpu_family_matrix import (
@@ -8,8 +55,6 @@
 
 from github_actions_utils import *
 
-# This file helps generate a package target matrix for workflows.
-
 
 def determine_package_targets(args):
     amdgpu_families = args.get("AMDGPU_FAMILIES")

build_tools/github_actions/tests/configure_target_run_test.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.fspath(Path(__file__).parent.parent))
+import configure_target_run
+
+
+class ConfigureTargetRunTest(unittest.TestCase):
+    def test_linux_gfx94X(self):
+        # gfx94x is the outer key used to construct workflow pipelines, while
+        # gfx94X-dcgpu is the inner key, which we use for package names. When
+        # run from a workflow, we expect to only work on the inner keys.
+        runner_label = configure_target_run.get_runner_label("gfx94x", "linux")
+        self.assertEqual(runner_label, "linux-mi325-1gpu-ossci-rocm")
+
+    def test_linux_gfx94X_dcgpu(self):
+        # gfx94x is the outer key used to construct workflow pipelines, while
+        # gfx94X-dcgpu is the inner key, which we use for package names. When
+        # run from a workflow, we expect to only work on the inner keys.
+        runner_label = configure_target_run.get_runner_label("gfx94X-dcgpu", "linux")
+        self.assertEqual(runner_label, "linux-mi325-1gpu-ossci-rocm")
+
+    def test_windows_gfx115x(self):
+        runner_label = configure_target_run.get_runner_label("gfx115x", "windows")
+        self.assertEqual(runner_label, "windows-strix-halo-gpu-rocm")
+
+    def test_windows_gfx1151(self):
+        runner_label = configure_target_run.get_runner_label("gfx1151", "windows")
+        self.assertEqual(runner_label, "windows-strix-halo-gpu-rocm")
+
+    def test_windows_gfx120X_all(self):
+        runner_label = configure_target_run.get_runner_label("gfx120X-all", "windows")
+        # No runner label yet.
+        self.assertEqual(runner_label, "")
+
+
+if __name__ == "__main__":
+    unittest.main()