exir: merge main into exir-flatbuffer-serialize-fastpath_v2

Change-Id: I23787d086aa9229f5d93d1e16c6f6297119e7f5a
Signed-off-by: Chizkiyahu Raful <chizkiyahu.raful@arm.com>

Author: chizkiyahu

.ci/scripts/unittest-buck2.sh

@@ -45,6 +45,14 @@ done
 
 # Build only without testing
 buck2 build //codegen/tools/... \
+        //exir/_serialize/test/... \
+        //exir/backend/test:test_delegate_map_builder \
+        //exir/backend/test:test_graph_partition \
+        //exir/backend/test:test_group_partitioner \
+        //exir/backend/test:test_passes \
+        //exir/dialects/backend/test/... \
+        //exir/dialects/edge/op/... \
+        //exir/operator/... \
         //extension/llm/runner/io_manager:io_manager \
         //extension/llm/modules/... \
         //extension/llm/runner:multimodal_runner_lib \

backends/arm/quantizer/arm_quantizer.py

@@ -25,7 +25,7 @@
     ArmCompileSpec,
 )  # isort: skip
 from executorch.backends.arm.vgf import VgfCompileSpec
-from executorch.exir.graph_module import get_cond_while_submodules
+from executorch.exir.graph_module import _get_control_flow_submodules
 
 from torch.fx import GraphModule, Node
 from torchao.quantization.pt2e import (
@@ -639,6 +639,27 @@ def validate(self, model: GraphModule) -> None:
                         f"Quantizer detected operator {node.name} with different device inputs: {devices}."
                     )
 
+    @staticmethod
+    def _get_submodules_not_handled_by_torchao(
+        graph_module: GraphModule,
+    ):
+        """Returns control flow submodules that torchao's
+        prepare_pt2e/convert_pt2e do not handle natively. torchao now
+        recursively handles while_loop body_fn.
+
+        (arg 1), so we only need to manually handle:
+          - cond true/false branches (args 1, 2)
+          - while_loop cond_fn (arg 0)
+
+        """
+        return _get_control_flow_submodules(
+            graph_module,
+            {
+                torch.ops.higher_order.cond: [1, 2],
+                torch.ops.higher_order.while_loop: [0],
+            },
+        )
+
     def quantize_with_submodules(
         self,
         model: GraphModule,
@@ -648,6 +669,10 @@ def quantize_with_submodules(
         """Quantizes a GraphModule in a way such that conditional submodules are
         handled properly.
 
+        Note: torchao's prepare_pt2e and convert_pt2e natively handle
+        while_loop body_fn submodules, so we only manually process cond
+        branches and while_loop cond_fn here.
+
         Args:
             model (GraphModule): The model to quantize.
             calibration_samples (list[tuple]): A list of inputs to used to
@@ -663,12 +688,12 @@ def quantize_with_submodules(
         prepare_fn = prepare_qat_pt2e if is_qat else prepare_pt2e
 
         prepared = prepare_fn(model, self)
-        for name, submodule, _ in get_cond_while_submodules(prepared):
+        for name, submodule, _ in self._get_submodules_not_handled_by_torchao(prepared):
             prepared.set_submodule(name, prepare_fn(submodule, self), strict=True)
         for inp in calibration_samples:
             prepared(*inp)
 
-        for name, submodule, _ in get_cond_while_submodules(prepared):
+        for name, submodule, _ in self._get_submodules_not_handled_by_torchao(prepared):
             prepared.set_submodule(name, convert_pt2e(submodule), strict=True)
         converted = convert_pt2e(prepared)
         return converted

backends/arm/test/misc/test_runner_utils.py

@@ -0,0 +1,79 @@
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from pathlib import Path
+from typing import Any, cast
+
+from executorch.backends.arm.test import runner_utils
+
+
+class _FakeExecutorchProgramManager:
+    def __init__(self, buffer: bytes) -> None:
+        self.buffer = buffer
+
+    def exported_program(self):
+        return object()
+
+
+def test_run_corstone_no_target_uses_short_input_aliases_in_semihosting_cmd(
+    monkeypatch, tmp_path: Path
+) -> None:
+    long_input_paths = [
+        str(tmp_path / ("very_long_input_name_" * 6 + "0.bin")),
+        str(tmp_path / ("very_long_input_name_" * 6 + "1.bin")),
+    ]
+
+    monkeypatch.setattr(
+        runner_utils,
+        "save_inputs_to_file",
+        lambda exported_program, inputs, intermediate_path: long_input_paths,
+    )
+
+    copied_files: list[tuple[str, str]] = []
+
+    def _fake_copyfile(src: str, dst: str) -> None:
+        copied_files.append((src, dst))
+
+    monkeypatch.setattr(runner_utils.shutil, "copyfile", _fake_copyfile)
+
+    captured: dict[str, list[str]] = {}
+
+    def _fake_run_cmd(cmd, check=True):
+        captured["cmd"] = cmd
+        return runner_utils.subprocess.CompletedProcess(
+            cmd, 0, stdout=b"OK", stderr=b""
+        )
+
+    monkeypatch.setattr(runner_utils, "_run_cmd", _fake_run_cmd)
+    monkeypatch.setattr(
+        runner_utils,
+        "get_output_from_file",
+        lambda exported_program, intermediate_path, output_base_name: ("sentinel",),
+    )
+
+    elf_path = tmp_path / "arm_executor_runner"
+    elf_path.write_bytes(b"")
+
+    output = runner_utils.run_corstone(
+        executorch_program_manager=cast(
+            Any, _FakeExecutorchProgramManager(buffer=b"pte")
+        ),
+        inputs=cast(Any, ()),
+        intermediate_path=tmp_path,
+        target_board="corstone-320",
+        elf_path=elf_path,
+        timeout=1,
+    )
+
+    assert output == ("sentinel",)
+    assert [Path(dst).name for _, dst in copied_files] == ["i0.bin", "i1.bin"]
+
+    semihosting_cmd_arg = next(
+        arg for arg in captured["cmd"] if "semihosting-cmd_line" in arg
+    )
+    assert "-i i0.bin" in semihosting_cmd_arg
+    assert "-i i1.bin" in semihosting_cmd_arg
+    assert long_input_paths[0] not in semihosting_cmd_arg
+    assert long_input_paths[1] not in semihosting_cmd_arg

backends/arm/test/runner_utils.py

@@ -406,14 +406,24 @@ def run_corstone(
         f.write(executorch_program_manager.buffer)
 
     input_paths = save_inputs_to_file(exported_program, inputs, intermediate_path)
+    # Keep semihosting command line short: the FVP truncates long cmd strings.
+    # Alias generated input files to compact names in the same directory.
+    aliased_input_paths = []
+    for idx, input_path in enumerate(input_paths):
+        short_name = f"i{idx}.bin"
+        short_path = os.path.join(intermediate_path, short_name)
+        if os.path.abspath(input_path) != os.path.abspath(short_path):
+            shutil.copyfile(input_path, short_path)
+        aliased_input_paths.append(short_path)
 
     output_base_name = "out"
 
     cmd_line = "executor_runner -m program.pte -o out"
-    for input_path in input_paths:
-        relative_path = os.path.relpath(
-            Path(input_path).resolve(), start=intermediate_path
-        )
+    for input_path in aliased_input_paths:
+        # Use local basenames to avoid '/var' -> '/private/var' resolve expansion
+        # on macOS, which can produce long '../../..' paths and exceed FVP's
+        # semihosting cmd_line limit.
+        relative_path = Path(input_path).name
         cmd_line += f" -i {relative_path}"
 
     if len(cmd_line) > 256:

backends/cadence/aot/remove_ops.py

@@ -757,8 +757,8 @@ def targets(self) -> list[EdgeOpOverload]:
     def maybe_remove_or_replace(self, node: Node) -> bool:
         cat_node = get_arg(node, "input", Node)
         slice_dim = get_arg(node, "dim", int)
-        start_idx = get_arg(node, "start", int)
-        end_idx = get_arg(node, "end", int)
+        start_idx = get_arg(node, "start", Optional[int])
+        end_idx = get_arg(node, "end", Optional[int])
         step = get_arg(node, "step", int)
 
         if cat_node.target != exir_ops.edge.aten.cat.default or step != 1:

backends/cortex_m/passes/convert_to_cortex_m_pass.py

@@ -71,7 +71,7 @@ def _get_batch_size_from_conv(self, conv_node: torch.fx.Node):
 
     def _get_linear_replacement(self, node):
         """
-         Let
+        Let
         - yi be the output activations (y1, ... yn)
         - xj be the input activations (x1, ... xm)
         - wij be the weights (w11, ... wnm)

examples/arm/aot_arm_compiler.py

@@ -36,11 +36,12 @@
 from executorch.backends.arm.util._factory import create_partitioner, create_quantizer
 
 from executorch.backends.arm.vgf import VgfCompileSpec
+from executorch.backends.cortex_m.passes.cortex_m_pass_manager import CortexMPassManager
 
-# To use Cortex-M backend
 from executorch.backends.cortex_m.passes.replace_quant_nodes_pass import (
     ReplaceQuantNodesPass,
 )
+from executorch.backends.cortex_m.quantizer.quantizer import CortexMQuantizer
 
 from executorch.devtools import generate_etrecord
 from executorch.devtools.backend_debug import get_delegation_info
@@ -396,6 +397,7 @@ def forward(self, x):
     "TOSA-1.0+INT",
     "TOSA-1.0+FP",
     "TOSA-1.0+INT+int16",
+    "cortex-m55+int8",
 ]
 
 
@@ -528,7 +530,7 @@ def get_args():
         required=False,
         default="ethos-u55-128",
         choices=TARGETS,
-        help=f"For ArmBackend delegated models, pick the target, and therefore the instruction set generated. valid targets are {TARGETS}",
+        help=f"Target backend. For delegated models: Ethos-U/VGF/TOSA variants. For non-delegated: cortex-m55+int8 (CMSIS-NN portable kernels). Valid targets: {TARGETS}",
     )
     parser.add_argument(
         "-e",
@@ -795,6 +797,75 @@ def to_edge_TOSA_delegate(
     return model_quant, edge
 
 
+def to_edge_cortex_m(
+    exported_program: ExportedProgram,
+    args,
+    model: GraphModule,
+    example_inputs: Tuple[torch.Tensor],
+):
+    """Cortex-M/CMSIS-NN compilation path with no delegation."""
+    logging.info("Using Cortex-M/CMSIS-NN compilation path (no delegation)")
+
+    def _to_channels_last(x):
+        if isinstance(x, torch.Tensor):
+            if x.dim() == 4 and not x.is_contiguous(memory_format=torch.channels_last):
+                logging.warning(
+                    "Converting input tensor with shape %s to channels_last",
+                    list(x.shape),
+                )
+                return x.to(memory_format=torch.channels_last)
+            return x
+        elif isinstance(x, tuple):
+            return tuple(_to_channels_last(t) for t in x)
+        return x
+
+    if not args.quantize:
+        logging.warning(
+            "Quantization is DISABLED. Cortex-M typically requires quantization."
+        )
+    else:
+        model = model.to(memory_format=torch.channels_last)
+        example_inputs = tuple(_to_channels_last(x) for x in example_inputs)
+
+        quantizer = CortexMQuantizer()
+        prepared = prepare_pt2e(model, quantizer)
+
+        dataset = get_calibration_data(
+            args.model_name, example_inputs, args.evaluate, args.evaluate_config
+        )
+
+        if isinstance(dataset, DataLoader):
+            for sample, _ in dataset:
+                prepared(_to_channels_last(sample))
+        else:
+            prepared(*tuple(_to_channels_last(x) for x in dataset))
+
+        model_quant = convert_pt2e(prepared)
+
+        exported_program = torch.export.export(
+            model_quant, example_inputs, strict=args.strict_export
+        )
+
+    edge = to_edge_transform_and_lower(
+        exported_program,
+        compile_config=EdgeCompileConfig(
+            preserve_ops=[
+                torch.ops.aten.linear.default,
+                torch.ops.aten.hardsigmoid.default,
+                torch.ops.aten.hardsigmoid_.default,
+                torch.ops.aten.hardswish.default,
+                torch.ops.aten.hardswish_.default,
+            ],
+            _check_ir_validity=False,
+        ),
+    )
+
+    pass_manager = CortexMPassManager(edge.exported_program())
+    edge._edge_programs["forward"] = pass_manager.transform()
+
+    return model_quant if args.quantize else None, edge
+
+
 def to_edge_no_delegate(
     exported_program: ExportedProgram,
     args,
@@ -873,7 +944,24 @@ def to_edge_no_delegate(
 
     # Quantize if required
     model_quant = None
-    if args.delegate:
+    if args.target == "cortex-m55+int8":
+        # Cortex-M path: CMSIS-NN portable kernels, no delegation
+        if getattr(args, "evaluate", False):
+            logging.error(
+                "--evaluate is not supported for target 'cortex-m55+int8' "
+                "because this path does not use a TOSA delegate."
+            )
+            sys.exit(1)
+        if args.delegate:
+            logging.warning(
+                "--delegate is ignored for target 'cortex-m55+int8' "
+                "(this target does not use delegated ops)."
+            )
+            args.delegate = False
+        model_quant, edge = to_edge_cortex_m(
+            exported_program, args, model, example_inputs
+        )
+    elif args.delegate:
         model_quant, edge = to_edge_TOSA_delegate(
             exported_program, args, model, example_inputs
         )