Add CoreAI CI on GitHub's experimental macOS27 runner (#23218)

This PR creates a CoreAI CI job on macOS27 runner.

It also pins the CoreAI dependencies in a new requirements.txt.

Author: metascroy

.github/pytorch-probot.yml

@@ -3,6 +3,7 @@ tracking_issue: 7679
 ciflow_push_tags:
 - ciflow/android
 - ciflow/apple
+- ciflow/coreai
 - ciflow/cuda
 - ciflow/cuda-perf
 - ciflow/docker

.github/workflows/coreai.yml

@@ -0,0 +1,68 @@
+name: Core AI
+
+on:
+  push:
+    branches:
+      - main
+      - release/*
+    tags:
+      - ciflow/coreai/*
+  pull_request:
+    paths:
+      - .github/workflows/coreai.yml
+      - backends/apple/coreai/**
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref_name }}-${{ github.ref_type == 'branch' && github.sha }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  run-decision:
+    name: CI run decision
+    uses: ./.github/workflows/_ci-run-decision.yml
+
+  test-coreai:
+    needs: run-decision
+    if: |
+      github.event_name == 'pull_request' ||
+      needs.run-decision.outputs.is-full-run == 'true'
+    uses: pytorch/test-infra/.github/workflows/macos_job.yml@main
+    with:
+      default-packages: ""
+      job-name: test-coreai
+      # GitHub-hosted macOS 27 with Xcode 27 (public preview).
+      runner: xcode-27
+      # coreai-opt supports Python < 3.14.
+      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::Toolchain"
+        sw_vers
+        xcodebuild -version
+        xcrun --show-sdk-version
+        echo "::endgroup::"
+
+        echo "::group::Install the Metal Toolchain"
+        # coreai-build ships in the Metal Toolchain; without it the AOT compile
+        # tests skip.
+        xcodebuild -downloadComponent MetalToolchain
+        xcrun --find coreai-build
+        echo "::endgroup::"
+
+        echo "::group::Install ExecuTorch and Core AI requirements"
+        ${CONDA_RUN} python install_executorch.py --editable > /dev/null
+        ${CONDA_RUN} pip install -r backends/apple/coreai/requirements.txt
+        ${CONDA_RUN} pip list
+        echo "::endgroup::"
+
+        echo "::group::Run Core AI export tests"
+        ${CONDA_RUN} python -m pytest backends/apple/coreai
+        echo "::endgroup::"

backends/apple/__init__.py

@@ -33,21 +33,15 @@ Legitimate non-prose dashes are fine: CLI flags (`--platform`,
 
 ## Running the tests
 
-Run the whole backend suite (both `test/` and `passes/test/`) with the helper
-script, from inside the Core AI conda env:
+Run the whole backend suite (both `test/` and `passes/test/`) from the
+repository root, in an env with ExecuTorch installed in editable mode and
+`backends/apple/coreai/requirements.txt` installed:
 
 ```bash
-conda run -n coreai backends/apple/coreai/run_all_tests.sh
+python -m pytest backends/apple/coreai
 ```
 
-Extra args are forwarded to `unittest`, e.g. `... run_all_tests.sh -v` or
-`... run_all_tests.sh -k sidecar`.
-
-**Use this script (unittest), not `pytest` directly.** pytest's default
-discovery puts `backends/apple/` on `sys.path`, so `import coreai` resolves to
-this backend directory and shadows the real Apple `coreai` SDK (`coreai_torch`
-then fails importing `coreai.authoring`). unittest imports via the full
-`executorch.backends.apple.coreai.*` path and avoids the shadowing.
+Standard pytest options apply, e.g. `-v` or `-k sidecar`.
 
 The real-toolchain AOT test (`CoreAIAOTCompileTest`) is gated on
 `xcrun coreai-build`; it runs on macOS with the Metal Toolchain and skips

backends/apple/coreai/.llms/skills/code-writing.md

@@ -5,3 +5,21 @@
 > general use, and provides **no backward- or forward-compatibility guarantees**
 > (no BC/FC). APIs, compile specs, serialized manifests, and file layouts may
 > change or break at any time without notice. Do not depend on it.
+
+## Running the tests
+
+Install ExecuTorch in editable mode, then the pinned Core AI SDK packages:
+
+```bash
+python install_executorch.py --editable
+pip install -r backends/apple/coreai/requirements.txt
+```
+
+Run the backend's Python tests from the repository root:
+
+```bash
+python -m pytest backends/apple/coreai
+```
+
+`CoreAIAOTCompileTest` needs `xcrun coreai-build` from the Metal Toolchain
+(`xcodebuild -downloadComponent MetalToolchain`) and skips without it.

backends/apple/coreai/README.md

@@ -138,7 +138,7 @@ def _shape_symbols(shape) -> Set[str]:
 
 def graph_input_names(program, entrypoint: str = MAIN_ENTRYPOINT) -> List[str]:
     """Names of the converted coreai graph's inputs (in argument order)."""
-    graph = program.get_graph(entrypoint)
+    graph = program._get_graph(entrypoint)
     names = []
     for attr in graph.arg_attrs:
         if "coreai.name" in attr:

backends/apple/coreai/compiler/enumerated_shapes.py

@@ -18,7 +18,7 @@
 import torch
 from executorch.backends.apple.coreai.compiler.constants import MAIN_ENTRYPOINT
 from torch.export.exported_program import ExportedProgram
-from torch.export.graph_signature import InputKind
+from torch.export.graph_signature import InputKind, OutputKind
 
 logger = logging.getLogger(__name__)
 
@@ -49,18 +49,40 @@ def _coreai_io(program, entrypoint: str = MAIN_ENTRYPOINT):
     Ranked tensors -> (element_type_str, shape_tuple).  Any non-tensor coreai
     type is represented as (str(type), None) so the comparison can flag it,
     rather than assuming a tensor and crashing on ``.element_type`` / ``.shape``.
+
+    Mutated buffers the delegate owns are skipped: coreai-torch marks the state
+    argument with ``MutableBuffers.buffer_mutation`` naming its result, and
+    neither crosses the ExecuTorch boundary.
     """
     from coreai._compiler.ir import RankedTensorType
 
-    func_type = program.get_graph(entrypoint).function_type.value
+    graph = program._get_graph(entrypoint)
+    func_type = graph.function_type.value
 
     def _describe(t):
         if RankedTensorType.isinstance(t):
             return (str(t.element_type), tuple(t.shape))
         return (str(t), None)
 
-    inputs = [_describe(t) for t in func_type.inputs]
-    outputs = [_describe(t) for t in func_type.results]
+    arg_attrs = list(graph.arg_attrs or [])
+    res_attrs = list(graph.res_attrs or [])
+    state_results = {
+        attrs["MutableBuffers.buffer_mutation"].value
+        for attrs in arg_attrs
+        if "MutableBuffers.buffer_mutation" in attrs
+    }
+    inputs = [
+        _describe(t)
+        for i, t in enumerate(func_type.inputs)
+        if i >= len(arg_attrs) or "MutableBuffers.buffer_mutation" not in arg_attrs[i]
+    ]
+    outputs = [
+        _describe(t)
+        for i, t in enumerate(func_type.results)
+        if i >= len(res_attrs)
+        or "coreai.name" not in res_attrs[i]
+        or res_attrs[i]["coreai.name"].value not in state_results
+    ]
     return inputs, outputs
 
 
@@ -73,20 +95,20 @@ def _edge_io(edge_program: ExportedProgram):
     entries).
 
     Inputs walk ``graph_signature.input_specs``, which is ordered like the
-    placeholders. Mutated buffers are included alongside the user inputs,
-    mirroring ``TorchConverter._register_io``: a mutation is passed in and
-    handed back, so coreai gives it a graph argument.
+    placeholders, and outputs walk ``output_specs``, ordered like the output
+    node. Mutated buffers the delegate owns (``BUFFER`` inputs in
+    ``buffers_to_mutate`` and their ``BUFFER_MUTATION`` outputs) are skipped:
+    ExecuTorch never hands that state to the delegate. Mutated user inputs
+    stay, because ExecuTorch does pass those across.
     """
     placeholders = {
         n.name: n for n in edge_program.graph.nodes if n.op == "placeholder"
     }
     signature = edge_program.graph_signature
-    mutated = set(signature.buffers_to_mutate.values())
 
     inputs = []
     for spec in signature.input_specs:
-        is_mutated_buffer = spec.kind == InputKind.BUFFER and spec.target in mutated
-        if spec.kind != InputKind.USER_INPUT and not is_mutated_buffer:
+        if spec.kind != InputKind.USER_INPUT:
             continue
         node = placeholders.get(getattr(spec.arg, "name", None))
         # A non-tensor input carries its literal value on the spec instead.
@@ -96,7 +118,11 @@ def _edge_io(edge_program: ExportedProgram):
         else:
             inputs.append((type(val).__name__, None))
     outputs = []
-    for arg in edge_program.graph.output_node().args[0]:
+    for spec, arg in zip(
+        signature.output_specs, edge_program.graph.output_node().args[0]
+    ):
+        if spec.kind == OutputKind.BUFFER_MUTATION:
+            continue
         val = arg.meta.get("val") if hasattr(arg, "meta") else arg
         if hasattr(val, "dtype"):
             outputs.append((val.dtype, tuple(val.shape)))

backends/apple/coreai/compiler/io_compat.py

@@ -0,0 +1,3 @@
+coreai-core==1.0.0b3
+coreai-torch==0.4.3
+coreai-opt==0.3.0