Merge branch 'main' into add_moreTC_quantization

Author: Jiseong-oh

.ci/scripts/setup-qnn-deps.sh

@@ -11,4 +11,5 @@ source "$(dirname "${BASH_SOURCE[0]}")/../../backends/qualcomm/scripts/install_q
 
 setup_libcpp 12
 setup_android_ndk
-install_qnn
+install_qnn
+pip install -r backends/qualcomm/requirements.txt

.ci/scripts/test_wheel_package_qnn.sh

@@ -177,6 +177,9 @@ PY
   "$PIPBIN" install . --no-build-isolation
   popd > /dev/null
 
+  # Install qualcomm backend dependencies  
+  "$PIPBIN" install -r "$REPO_ROOT/backends/qualcomm/requirements.txt"
+
   echo "=== [$LABEL] Import smoke tests ==="
   "$PYBIN" -c "import executorch; print('executorch imported successfully')"
   "$PYBIN" -c "import executorch.backends.qualcomm; print('executorch.backends.qualcomm imported successfully')"

.githooks/README.md

@@ -1,57 +1,63 @@
 # Git Hooks
 
-This directory contains Git hooks for the ExecuTorch repository.
+This directory contains Git hooks for the ExecuTorch repository. It is used as
+`core.hooksPath`, so git looks here instead of `.git/hooks/`.
 
-## Pre-commit Hook
+## Hooks
 
-The pre-commit hook automatically updates the PyTorch commit pin in `.ci/docker/ci_commit_pins/pytorch.txt` whenever `torch_pin.py` is modified.
+### pre-commit
 
-### How It Works
+Runs on every commit:
 
-1. When you commit changes to `torch_pin.py`, the hook detects the change
-2. It parses the `NIGHTLY_VERSION` field (e.g., `dev20251004`)
-3. Converts it to a date string (e.g., `2025-10-04`)
-4. Fetches the corresponding commit hash from the PyTorch nightly branch at https://github.com/pytorch/pytorch/tree/nightly
-5. Updates `.ci/docker/ci_commit_pins/pytorch.txt` with the new commit hash
-6. Automatically stages the updated file for commit
+1. **torch_pin sync** — when `torch_pin.py` is staged, updates the PyTorch commit
+   pin in `.ci/docker/ci_commit_pins/pytorch.txt` and syncs grafted c10 files.
+2. **lintrunner** — runs `lintrunner -a --revision HEAD^ --skip MYPY` on changed
+   files. Auto-fixes formatting and blocks on lint errors. Soft-fails if lintrunner
+   is not installed. Runs `lintrunner init` automatically when `.lintrunner.toml`
+   changes.
 
-### Installation
+### pre-push
 
-To install the Git hooks, run:
+Delegates to `.git/hooks/pre-push` if one exists. This allows backend-specific
+pre-push hooks (e.g., ARM's license and commit message checks) to work alongside
+the repo-wide hooks.
+
+## Installation
+
+Hooks are installed automatically by `./install_executorch.sh`.
+
+To install manually:
 
 ```bash
-.githooks/install.sh
+git config core.hooksPath .githooks
 ```
 
-This will copy the pre-commit hook to `.git/hooks/` and make it executable.
+### ARM backend pre-push
 
-### Manual Usage
-
-You can also run the update script manually at any time:
+ARM contributors should additionally install the ARM-specific pre-push hook:
 
 ```bash
-python .github/scripts/update_pytorch_pin.py
+cp backends/arm/scripts/pre-push .git/hooks/
 ```
 
-### Uninstalling
+## Bypassing
 
-To remove the pre-commit hook:
+To skip hooks for a single commit or push:
 
 ```bash
-rm .git/hooks/pre-commit
+git commit --no-verify
+git push --no-verify
 ```
 
 ## Troubleshooting
 
-If the hook fails during a commit:
+If the torch_pin hook fails:
 
 1. Check that Python 3 is available in your PATH
 2. Ensure you have internet connectivity to fetch commits from GitHub
 3. Verify that the `NIGHTLY_VERSION` in `torch_pin.py` is in the correct format (`devYYYYMMDD`)
-4. Make sure the corresponding nightly release exists in the PyTorch nightly branch
 
-You can run the script manually to see detailed error messages:
+If lintrunner fails:
 
-```bash
-python .github/scripts/update_pytorch_pin.py
-```
+1. Run `lintrunner init` to install linter tools
+2. Check that your virtual environment is activated

.githooks/install.sh

@@ -27,4 +27,68 @@ if git diff --cached --name-only | grep -q "^torch_pin.py$"; then
     fi
 fi
 
-exit 0
+# --- lintrunner ---
+
+if ! command -v lintrunner >/dev/null 2>&1; then
+    echo "Warning: lintrunner not found. Skipping lint checks."
+    echo "Install with: pip install lintrunner lintrunner-adapters && lintrunner init"
+    exit 0
+fi
+
+if [ ! -f .lintrunner.toml ]; then
+    echo "Warning: .lintrunner.toml not found. Skipping lint checks."
+    exit 0
+fi
+
+git_dir=$(git rev-parse --git-dir)
+
+# Portable hash: sha256sum (Linux) or shasum (macOS)
+if command -v sha256sum >/dev/null 2>&1; then
+    toml_hash=$(sha256sum .lintrunner.toml | cut -d' ' -f1)
+else
+    toml_hash=$(shasum -a 256 .lintrunner.toml | cut -d' ' -f1)
+fi
+stored_hash=""
+[ -f "${git_dir}/.lintrunner_init_hash" ] && stored_hash=$(cat "${git_dir}/.lintrunner_init_hash")
+
+if [ "${toml_hash}" != "${stored_hash}" ]; then
+    echo "Running lintrunner init..."
+    if lintrunner init; then
+        echo "${toml_hash}" > "${git_dir}/.lintrunner_init_hash"
+    else
+        echo "lintrunner init failed. Run 'lintrunner init' manually."
+        exit 1
+    fi
+fi
+
+staged_files=$(git diff --cached --name-only --diff-filter=ACMR)
+
+# Use HEAD^ if it exists (skip on initial commit)
+revision_flag="--revision HEAD^"
+if ! git rev-parse HEAD^ >/dev/null 2>&1; then
+    revision_flag=""
+fi
+
+lintrunner -a $revision_flag --skip MYPY
+lint_status=$?
+
+# Check if lintrunner modified any staged files. If so, block the commit
+# so the user can review the changes before committing.
+files_modified=0
+while IFS= read -r path; do
+    [ -z "${path}" ] && continue
+    if ! git diff --quiet -- "${path}" 2>/dev/null; then
+        files_modified=1
+        break
+    fi
+done <<< "${staged_files}"
+
+if [ $files_modified -eq 1 ]; then
+    echo "Lintrunner modified files. Review with 'git diff', then 'git add -u && git commit'."
+    exit 1
+fi
+
+if [ $lint_status -ne 0 ]; then
+    echo "Lint errors found. Fix them and try again, or use 'git commit --no-verify' to skip."
+    exit 1
+fi

.githooks/pre-commit

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+# Delegate to local pre-push hook if present (e.g., ARM backend).
+# .githooks/ is set as core.hooksPath, so git won't look in .git/hooks/
+# automatically. This passthrough ensures local hooks still run.
+local_hook="$(git rev-parse --git-dir)/hooks/pre-push"
+if [ -x "$local_hook" ]; then
+    "$local_hook" "$@"
+fi

.githooks/pre-push

@@ -0,0 +1,106 @@
+name: MLX
+
+on:
+  push:
+    branches:
+      - main
+      - release/*
+  pull_request:
+    paths:
+      - .github/workflows/mlx.yml
+      - backends/mlx/**
+      - extension/llm/export/**
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  test-mlx:
+    uses: pytorch/test-infra/.github/workflows/macos_job.yml@main
+    with:
+      job-name: test-mlx
+      runner: macos-14-xlarge
+      python-version: "3.12"
+      submodules: recursive
+      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+      timeout: 90
+      script: |
+        set -eux
+
+        echo "::group::Install ExecuTorch and configure build"
+        ${CONDA_RUN} python install_executorch.py > /dev/null
+        # The sanitizers fail on github VM runner, but pass on real device
+        # TODO: figure out why
+        ${CONDA_RUN} cmake --preset mlx-release -DEXECUTORCH_BUILD_TESTS=ON -DEXECUTORCH_MLX_ENABLE_SANITIZERS=OFF
+        echo "::endgroup::"
+
+        ${CONDA_RUN} pip list
+
+        echo "::group::Build test runners"
+        ${CONDA_RUN} cmake --build cmake-out --target op_test_runner multi_thread_test_runner -j$(( $(sysctl -n hw.ncpu) - 1 ))
+        echo "::endgroup::"
+
+        echo "::group::Run op unit tests"
+        ${CONDA_RUN} python -m executorch.backends.mlx.test.run_all_tests -j4 --max-tasks-per-worker 10 --clean-after
+        echo "::endgroup::"
+
+        echo "::group::Run Python unit tests"
+        ${CONDA_RUN} python -m pytest \
+          backends/mlx/test/test_passes.py \
+          backends/mlx/test/test_pattern_utils.py \
+          backends/mlx/test/test_partitioner.py \
+          -v
+        echo "::endgroup::"
+
+        echo "::group::Run multi-thread stress test"
+        ${CONDA_RUN} python backends/mlx/test/export_multi_thread_test_model.py /tmp/multi_thread_test_model.pte
+        ET_TESTING_MODEL_PATH=/tmp/multi_thread_test_model.pte \
+          ET_TESTING_NUM_THREADS=50 \
+          ET_PREDICTIONS_PER_THREAD=100 \
+          ./cmake-out/backends/mlx/test/multi_thread_test_runner
+        echo "::endgroup::"
+
+  backend-tester:
+    strategy:
+      fail-fast: false
+      matrix:
+        suite: [models, operators]
+    uses: pytorch/test-infra/.github/workflows/macos_job.yml@main
+    with:
+      job-name: test-mlx-backend-${{ matrix.suite }}
+      runner: macos-14-xlarge
+      python-version: "3.12"
+      submodules: recursive
+      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+      timeout: 120
+      script: |
+        set -eux
+
+        echo "::group::Install ExecuTorch"
+        ${CONDA_RUN} python install_executorch.py > /dev/null
+        echo "::endgroup::"
+
+        ${CONDA_RUN} pip list
+
+        echo "::group::Run backend test suite (${{ matrix.suite }})"
+        ${CONDA_RUN} pytest -c /dev/null backends/test/suite/${{ matrix.suite }}/ -m flow_mlx -n auto 2>&1 | tee pytest_output.txt || true
+        echo "::endgroup::"
+
+        # Parse pytest summary and check failure threshold
+        if grep -E "^=+ .* =+$" pytest_output.txt | tail -1 | grep -q "failed"; then
+          FAILED=$(grep -E "^=+ .* =+$" pytest_output.txt | tail -1 | grep -oE "[0-9]+ failed" | grep -oE "[0-9]+")
+        else
+          FAILED=0
+        fi
+
+        if [ "${{ matrix.suite }}" = "operators" ]; then
+          MAX_FAILURES=0
+        else
+          MAX_FAILURES=3
+        fi
+
+        echo "Failed tests: $FAILED (max allowed: $MAX_FAILURES)"
+        if [ "$FAILED" -gt "$MAX_FAILURES" ]; then
+          echo "::error::Too many test failures: $FAILED > $MAX_FAILURES"
+          exit 1
+        fi

.github/workflows/mlx.yml

@@ -74,5 +74,7 @@ xcuserdata/
 *.dll
 *.pyd
 
+
 # Agents
 .claude/*.local.*
+extension/pybindings/mlx.metallib

.gitignore

@@ -67,3 +67,7 @@
 [submodule "third-party/json"]
 	path = third-party/json
 	url = https://github.com/nlohmann/json.git
+[submodule "backends/mlx/third-party/mlx"]
+	path = backends/mlx/third-party/mlx
+	url = https://github.com/ml-explore/mlx.git
+	shallow = true

.gitmodules

@@ -682,6 +682,11 @@ if(EXECUTORCH_BUILD_MPS)
   list(APPEND _executorch_backends mpsdelegate)
 endif()
 
+if(EXECUTORCH_BUILD_MLX)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/mlx)
+  list(APPEND _executorch_backends mlxdelegate)
+endif()
+
 if(EXECUTORCH_BUILD_NEURON)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/mediatek)
   list(APPEND _executorch_backends neuron_backend)
@@ -982,6 +987,10 @@ if(EXECUTORCH_BUILD_PYBIND)
     list(APPEND _dep_libs mpsdelegate)
   endif()
 
+  if(EXECUTORCH_BUILD_MLX)
+    list(APPEND _dep_libs mlxdelegate)
+  endif()
+
   if(EXECUTORCH_BUILD_OPENVINO)
     list(APPEND _dep_libs openvino_backend)
   endif()
@@ -1082,6 +1091,12 @@ if(EXECUTORCH_BUILD_PYBIND)
   install(TARGETS data_loader
           LIBRARY DESTINATION executorch/extension/pybindings
   )
+
+  # Copy MLX metallib next to _portable_lib.so for editable installs. MLX uses
+  # dladdr() to find the directory containing the library with MLX code, then
+  # looks for mlx.metallib in that directory. When MLX is statically linked into
+  # _portable_lib.so, we need the metallib colocated with it.
+  executorch_target_copy_mlx_metallib(portable_lib)
 endif()
 
 if(EXECUTORCH_BUILD_WASM)