pull.yml

name: pull

on:
  pull_request:
  push:
    branches:
      - main
      - release/*
  workflow_dispatch:

concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}-${{ github.event_name == 'workflow_dispatch' && github.run_id }}-${{ github.event_name == 'schedule' }}
  cancel-in-progress: true

jobs:
  docker-image:
    name: Resolve CI docker image
    uses: ./.github/workflows/_docker-image.yml

  # Emits the list of changed files for the current PR or push commit.
  # On PR: PR diff. On push: diff against `github.event.before`.
  # On events without a diff base (workflow_dispatch, tag creation,
  # initial push), emits '*' — note that `contains('*', 'path')` is
  # false (literal substring match, not glob), so path-filtered jobs
  # rely on run-decision's is-full-run output for those events.
  changed-files:
    name: Get changed files
    uses: ./.github/workflows/_get-changed-files.yml
    with:
      # Opt in to push-event diff so path-filtered jobs can skip pushes
      # that don't touch their relevant paths. Without this, push events
      # emit '*' and `contains('*', 'path')` is always false.
      include-push-diff: true

  run-decision:
    name: CI run decision
    uses: ./.github/workflows/_ci-run-decision.yml

  test-qnn-wheel-packages-linux:
    needs: docker-image
    name: test-qnn-wheel-packages-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
      matrix:
        python-version: [ "3.11", "3.12", "3.13" ]
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 180
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        # Create a clean env for each python version
        conda create -y -n test_env_${{ matrix.python-version }} python=${{ matrix.python-version }}
        conda activate test_env_${{ matrix.python-version }}

        PYTHON_EXECUTABLE=python bash .ci/scripts/test_wheel_package_qnn.sh "${{ matrix.python-version }}"

  test-arduino-library:
    needs: changed-files
    if: |
      github.event_name != 'pull_request' ||
      contains(needs.changed-files.outputs.changed-files, '.github/workflows/_test_arduino_library.yml') ||
      contains(needs.changed-files.outputs.changed-files, '.github/workflows/pull.yml') ||
      contains(needs.changed-files.outputs.changed-files, 'backends/cortex_m/') ||
      contains(needs.changed-files.outputs.changed-files, 'examples/arduino/') ||
      contains(needs.changed-files.outputs.changed-files, 'kernels/portable/') ||
      contains(needs.changed-files.outputs.changed-files, 'runtime/') ||
      contains(needs.changed-files.outputs.changed-files, 'schema/') ||
      contains(needs.changed-files.outputs.changed-files, 'version.txt')
    name: test-arduino-library
    uses: ./.github/workflows/_test_arduino_library.yml
    permissions:
      id-token: write
      contents: read

  test-minimal-wheel-linux:
    needs: [docker-image, changed-files]
    if: |
      github.event_name != 'pull_request' ||
      contains(needs.changed-files.outputs.changed-files, '.ci/scripts/test_minimal_wheel.sh') ||
      contains(needs.changed-files.outputs.changed-files, '.github/workflows/pull.yml') ||
      contains(needs.changed-files.outputs.changed-files, 'exir/') ||
      contains(needs.changed-files.outputs.changed-files, 'extension/flat_tensor') ||
      contains(needs.changed-files.outputs.changed-files, 'extension/pytree') ||
      contains(needs.changed-files.outputs.changed-files, 'pyproject.toml') ||
      contains(needs.changed-files.outputs.changed-files, 'schema/') ||
      contains(needs.changed-files.outputs.changed-files, 'setup.py') ||
      contains(needs.changed-files.outputs.changed-files, 'tools/cmake/')
    name: test-minimal-wheel-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      script: |
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/test_minimal_wheel.sh

  test-setup-linux-gcc:
    needs: docker-image
    name: test-setup-linux-gcc
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-gcc11-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Build and test ExecuTorch with the add model on portable backend.
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_model.sh "add" "${BUILD_TOOL}" "portable"

  test-pybindings-no-aten:
    needs: [docker-image, changed-files]
    if: |
      github.event_name != 'pull_request' ||
      contains(needs.changed-files.outputs.changed-files, '.github/workflows/pull.yml') ||
      contains(needs.changed-files.outputs.changed-files, 'extension/pybindings/') ||
      contains(needs.changed-files.outputs.changed-files, 'runtime/') ||
      contains(needs.changed-files.outputs.changed-files, 'tools/cmake/')
    name: test-pybindings-no-aten
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        set -eux
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"
        ./install_executorch.sh

        cmake -S . -B cmake-out-no-aten \
          -DCMAKE_BUILD_TYPE=Release \
          -DEXECUTORCH_BUILD_PYBIND=ON \
          -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON \
          -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON \
          -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON \
          -DEXECUTORCH_BUILD_EXTENSION_NAMED_DATA_MAP=ON \
          -DPYTHON_EXECUTABLE="$(which python)"
        cmake --build cmake-out-no-aten --target portable_lib -j "$(nproc)"

        python -m examples.portable.scripts.export \
          --model_name=add \
          --output_dir=cmake-out-no-aten
        python - <<'PY'
        from pathlib import Path

        from executorch.extension.pybindings.test.make_test import (
            create_program,
            ModuleAddBFloat16,
        )

        program, _ = create_program(ModuleAddBFloat16())
        Path("cmake-out-no-aten/add_bfloat16.pte").write_bytes(bytes(program.buffer))
        PY
        EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
          PYTHONPATH=cmake-out-no-aten:.. \
          python extension/pybindings/test/test_pybindings_no_aten.py \
            PybindingsNoAtenTest.test_z_torch_tensor_uses_python_api
        EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT=executorch \
          EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
          PYTHONPATH=cmake-out-no-aten:.. \
          python extension/pybindings/test/test_pybindings_no_aten.py \
            PybindingsNoAtenTest.test_executorch_output_is_sticky_after_torch_import
        python -m pip uninstall -y torch torchvision torchaudio
        EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
          EXECUTORCH_PYBIND_TEST_BFLOAT16_PTE=cmake-out-no-aten/add_bfloat16.pte \
          PYTHONPATH=cmake-out-no-aten:.. \
          python extension/pybindings/test/test_pybindings_no_aten.py \
            PybindingsNoAtenTest.test_output_policy_without_torch
        EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT=executorch \
          EXECUTORCH_PYBIND_TEST_PTE=cmake-out-no-aten/add.pte \
          EXECUTORCH_PYBIND_TEST_BFLOAT16_PTE=cmake-out-no-aten/add_bfloat16.pte \
          PYTHONPATH=cmake-out-no-aten:.. \
          python extension/pybindings/test/test_pybindings_no_aten.py
        if ldd cmake-out-no-aten/_C*.so | grep -Eiq 'torch|aten|c10'; then
          echo "torch-free pybindings unexpectedly link against ATen"
          exit 1
        fi

  test-models-linux-basic:
    needs: docker-image
    name: test-models-linux-basic
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        model: [mv3, vit]
        backend: [portable, xnnpack-quantization-delegation]
        build-tool: [cmake, buck2]
        runner: [mt-l-x86iavx512-8-64, mt-l-arm64g4-16-62]
        docker-image: [executorch-ubuntu-22.04-clang12, executorch-ubuntu-22.04-gcc11-aarch64]
        # Excluding specific runner + docker image combinations that don't make sense:
        #   - Excluding the ARM64 gcc image on the x86 runner
        #   - Excluding the x86 clang image on the ARM64 runner
        exclude:
          - runner: mt-l-x86iavx512-8-64
            docker-image: executorch-ubuntu-22.04-gcc11-aarch64
          - runner: mt-l-arm64g4-16-62
            docker-image: executorch-ubuntu-22.04-clang12
          # TODO: Need to figure out why buck2 doesnt work on Graviton instances.
          - runner: mt-l-arm64g4-16-62
            build-tool: buck2
      fail-fast: false
    with:
      runner: ${{ matrix.runner }}
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:${{ matrix.docker-image }}-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        MODEL_NAME=${{ matrix.model }}
        BUILD_TOOL=${{ matrix.build-tool }}
        BACKEND=${{ matrix.backend }}

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Build and test ExecuTorch
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_model.sh "${MODEL_NAME}" "${BUILD_TOOL}" "${BACKEND}"

  test-models-linux:
    needs: docker-image
    name: test-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        model: [linear, add, add_mul, ic3, mv2, resnet18, resnet50, mobilebert, emformer_transcribe]
        backend: [portable, xnnpack-quantization-delegation]
        runner: [mt-l-x86iavx512-8-64]
        include:
          - model: ic4
            backend: portable
            runner: mt-l-x86iavx512-16-128
          - model: ic4
            backend: xnnpack-quantization-delegation
            runner: mt-l-x86iavx512-16-128
          - model: emformer_join
            backend: portable
            runner: mt-l-x86iavx512-16-128
          - model: emformer_join
            backend: xnnpack-quantization-delegation
            runner: mt-l-x86iavx512-16-128
          - model: phi_4_mini
            backend: portable
            runner: mt-l-x86iavx512-16-128
          - model: llama3_2_vision_encoder
            backend: portable
            runner: mt-l-x86iavx512-16-128
          - model: w2l
            backend: portable
            runner: mt-l-x86iavx512-16-128
      fail-fast: false
    with:
      runner: ${{ matrix.runner }}
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        MODEL_NAME=${{ matrix.model }}
        BUILD_TOOL=cmake
        BACKEND=${{ matrix.backend }}

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Build and test ExecuTorch
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_model.sh "${MODEL_NAME}" "${BUILD_TOOL}" "${BACKEND}"

  test-parakeet-xnnpack-linux:
    needs: docker-image
    name: test-parakeet-xnnpack-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-16-128
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      script: |
        set -eux

        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        echo "::group::Setup ExecuTorch"
        ./install_executorch.sh
        echo "::endgroup::"

        echo "::group::Export Parakeet with XNNPACK"
        bash .ci/scripts/export_model_artifact.sh xnnpack "nvidia/parakeet-tdt" "quantized-8da4w" "./parakeet_output"
        echo "::endgroup::"

        echo "::group::Test Parakeet with XNNPACK"
        bash .ci/scripts/test_model_e2e.sh xnnpack "nvidia/parakeet-tdt" "quantized-8da4w" "./parakeet_output"
        echo "::endgroup::"

  test-voxtral-realtime-xnnpack-linux:
    needs: docker-image
    name: test-voxtral-realtime-xnnpack-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-16-128
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      secrets-env: VOXTRAL_REALTIME_HF_TOKEN
      script: |
        set -eux

        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        export HF_TOKEN="${SECRET_VOXTRAL_REALTIME_HF_TOKEN}"

        echo "::group::Setup ExecuTorch"
        ./install_executorch.sh
        echo "::endgroup::"

        echo "::group::Export Voxtral Realtime with XNNPACK"
        bash .ci/scripts/export_model_artifact.sh xnnpack "mistralai/Voxtral-Mini-4B-Realtime-2602" "quantized-8da4w" "./voxtral_realtime_output"
        echo "::endgroup::"

        echo "::group::Test Voxtral Realtime with XNNPACK"
        bash .ci/scripts/test_model_e2e.sh xnnpack "mistralai/Voxtral-Mini-4B-Realtime-2602" "quantized-8da4w" "./voxtral_realtime_output"
        echo "::endgroup::"

  test-llama-runner-linux:
    needs: docker-image
    # Test Both linux x86 and linux aarch64
    name: test-llama-runner-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        dtype: [fp32]
        mode: [xnnpack+custom+qe,xnnpack+custom+quantize_kv,xnnpack+quantize_kv]
        runner: [mt-l-x86iavx512-8-64, mt-l-arm64g4-16-62]
        docker-image: [executorch-ubuntu-22.04-clang12, executorch-ubuntu-22.04-gcc11-aarch64]
        include:
          - dtype: bf16
            mode: custom
            runner: mt-l-x86iavx512-8-64
            docker-image: executorch-ubuntu-22.04-clang12
        # Excluding specific runner + docker image combinations that don't make sense:
        #   - Excluding the ARM64 gcc image on the x86 runner
        #   - Excluding the x86 clang image on the ARM64 runner
        exclude:
          - runner: mt-l-x86iavx512-8-64
            docker-image: executorch-ubuntu-22.04-gcc11-aarch64
          - runner: mt-l-arm64g4-16-62
            docker-image: executorch-ubuntu-22.04-clang12
      fail-fast: false
    with:
      runner: ${{ matrix.runner }}
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:${{ matrix.docker-image }}-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 900
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        DTYPE=${{ matrix.dtype }}
        BUILD_TOOL="cmake"
        MODE=${{ matrix.mode }}
        ARTIFACTS_DIR_NAME="artifacts-to-be-uploaded/${DTYPE}-${MODE}"
        ARTIFACTS_DIR_NAME="${ARTIFACTS_DIR_NAME/+/-}"

        # Setup executorch
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Install requirements for export_llama
        PYTHON_EXECUTABLE=python bash examples/models/llama/install_requirements.sh
        # Test llama2
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_llama.sh -model stories110M -build_tool "${BUILD_TOOL}" -dtype "${DTYPE}" -mode "${MODE}" -upload "${ARTIFACTS_DIR_NAME}"

  test-llama-runner-linux-android:
    needs: docker-image
    name: test-llama-runner-linux-android
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-android-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"
        BUILD_TOOL="cmake"
        PYTHON_EXECUTABLE=python \
        bash .ci/scripts/build_llama_android.sh  "${BUILD_TOOL}"

  test-custom-ops-linux:
    needs: docker-image
    name: test-custom-ops-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Test custom ops
        PYTHON_EXECUTABLE=python bash examples/portable/custom_ops/test_custom_ops.sh "${BUILD_TOOL}"

  test-selective-build-linux:
    needs: docker-image
    name: test-selective-build-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Test selective build
        PYTHON_EXECUTABLE=python bash examples/selective_build/test_selective_build.sh "${BUILD_TOOL}"

  test-multimodal-linux:
    needs: docker-image
    if: ${{ !github.event.pull_request.head.repo.fork }}
    name: test-multimodal-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    secrets: inherit
    strategy:
      fail-fast: false
      matrix:
        model: ["gemma3-4b"]  # llava gives segfault so not covering.
    with:
      secrets-env: EXECUTORCH_HF_TOKEN
      runner: mt-l-x86iavx512-94-768
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        echo "::group::Setup ExecuTorch"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"
        echo "::endgroup::"

        echo "::group::Setup Huggingface"
        pip install -U "huggingface_hub[cli]<1.0" accelerate
        huggingface-cli login --token $SECRET_EXECUTORCH_HF_TOKEN
        OPTIMUM_ET_VERSION=$(cat .ci/docker/ci_commit_pins/optimum-executorch.txt)
        pip install git+https://github.com/huggingface/optimum-executorch.git@${OPTIMUM_ET_VERSION}
        echo "::endgroup::"

        echo "::group::Test ${{ matrix.model }}"
        python .ci/scripts/test_huggingface_optimum_model.py --model ${{ matrix.model }} --quantize --recipe xnnpack
        echo "::endgroup::"

  test-moshi-linux:
    needs: docker-image
    name: test-moshi-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        set -eux
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # install Mimi requirements
        bash examples/models/moshi/mimi/install_requirements.sh

        # reinstall executorch
        bash ./install_executorch.sh --minimal
        pip list

        # run python unittest
        python -m unittest examples.models.moshi.mimi.test_mimi

  test-quantized-aot-lib-linux:
    needs: docker-image
    name: test-quantized-aot-lib-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        PYTHON_EXECUTABLE=python bash examples/xnnpack/quantization/test_quantize.sh "${BUILD_TOOL}" mv2

  test-binary-size-linux-gcc:
    needs: docker-image
    name: test-binary-size-linux-gcc
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-gcc9-nopytorch-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      upload-artifact: bloaty-linux-gcc
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        ./install_requirements.sh
        # build module for executorch.extension.pybindings.portable_lib
        bash test/build_size_test.sh

        # Bloaty per-bucket size report (best-effort; never fails the size job).
        mkdir -p /tmp/bloaty-elfs
        cp cmake-out/test/size_test /tmp/bloaty-elfs/head.elf
        GITHUB_HEAD_SHA="${{ github.event.pull_request.head.sha || github.sha }}" \
          bash .ci/scripts/bloaty-measure.sh "linux-gcc" /tmp/bloaty-elfs/head.elf strip

        strip cmake-out/test/size_test
        output=$(ls -la cmake-out/test/size_test)
        arr=($output)
        size=${arr[4]}
        # Current CI size: 52168 (gcc9-nopytorch, 2026-07-06)
        threshold="52168"
        if [[ "$size" -le "$threshold" ]]; then
          echo "Success $size <= $threshold"
        else
          echo "Fail $size > $threshold"
          exit 1
        fi

  test-binary-size-linux:
    needs: docker-image
    name: test-binary-size-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      upload-artifact: bloaty-linux-clang
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        ./install_requirements.sh --use-pt-pinned-commit

        # build module for executorch.extension.pybindings.portable_lib
        bash test/build_size_test.sh

        # Bloaty per-bucket size report (best-effort; never fails the size job).
        mkdir -p /tmp/bloaty-elfs
        cp cmake-out/test/size_test /tmp/bloaty-elfs/head.elf
        GITHUB_HEAD_SHA="${{ github.event.pull_request.head.sha || github.sha }}" \
          bash .ci/scripts/bloaty-measure.sh "linux-clang" /tmp/bloaty-elfs/head.elf strip

        strip cmake-out/test/size_test
        output=$(ls -la cmake-out/test/size_test)
        arr=($output)
        size=${arr[4]}
        # Current CI size: 44160 (clang12, 2026-03-06)
        threshold="45000"
        if [[ "$size" -le "$threshold" ]]; then
          echo "Success $size <= $threshold"
        else
          echo "Fail $size > $threshold"
          exit 1
        fi

  test-arm-cortex-m-size-test:
    needs: docker-image
    name: test-arm-cortex-m-size-test
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        os: [bare_metal, zephyr-preset]
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      upload-artifact: bloaty-arm-${{ matrix.os }}
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        cxx_flags="-fno-exceptions -fno-rtti -Wall -Werror -Wno-int-in-bool-context -DET_HAVE_PREAD=0"
        setup_script_args=""
        if [[ ${{ matrix.os}} == "bare_metal" ]]; then
          toolchain_prefix=arm-none-eabi-
          threshold="118000" # GCC 15.2 baseline: 115868 bytes, 2026-05-13
          toolchain_cmake=examples/arm/ethos-u-setup/arm-none-eabi-gcc.cmake
        elif [[ ${{ matrix.os}} == "zephyr-preset" ]]; then
          setup_script_args="--target-toolchain zephyr"
          toolchain_prefix=arm-zephyr-eabi-
          threshold="136020" # 136 KiB
          toolchain_cmake=examples/zephyr/x86_64-linux-arm-zephyr-eabi-gcc.cmake
        else
          echo "Unsupported OS selection: ${{ matrix.os }}"
          exit 1
        fi

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"
        .ci/scripts/setup-arm-baremetal-tools.sh ${setup_script_args}
        source examples/arm/arm-scratch/setup_path.sh

        # User toolchain
        ${toolchain_prefix}c++ --version

        # Setup cmake target to desired toolchain
        toolchain_cmake=$(realpath ${toolchain_cmake})

        # Build and run size test
        if [[ ${{ matrix.os}} == "bare_metal" ]]; then
          bash test/build_size_test.sh "-DCMAKE_TOOLCHAIN_FILE=${toolchain_cmake} -DEXECUTORCH_BUILD_ARM_BAREMETAL=ON"
        elif [[ ${{ matrix.os}} == "zephyr-preset" ]]; then
          CXXFLAGS=${cxx_flags} cmake --preset zephyr -DCMAKE_BUILD_TYPE=Release -DEXECUTORCH_OPTIMIZE_SIZE=ON -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON -DCMAKE_INSTALL_PREFIX=cmake-out -Bcmake-out .
          cmake --build cmake-out -j9 --target install --config Release
          CXXFLAGS=${cxx_flags}  cmake -DCMAKE_TOOLCHAIN_FILE=${toolchain_cmake} -DEXECUTORCH_SIZE_TEST_NO_OS_LINK=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=cmake-out -Bcmake-out/test test
          cmake --build cmake-out/test -j9 --config Release
        else
          echo "Fail unsupported OS selection ${{ matrix.os }}"
          exit 1
        fi

        elf="cmake-out/test/size_test"

        # Dump basic info
        ls -al ${elf}
        ${toolchain_prefix}size ${elf}

        # Dump symbol
        python .github/scripts/run_nm.py -e ${elf}
        python .github/scripts/run_nm.py -e ${elf} -f "executorch" -p "${toolchain_prefix}"
        python .github/scripts/run_nm.py -e ${elf} -f "executorch_text" -p "${toolchain_prefix}"

        # Bloaty per-bucket size report (best-effort; never fails the size job).
        # Runs BEFORE the in-place strip below so the head ELF is still unstripped.
        mkdir -p /tmp/bloaty-elfs
        cp "${elf}" /tmp/bloaty-elfs/head.elf
        GITHUB_HEAD_SHA="${{ github.event.pull_request.head.sha || github.sha }}" \
          bash .ci/scripts/bloaty-measure.sh "arm-${{ matrix.os }}" /tmp/bloaty-elfs/head.elf "${toolchain_prefix}strip"

        # Add basic guard - TODO: refine this!
        ${toolchain_prefix}strip ${elf}
        output=$(ls -la ${elf})
        arr=($output)
        size=${arr[4]}
        echo "size: $size, threshold: $threshold"
        if [[ "$size" -le "$threshold" ]]; then
          echo "Success $size <= $threshold"
        else
          echo "Fail $size > $threshold"
          exit 1
        fi

  test-mcu-cortex-m-backend:
    needs: docker-image
    name: test-mcu-cortex-m-backend
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"

        # Install arm dependencies
        .ci/scripts/setup-arm-baremetal-tools.sh
        source examples/arm/arm-scratch/setup_path.sh

        # To build cortex-m test runner
        backends/cortex_m/test/build_test_runner.sh

        # To run cortex_m tests
        pytest --config-file=backends/arm/test/pytest.ini backends/cortex_m/test

  android:
    uses: ./.github/workflows/_android.yml
    permissions:
      id-token: write
      contents: read

  llm-server:
    needs: [changed-files, run-decision]
    if: |
      github.event_name == 'pull_request' && (
        contains(needs.changed-files.outputs.changed-files, 'examples/llm_server') ||
        contains(needs.changed-files.outputs.changed-files, 'examples/models/muse-glimmer/serving') ||
        contains(needs.changed-files.outputs.changed-files, 'examples/models/muse-glimmer/tests') ||
        contains(needs.changed-files.outputs.changed-files, 'examples/models/muse_glimmer') ||
        contains(needs.changed-files.outputs.changed-files, 'extension/llm/batching') ||
        contains(needs.changed-files.outputs.changed-files, 'extension/llm/serving') ||
        contains(needs.changed-files.outputs.changed-files, 'extension/llm/runner') ||
        contains(needs.changed-files.outputs.changed-files, 'extension/llm/tokenizers') ||
        contains(needs.changed-files.outputs.changed-files, '.github/workflows/_get-changed-files.yml') ||
        contains(needs.changed-files.outputs.changed-files, '.github/workflows/_ci-run-decision.yml') ||
        contains(needs.changed-files.outputs.changed-files, '.github/workflows/_llm_server.yml') ||
        contains(needs.changed-files.outputs.changed-files, '.github/workflows/pull.yml') ||
        contains(needs.changed-files.outputs.changed-files, '.github/workflows/trunk.yml') ||
        needs.run-decision.outputs.is-full-run == 'true'
      )
    uses: ./.github/workflows/_llm_server.yml
    permissions:
      id-token: write
      contents: read

  unittest:
    uses: ./.github/workflows/_unittest.yml
    permissions:
      id-token: write
      contents: read
    with:
      build-mode: Debug
      build-tool: cmake
      docker-image: ci-image:executorch-ubuntu-22.04-clang12

  unittest-editable:
    uses: ./.github/workflows/_unittest.yml
    permissions:
      id-token: write
      contents: read
    with:
      build-mode: Debug
      build-tool: cmake
      editable: true
      docker-image: ci-image:executorch-ubuntu-22.04-clang12

  unittest-buck:
    uses: ./.github/workflows/_unittest.yml
    permissions:
      id-token: write
      contents: read
    with:
      build-mode: Debug
      build-tool: buck2
      docker-image: ci-image:executorch-ubuntu-22.04-clang12

  test-qnn-buck-build-linux:
    needs: docker-image
    name: test-qnn-buck-build-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        set -eux

        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        # Download QNN SDK and get the path
        QNN_SDK_ROOT=$(python3 backends/qualcomm/scripts/download_qnn_sdk.py --print-sdk-path)
        echo "QNN_SDK_ROOT=${QNN_SDK_ROOT}"

        # Configure Buck to find the QNN SDK
        echo "[qualcomm]" >> .buckconfig
        echo "  qnn_sdk_root = ${QNN_SDK_ROOT}" >> .buckconfig

        # Setup buck2
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool buck2

        # Build QNN backend with Buck
        buck2 build //backends/qualcomm/...

  test-arm-backend-no-driver:
    needs: docker-image
    name: test-arm-backend-no-driver
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        include:
          - test_arm_backend: test_pytest_ops_no_target
          - test_arm_backend: test_pytest_ops_tosa
          - test_arm_backend: test_pytest_models_tosa
          - test_arm_backend: test_run_tosa
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"

        .ci/scripts/setup-arm-baremetal-tools.sh --disable-ethos-u-deps

        if [[ "${{ matrix.test_arm_backend }}" == "test_pytest_ops_no_target" ]]; then
          python backends/arm/scripts/docgen/generate_op_support.py \
            --backend all --check || exit 1

          python backends/arm/scripts/docgen/generate_op_support.py \
            --backend all || exit 1

          git diff --exit-code -- \
            docs/source/backends/arm-vgf/VGF_op_support.md \
            docs/source/backends/arm-ethos-u/U55_op_support.md \
            docs/source/backends/arm-ethos-u/U85_op_support.md || {
              echo "::error::Operator support documentation is outdated. Regenerate it and commit the changes."
              exit 1
            }
        fi

        ARM_TEST=${{ matrix.test_arm_backend }}

        # Test test_arm_backend.sh with test
        backends/arm/test/test_arm_backend.sh "${ARM_TEST}"

  test-arm-backend-vkml:
    needs: docker-image
    name: test-arm-backend-vkml
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        include:
          - test_arm_backend: test_pytest_ops_vkml
          - test_arm_backend: test_ootb_tests_vgf
          - test_arm_backend: test_runtime_vgf
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-24.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      script: |
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"

        .ci/scripts/setup-arm-baremetal-tools.sh \
          --disable-ethos-u-deps \
          --enable-mlsdk-deps \
          --install-mlsdk-deps-with-pip

        ARM_TEST=${{ matrix.test_arm_backend }}

        if [[ -n "${RUNNER_TEST_RESULTS_DIR:-}" ]]; then
          export PYTEST_ADDOPTS="--junit-xml=${RUNNER_TEST_RESULTS_DIR}/${ARM_TEST}.xml ${PYTEST_ADDOPTS:-}"
        fi

        backends/arm/test/test_arm_backend.sh "${ARM_TEST}"

  test-arm-backend-public-api-backward-compatibility:
    needs: docker-image
    name: test-arm-backend-public-api-backward-compatibility
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-24.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"

        .ci/scripts/setup-arm-baremetal-tools.sh --enable-mlsdk-deps --install-mlsdk-deps-with-pip
        source examples/arm/arm-scratch/setup_path.sh

        backends/arm/scripts/public_api_manifest/validate_all_public_api_manifests.sh

        python backends/arm/test/public_api_bc/run_public_api_bc_scenarios.py

  test-llama-runner-qnn-linux:
    needs: docker-image
    name: test-llama-runner-qnn-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        dtype: [fp32]
        pt2e_quantize: [qnn_16a16w, qnn_8a8w]
        mode: [qnn]
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 900
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        DTYPE=${{ matrix.dtype }}
        BUILD_TOOL="cmake"
        MODE=${{ matrix.mode }}
        PT2E_QUANTIZE=${{ matrix.pt2e_quantize }}

        ./install_requirements.sh --use-pt-pinned-commit
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/build-qnn-sdk.sh

        # Setup executorch
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"
        # Install requirements for export_llama
        PYTHON_EXECUTABLE=python bash examples/models/llama/install_requirements.sh
        # Test llama2
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_llama.sh -model stories110M -build_tool "${BUILD_TOOL}" -mode "${MODE}" -dtype "${DTYPE}" -pt2e_quantize "${PT2E_QUANTIZE}"

  test-static-llama-qnn-linux:
    needs: docker-image
    name: test-static-llama-qnn-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        task: [stories_110m, stories_260k_bc]
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 180
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/build-qnn-sdk.sh

        # Setup executorch
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"

        # Setup install_requirements for llama
        PYTHON_EXECUTABLE=python bash examples/models/llama/install_requirements.sh

        PYTHON_EXECUTABLE=python bash .ci/scripts/test_qnn_static_llm.sh ${{ matrix.task }}

  test-sqnr-static-llm-qnn-linux:
    needs: docker-image
    name: test-sqnr-static-llm-qnn-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        task: [smollm2_135m]
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 180
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/build-qnn-sdk.sh

        # Setup executorch
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"

        # Setup install_requirements for llama
        PYTHON_EXECUTABLE=python bash examples/models/llama/install_requirements.sh

        PYTHON_EXECUTABLE=python bash .ci/scripts/test_qnn_static_llm.sh ${{ matrix.task }} sqnr

  test-qnn-models-linux:
    needs: docker-image
    name: test-qnn-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        model: [mv2, mv3, dl3]
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 180
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool cmake
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/build-qnn-sdk.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_model.sh ${{ matrix.model }} "cmake" "qnn"

  test-qnn-direct-build-linux:
    needs: docker-image
    name: test-qnn-direct-build-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 30
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool cmake
        PYTHON_EXECUTABLE=python bash .ci/scripts/build-qnn-direct-sdk.sh

  test-qnn-testsuite-linux:
    name: test-qnn-testsuite-linux
    permissions:
      id-token: write
      contents: read
    uses: ./.github/workflows/_test_backend.yml
    with:
      backend: qnn
      flows: '["qnn"]'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 120
      run-linux: true
      # No runner-linux, so this takes _test_backend.yml's default. The suite
      # runs one export worker per core, so what matters is memory per core:
      # the instance this used to run on gave each worker about 4 GiB and the
      # job was killed. The default label is a little under 8 GiB per core.

  test-qnn-passes-linux:
    needs: docker-image
    name: test-qnn-passes-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 30
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        # Source (not bash) so QNN_SDK_ROOT stays in the environment
        PYTHON_EXECUTABLE=python source .ci/scripts/build-qnn-sdk.sh

        # Editable install so the PyQnnManagerAdaptor .so built by build-qnn-sdk.sh
        # is visible in the source tree (the _passes import chain pulls it in transitively)
        CMAKE_ARGS="-DEXECUTORCH_BUILD_QNN=ON -DQNN_SDK_ROOT=$QNN_SDK_ROOT -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON" \
          PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool cmake --editable true

        # test_mha_to_sha imports oss_scripts/llama which transitively needs torchtune
        pip install -r requirements-examples.txt

        # Run QNN pass unit tests
        pytest -xvs backends/qualcomm/tests/test_passes.py

        # And the checks that importing the backend has no side effects. These need no SDK and
        # no device, but they do need the package importable, which this job already arranges.
        pytest -xvs backends/qualcomm/tests/test_import_side_effects.py

  test-qnn-delegate-linux:
    needs: docker-image
    name: test-qnn-delegate-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      # Intel, unlike the avx512 labels: those are r7a, i.e. AMD EPYC, and the
      # QNN backend disables MKLDNN on an AMD host through a non-bracketed
      # torch.backends mutation that raises once the tests have frozen the
      # flags. Same 8 vCPU / 64Gi, on r7i.
      runner: mt-l-x86iamx-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        # Source (not bash) so QNN_SDK_ROOT stays in the environment
        PYTHON_EXECUTABLE=python source .ci/scripts/build-qnn-sdk.sh

        # Editable install so the PyQnnManagerAdaptor .so built by build-qnn-sdk.sh
        # is visible in the source tree
        CMAKE_ARGS="-DEXECUTORCH_BUILD_QNN=ON -DQNN_SDK_ROOT=$QNN_SDK_ROOT -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON" \
          PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool cmake --editable true

        pip install -r requirements-examples.txt

        # Enable conftest.py to call setup_environment() for pytest runs
        export QNN_DELEGATE_TEST=1
        export LD_LIBRARY_PATH="$QNN_SDK_ROOT/lib/x86_64-linux-clang/:$(realpath build-x86/lib/):${LD_LIBRARY_PATH:-}"

        # Run operator test classes only.
        pytest -vs backends/qualcomm/tests/test_qnn_delegate.py \
            -k "TestQNNFloatingPointOperator or TestQNNQuantizedOperator"

  test-phi-3-mini-runner-linux:
    needs: docker-image
    name: test-phi-3-mini-runner-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-94-192
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"
        echo "::group::Setup ExecuTorch"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"
        echo "::endgroup::"

        echo "::group::Setup requirements"
        # install phi-3-mini requirements
        bash examples/models/phi-3-mini/install_requirements.sh
        echo "::endgroup::"

        # run e2e (export, tokenizer and runner)
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_phi_3_mini.sh Release

  test-qnn-python-imports-linux:
    needs: docker-image
    name: test-qnn-python-imports-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-qnn-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 15
      script: |
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-qnn-deps.sh
        PYTHON_EXECUTABLE=python source .ci/scripts/build-qnn-sdk.sh

        CMAKE_ARGS="-DEXECUTORCH_BUILD_QNN=ON -DQNN_SDK_ROOT=$QNN_SDK_ROOT -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON" \
          PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool cmake --editable true

        pip install -r requirements-examples.txt

        # Source the QNN SDK environment so its bundled Python helpers
        # (e.g. QnnOpPackageGenerator) are importable during the smoke test.
        # envsetup.sh references PYTHONPATH (and friends) directly, which trips
        # the `set -u` inherited from build-qnn-sdk.sh, so relax it for the
        # duration of the source call.
        set +u
        source "${QNN_SDK_ROOT}/bin/envsetup.sh"
        set -u

        # Validate QNN backend Python imports resolve.
        # Catches backend-side Python dependency issues early with a clear error.
        python .ci/scripts/test_backend_imports.py \
          --name QNN \
          --package-root backends/qualcomm \
          --package-prefix executorch.backends.qualcomm

        # Static check that maintained QNN examples still reference valid internal modules.
        python .ci/scripts/test_example_imports.py \
          --name QNN \
          --examples-root examples/qualcomm \
          --module-prefix executorch.examples.qualcomm

  test-eval_llama-wikitext-linux:
    needs: docker-image
    name: test-eval_llama-wikitext-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-94-192
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # install llama requirements
        bash examples/models/llama/install_requirements.sh

        # run eval_llama wikitext task
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_eval_llama_wikitext.sh

  # TODO(larryliu0820): Fix this issue before reenabling it: https://gist.github.com/larryliu0820/7377ecd0d79dbc06076cec8d9f2b85d2
  # test-eval_llama-mmlu-linux:
  #   name: test-eval_llama-mmlu-linux
  #   uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
  #   permissions:
  #     id-token: write
  #     contents: read
  #   strategy:
  #     fail-fast: false
  #   with:
  #     runner: mt-l-x86iavx512-94-192
  #     docker-image: ci-image:executorch-ubuntu-22.04-clang12
  #     submodules: 'recursive'
  #     ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
  #     timeout: 90
  #     script: |
  #       # The generic Linux job chooses to use base env, not the one setup by the image
  #       CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
  #       conda activate "${CONDA_ENV}"

  #       PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

  #       # install llama requirements
  #       bash examples/models/llama/install_requirements.sh

  #       # run eval_llama mmlu task
  #       PYTHON_EXECUTABLE=python bash .ci/scripts/test_eval_llama_mmlu.sh

  test-llama_runner_eager-linux:
    needs: docker-image
    name: test-llama_runner_eager-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-94-192
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # install llama requirements
        bash examples/models/llama/install_requirements.sh

        # run llama runner in eager mode
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_llama_runner_eager.sh

  test-lora-linux:
    needs: docker-image
    name: test-lora-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-94-192
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # Install llama requirements
        bash examples/models/llama/install_requirements.sh

        # run llama runner in eager mode
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_lora.sh

  test-lora-multimethod-linux:
    needs: docker-image
    name: test-lora-multimethod-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-94-192
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # Install llama requirements
        bash examples/models/llama/install_requirements.sh

        # run llama runner in eager mode
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_lora_multimethod.sh

  test-mediatek-models-linux:
    # NeuroPilot's converter requires Python 3.10; re-enable with a Python 3.11+ SDK.
    if: ${{ false }}
    needs: docker-image
    name: test-mediatek-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-94-192
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-mediatek-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        source .ci/scripts/utils.sh
        install_executorch "--use-pt-pinned-commit"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-mediatek-deps.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/build-mediatek-sdk.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_model.sh "mv3" "buck2" "mediatek"
        # placeholder for mediatek to add more tests

  test-openvino-linux:
    needs: docker-image
    name: test-openvino-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-gcc11-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-openvino.sh
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_openvino.sh

  test-build-wasm-linux:
    needs: docker-image
    name: test-build-wasm-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"

        # Install Node.js and Emscripten
        source .ci/scripts/setup-emscripten.sh

        # Test selective build
        PYTHON_EXECUTABLE=python bash examples/wasm/test_build_wasm.sh

        # Build the WebGPU configuration of the Wasm bindings. Build only:
        # running a delegated model needs a browser with WebGPU.
        PYTHON_EXECUTABLE=python bash scripts/build_wasm_tests.sh --webgpu

  unittest-wasm-bindings:
    needs: docker-image
    name: unittest-wasm-bindings
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        enable-etdump: ['', '--enable-etdump']
      fail-fast: false
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        BUILD_TOOL="cmake"
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "${BUILD_TOOL}"

        # Install Node.js and Emscripten
        source .ci/scripts/setup-emscripten.sh

        export PNPM_VERSION=10.24.0

        curl -fsSL https://get.pnpm.io/install.sh | env PNPM_VERSION=$PNPM_VERSION SHELL="$(which bash)" sh -

        export PNPM_HOME="$HOME/.local/share/pnpm"
        export PATH="$PNPM_HOME:$PATH"

        pnpm --version

        # Test selective build
        bash scripts/build_wasm_tests.sh ${{ matrix.enable-etdump }}

        # Install Jest
        cd cmake-out-wasm/extension/wasm/test
        pnpm add -D jest@30.2.0 --ignore-scripts

        # Run unit test
        pnpm test

  unittest-nxp-neutron:
    needs: docker-image
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 150
      script: |
        set -eux

        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        # Install eIQ packages
        pip install -r backends/nxp/requirements-eiq.txt

        # Build and install Executorch
        PYTHON_EXECUTABLE=python \
        CMAKE_ARGS="-DEXECUTORCH_BUILD_NXP_NEUTRON=ON -DEXECUTORCH_BUILD_NXP_NEUTRON_RUNNER=ON \
        -DEXECUTORCH_BUILD_KERNELS_PORTABLE=ON -DEXECUTORCH_BUILD_PYBIND=ON -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON \
        -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON -DEXECUTORCH_BUILD_EXTENSION_FLAT_TENSOR=ON \
        -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON -DEXECUTORCH_BUILD_EXTENSION_NAMED_DATA_MAP=ON" \
        .ci/scripts/setup-linux.sh --build-tool "cmake"  --editable true

        # Install test requirements
        pip install -r backends/nxp/requirements-tests-pypi.txt
        PYTHON_EXECUTABLE=python bash examples/nxp/setup.sh

        # Run aot examples:
        PYTHON_EXECUTABLE=python bash examples/nxp/run_aot_example.sh cifar10

        # Run e2e example with Simulator:
        PYTHON_EXECUTABLE=python bash examples/nxp/run.sh cifar10

        # Run unit tests:
        PYTHON_EXECUTABLE=python NXP_RUNNER_PATH="./examples/nxp/executor_runner/build/nxp_executor_runner" \
        bash backends/nxp/run_unittests.sh

  test-vulkan-models-linux:
    needs: docker-image
    name: test-vulkan-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        set -eux

        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        # Setup swiftshader and Vulkan SDK which are required to build the Vulkan delegate
        source .ci/scripts/setup-vulkan-linux-deps.sh

        # Setup python
        PYTHON_EXECUTABLE=python \
        CMAKE_ARGS="-DEXECUTORCH_BUILD_VULKAN=ON" \
        .ci/scripts/setup-linux.sh --build-tool "cmake"

        PYTHON_EXECUTABLE=python bash backends/vulkan/test/scripts/test_model.sh --build

        # Test models serially
        models="mv2 mv3 edsr resnet18 resnet50 dl3 w2l ic3 ic4"
        for model in $models; do
          python -m examples.vulkan.export --model_name=$model --test
        done

        # For selected vision models, test with dynamic shapes
        models="mv2 resnet18 resnet50 ic3 densenet161"
        for model in $models; do
          python -m examples.vulkan.export --model_name=$model --test -d
        done

  test-vulkan-operators-linux:
    needs: docker-image
    name: test-vulkan-operators-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        set -eux

        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        # Setup swiftshader and Vulkan SDK which are required to build the Vulkan delegate
        source .ci/scripts/setup-vulkan-linux-deps.sh

        # Setup python
        PYTHON_EXECUTABLE=python \
        CMAKE_ARGS="-DEXECUTORCH_BUILD_VULKAN=ON" \
        .ci/scripts/setup-linux.sh --build-tool "cmake"

        # Custom operator tests
        PYTHON_EXECUTABLE=python bash backends/vulkan/test/ops/benchmark/build_and_run.sh
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=add
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=q8csw_linear --set=correctness,performance
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=q8csw_conv2d
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=q4gsw_linear --set=correctness,performance
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=choose_qparams_per_row --set=correctness,performance
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=q8ta/qdq --set=correctness
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=q8ta/clone --set=correctness
        ./cmake-out/backends/vulkan/test/ops/benchmark/etvk_bench --op=q8ta/binary --set=correctness

        # "Classic" Operator tests
        PYTHON_EXECUTABLE=python bash backends/vulkan/test/scripts/test_op.sh --build
        # TODO(ssjia): figure out how to run custom op tests in CI. Currently, they are
        # failing due to to the libstdc++.so.6 installed with conda not supporting
        # GLIBCXX_3.4.30. These tests are still run in Meta internal CI.
        # ./cmake-out/backends/vulkan/test/op_tests/vulkan_sdpa_test

        # Run e2e testing for selected operators. More operators will be tested via this
        # route in the future.
        python -m unittest backends/vulkan/test/test_vulkan_delegate.py -k "*pt2e*"
        python -m unittest backends/vulkan/test/test_vulkan_delegate.py -k "*torchao*"
        python -m unittest backends/vulkan/test/test_vulkan_graph_builder.py
        python -m unittest backends/vulkan/test/test_vulkan_dynamic.py

  test-coreml-bc-macos:
    needs: [changed-files, run-decision]
    if: |
      contains(needs.changed-files.outputs.changed-files, 'backends/apple/coreml') ||
      contains(needs.changed-files.outputs.changed-files, '.ci/scripts/test_coreml_bc.sh') ||
      contains(needs.changed-files.outputs.changed-files, '.ci/scripts/utils.sh') ||
      contains(needs.changed-files.outputs.changed-files, 'install_executorch.py') ||
      contains(needs.changed-files.outputs.changed-files, 'install_executorch.sh') ||
      contains(needs.changed-files.outputs.changed-files, 'install_requirements.py') ||
      contains(needs.changed-files.outputs.changed-files, 'install_requirements.sh') ||
      contains(needs.changed-files.outputs.changed-files, '.github/workflows/pull.yml') ||
      needs.run-decision.outputs.is-full-run == 'true'
    name: test-coreml-bc-macos (${{ matrix.runner }})
    uses: pytorch/test-infra/.github/workflows/macos_job.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        runner: [macos-m1-stable, macos-m2-stable]
      fail-fast: false
    with:
      default-packages: ""
      runner: ${{ matrix.runner }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 180
      script: |
        set -eux

        # Set up Python environment
        eval "$(conda shell.bash hook)"
        conda activate

        echo "::group::Run CoreML Backward Compatibility Test"
        # Copy script to temp location since it will checkout old commits
        # which would overwrite the script itself
        TEMP_SCRIPT=$(mktemp)
        cp .ci/scripts/test_coreml_bc.sh "${TEMP_SCRIPT}"
        bash "${TEMP_SCRIPT}" "$(pwd)"
        rm -f "${TEMP_SCRIPT}"
        echo "::endgroup::"

  nxp-build-test:
    needs: docker-image
    name: nxp-build-test
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        # Build
        cmake -DEXECUTORCH_BUILD_NXP_NEUTRON=ON -DEXECUTORCH_BUILD_NXP_NEUTRON_EXTERNAL_MEM=ON -Bcmake-out .
        cmake --build cmake-out --target executorch_delegate_neutron --config Release

        # Build check for the neutron backend library
        lib_neutron="cmake-out/backends/nxp/libexecutorch_delegate_neutron.a"
        if [ -f $lib_neutron ]; then
            echo "Neutron backend library built."
        else
            echo "Neutron backend library not found!"
            exit 1
        fi

  nxp-mcuxpresso-test:
    needs: docker-image
    name: nxp-mcuxpresso-test
    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: mt-l-x86iavx512-8-64
      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-arm-sdk-${{ needs.docker-image.outputs.ci-docker-hash }}
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 90
      script: |
        # The generic Linux job chooses to use base env, not the one setup by the image
        CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
        conda activate "${CONDA_ENV}"

        ./examples/nxp/mcuxpresso/imxrt700/executorch_cifarnet/test_build_from_scratch.sh