Split CI to build and test jobs (#8359)

The CI has been re-organized with the following:
```
ci.yml (Main Orchestrator)
├── filter job
│   ├── Documentation Only? → Yes → Skip CI
│   └── Documentation Only? → No → Continue CI
│
├── Build Jobs
│   └── ci-slang-build.yml
│       ├── common-setup action
│       ├── Build & Package
│       └── Upload Artifacts (Build package and Tests package)
│
└── Test Jobs
    └── ci-slang-test.yml
        └── common-test-setup action
            ├── Download Tests Artifacts ← (from Build)
            └── Run Tests
```

To achieve fine-grained build->test dependency, instead of using `matrix
strategy` in single build (or single test) job, the main ci.yml
statically defines the each config of the build and test job.
e.g. `build-windows-debug-cl-x86_64-gpu` and
`test-windows-debug-cl-x86_64-gpu` are a pair of the build-test job for
the windows/debug/ci config.


Closes: https://github.com/shader-slang/slang/issues/6728

---------

Co-authored-by: slangbot <ellieh+slangbot@nvidia.com>
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>

1 files changed, 163 insertions, 365 deletions

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2886821af..61ed00769 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,106 +10,13 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.event_name != 'push' }}
 jobs:
-  build:
-    strategy:
-      matrix:
-        os: [linux, macos, windows]
-        config: [debug, release]
-        compiler: [gcc, clang, cl]
-        platform: [x86_64, aarch64, wasm]
-        exclude:
-          # Default to x64, but aarch64 on osx
-          - { os: linux, platform: aarch64 }
-          - { os: windows, platform: aarch64 }
-          - { os: macos, platform: x86_64 }
-          - { os: linux, config: debug, platform: wasm }
-          - { os: windows, platform: wasm }
-          - { os: macos, platform: wasm }
-          # Unused compiler configs
-          - { os: linux, compiler: clang }
-          - { os: linux, compiler: cl }
-          - { os: windows, compiler: gcc }
-          - { os: windows, compiler: clang }
-          - { os: macos, compiler: gcc }
-          - { os: macos, compiler: cl }
-        include:
-          - { os: linux, runs-on: ubuntu-22.04 }
-          - { os: macos, runs-on: macos-latest }
-          - { os: windows, runs-on: windows-latest }
-          # Warnings are treated as errors by default.
-          # But we may want to disable it temporarily.
-          - { os: linux, warnings-as-errors: true }
-          - { os: macos, warnings-as-errors: true }
-          - { os: windows, warnings-as-errors: true }
-          # Set a test category depending on the config, smoke by default,
-          # quick or full conditionally otherwise
-          - test-category: smoke
-          - { os: windows, test-category: quick }
-          - { config: release, test-category: full }
-          # default not full gpu tests
-          - full-gpu-tests: false
-          - build-llvm: true
-          - { platform: wasm, build-llvm: false }
-          # The runners don't have a GPU by default except for the self-hosted ones
-          - has-gpu: false
-          # Self-hosted aarch64 build
-          - os: linux
-            config: release
-            compiler: gcc
-            platform: aarch64
-            test-category: smoke
-            full-gpu-tests: false
-            runs-on: ubuntu-24.04-arm
-            has-gpu: false
-            build-llvm: false
-          # Self-hosted full gpu build - release
-          - os: windows
-            config: release
-            compiler: cl
-            platform: x86_64
-            test-category: full
-            # Run full gpu tests on PR/Main branch, but not on merge_group.
-            full-gpu-tests: true
-            # Run on self-hosted machine when using full-gpu-tests, otherwise on github runners.
-            runs-on: ["Windows", "self-hosted", "GCP-T4"]
-            has-gpu: true
-            server-count: 8
-          # Self-hosted full gpu build - debug
-          - os: windows
-            config: debug
-            compiler: cl
-            platform: x86_64
-            test-category: full
-            full-gpu-tests: true
-            runs-on: ["Windows", "self-hosted", "GCP-T4"]
-            has-gpu: true
-            server-count: 8
-          # Enable GPU tests for macOS release
-          - os: macos
-            config: release
-            full-gpu-tests: true
-            has-gpu: true
-            server-count: 3
-          # Enable debug layers for all by default
-          - enable-debug-layers: true
-      fail-fast: false
-    runs-on: ${{ matrix.runs-on }}
-
-    defaults:
-      run:
-        shell: bash
-
+  filter:
+    runs-on: ubuntu-latest
+    outputs:
+      should-run: ${{ steps.filter.outputs.should-run }}
     steps:
-      - name: Add bash to PATH
-        shell: pwsh
-        if: ${{matrix.os == 'windows'}}
-        run: |
-          Add-Content -Path $env:GITHUB_PATH -Value "C:\\Program Files\\Git\\bin"
-          Add-Content -Path $env:GITHUB_PATH -Value "C:\\Program Files\\Git\\usr\\bin"
-
       - uses: actions/checkout@v4
         with:
-          submodules: "recursive"
           fetch-depth: "2"
       - id: filter
         run: |
@@ -135,272 +42,163 @@ jobs:
             shouldRun=true
           fi
           echo "should-run=$shouldRun" >> $GITHUB_OUTPUT
-      - name: Install dependencies
-        run: |
-          if [[ "${{ matrix.os }}" = "linux" ]]; then
-              sudo apt-get update
-              sudo apt-get install -y libx11-dev 
-          fi
-      - name: Setup Node.js
-        if: matrix.os == 'linux'
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20.x"
-      - name: Setup
-        if: steps.filter.outputs.should-run == 'true'
-        uses: ./.github/actions/common-setup
-        with:
-          os: ${{matrix.os}}
-          compiler: ${{matrix.compiler}}
-          platform: ${{matrix.platform}}
-          config: ${{matrix.config}}
-          build-llvm: ${{ matrix.build-llvm }}
-
-      # Don't need to check this on every config
-      - name: Check Stable Names Table
-        if: ${{ matrix.os == 'linux' && matrix.config == 'debug' }}
-        run: ./extras/check-ir-stable-names-gh-actions.sh
-
-      - name: Check Version Constants
-        id: check-ir-versions
-        if: ${{ matrix.os == 'linux' && matrix.config == 'debug' && github.event_name == 'pull_request' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_EVENT_NAME: ${{ github.event_name }}
-          GITHUB_EVENT_PULL_REQUEST_NUMBER: ${{ github.event.pull_request.number }}
-          GITHUB_BASE_REF: ${{ github.base_ref }}
-        run: ./extras/check-inst-version-changes.sh
-
-      - name: Upload IR version check results
-        if: ${{ steps.check-ir-versions.outputs.artifact_created == 'true' }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: ir-version-check-results
-          path: ir-version-check-artifact/
-          retention-days: 1
-
-      - name: Build Slang
-        if: steps.filter.outputs.should-run == 'true'
-        run: |
-          echo "cmake version: $(cmake --version)"
 
-
-          if [[ "${{ matrix.platform }}" = "wasm" ]]; then
-              git clone https://github.com/emscripten-core/emsdk.git
-              pushd emsdk
-                ./emsdk install latest
-                ./emsdk activate latest
-                source ./emsdk_env.sh
-              popd
-              cmake --workflow --preset generators --fresh
-              mkdir generators
-              cmake --install build --config Release --component generators --prefix generators
-              emcmake cmake -DSLANG_GENERATORS_PATH=generators/bin --preset emscripten -DSLANG_SLANG_LLVM_FLAVOR=DISABLE
-              cmake --build --preset emscripten --config "$cmake_config" --target slang-wasm
-              mkdir "build.em/$cmake_config/bin/smoke"
-              cp tests/wasm/smoke/* "build.em/$cmake_config/bin/smoke/"
-              cd "build.em/$cmake_config/bin"
-              [ -f "slang-wasm.wasm" ]
-              [ -f "slang-wasm.js" ]
-              node smoke/smoke-test.js smoke/rand_float.slang computeMain
-          else
-            # Set up ccache launcher arguments if ccache is available (self-hosted runners)
-            cmake_launcher_defines=()
-            if [[ -n "${{ env.ccache_symlinks_path }}" ]]; then
-              cmake_launcher_defines+=("-DCMAKE_C_COMPILER_LAUNCHER=${{ env.ccache_symlinks_path }}")
-              cmake_launcher_defines+=("-DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.ccache_symlinks_path }}")
-            fi
-
-            if [[ "${{ matrix.os }}" =~ "windows" && "${{ matrix.config }}" == "debug" ]]; then
-              # Doing a debug build will try to link against a release built llvm, this
-              # is a problem on Windows, so make slang-llvm in release build and use
-              # that as though it's a fetched binary via these presets.
-              cmake --workflow --preset slang-llvm
-              # Configure, pointing to our just-generated slang-llvm archive
-              cmake --preset default --fresh \
-                -DSLANG_SLANG_LLVM_FLAVOR=FETCH_BINARY \
-                "-DSLANG_SLANG_LLVM_BINARY_URL=$(pwd)/build/dist-release/slang-llvm.zip" \
-                "-DCMAKE_COMPILE_WARNING_AS_ERROR=${{matrix.warnings-as-errors}}" \
-                "${cmake_launcher_defines[@]}"
-              cmake --workflow --preset "${{matrix.config}}"
-            elif [[ "${{ matrix.build-llvm }}" = "false" ]]; then
-              # linux aarch64 cannot build llvm.
-              cmake --preset default --fresh \
-                -DSLANG_SLANG_LLVM_FLAVOR=DISABLE \
-                -DCMAKE_COMPILE_WARNING_AS_ERROR=${{matrix.warnings-as-errors}} \
-                "${cmake_launcher_defines[@]}"
-              cmake --workflow --preset "${{matrix.config}}"
-            else
-              # Otherwise, use the "system" llvm we have just build or got from the
-              # cache in the setup phase
-              cmake --preset default --fresh \
-                -DSLANG_SLANG_LLVM_FLAVOR=USE_SYSTEM_LLVM \
-                -DCMAKE_COMPILE_WARNING_AS_ERROR=${{matrix.warnings-as-errors}} \
-                "${cmake_launcher_defines[@]}"
-              cmake --workflow --preset "${{matrix.config}}"
-            fi
-          fi
-
-      - name: Check documented compiler versions
-        if: steps.filter.outputs.should-run == 'true'
-        run: bash extras/verify-documented-compiler-version.sh
-
-      - name: Check runtime environment
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm' && (matrix.platform != 'aarch64' || matrix.os == 'macos')
-        run: |
-          smokeResult=$("$bin_dir/slang-test" tests/render/check-backend-support-on-ci.slang)
-          supportedBackends="$(echo "$smokeResult" | grep 'Supported backends: ')"
-
-          # LLVM is required to run the filecheck
-          echo "Checking llvm ..." && echo "$supportedBackends" | grep -q llvm
-
-          if [[ "${{matrix.os}}" == "macos" ]]
-          then
-            for backend in metal
-            do
-              echo "Checking $backend ..." && echo "$supportedBackends" | grep -q "$backend"
-            done
-
-            for api in 'mtl,metal'
-            do
-              echo "Checking $api ..." && echo "$smokeResult" | grep -q "Check $api: Supported"
-            done
-          else
-            if [[ "${{matrix.full-gpu-tests}}" == "true" ]]
-          then
-            for backend in fxc dxc glslang visualstudio genericcpp nvrtc metal tint # clang gcc
-            do
-              echo "Checking $backend ..." && echo "$supportedBackends" | grep -q "$backend"
-            done
-
-            for api in 'vk,vulkan' 'dx12,d3d12' 'dx11,d3d11' 'cuda' 'wgpu,webgpu'
-            do
-              echo "Checking $api ..." && echo "$smokeResult" | grep -q "Check $api: Supported"
-            done
-
-            echo "Printing CUDA compiler version: ..." && nvcc --version
-            echo "Printing GPU driver version: ..." && nvidia-smi -q | grep Version
-            echo "Printing Vulkan SDK version: ..." && vulkaninfo | grep -i version
-            fi
-          fi
-
-      - name: Test Slang
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm' && (matrix.platform != 'aarch64' || matrix.os == 'macos')
-        run: |
-          export SLANG_RUN_SPIRV_VALIDATION=1
-          export SLANG_USE_SPV_SOURCE_LANGUAGE_UNKNOWN=1
-          if [ "${{ matrix.enable-debug-layers }}" == "true" ]; then
-            export VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation
-          fi
-          if [[ "${{matrix.full-gpu-tests}}" == "true" ]]; then
-            "$bin_dir/slang-test" \
-              -use-test-server \
-              -server-count ${{ matrix.server-count }} \
-              -category ${{ matrix.test-category }} \
-              -expected-failure-list tests/expected-failure-github.txt \
-              -skip-reference-image-generation \
-              -show-adapter-info \
-              -enable-debug-layers ${{ matrix.enable-debug-layers }}
-          else
-            "$bin_dir/slang-test" \
-              -use-test-server \
-              -category ${{ matrix.test-category }} \
-              -expected-failure-list tests/expected-failure-github.txt \
-              -expected-failure-list tests/expected-failure-no-gpu.txt \
-              -skip-reference-image-generation \
-              -show-adapter-info \
-              -enable-debug-layers ${{ matrix.enable-debug-layers }}
-          fi
-      - name: Run Slang examples
-        # Run GLSL backend tests on release for pull requests, and not on merge_group, to reduce CI load.
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm' && matrix.full-gpu-tests && matrix.config == 'release' && github.event_name == 'pull_request'
-        run: |
-          .github/workflows/ci-examples.sh \
-           --bin-dir "$bin_dir" \
-           --os "${{matrix.os}}" \
-           --platform "${{matrix.platform}}" \
-           --config "${{matrix.config}}" \
-           --skip-file tests/expected-example-failure-github.txt
-      - name: Run slangc tests
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm'
-        run: |
-          PATH=$bin_dir:$PATH tools/slangc-test/test.sh
-      - name: Test Slang via glsl
-        # Run GLSL backend tests on release for pull requests, and not on merge_group, to reduce CI load.
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm' && matrix.os != 'macos' && matrix.full-gpu-tests && matrix.config == 'release'
-        run: |
-          export SLANG_RUN_SPIRV_VALIDATION=1
-          export SLANG_USE_SPV_SOURCE_LANGUAGE_UNKNOWN=1
-          "$bin_dir/slang-test" \
-            -use-test-server \
-            -server-count ${{ matrix.server-count }} \
-            -category ${{ matrix.test-category }} \
-            -emit-spirv-via-glsl \
-            -api vk \
-            -expected-failure-list tests/expected-failure-via-glsl.txt \
-            -skip-reference-image-generation \
-            -show-adapter-info
-      - name: Run slang-rhi tests
-        # Run slang-rhi tests on debug+release for pull requests, and only on release for merge_group, to reduce CI load.
-        # Some of the expensive tests that are not relevant for Slang (because they just test graphics API related things) are excluded using -tce.
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm' && matrix.full-gpu-tests && (github.event_name == 'pull_request' || matrix.config == 'release')
-        run: |
-          export SLANG_RHI_EXCLUDE_TESTS="md-clear*,cmd-copy*,cmd-upload*,fence*,staging-heap*,texture-create*"
-          if [[ "${{matrix.os}}" == "macos" ]]; then
-            export SLANG_RHI_EXCLUDE_TESTS="sampler-array"
-          fi
-          "$bin_dir/slang-rhi-tests" -check-devices -tce="$SLANG_RHI_EXCLUDE_TESTS"
-      - name: Run slangpy tests
-        # Run slangpy tests on debug+release for pull requests, and only on release for merge_group, to reduce CI load.
-        if: steps.filter.outputs.should-run == 'true' && matrix.platform != 'wasm' && matrix.full-gpu-tests && (github.event_name == 'pull_request' || matrix.config == 'release')
-        run: |
-          python --version
-          echo "Cleaning up existing installations and installing slangpy..."
-
-          # Try to uninstall existing slangpy
-          python -m pip uninstall -y slangpy || echo "slangpy not found or already removed"
-
-          # Install slangpy
-          python -m pip install --verbose slangpy --user
-
-          # Get site packages directory
-          SITE_PACKAGES=$(python -c "import slangpy; import os; print(os.path.dirname(os.path.dirname(slangpy.__file__)))")
-          echo "Site packages directory: $SITE_PACKAGES"
-          echo "bin_dir location: $bin_dir"
-          echo "lib_dir location: $lib_dir"
-          # Copy library files
-          if [[ "${{matrix.os}}" == "windows" ]]; then
-            cp "$bin_dir"/slang*.dll "$SITE_PACKAGES/slangpy/" || { echo "Failed to copy library files"; exit 1; }
-          else
-            cp "$lib_dir"/libslang*.* "$SITE_PACKAGES/slangpy/" || { echo "Failed to copy library files"; exit 1; }
-          fi
-
-          echo "Listing files in slangpy directory..."
-          ls -la "$SITE_PACKAGES/slangpy/"
-
-          echo "Installing python packages..."
-
-          # Only install additional packages on GitHub-hosted runners, not self-hosted
-          if [[ "${{ runner.environment }}" != "self-hosted" ]]; then
-            # Download and install requirements from slangpy repository
-            echo "Fetching requirements-dev.txt from slangpy repository..."
-            curl -fsSL https://raw.githubusercontent.com/shader-slang/slangpy/main/requirements-dev.txt -o requirements-dev.txt
-            
-            echo "Installing development requirements..."
-            python -m pip install -r requirements-dev.txt
-            python -m pip install pytest-github-actions-annotate-failures
-          else
-            echo "Skipping additional package installation on self-hosted runner"
-          fi
-
-          echo "Running pytest on slangpy tests..."
-          export PYTHONPATH="$SITE_PACKAGES"
-          python -m pytest "$SITE_PACKAGES/slangpy/tests" -ra
-      - uses: actions/upload-artifact@v4
-        if: steps.filter.outputs.should-run == 'true' && ! matrix.full-gpu-tests
-        with:
-          name: slang-build-${{matrix.os}}-${{matrix.platform}}-${{matrix.compiler}}-${{matrix.config}}
-          # The install directory used in the packaging step
-          path: |
-            build/dist-${{matrix.config}}/**/ZIP/slang/*
-            build.em/Release
+  # Linux builds
+  build-linux-debug-gcc-x86_64:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: linux
+      compiler: gcc
+      platform: x86_64
+      config: debug
+      runs-on: '["ubuntu-22.04"]'
+
+  build-linux-release-gcc-x86_64:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: linux
+      compiler: gcc
+      platform: x86_64
+      config: release
+      runs-on: '["ubuntu-22.04"]'
+
+  build-linux-release-gcc-wasm:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: linux
+      compiler: gcc
+      platform: wasm
+      config: release
+      runs-on: '["ubuntu-22.04"]'
+
+  # macOS builds
+  build-macos-debug-clang-aarch64:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: macos
+      compiler: clang
+      platform: aarch64
+      config: debug
+      runs-on: '["macos-latest"]'
+
+  build-macos-release-clang-aarch64:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: macos
+      compiler: clang
+      platform: aarch64
+      config: release
+      runs-on: '["macos-latest"]'
+
+  # Windows builds (self-hosted)
+  build-windows-debug-cl-x86_64-gpu:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: windows
+      compiler: cl
+      platform: x86_64
+      config: debug
+      runs-on: '["Windows", "self-hosted", "GCP-T4"]'
+
+  build-windows-release-cl-x86_64-gpu:
+    needs: [filter]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-build.yml
+    with:
+      os: windows
+      compiler: cl
+      platform: x86_64
+      config: release
+      runs-on: '["Windows", "self-hosted", "GCP-T4"]'
+
+  # Linux tests
+  test-linux-debug-gcc-x86_64:
+    needs: [filter, build-linux-debug-gcc-x86_64]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-test.yml
+    with:
+      os: linux
+      compiler: gcc
+      platform: x86_64
+      config: debug
+      runs-on: '["ubuntu-22.04"]'
+      test-category: smoke
+
+  test-linux-release-gcc-x86_64:
+    needs: [filter, build-linux-release-gcc-x86_64]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-test.yml
+    with:
+      os: linux
+      compiler: gcc
+      platform: x86_64
+      config: release
+      runs-on: '["ubuntu-22.04"]'
+      test-category: full
+
+  # macOS tests
+  test-macos-debug-clang-aarch64:
+    needs: [filter, build-macos-debug-clang-aarch64]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-test.yml
+    with:
+      os: macos
+      compiler: clang
+      platform: aarch64
+      config: debug
+      runs-on: '["macos-latest"]'
+      test-category: smoke
+      server-count: 3
+
+  test-macos-release-clang-aarch64:
+    needs: [filter, build-macos-release-clang-aarch64]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-test.yml
+    with:
+      os: macos
+      compiler: clang
+      platform: aarch64
+      config: release
+      runs-on: '["macos-latest"]'
+      test-category: full
+      full-gpu-tests: true
+      server-count: 3
+
+  # Windows GPU tests (self-hosted)
+  test-windows-debug-cl-x86_64-gpu:
+    needs: [filter, build-windows-debug-cl-x86_64-gpu]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-test.yml
+    with:
+      os: windows
+      compiler: cl
+      platform: x86_64
+      config: debug
+      runs-on: '["Windows", "self-hosted", "GCP-T4"]'
+      test-category: full
+      full-gpu-tests: true
+
+  test-windows-release-cl-x86_64-gpu:
+    needs: [filter, build-windows-release-cl-x86_64-gpu]
+    if: needs.filter.outputs.should-run == 'true'
+    uses: ./.github/workflows/ci-slang-test.yml
+    with:
+      os: windows
+      compiler: cl
+      platform: x86_64
+      config: release
+      runs-on: '["Windows", "self-hosted", "GCP-T4"]'
+      test-category: full
+      full-gpu-tests: true