2026-06-10 nightly release (b771dab)

Author: pytorchbot

.github/workflows/mlx.yml

@@ -13,6 +13,7 @@ on:
       - backends/mlx/**
       - extension/llm/export/**
       - extension/audio/**
+      - examples/models/gemma4_31b/**
       - examples/models/parakeet/**
       - examples/models/voxtral_realtime/**
       - examples/models/qwen3_5_moe/**
@@ -77,6 +78,8 @@ jobs:
           backends/mlx/test/test_passes.py \
           backends/mlx/test/test_pattern_utils.py \
           backends/mlx/test/test_partitioner.py \
+          backends/mlx/test/test_serialization_dedup.py \
+          examples/models/gemma4_31b/quant/tests/test_pack_mlx.py \
           examples/models/gemma4_31b/tests/test_mlx_pipeline.py \
           -v
         echo "::endgroup::"
@@ -89,20 +92,16 @@ jobs:
           ./cmake-out/backends/mlx/test/multi_thread_test_runner
         echo "::endgroup::"
 
-        echo "::group::Run gated_delta_rule op tests"
-        ${CONDA_RUN} python -m executorch.backends.mlx.model_ops.test_gated_delta_rule run -v
-        echo "::endgroup::"
-
-        echo "::group::Run tq_norm op tests"
-        ${CONDA_RUN} python -m executorch.backends.mlx.model_ops.test_tq_norm run -v
-        echo "::endgroup::"
-
-        echo "::group::Run tq4_compress op tests"
-        ${CONDA_RUN} python -m executorch.backends.mlx.model_ops.test_tq4_compress run -v
-        echo "::endgroup::"
-
-        echo "::group::Run tq_dequant op tests"
-        ${CONDA_RUN} python -m executorch.backends.mlx.model_ops.test_tq_dequant run -v
+        echo "::group::Run custom_kernel_ops op tests"
+        # Run every custom_kernel_ops/**/test/test_*.py via its OpTestCase `run`
+        # CLI. Recurses into per-format subpackages (e.g. gguf/test), so adding a
+        # new op test file requires no change here.
+        set -e
+        for t in $(find backends/mlx/custom_kernel_ops -path '*/test/test_*.py' | sort); do
+          mod="executorch.$(echo "${t%.py}" | tr '/' '.')"
+          echo "--- ${mod} ---"
+          ${CONDA_RUN} python -m "${mod}" run -v
+        done
         echo "::endgroup::"
 
   test-mlx-qwen35-moe:

.github/workflows/test-backend-coreml.yml

@@ -43,5 +43,5 @@ jobs:
             && '["coreml"]'
             || '["coreml", "coreml_static_int8"]' }}
       ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
-      timeout: 120
+      timeout: 180
       run-macos: true

.github/workflows/trunk.yml

@@ -258,6 +258,7 @@ jobs:
           - test_arm_backend: test_pytest_models_ethos_u85
           - test_arm_backend: test_run_ethos_u85
           - test_arm_backend: test_smaller_stories_llama_tosa
+          - test_arm_backend: test_model_smollm2_135M_ethos_u85
           - test_arm_backend: test_memory_allocation
           - test_arm_backend: test_ootb_tests_ethos_u
           - test_arm_backend: test_ootb_tests_tosa

Makefile

@@ -261,7 +261,8 @@ parakeet-vulkan:
 
 dinov2-cuda:
 	@echo "==> Building and installing ExecuTorch with CUDA..."
-	cmake --workflow --preset llm-release-cuda
+	cmake --preset llm-release-cuda -DEXECUTORCH_BUILD_EXTENSION_IMAGE=ON
+	cmake --build --preset llm-release-cuda-install
 	@echo "==> Building DINOv2 runner with CUDA..."
 	cd examples/models/dinov2 && cmake --workflow --preset dinov2-cuda
 	@echo ""
@@ -270,7 +271,8 @@ dinov2-cuda:
 
 dinov2-cuda-debug:
 	@echo "==> Building and installing ExecuTorch with CUDA (debug mode)..."
-	cmake --workflow --preset llm-debug-cuda
+	cmake --preset llm-debug-cuda -DEXECUTORCH_BUILD_EXTENSION_IMAGE=ON
+	cmake --build --preset llm-debug-cuda-install
 	@echo "==> Building DINOv2 runner with CUDA (debug mode)..."
 	cd examples/models/dinov2 && cmake --workflow --preset dinov2-cuda-debug
 	@echo ""

backends/aoti/aoti_partitioner.py

@@ -14,7 +14,11 @@
     Partitioner,
     PartitionResult,
 )
-from executorch.exir.backend.utils import tag_constant_data, tag_mutated_buffer
+from executorch.exir.backend.utils import (
+    get_non_lowered_nodes,
+    tag_constant_data,
+    tag_mutated_buffer,
+)
 from torch._export.utils import is_buffer, is_lifted_tensor_constant, is_param
 from torch.export.exported_program import ExportedProgram
 
@@ -60,8 +64,17 @@ def is_control_flow(node: torch.fx.Node) -> bool:
                 torch.ops.higher_order.while_loop,
             ]
 
+        # Nodes already lowered by an earlier partitioner (e.g. a preceding
+        # TensorRT partition) appear as executorch_call_delegate calls and their
+        # output getitems; re-delegating them would nest a foreign delegate. Tag
+        # only the remaining non-lowered ops so this partitioner composes after
+        # others.
+        non_lowered_nodes = set(get_non_lowered_nodes(exported_program.graph))
+
         for node in exported_program.graph.nodes:
             if node.op == "call_function":
+                if node not in non_lowered_nodes:
+                    continue
                 node.meta["delegation_tag"] = tag
             # Tag get_attr nodes that are used by control flow operations
             elif node.op == "get_attr":
@@ -76,17 +89,22 @@ def is_control_flow(node: torch.fx.Node) -> bool:
         tag_constant_data(exported_program)
         tag_mutated_buffer(exported_program)
 
-        # Tag constant placeholders that have no users
-        # tag_constant_data only tags constants that have users with delegation_tag
-        # but we need to tag all constants for this partition
+        # A constant that still has users feeds only a prior delegate; tagging it
+        # would fail backend lowering's same-tag check (its user keeps the prior
+        # tag). tag_constant_data already claimed the ones this partition uses, so
+        # tag only the genuinely unused constants here.
         for node in exported_program.graph.nodes:
-            if node.op == "placeholder" and (
-                is_param(exported_program, node)
-                or is_buffer(exported_program, node)
-                or is_lifted_tensor_constant(exported_program, node)
+            if (
+                node.op == "placeholder"
+                and not node.users
+                and "delegation_tag" not in node.meta
+                and (
+                    is_param(exported_program, node)
+                    or is_buffer(exported_program, node)
+                    or is_lifted_tensor_constant(exported_program, node)
+                )
             ):
-                if "delegation_tag" not in node.meta:
-                    node.meta["delegation_tag"] = tag
+                node.meta["delegation_tag"] = tag
 
         return PartitionResult(
             tagged_exported_program=exported_program, partition_tags=partition_tags

backends/aoti/slim/core/slim_tensor.h

@@ -497,15 +497,17 @@ class SlimTensor {
                   static_cast<size_t>(dst_offset), elem_size, &dst_byte_offset),
           "copy_: byte offset overflow");
 
-      // Copy elem_size bytes from src to dst
+      char* dst_byte_offset_ptr =
+          add_byte_offset_checked(dst_data, dst_byte_offset);
+      const char* src_byte_offset_ptr =
+          add_byte_offset_checked(src_data, src_byte_offset);
       if (this->device().is_cpu() && other.device().is_cpu()) {
-        std::memcpy(
-            dst_data + dst_byte_offset, src_data + src_byte_offset, elem_size);
+        std::memcpy(dst_byte_offset_ptr, src_byte_offset_ptr, elem_size);
       } else if (this->device().is_cuda() || other.device().is_cuda()) {
 #if defined(CUDA_AVAILABLE)
         DeviceTraits<c10::DeviceType::CUDA>::memcpy(
-            dst_data + dst_byte_offset,
-            src_data + src_byte_offset,
+            dst_byte_offset_ptr,
+            src_byte_offset_ptr,
             elem_size,
             device(), // dst device
             other.device() // src device
@@ -555,6 +557,17 @@ class SlimTensor {
   }
 
  private:
+  template <typename T>
+  static T* add_byte_offset_checked(T* data, size_t byte_offset) {
+    uintptr_t data_int = reinterpret_cast<uintptr_t>(data);
+    uintptr_t data_offset_int = 0;
+    ET_CHECK_MSG(
+        !::c10::add_overflows(data_int, byte_offset, &data_offset_int),
+        "copy_: data pointer overflow");
+    return reinterpret_cast<T*>( // NOLINT(performance-no-int-to-ptr)
+        data_offset_int);
+  }
+
   SlimTensor _clone_impl(
       c10::IntArrayRef sizes,
       c10::IntArrayRef strides,

backends/aoti/slim/core/test/test_slimtensor_copy.cpp

@@ -8,9 +8,12 @@
 
 #include <gtest/gtest.h>
 
+#include <limits>
+
 #include <executorch/backends/aoti/slim/core/slim_tensor.h>
 #include <executorch/backends/aoti/slim/core/storage.h>
 #include <executorch/backends/aoti/slim/factory/empty.h>
+#include <executorch/runtime/platform/platform.h>
 
 namespace executorch::backends::aoti::slim {
 
@@ -214,6 +217,42 @@ TEST(SlimTensorCopyTest, CopyNonContiguousDst) {
   EXPECT_FLOAT_EQ(dst_data[5], 5.0f);
 }
 
+// =============================================================================
+// Overflow Validation Tests
+// =============================================================================
+
+TEST(SlimTensorCopyTest, CopyFailsWhenDataPointerOverflows) {
+  std::vector<int64_t> sizes = {2};
+  std::vector<int64_t> src_strides = {1};
+  // For Short, INT64_MAX elements becomes UINTPTR_MAX - 1 bytes. That
+  // passes byte-offset validation and only fails at checked pointer addition.
+  std::vector<int64_t> dst_strides = {std::numeric_limits<int64_t>::max()};
+
+  Storage src_storage = make_cpu_storage(2 * sizeof(int16_t));
+  int16_t* src_data = static_cast<int16_t*>(src_storage->data());
+  src_data[0] = 1;
+  src_data[1] = 2;
+  SlimTensor src(
+      std::move(src_storage),
+      makeArrayRef(sizes),
+      makeArrayRef(src_strides),
+      c10::ScalarType::Short);
+
+  Storage dst_storage = make_cpu_storage(sizeof(int16_t));
+  SlimTensor dst(
+      std::move(dst_storage),
+      makeArrayRef(sizes),
+      makeArrayRef(dst_strides),
+      c10::ScalarType::Short);
+
+  EXPECT_DEATH(
+      {
+        et_pal_init();
+        dst.copy_(src);
+      },
+      "copy_: data pointer overflow");
+}
+
 // =============================================================================
 // Storage Offset Tests
 // =============================================================================

backends/arm/README.md

@@ -251,7 +251,7 @@ Below is an overview of some of the testing options this script provides:
 | `test_arm_backend.sh test_pytest_ops_vkml`         | Runs operator unit tests for VKML/VGF specific use-cases.    |
 | `test_arm_backend.sh test_pytest_models_vkml`      | Runs model unit tests for VKML/VGF specific use-cases.       |
 | `test_arm_backend.sh test_run_vkml`                | Runs end-to-end unit tests for VKML/VGF specific use-cases.  |
-| `test_arm_backend.sh test_model_smollm2_135M`      | Runs some models with Corstone FVP.                          |
+| `test_arm_backend.sh test_model_smollm2_135M_ethos_u85`      | Runs smollm2_135M for Ethos-U85 specific use-cases.                          |
 | `test_arm_backend.sh test_ootb_tests_ethos_u`      | Runs out-of-the-box tests for Ethos-U.                       |
 | `test_arm_backend.sh test_ootb_tests_tosa`         | Runs out-of-the-box tests for TOSA.                          |
 | `test_arm_backend.sh test_ootb_tests_vgf`          | Runs out-of-the-box tests for VKML/VGF.                      |

backends/arm/_passes/fuse_duplicate_users_pass.py

@@ -34,6 +34,7 @@ def call(self, graph_module: GraphModule) -> PassResult:
         graph = graph_module.graph
         modified = False
 
+        node_order = {node: index for index, node in enumerate(graph.nodes)}
         producers: Deque[Node] = deque(node for node in graph.nodes)
 
         while producers:
@@ -48,7 +49,7 @@ def call(self, graph_module: GraphModule) -> PassResult:
             if len(user_nodes) < 2:
                 continue
 
-            candidate_groups = self._get_candidate_groups(user_nodes)
+            candidate_groups = self._get_candidate_groups(node_order, user_nodes)
 
             signature_to_user: Dict[Tuple[Hashable, ...], Node] = {}
             for group in candidate_groups:
@@ -84,7 +85,7 @@ def call(self, graph_module: GraphModule) -> PassResult:
 
         return PassResult(graph_module, modified)
 
-    def _get_candidate_groups(self, user_nodes):
+    def _get_candidate_groups(self, node_order, user_nodes):
         users_by_target: Dict[Tuple[str, Hashable], List[Node]] = {}
         for user in user_nodes:
             if user.graph is None:
@@ -98,9 +99,12 @@ def _get_candidate_groups(self, user_nodes):
             target_signature = (user.op, target_key)
             users_by_target.setdefault(target_signature, []).append(user)
 
-        candidate_groups = [
-            group for group in users_by_target.values() if len(group) > 1
-        ]
+        candidate_groups = []
+        for group in users_by_target.values():
+            if len(group) > 1:
+                candidate_groups.append(
+                    sorted(group, key=lambda node: node_order[node])
+                )
 
         return candidate_groups
 

backends/arm/_passes/rewrite_avg_pool2d_pass.py

@@ -65,9 +65,11 @@ def call_operator(self, op, args, kwargs, meta, updated=False):
         # Materialize output zero-point as a scalar tensor
         output_zp = super().call_scalar(out_zp_val, meta)
 
-        # Determine accumulator dtype for AVG_POOL2D: INT32 for integer inputs, FP32 otherwise
+        # Determine accumulator dtype for AVG_POOL2D.
         if x.data.dtype in (torch.int8, torch.int16):
             acc_type = torch.int32
+        elif x.data.dtype in (torch.float8_e4m3fn, torch.float8_e5m2):
+            acc_type = torch.float16
         else:
             acc_type = torch.float32