# Pytest corpus checks for emulation/rocjitsu/.
#
# Fast smoke tests for rocjitsu. This is likely going to be added to TheRock
# tests, but it is currently a stopgap solution. It allows developers to
# quickly check that their changes to rocjitsu didn't break gfx1250 emulation.
name: "rocjitsu-test-corpus"

on:
  pull_request:
    paths:
      - "emulation/rocjitsu/**"
      - ".github/scripts/rocjitsu_corpus_translation_comment*.py"
      - ".github/workflows/rocjitsu-*.yml"
  push:
    branches:
      - develop
    paths:
      - "emulation/rocjitsu/**"
      - ".github/workflows/rocjitsu-*.yml"
  workflow_dispatch:
    inputs:
      corpus_repository:
        description: "Repository containing the rocjitsu pytest corpus"
        default: "ROCm/rocjitsu-test-corpus"
        required: true
      corpus_ref:
        description: "Branch, tag, or SHA containing the gfx1250 corpus suites"
        # Last updated on 2026/07/29.
        default: "42944a3ff37490441dcd0f1838e289a419af082d"
        required: true
      legacy_corpus_ref:
        description: "Branch, tag, or SHA for the existing corpus tests"
        # TODO: Drop this pin once the workflow's ROCm SDK includes the gfx1250
        # rocBLAS and hipBLASLt libraries required by the latest corpus.
        # Last updated on 2026/07/17.
        default: "aa54cc86c9ebff3eb840743b36ff8d9b3b2d43c4"
        required: true

concurrency:
  # Preserve every non-PR run, including manual reruns of one develop commit.
  # This intentionally prevents back-to-back develop pushes from cancelling
  # the full lane so each can publish. PR updates still supersede old revisions.
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true

permissions:
  contents: read

env:
  ROCJITSU_SOURCE_DIR: ${{ github.workspace }}/rocm-systems/emulation/rocjitsu
  ROCJITSU_BUILD_DIR: ${{ github.workspace }}/build
  ROCJITSU_CORPUS_DIR: ${{ github.workspace }}/rocjitsu-test-corpus
  ROCJITSU_DBT_CORPUS_DIR: ${{ github.workspace }}/rocjitsu-dbt-test-corpus
  ROCJITSU_DBT_VENV: ${{ github.workspace }}/gfx1250-dbt-venv-${{ github.run_id }}-${{ github.run_attempt }}
  ROCJITSU_HSACO_CORPUS: ${{ github.workspace }}/gfx1250-packaged-hsacos-${{ github.run_id }}-${{ github.run_attempt }}
  ROCJITSU_DBT_CORPUS_REF: 42944a3ff37490441dcd0f1838e289a419af082d
  ROCJITSU_DBT_SHA_FRAGMENTS: ${{ github.workspace }}/gfx1250-dbt-sha-pairs-${{ github.run_id }}-${{ github.run_attempt }}/fragments
  ROCJITSU_DBT_SHA_MANIFEST: ${{ github.workspace }}/gfx1250-dbt-sha-pairs-${{ github.run_id }}-${{ github.run_attempt }}/gfx1250-b0-a0-sha-pairs.json
  ROCM_SDK_VERSION: 7.15.0a20260728
  UV_VERSION: 0.9.26

jobs:
  test:
    runs-on: azure-linux-scale-rocm
    name: test (${{ matrix.name }})
    container:
      image: ghcr.io/rocm/no_rocm_image_ubuntu24_04@sha256:4150afe4759d14822f0e3f8930e1124f26e11f68b5c7b91ec9a02b20b1ebbb98
      options: --user 0:0
      env:
        DEBIAN_FRONTEND: noninteractive
    continue-on-error: ${{ matrix.allow_failure }}
    strategy:
      fail-fast: false
      matrix:
        include:
          - name: release
            allow_failure: false
            # 20,000 verified objects completed in 148.97s locally; 20 minutes
            # leaves substantial runner headroom while this release-only gate lands.
            verify_dbt_idempotence: 1
            dbt_timeout: 60
            dbt_memory_limit_mib: 4096
            dbt_job_timeout: 20
            test_regex: ''
            build_type: Release
            enable_asan: 0
            enable_ubsan: 0
            enable_tsan: 0
            enable_expensive_checks: 0
            sanitizer_runtime: STATIC
          - name: asan-ubsan
            allow_failure: true
            # Keep the first corpus gate on the fastest lane. Focused second-pass
            # paths remain covered by the sanitizer test suite.
            verify_dbt_idempotence: 0
            dbt_timeout: 180
            dbt_memory_limit_mib: 4096
            dbt_job_timeout: 30
            test_regex: ''
            build_type: RelWithDebInfo
            enable_asan: 1
            enable_ubsan: 1
            enable_tsan: 0
            enable_expensive_checks: 1
            sanitizer_runtime: SHARED
          - name: tsan
            allow_failure: false
            verify_dbt_idempotence: 0
            dbt_timeout: 30
            dbt_memory_limit_mib: 4096
            dbt_job_timeout: 20
            run_static_asan_launch: true
            test_regex: ''
            build_type: RelWithDebInfo
            enable_asan: 0
            enable_ubsan: 0
            enable_tsan: 1
            enable_expensive_checks: 0
            sanitizer_runtime: SHARED
          - name: asan-ubsan-gcc
            allow_failure: true
            verify_dbt_idempotence: 0
            # GCC's combined sanitizers need additional headroom on the largest
            # packaged code objects.
            dbt_timeout: 180
            dbt_memory_limit_mib: 8192
            dbt_job_timeout: 30
            test_regex: ''
            build_type: RelWithDebInfo
            enable_asan: 1
            enable_ubsan: 1
            enable_tsan: 0
            enable_expensive_checks: 1
            sanitizer_runtime: SHARED
            c_compiler: gcc
            cxx_compiler: g++

    steps:
      - name: Install base dependencies
        run: |
          apt-get update
          apt-get install -y --no-install-recommends \
            build-essential \
            ca-certificates \
            cmake \
            git \
            libclang-rt-dev \
            libdrm-dev \
            ninja-build \
            clang

      - name: Checkout rocm-systems
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
        with:
          path: rocm-systems
          sparse-checkout: |
            emulation/rocjitsu
            .github
            shared/machine-readable-isa/isa

      - name: Checkout rocjitsu corpus
        if: matrix.name == 'release'
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
        with:
          repository: ${{ github.event.inputs.corpus_repository || 'ROCm/rocjitsu-test-corpus' }}
          # Last updated on 2026/07/17.
          ref: ${{ github.event.inputs.legacy_corpus_ref || 'aa54cc86c9ebff3eb840743b36ff8d9b3b2d43c4' }}
          path: rocjitsu-test-corpus

      - name: Checkout gfx1250 corpus
        if: matrix.enable_tsan == 0
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
        with:
          repository: ${{ github.event.inputs.corpus_repository || 'ROCm/rocjitsu-test-corpus' }}
          # Last updated on 2026/07/29.
          ref: ${{ github.event.inputs.corpus_ref || env.ROCJITSU_DBT_CORPUS_REF }}
          path: rocjitsu-dbt-test-corpus

      - name: Set up Python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version: "3.12"

      - name: Set up uv
        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
        with:
          version: ${{ env.UV_VERSION }}

      - name: Test DBT SHA-pair tooling
        if: matrix.name == 'release'
        run: |
          python3 \
            "${ROCJITSU_SOURCE_DIR}/tests/corpus/test-record-gfx1250-dbt-sha-pairs.py"
          python3 \
            "${GITHUB_WORKSPACE}/rocm-systems/.github/scripts/test-rocjitsu-corpus-translation-comment.py"

      - name: Install ROCm SDK
        run: |
          uv pip install --system --prerelease allow \
            --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
            "rocm[devel,libraries]==${ROCM_SDK_VERSION}"
          ROCM_LIB="$(rocm-sdk path --root)"/lib
          echo "LD_LIBRARY_PATH=${ROCM_LIB}:${LD_LIBRARY_PATH:-}" >> "${GITHUB_ENV}"

      - name: Build rocjitsu
        id: build_rocjitsu
        working-directory: ${{ env.ROCJITSU_SOURCE_DIR }}
        shell: bash
        run: |
          ROCMINFO=RocminfoTest
          RCCL_DAEMON=RcclDaemonTest
          EXCLUDED_TESTS="${ROCMINFO}|${RCCL_DAEMON}"
          ASAN_UBSAN_EXCLUDED_TESTS=(
            "HsaTest\.InitSucceeded"
            "HsaTest\.GpuAgentFound"
            "Cdna4ToCdna3SimulatedDispatchTest\..*"
            "Cdna4ToCdna3DbtGuestTest\..*"
            "HipMemcpyTest\.RoundTripFloat"
            "HipMemcpyTest\.RoundTripInt"
            "HipMemcpyTest\.DeviceToDevice"
            "HipVectorAddTest\.CorrectResult"
            "DaemonTest\.HipVectorAdd"
            "DaemonTest\.HipMemcpyRoundTripFloat"
            "DaemonTest\.HipMemcpyRoundTripInt"
            "DaemonTest\.HipMemcpyDeviceToDevice"
            "DaemonTest\.TwoIndependentClients"
            "DaemonTest\.LoggingPlugin"
            "BfeRegressionTest\.ThreadIdxY"
            "LoggingTest\.dispatch_logged"
            "ProfiledPluginTest\.hook_profile_output"
            "CvtNarrow\.AllTests"
            "RaceTest\..*"
          )
          TSAN_EXCLUDED_TESTS=(
            "${ASAN_UBSAN_EXCLUDED_TESTS[@]}"
            # This test has a five-second wall-clock assertion that becomes
            # load-sensitive at the TSan job's CI-level parallelism.
            "DaemonApi\.FullListenerQueueDoesNotBlockOrRemoveSocket"
          )

          TEST_REGEX="${{ matrix.test_regex }}"
          CMAKE_CONFIG_FLAGS=()
          if [[ "${{ matrix.enable_asan }}" == "1" && "${{ matrix.enable_ubsan }}" == "1" ]]; then
            EXCLUDED_TESTS="${EXCLUDED_TESTS}|$(IFS='|'; echo "${ASAN_UBSAN_EXCLUDED_TESTS[*]}")"
            CMAKE_CONFIG_FLAGS+=(
              -DCMAKE_C_FLAGS_RELWITHDEBINFO="-O2 -g"
              -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-O2 -g"
            )
          fi
          if [[ "${{ matrix.enable_tsan }}" == "1" ]]; then
            EXCLUDED_TESTS="${EXCLUDED_TESTS}|$(IFS='|'; echo "${TSAN_EXCLUDED_TESTS[*]}")"
          fi
          if [[ -n "${{ matrix.c_compiler }}" ]]; then
            CMAKE_CONFIG_FLAGS+=(-DCMAKE_C_COMPILER="${{ matrix.c_compiler }}")
          fi
          if [[ -n "${{ matrix.cxx_compiler }}" ]]; then
            CMAKE_CONFIG_FLAGS+=(-DCMAKE_CXX_COMPILER="${{ matrix.cxx_compiler }}")
          fi

          CXXFLAGS=""
          if [[ -z "${{ matrix.cxx_compiler }}" || "${{ matrix.cxx_compiler }}" == *clang* ]]; then
            CXXFLAGS="-Wno-error=unknown-warning-option -Wno-error=nested-anon-types"
          fi
          ROCM_PATH=`rocm-sdk path --root` \
            cmake -B "${ROCJITSU_BUILD_DIR}" -G Ninja \
            -DCMAKE_BUILD_TYPE="${{ matrix.build_type }}" \
            -DCMAKE_C_FLAGS="${CFLAGS:-}" \
            -DCMAKE_CXX_FLAGS="${CXXFLAGS:-}" \
            "${CMAKE_CONFIG_FLAGS[@]}" \
            -DRJ_ENABLE_ASAN=${{ matrix.enable_asan }} \
            -DRJ_ENABLE_UBSAN=${{ matrix.enable_ubsan }} \
            -DRJ_ENABLE_TSAN=${{ matrix.enable_tsan }} \
            -DRJ_ENABLE_EXPENSIVE_CHECKS=${{ matrix.enable_expensive_checks }} \
            -DRJ_SANITIZER_RUNTIME=${{ matrix.sanitizer_runtime }}

          # Set a conservative number of workers to avoid OOM and excessive system load.
          WORKERS="$(( ($(nproc) + 1) / 2 ))"
          cmake --build "${ROCJITSU_BUILD_DIR}" -j "${WORKERS}"

          CTEST_SELECTION=()
          if [[ -n "${TEST_REGEX}" ]]; then
            CTEST_SELECTION=(-R "${TEST_REGEX}")
          fi
          ctest --test-dir "${ROCJITSU_BUILD_DIR}" \
            "${CTEST_SELECTION[@]}" \
            -E "${EXCLUDED_TESTS}" \
            --output-on-failure \
            -j "${WORKERS}"

          echo "${ROCJITSU_BUILD_DIR}/tools/rocjitsu" >> "${GITHUB_PATH}"
          echo "CXXFLAGS=" >> "${GITHUB_ENV}"

      - name: Test static ASan launcher preload
        if: matrix.run_static_asan_launch
        working-directory: ${{ env.ROCJITSU_SOURCE_DIR }}
        shell: bash
        run: |
          STATIC_ASAN_BUILD_DIR="${ROCJITSU_BUILD_DIR}-asan-static-launch-preload"
          CXXFLAGS="-Wno-error=unknown-warning-option -Wno-error=nested-anon-types"
          ROCM_PATH="$(rocm-sdk path --root)" \
            cmake -B "${STATIC_ASAN_BUILD_DIR}" -G Ninja \
            -DCMAKE_BUILD_TYPE=RelWithDebInfo \
            -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
            -DRJ_ENABLE_ASAN=1 \
            -DRJ_ENABLE_UBSAN=0 \
            -DRJ_ENABLE_TSAN=0 \
            -DRJ_ENABLE_EXPENSIVE_CHECKS=0 \
            -DRJ_SANITIZER_RUNTIME=STATIC

          cmake --build "${STATIC_ASAN_BUILD_DIR}" \
            --target launch_preload_test
          ctest --test-dir "${STATIC_ASAN_BUILD_DIR}" \
            -R '^LaunchPreloadTest\.' \
            --output-on-failure

      - name: Install corpus test dependencies
        if: matrix.name == 'release'
        working-directory: ${{ env.ROCJITSU_CORPUS_DIR }}
        run: |
          uv pip install --system -r requirements.txt
          uv pip install --system --prerelease allow \
            --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
            "rocm-sdk-device-gfx942==${ROCM_SDK_VERSION}" \
            "rocm-sdk-device-gfx950==${ROCM_SDK_VERSION}"
          rocm-sdk init

      - name: Run amdisa tests
        if: matrix.name == 'release'
        working-directory: ${{ env.ROCJITSU_SOURCE_DIR }}
        run: |
          uv pip install --system -e lib/python
          python -m pytest lib/python/amdisa/tests

      - name: Run corpus tests
        if: matrix.name == 'release'
        working-directory: ${{ env.ROCJITSU_CORPUS_DIR }}
        shell: bash
        env:
          ROCJITSU_ROOT: ${{ env.ROCJITSU_SOURCE_DIR }}
          ROCJITSU_BUILD: ${{ env.ROCJITSU_BUILD_DIR }}
        run: |

          ROCM_PATH="$(rocm-sdk path --root)"
          export ROCM_PATH
          export ROCJITSU_SOURCE_DIR

          corpus_test_status=0

          WORKERS="$(nproc)"
          if (( WORKERS > 16 )); then
            WORKERS=16
          fi
          corpus_test_flags=(
            --workers "${WORKERS}" \
            --soft-timeout 15 \
            --hard-timeout 30 \
            --rerun-failed \
          )
          bash "${ROCJITSU_SOURCE_DIR}/tests/corpus/run-corpus-tests.sh" "${corpus_test_flags[@]}" || corpus_test_status=$?
          exit "${corpus_test_status}"

      - name: Compare plain and translated gfx1250 simulator runs
        if: ${{ !cancelled() && matrix.name == 'release' && steps.build_rocjitsu.outcome == 'success' }}
        timeout-minutes: 45
        working-directory: ${{ env.ROCJITSU_DBT_CORPUS_DIR }}
        shell: bash
        env:
          ROCJITSU_SEMANTIC_TIMEOUT_SECONDS: 120
        run: |
          ROCM_PATH="$(rocm-sdk path --root)"
          export ROCM_PATH
          LAUNCHER="${ROCJITSU_BUILD_DIR}/tools/rocjitsu/rocjitsu"
          CONFIG="${ROCJITSU_SOURCE_DIR}/configs/gfx1250.json"
          HOTSWAP="${ROCJITSU_BUILD_DIR}/lib/rocjitsu/src/rocjitsu/hooks/libhsa_hotswap_rocjitsu.so"
          test -f "${HOTSWAP}"
          # Disable ROCr's built-in mechanism in both legs. Load the branch-built
          # hook explicitly so the candidate leg qualifies this checkout. Keep
          # every env option before the shared NAME=VALUE assignment.
          COMMON_UNSETS="-u LD_PRELOAD -u HSA_HOTSWAP_ENABLE"
          COMMON_HOTSWAP_ENV="HSA_HOTSWAP_DISABLE=1"
          PLAIN_WRAPPER="env ${COMMON_UNSETS} -u HSA_TOOLS_LIB -u HSA_TOOLS_DISABLE_REGISTER -u HSA_HOTSWAP_VERBOSE ${COMMON_HOTSWAP_ENV} ${LAUNCHER} --config ${CONFIG} --"
          TRANSLATED_WRAPPER="env ${COMMON_UNSETS} ${COMMON_HOTSWAP_ENV} HSA_TOOLS_DISABLE_REGISTER=1 HSA_TOOLS_LIB=${HOTSWAP} HSA_HOTSWAP_VERBOSE=1 ${LAUNCHER} --config ${CONFIG} --"

          python3 "${ROCJITSU_SOURCE_DIR}/tests/corpus/test-validate-gfx1250-semantic-translations.py"

          python3 -m pytest tests/test_corpus.py \
            --target gfx1250 \
            --suite semantics \
            --run-tests-config "${ROCJITSU_SOURCE_DIR}/tests/corpus/gfx1250_b0_a0_semantic_tests.json" \
            --run-wrapper "${PLAIN_WRAPPER}" \
            --comparison-run-wrapper "${TRANSLATED_WRAPPER}" \
            --comparison-required-stderr "[hsa-hotswap-rj] eager translation " \
            --comparison-required-stderr "outcome=translated" \
            --comparison-required-stderr "translation_status=0 status=0" \
            --artifact-directory .pytest-artifacts/gfx1250-semantic-qualification \
            --timeout "${ROCJITSU_SEMANTIC_TIMEOUT_SECONDS}" \
            -q \
            --tb=short

          python3 "${ROCJITSU_SOURCE_DIR}/tests/corpus/validate-gfx1250-semantic-translations.py" \
            --translator "${ROCJITSU_BUILD_DIR}/tools/rj_dbt_translate" \
            --selection "${ROCJITSU_SOURCE_DIR}/tests/corpus/gfx1250_b0_a0_semantic_tests.json" \
            --expectations "${ROCJITSU_SOURCE_DIR}/tests/corpus/gfx1250_b0_a0_semantic_rewrites.json" \
            --artifact-directory .pytest-artifacts/gfx1250-semantic-qualification \
            --expected-runtime-translations 2

      - name: Upload gfx1250 semantic qualification logs
        if: ${{ always() && matrix.name == 'release' }}
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: gfx1250-semantic-qualification-${{ matrix.name }}
          path: |
            ${{ env.ROCJITSU_DBT_CORPUS_DIR }}/.pytest-artifacts/gfx1250-semantic-qualification/**/logs
            ${{ env.ROCJITSU_DBT_CORPUS_DIR }}/.pytest-artifacts/gfx1250-semantic-qualification/translation-diffs
          if-no-files-found: ignore
          retention-days: 7

      - name: Extract pinned gfx1250 packaged HSACOs
        id: extract_dbt
        if: ${{ !cancelled() && matrix.enable_tsan == 0 && steps.build_rocjitsu.outcome == 'success' }}
        timeout-minutes: 10
        working-directory: ${{ env.ROCJITSU_DBT_CORPUS_DIR }}
        shell: bash
        run: |
          uv venv --python 3.12 "${ROCJITSU_DBT_VENV}"
          uv pip install \
            --python "${ROCJITSU_DBT_VENV}/bin/python" \
            "pytest>=5.4.1" \
            "pytest-xdist>=1.32.0"
          uv pip install \
            --python "${ROCJITSU_DBT_VENV}/bin/python" \
            -r "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/requirements-gfx1250-dbt.txt"
          "${ROCJITSU_DBT_VENV}/bin/rocm-sdk" init

          DBT_ROCM_PATH="$("${ROCJITSU_DBT_VENV}/bin/rocm-sdk" path --root)"
          LD_LIBRARY_PATH="${DBT_ROCM_PATH}/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}" \
            "${ROCJITSU_DBT_VENV}/bin/python" \
            scripts/extract_gfx1250_hsacos.py \
            --environment "${ROCJITSU_DBT_VENV}" \
            --destination "${ROCJITSU_HSACO_CORPUS}"

      - name: Run gfx1250 DBT corpus tests
        id: run_dbt
        if: ${{ !cancelled() && matrix.enable_tsan == 0 && steps.extract_dbt.outcome == 'success' }}
        timeout-minutes: ${{ matrix.dbt_job_timeout }}
        working-directory: ${{ env.ROCJITSU_DBT_CORPUS_DIR }}
        shell: bash
        run: |
          DBT_ROCM_PATH="$("${ROCJITSU_DBT_VENV}/bin/rocm-sdk" path --root)"
          DBT_TRANSLATOR_BINARY="${ROCJITSU_BUILD_DIR}/tools/rj_dbt_translate"
          DBT_TRANSLATOR="${DBT_TRANSLATOR_BINARY}"
          if [[ "${{ matrix.verify_dbt_idempotence }}" == "1" ]]; then
            DBT_TRANSLATOR="${RUNNER_TEMP}/rj_dbt_translate-verify-idempotence"
            printf '#!/usr/bin/env bash\nexec %q --verify-idempotence "$@"\n' \
              "${DBT_TRANSLATOR_BINARY}" \
              > "${DBT_TRANSLATOR}"
            chmod +x "${DBT_TRANSLATOR}"
          fi
          DBT_WORKERS="$(nproc)"
          if (( DBT_WORKERS > 16 )); then
            DBT_WORKERS=16
          fi
          "${ROCJITSU_DBT_VENV}/bin/python" -m pytest tests/test_corpus.py \
            --target gfx1250 \
            --suite dbt \
            --dbt-corpus "${ROCJITSU_HSACO_CORPUS}" \
            --dbt-translator "${DBT_TRANSLATOR}" \
            --dbt-llvm-objdump "${DBT_ROCM_PATH}/lib/llvm/bin/llvm-objdump" \
            --dbt-package-lock "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_20260726_package_lock.json" \
            --dbt-expected-failures "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_b0_a0_expected_failures.json" \
            --dbt-expected-rewrites "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_b0_a0_expected_rewrites.json" \
            --dbt-allow-incomplete-corpus \
            --dbt-timeout "${{ matrix.dbt_timeout }}" \
            --dbt-memory-limit-mib "${{ matrix.dbt_memory_limit_mib }}" \
            --artifact-directory .pytest-artifacts/gfx1250-dbt \
            -n "${DBT_WORKERS}" \
            --durations=0 \
            -q \
            -rxX \
            --tb=short

      - name: Collect gfx1250 B0-to-A0 SHA pairs
        id: collect_dbt_sha_pairs
        if: >-
          matrix.name == 'release' &&
          steps.run_dbt.outcome == 'success' &&
          (github.event_name == 'pull_request' ||
           (github.ref == 'refs/heads/develop' &&
            (github.event_name == 'push' ||
             (github.event_name == 'workflow_dispatch' &&
              github.event.inputs.corpus_repository == 'ROCm/rocjitsu-test-corpus' &&
              github.event.inputs.corpus_ref == env.ROCJITSU_DBT_CORPUS_REF))))
        timeout-minutes: 15
        working-directory: ${{ env.ROCJITSU_DBT_CORPUS_DIR }}
        shell: bash
        run: |
          DBT_WORKERS="$(nproc)"
          if (( DBT_WORKERS > 16 )); then
            DBT_WORKERS=16
          fi
          python3 \
            "${ROCJITSU_SOURCE_DIR}/tests/corpus/record-gfx1250-dbt-sha-pairs.py" \
            collect \
            --translator "${ROCJITSU_BUILD_DIR}/tools/rj_dbt_translate" \
            --corpus "${ROCJITSU_HSACO_CORPUS}" \
            --input-manifest "${ROCJITSU_HSACO_CORPUS}/manifests/SHA256SUMS" \
            --expected-failures "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_b0_a0_expected_failures.json" \
            --fragments "${ROCJITSU_DBT_SHA_FRAGMENTS}" \
            --workers "${DBT_WORKERS}" \
            --timeout "${{ matrix.dbt_timeout }}"

      - name: Finalize gfx1250 B0-to-A0 SHA pairs
        id: finalize_dbt_sha_pairs
        if: matrix.name == 'release' && steps.collect_dbt_sha_pairs.outcome == 'success'
        timeout-minutes: 2
        working-directory: ${{ env.ROCJITSU_DBT_CORPUS_DIR }}
        shell: bash
        run: |
          python3 \
            "${ROCJITSU_SOURCE_DIR}/tests/corpus/record-gfx1250-dbt-sha-pairs.py" \
            finalize \
            --fragments "${ROCJITSU_DBT_SHA_FRAGMENTS}" \
            --output "${ROCJITSU_DBT_SHA_MANIFEST}" \
            --input-manifest "${ROCJITSU_HSACO_CORPUS}/manifests/SHA256SUMS" \
            --expected-failures "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_b0_a0_expected_failures.json" \
            --expected-rewrites "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_b0_a0_expected_rewrites.json" \
            --package-lock "${ROCJITSU_SOURCE_DIR}/tests/corpus/dbt/gfx1250_20260726_package_lock.json" \
            --source-commit "${GITHUB_SHA}" \
            --corpus-commit "$(git rev-parse HEAD)" \
            --rocm-sdk-version "${ROCM_SDK_VERSION}"

      - name: Upload develop gfx1250 B0-to-A0 SHA pairs
        if: >-
          matrix.name == 'release' &&
          steps.finalize_dbt_sha_pairs.outcome == 'success' &&
          github.event_name != 'pull_request'
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: gfx1250-b0-a0-sha-pairs
          path: ${{ env.ROCJITSU_DBT_SHA_MANIFEST }}
          if-no-files-found: error
          retention-days: 45

      # PR jobs intentionally have no write token. They publish only data here;
      # the trusted workflow_run job downloads it and maintains the PR comment.
      - name: Upload PR gfx1250 B0-to-A0 SHA pairs
        if: >-
          matrix.name == 'release' &&
          steps.finalize_dbt_sha_pairs.outcome == 'success' &&
          github.event_name == 'pull_request'
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: gfx1250-b0-a0-sha-pairs-candidate
          path: ${{ env.ROCJITSU_DBT_SHA_MANIFEST }}
          if-no-files-found: error
          retention-days: 7

      # Debugging aid only. The pinned extraction is reproducible, so retain
      # translator logs but never upload the extracted HSACOs.
      - name: Upload gfx1250 DBT diagnostic logs
        if: always() && matrix.enable_tsan == 0
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: gfx1250-dbt-logs-${{ matrix.name }}
          path: ${{ env.ROCJITSU_DBT_CORPUS_DIR }}/.pytest-artifacts/gfx1250-dbt
          if-no-files-found: ignore
          retention-days: 7