Update

[ghstack-poisoned]

Author: JCNTH

backends/arm/quantizer/quantization_annotator.py

@@ -547,7 +547,6 @@ def _match_pattern(
     torch.ops.aten.split.Tensor,
     torch.ops.aten.split_with_sizes.default,
     torch.ops.aten.split_copy.Tensor,
-    torch.ops.aten.transpose.Dimname,
     torch.ops.aten.transpose.int,
     torch.ops.aten.transpose_copy.int,
     torch.ops.aten.t_copy.default,
@@ -575,6 +574,15 @@ def _match_pattern(
     torch.ops.aten.detach_copy.default,
 }
 
+# Dimname has been removed from upstream PyTorch, but there may be a window
+# where developers in this backend are using a mainline build of this backend
+# with an older version of PyTorch.
+# TODO: remove this once the build has time to be propagated and majority of
+# dev expected to be unimpacted
+_transpose_dimname = getattr(torch.ops.aten.transpose, "Dimname", None)
+if _transpose_dimname is not None:
+    _one_to_one_shared_input_qspec.add(_transpose_dimname)
+
 _one_to_one_shared_input_or_input_act_qspec: set[OpOverload] = {
     torch.ops.aten.alias.default,
     torch.ops.aten.clone.default,

backends/arm/test/runner_utils.py

@@ -892,7 +892,7 @@ def _elf_search_roots() -> list[Path]:
 
 
 def _elf_path_candidates(
-    target_board: str, use_portable_ops: bool = False
+    target_board: str, use_portable_ops: bool = False, build_dir_suffix: str = ""
 ) -> list[Path]:
     if target_board not in VALID_TARGET:
         raise ValueError(f"Unsupported target: {target_board}")
@@ -901,11 +901,14 @@ def _elf_path_candidates(
     if target_board in ("corstone-300", "corstone-320"):
         build_dir = Path(
             "arm_test",
-            f"arm_semihosting_executor_runner_{portable_ops_str}{target_board}",
+            f"arm_semihosting_executor_runner_"
+            f"{portable_ops_str}{target_board}{build_dir_suffix}",
         )
         binary_name = "arm_executor_runner"
     else:
-        build_dir = Path("arm_test", f"arm_executor_runner_{portable_ops_str}vkml")
+        build_dir = Path(
+            "arm_test", f"arm_executor_runner_{portable_ops_str}vkml{build_dir_suffix}"
+        )
         binary_name = "executor_runner"
 
     candidates: list[Path] = []
@@ -950,9 +953,15 @@ def _resolve_existing_elf_path(elf_candidates: Iterable[Path]) -> Path:
     )
 
 
-def get_elf_path(target_board: str, use_portable_ops: bool = False) -> str:
+def get_elf_path(
+    target_board: str, use_portable_ops: bool = False, build_dir_suffix: str = ""
+) -> str:
     elf_path = _resolve_existing_elf_path(
-        _elf_path_candidates(target_board, use_portable_ops=use_portable_ops)
+        _elf_path_candidates(
+            target_board,
+            use_portable_ops=use_portable_ops,
+            build_dir_suffix=build_dir_suffix,
+        )
     )
     return str(elf_path)
 

backends/arm/test/tester/serialize.py

@@ -34,20 +34,25 @@ def __init__(
         module: Optional[torch.nn.Module],
         use_portable_ops: bool = False,
         timeout: int = 120,
+        build_dir_suffix: str = "",
     ):
         """
         Args:
             compile_spec: CompileSpecs to be used for serialization.
             module: Original Module to be used for serialization. Optional - can be used for reference output generation.
             portable_ops: If True tests with compiled in portable ops, default is to test without this to get error if not fully delegated
             timeout: Timeout for fvp. Default is 120 seconds.
+            build_dir_suffix: Suffix appended to the executor-runner build dir
+                name when resolving the ELF, letting callers select a runner
+                built for a specific target (e.g. a Cortex-M variant).
         """
         super().__init__()
         self.module = module
         self.timeout = timeout
         self.executorch_program_manager: ExecutorchProgramManager | None
         self.compile_spec = compile_spec
         self.use_portable_ops = use_portable_ops
+        self.build_dir_suffix = build_dir_suffix
 
     def run(self, artifact: ExecutorchProgramManager, inputs=None) -> None:
         super().run(artifact, inputs)
@@ -62,7 +67,9 @@ def run_artifact(self, inputs):
         inputs_flattened, _ = tree_flatten(inputs)
         intermediate_path = self.compile_spec._get_intermediate_path()
         target_board = get_target_board(self.compile_spec)
-        elf_path = get_elf_path(target_board, self.use_portable_ops)
+        elf_path = get_elf_path(
+            target_board, self.use_portable_ops, build_dir_suffix=self.build_dir_suffix
+        )
 
         if not os.path.exists(elf_path):
             raise FileNotFoundError(

backends/cadence/aot/replace_ops.py

@@ -632,6 +632,7 @@ def maybe_remove_or_replace(self, node: torch.fx.Node) -> bool:
         value = 0 if len(node.args) == 2 else node.args[2]
 
         arg_shape = input_node.meta["val"].shape
+        dtype = input_node.meta["val"].dtype
 
         # Convert orig_padding to a list for manipulation
         # pyre-ignore[6]: Argument type
@@ -663,7 +664,7 @@ def maybe_remove_or_replace(self, node: torch.fx.Node) -> bool:
                         left_padding_shape,
                         value,
                     ),
-                    kwargs={"dtype": torch.float32},
+                    kwargs={"dtype": dtype},
                 )
                 left_padding_node.meta = node.meta
             cat_tensors.append(left_padding_node)
@@ -683,7 +684,7 @@ def maybe_remove_or_replace(self, node: torch.fx.Node) -> bool:
                         right_padding_shape,
                         value,
                     ),
-                    kwargs={"dtype": torch.float32},
+                    kwargs={"dtype": dtype},
                 )
                 right_padding_node.meta = node.meta
             cat_tensors.append(right_padding_node)

backends/cadence/aot/tests/test_replace_ops_passes.py

@@ -839,6 +839,30 @@ def test_replace_pad_with_cat(self, shape: Tuple[int], padding: Tuple[int]) -> N
             0,
         )
 
+    @torch.no_grad()
+    def test_replace_pad_with_cat_preserves_dtype(self) -> None:
+        # The padding constant tensors must match the input dtype, otherwise the
+        # resulting cat mixes dtypes and fails edge dialect dtype verification
+        # (e.g. for quantized int8 graphs).
+        x = torch.randint(-128, 127, (1, 2, 3), dtype=torch.int8)
+        original_gm = single_op_builder(
+            placeholders=(x,),
+            op=exir_ops.edge.aten.constant_pad_nd.default,
+            args=(x, [1, 1]),
+        )
+
+        p = ReplacePadWithCatPass()
+        result = cast(PassResult, p(original_gm))
+        self.assertTrue(result.modified)
+        graph_after_passes = result.graph_module
+
+        full_nodes = graph_after_passes.graph.find_nodes(
+            op="call_function", target=exir_ops.edge.aten.full.default
+        )
+        self.assertEqual(len(full_nodes), 2)
+        for full_node in full_nodes:
+            self.assertEqual(full_node.kwargs["dtype"], torch.int8)
+
     @torch.no_grad()
     def test_replace_repeat_with_cat(self) -> None:
         x = torch.randn([3, 5])

backends/cortex_m/target_config.py

@@ -78,6 +78,12 @@ def __post_init__(self) -> None:
                 f"{self.cpu.name}; supported: {allowed}"
             )
 
+    @property
+    def target_string(self) -> str:
+        """Canonical ``cortex-m<variant>`` string; inverse of
+        ``from_target_string``."""
+        return "cortex-m" + self.cpu.name[1:].lower()
+
     @property
     def backend(self) -> cmsis_nn.Backend:
         if self.isa is not None:
@@ -105,6 +111,6 @@ def from_target_string(cls, target: str) -> CortexMTargetConfig:
         except KeyError as e:
             raise ValueError(
                 f"Unsupported Cortex-M target string: {target!r}. "
-                f"Supported: {sorted('cortex-m' + m.name[1:].lower() for m in CortexM)}"
+                f"Supported: {sorted(cls(cpu=m).target_string for m in CortexM)}"
             ) from e
         return cls(cpu=cpu)

backends/cortex_m/test/build_test_runner.sh

@@ -33,7 +33,7 @@ ${build_executorch} --devtools --target_cpu="${target_cpu}" --cmake-args="-DCORT
 # Build executor runner with selected aten ops and semi hosting
 build_dir="${et_root_dir}/arm_test"
 build_executor_runner="${et_root_dir}/backends/arm/scripts/build_executor_runner.sh"
-build_root_test_dir="${et_root_dir}/arm_test/arm_semihosting_executor_runner_corstone-300"
+build_root_test_dir="${et_root_dir}/arm_test/arm_semihosting_executor_runner_corstone-300_${target}"
 
 select_ops_list="\
 aten::add.out,\

backends/cortex_m/test/tester.py

@@ -69,16 +69,22 @@ def __init__(self, target_config: Optional[CortexMTargetConfig] = None):
 
 
 class CortexMSerialize(Serialize):
-    def __init__(self):
+    def __init__(self, target_config: Optional[CortexMTargetConfig] = None):
+        target_config = target_config or CortexMTargetConfig(cpu=CortexM.M55)
         compile_spec = get_u55_compile_spec()
-        super().__init__(compile_spec, 1024)
+        # Select the runner built for this target (build_test_runner.sh writes
+        # one runner per target into a target-suffixed directory).
+        super().__init__(
+            compile_spec,
+            None,
+            build_dir_suffix=f"_{target_config.target_string}",
+        )
 
 
 cortex_m_stage_classes = {
     StageType.EXPORT: Export,
     StageType.QUANTIZE: CortexMQuantize,
     StageType.RUN_PASSES: CortexMRunPasses,
-    StageType.SERIALIZE: Serialize,
     StageType.TO_EDGE: CortexMToEdge,
     StageType.TO_EXECUTORCH: ToExecutorch,
     StageType.SERIALIZE: CortexMSerialize,
@@ -103,6 +109,9 @@ def __init__(
         stage_classes[StageType.RUN_PASSES] = lambda: CortexMRunPasses(
             target_config=target_config
         )
+        stage_classes[StageType.SERIALIZE] = lambda: CortexMSerialize(
+            target_config=target_config
+        )
         super().__init__(module, resolved_example_inputs, stage_classes)
 
     def test_dialect(

backends/mlx/ops.py

@@ -53,6 +53,7 @@
     BitwiseAndNode,
     BitwiseInvertNode,
     BitwiseOrNode,
+    BitwiseXorNode,
     BroadcastToNode,
     CeilNode,
     ClipNode,
@@ -497,6 +498,12 @@ def _isnan_handler(P: MLXProgramBuilder, n: Node) -> Slot:
         "aten.bitwise_or",
         True,
     ),
+    (
+        [torch.ops.aten.bitwise_xor.Tensor, torch.ops.aten.bitwise_xor.Scalar],
+        BitwiseXorNode,
+        "aten.bitwise_xor",
+        True,
+    ),
     (
         [torch.ops.aten.lt.Tensor, torch.ops.aten.lt.Scalar],
         LessNode,

backends/mlx/runtime/MLXInterpreter.h

@@ -1422,6 +1422,15 @@ exec_bitwise_or(const BitwiseOrNode& n, ExecutionState& st, StreamOrDevice s) {
       n.out, bitwise_or(st.const_tensor_ref(n.a), st.const_tensor_ref(n.b), s));
 }
 
+inline void exec_bitwise_xor(
+    const BitwiseXorNode& n,
+    ExecutionState& st,
+    StreamOrDevice s) {
+  st.set_tensor(
+      n.out,
+      bitwise_xor(st.const_tensor_ref(n.a), st.const_tensor_ref(n.b), s));
+}
+
 inline void exec_tri(const TriNode& n, ExecutionState& st, StreamOrDevice s) {
   int rows = resolve_int(n.n, st);
   int cols = resolve_int(n.m, st);
@@ -2078,6 +2087,9 @@ class Interpreter {
       case OpCode::BITWISE_OR:
         ops::exec_bitwise_or(std::get<BitwiseOrNode>(instr.node), st, s);
         break;
+      case OpCode::BITWISE_XOR:
+        ops::exec_bitwise_xor(std::get<BitwiseXorNode>(instr.node), st, s);
+        break;
       case OpCode::TRI:
         ops::exec_tri(std::get<TriNode>(instr.node), st, s);
         break;