pull.yml

name: pull

on:
  pull_request:
  push:
    branches:
      - main
      - release/*
    tags:
      - ciflow/trunk/*
  workflow_dispatch:

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

jobs:
  # Emits PR diff file list; non-PR events emit '*' so the per-job
  # `if:` short-circuits via `event_name != 'pull_request'`.
  changed-files:
    name: Get changed files
    uses: ./.github/workflows/_get-changed-files.yml

  test-qnn-wheel-packages-linux:
    name: test-qnn-wheel-packages-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
      matrix:
        python-version: [ "3.10", "3.11", "3.12", "3.13" ]
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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-setup-linux-gcc:
    name: test-setup-linux-gcc
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-gcc11
      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-models-linux-basic:
    name: test-models-linux-basic
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        model: [mv3, vit]
        backend: [portable, xnnpack-quantization-delegation]
        build-tool: [cmake, buck2]
        runner: [linux.2xlarge, linux.arm64.2xlarge]
        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 (linux.2xlarge)
        #   - Excluding the x86 clang image on the ARM64 runner (linux.arm64.2xlarge)
        exclude:
          - runner: linux.2xlarge
            docker-image: executorch-ubuntu-22.04-gcc11-aarch64
          - runner: linux.arm64.2xlarge
            docker-image: executorch-ubuntu-22.04-clang12
          # TODO: Need to figure out why buck2 doesnt work on Graviton instances.
          - runner: linux.arm64.2xlarge
            build-tool: buck2
      fail-fast: false
    with:
      runner: ${{ matrix.runner }}
      docker-image: ci-image:${{ matrix.docker-image }}
      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:
    name: test-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.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: [linux.2xlarge]
        include:
          - model: ic4
            backend: portable
            runner: linux.4xlarge.memory
          - model: ic4
            backend: xnnpack-quantization-delegation
            runner: linux.4xlarge.memory
          - model: emformer_join
            backend: portable
            runner: linux.4xlarge.memory
          - model: emformer_join
            backend: xnnpack-quantization-delegation
            runner: linux.4xlarge.memory
          - model: phi_4_mini
            backend: portable
            runner: linux.4xlarge.memory
          - model: llama3_2_vision_encoder
            backend: portable
            runner: linux.4xlarge.memory
          - model: w2l
            backend: portable
            runner: linux.4xlarge.memory
      fail-fast: false
    with:
      runner: ${{ matrix.runner }}
      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}"

        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:
    name: test-parakeet-xnnpack-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.4xlarge.memory
      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: 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:
    name: test-voxtral-realtime-xnnpack-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.4xlarge.memory
      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: 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:
    # Test Both linux x86 and linux aarch64
    name: test-llama-runner-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        dtype: [fp32]
        mode: [xnnpack+custom+qe,xnnpack+custom+quantize_kv,xnnpack+quantize_kv]
        runner: [linux.2xlarge, linux.arm64.2xlarge]
        docker-image: [executorch-ubuntu-22.04-clang12, executorch-ubuntu-22.04-gcc11-aarch64]
        include:
          - dtype: bf16
            mode: custom
            runner: linux.2xlarge
            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 (linux.2xlarge)
        #   - Excluding the x86 clang image on the ARM64 runner (linux.arm64.2xlarge)
        exclude:
          - runner: linux.2xlarge
            docker-image: executorch-ubuntu-22.04-gcc11-aarch64
          - runner: linux.arm64.2xlarge
            docker-image: executorch-ubuntu-22.04-clang12
      fail-fast: false
    with:
      runner: ${{ matrix.runner }}
      docker-image: ci-image:${{ matrix.docker-image }}
      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:
    name: test-llama-runner-linux-android
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-clang12-android
      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:
    name: test-custom-ops-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      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}"

        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:
    name: test-selective-build-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      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}"

        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:
    if: ${{ !github.event.pull_request.head.repo.fork }}
    name: test-multimodal-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.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: linux.24xlarge.memory
      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}"

        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:
    name: test-moshi-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      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: |
        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:
    name: test-quantized-aot-lib-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      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}"

        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:
    name: test-binary-size-linux-gcc
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-gcc9-nopytorch
      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}"

        ./install_requirements.sh
        # build module for executorch.extension.pybindings.portable_lib
        bash test/build_size_test.sh
        strip cmake-out/test/size_test
        output=$(ls -la cmake-out/test/size_test)
        arr=($output)
        size=${arr[4]}
        # Current CI size: 48008 (gcc9-nopytorch, 2026-03-06)
        threshold="48500"
        if [[ "$size" -le "$threshold" ]]; then
          echo "Success $size <= $threshold"
        else
          echo "Fail $size > $threshold"
          exit 1
        fi

  test-binary-size-linux:
    name: test-binary-size-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      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}"

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

        # build module for executorch.extension.pybindings.portable_lib
        bash test/build_size_test.sh
        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:
    name: test-arm-cortex-m-size-test
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        os: [bare_metal, zephyr-preset]
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-arm-sdk
      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} -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
        (
          # conda-forge bloaty depends on a newer libstdc++ than the docker image
          # ships, so pull libstdcxx-ng into the same env and invoke via `conda run`.
          bloaty_env=/tmp/bloaty-conda-env
          if [[ ! -x "${bloaty_env}/bin/bloaty" ]]; then
            conda create -y -p "${bloaty_env}" -c conda-forge bloaty libstdcxx-ng || exit 1
          fi
          bloaty_cmd=("conda" "run" "--no-capture-output" "-p" "${bloaty_env}" "bloaty")
          "${bloaty_cmd[@]}" --version || exit 1

          tmp_out=/tmp/bloaty-out
          rm -rf "${tmp_out}" && mkdir -p "${tmp_out}"
          BLOATY="${bloaty_cmd[*]}" python3 .github/scripts/bloaty_diff.py measure \
            --head /tmp/bloaty-elfs/head.elf \
            --job "arm-${{ matrix.os }}" \
            --binary-name size_test \
            --head-sha "${{ github.event.pull_request.head.sha || github.sha }}" \
            --strip-tool "${toolchain_prefix}strip" \
            --out "${tmp_out}" || exit 1
          mkdir -p artifacts-to-be-uploaded
          mv "${tmp_out}"/* artifacts-to-be-uploaded/
        ) || echo "bloaty report failed; continuing"

        # 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:
    name: test-mcu-cortex-m-backend
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: linux.2xlarge.memory
      docker-image: ci-image:executorch-ubuntu-22.04-arm-sdk
      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

  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:
    name: test-qnn-buck-build-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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:
    name: test-arm-backend-no-driver
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.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: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-arm-sdk
      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

        ARM_TEST=${{ matrix.test_arm_backend }}

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

  test-llama-runner-qnn-linux:
    name: test-llama-runner-qnn-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.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: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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:
    name: test-static-llama-qnn-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        task: [stories_110m, stories_260k_bc]
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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:
    name: test-sqnr-static-llm-qnn-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        task: [smollm2_135m]
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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:
    name: test-qnn-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        model: [mv2, mv3, dl3]
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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-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
      runner-linux: linux.2xlarge

  test-qnn-passes-linux:
    name: test-qnn-passes-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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

  test-qnn-delegate-linux:
    name: test-qnn-delegate-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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:
    name: test-phi-3-mini-runner-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.24xlarge
      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}"
        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:
    name: test-qnn-python-imports-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-qnn-sdk
      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:
    name: test-eval_llama-wikitext-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.24xlarge
      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 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_v2.yml@main
  #   permissions:
  #     id-token: write
  #     contents: read
  #   strategy:
  #     fail-fast: false
  #   with:
  #     runner: linux.24xlarge
  #     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:
    name: test-llama_runner_eager-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.24xlarge
      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 llama runner in eager mode
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_llama_runner_eager.sh

  test-lora-linux:
    name: test-lora-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.24xlarge
      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 llama runner in eager mode
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_lora.sh

  test-lora-multimethod-linux:
    name: test-lora-multimethod-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.24xlarge
      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 llama runner in eager mode
        PYTHON_EXECUTABLE=python bash .ci/scripts/test_lora_multimethod.sh

  test-mediatek-models-linux:
    name: test-mediatek-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.24xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-mediatek-sdk
      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:
    name: test-openvino-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-gcc11
      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:
    name: test-build-wasm-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      fail-fast: false
    with:
      runner: linux.2xlarge
      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}"

        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

  unittest-wasm-bindings:
    name: unittest-wasm-bindings
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    strategy:
      matrix:
        enable-etdump: ['', '--enable-etdump']
      fail-fast: false
    with:
      runner: linux.2xlarge
      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}"

        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:
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: linux.2xlarge
      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: |
        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
        PYTHON_EXECUTABLE=python bash examples/nxp/run_aot_example.sh mobilenetv2

        # 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-samsung-quantmodels-linux:
    name: test-samsung-quantmodels-linux
    # Skip this job if the pull request is from a fork (secrets are not available)
    if: github.event.pull_request.head.repo.full_name == github.repository || github.event_name != 'pull_request'
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    secrets: inherit
    with:
      secrets-env: SAMSUNG_AI_LITECORE_KEY
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-clang12-android
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 180
      script: |
        set -ex

        # 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 python
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # Setup Samsung SDK (AI Lite Core) and install enn backend
        export SAMSUNG_AI_LITECORE_KEY=$SECRET_SAMSUNG_AI_LITECORE_KEY

        trap 'bash .ci/scripts/cleanup-samsung-linux-deps.sh' EXIT TERM INT
        source .ci/scripts/setup-samsung-linux-deps.sh --skip-device-connect

        # Test quant models
        model_scripts="deeplab_v3 edsr inception_v3 inception_v4 mobilenet_v2 mobilenet_v3 resnet18 resnet50 vit wav2letter"
        for m_script in $model_scripts; do
          python -m executorch.examples.samsung.scripts.${m_script} -c e9955 -p A8W8
        done

  test-samsung-models-linux:
    name: test-samsung-models-linux
    # Skip this job if the pull request is from a fork (secrets are not available)
    if: github.event.pull_request.head.repo.full_name == github.repository || github.event_name != 'pull_request'
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    secrets: inherit
    with:
      secrets-env: SAMSUNG_AI_LITECORE_KEY
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-clang12-android
      submodules: 'recursive'
      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
      timeout: 360
      script: |
        set -ex

        # 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 python
        PYTHON_EXECUTABLE=python bash .ci/scripts/setup-linux.sh --build-tool "cmake"

        # Setup Samsung SDK (AI Lite Core) and install enn backend
        export SAMSUNG_AI_LITECORE_KEY=$SECRET_SAMSUNG_AI_LITECORE_KEY
        trap 'bash .ci/scripts/cleanup-samsung-linux-deps.sh' EXIT TERM INT
        source .ci/scripts/setup-samsung-linux-deps.sh

        # Check if device was reserved
        if [[ "${DEVICE_ACQUIRED:-0}" != "1" ]]; then
          echo "::warning::Skipping tests - no Samsung device available"
          exit 0
        fi

        # Test models
        python -m unittest discover -s backends/samsung/test/models -p "test_*.py"

  test-vulkan-models-linux:
    name: test-vulkan-models-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: linux.2xlarge
      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: |
        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:
    name: test-vulkan-operators-linux
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: linux.2xlarge
      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: |
        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/custom_ops/build_and_run.sh test_add
        ./cmake-out/backends/vulkan/test/custom_ops/test_q8csw_linear
        ./cmake-out/backends/vulkan/test/custom_ops/test_q8csw_conv2d
        ./cmake-out/backends/vulkan/test/custom_ops/test_q4gsw_linear
        ./cmake-out/backends/vulkan/test/custom_ops/test_choose_qparams_per_row
        ./cmake-out/backends/vulkan/test/custom_ops/test_q8ta_qdq
        ./cmake-out/backends/vulkan/test/custom_ops/test_q8ta_clone
        ./cmake-out/backends/vulkan/test/custom_ops/test_q8ta_binary

        # "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*"

  test-coreml-bc-macos:
    needs: changed-files
    if: |
      github.event_name != 'pull_request' ||
      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')
    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:
    name: nxp-build-test
    uses: pytorch/test-infra/.github/workflows/linux_job_v2.yml@main
    permissions:
      id-token: write
      contents: read
    with:
      runner: linux.2xlarge
      docker-image: ci-image:executorch-ubuntu-22.04-arm-sdk
      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 -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