Sep 25, 2026

[Executorch] Add MLX recipePython · 46 + / 5 −

Introduces 3 new declarations in src/transformers/exporters/exporter_executorch.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/exporters/exporter_executorch.py ↗ · 4 files

@@ -258,9 +273,33 @@ def prepare_for_cuda(model: PreTrainedModel, sample_inputs: dict[str, Any]):     return model, _make_contiguous(sample_inputs), partitioner  +def prepare_for_mlx(model: PreTrainedModel, sample_inputs: dict[str, Any]):+    """Apple Silicon GPU inference via the ExecuTorch MLX backend."""+    for value in sample_inputs.values():+        caches = [value]+        if isinstance(value, EncoderDecoderCache):+            caches = [value.self_attention_cache, value.cross_attention_cache]+        if any(isinstance(cache, StaticCache) for cache in caches):+            raise ValueError(+                "StaticCache is not supported by the ExecuTorch MLX backend. "+                "Use DynamicCache or set cache_implementation='dynamic' in GenerationConfig."+            )++    from executorch.backends.mlx import MLXPartitioner++    model.requires_grad_(False)+    model = model.to(device="cpu")+    # MLX does not support grouped MoE kernels.+    if isinstance(model, PreTrainedModel) and model._can_set_experts_implementation():+        model.set_experts_implementation("batched_mm")+    partitioner = [MLXPartitioner()]+    return model, _make_contiguous(sample_inputs), partitioner++ _BACKEND_PREPARE = {     "xnnpack": prepare_for_xnnpack,     "cuda": prepare_for_cuda,+    "mlx": prepare_for_mlx, }  

Add watch validationGo · 220 + / 2 −

Introduces 15 new declarations in staging/src/k8s.io/apiserver/pkg/storage/testing/correctness/watch.go.

Adds new systems design rather than adjusting what was there. Tests changed with it, with code of their own.

staging/src/k8s.io/apiserver/pkg/storage/testing/correctness/watch.go ↗ · 6 files

@@ -0,0 +1,203 @@+/*+Copyright The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++package correctness++import (+	"fmt"+	"math"+	"reflect"++	"github.com/google/go-cmp/cmp"++	"k8s.io/apimachinery/pkg/api/meta"+	"k8s.io/apimachinery/pkg/runtime"+	"k8s.io/apimachinery/pkg/watch"+	"k8s.io/apiserver/pkg/storage"+)++// WatchValidator checks watch streams against the event history the model+// derived from the recorded operations.

turbo-tasks-gc: Invalidating a deleted task should be a no-opRust · 284 + / 114 −

Introduces 21 new declarations in turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs ↗ · 6 files

@@ -343,103 +388,144 @@ impl<'e> ExecuteContextImpl<'e> {                     task.flags.set_meta_restoring(true);                 } -                if do_data || do_meta || data_restoring || meta_restoring {-                    let waiting_for_restore = data_restoring || meta_restoring;-                    if waiting_for_restore {-                        // The caller holds the task id outside the graph while waiting, so pin it-                        // against GC until the restored guard reaches the use boundary. Eviction is-                        // still allowed; the wait loop restores the category again if needed.-                        task.update_and_get_transient_ref_count(1);-                    }-                    // Drop lock while doing I/O (our I/O can overlap with the other thread).-                    drop(task);--                    // Perform I/O for categories we claimed.-                    let storage_data = do_data-                        .then(|| self.restore_task_data(task_id, SpecificTaskDataCategory::Data));-                    let storage_meta = do_meta-                        .then(|| self.restore_task_data(task_id, SpecificTaskDataCategory::Meta));--                    // Whether our own I/O found the task on disk (in any restored category).-                    // Another thread restoring it concurrently (`*_restoring`)-                    // also proves existence: it only sets the restoring bit-                    // after finding the task.-                    let found_on_disk = restored_from_disk(&storage_data)-                        || restored_from_disk(&storage_meta)-                        || data_restoring-                        || meta_restoring;--                    // Wait for categories claimed by another thread (after our I/O).-                    // Reuse the returned write guard to avoid a second lock acquisition.-                    task = if let Some(cat) = wait_category(data_restoring, meta_restoring) {-                        self.wait_for_restore_or_panic(task_id, cat)

src: add --process-timeout=NC++ · 694 + / 0 −

Introduces 9 new declarations in src/node_watchdog.cc.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

src/node_watchdog.cc ↗ · 27 files

@@ -99,6 +108,466 @@ void Watchdog::Timer(uv_timer_t* timer) {   uv_stop(&w->loop_); } +namespace {++constexpr uint64_t kNanosecondsPerMillisecond = 1000 * 1000;+// How long the main thread has to respond to the timeout. If it does not, it+// is most likely blocked in a synchronous native call.+constexpr uint64_t kProcessTimeoutResponseGraceMs = 2000;+// How long printing the diagnostics, writing the report and exiting may take.+constexpr uint64_t kProcessTimeoutExitGraceMs = 5000;++std::string FormatProcessTimeoutHeader(const std::string& duration) {+  return SPrintF("(node:%d) Process timed out after %s (--process-timeout). "+                 "Exiting with code %d.\n",+                 uv_os_getpid(),+                 duration,+                 static_cast<int>(ExitCode::kProcessTimeout));+}++// Called from the watchdog thread when the main thread cannot be trusted to+// exit on its own. It must not touch the Environment or V8.+//+// std::_Exit() does not run atexit handlers or static destructors, which is+// where code coverage data is written, so coverage is never recorded for a+// process that exits through here. The calls to this function are excluded+// from coverage reports for the same reason.+// LCOV_EXCL_START+[[noreturn]] void ForceProcessTimeoutExit(const std::string& message) {+  FPrintF(stderr, "%s", message);+  fflush(stderr);+  ResetStdio();+  std::_Exit(static_cast<int>(ExitCode::kProcessTimeout));

Preserve explicit register names in inline asm diagnosticsRust · 81 + / 34 −

Introduces 7 new declarations in compiler/rustc_ast_lowering/src/asm.rs.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

compiler/rustc_ast_lowering/src/asm.rs ↗ · 10 files

@@ -393,24 +394,21 @@ impl<'hir> LoweringContext<'_, 'hir> {                                     }                                     _ => None,                                 };-                                let reg_str = |idx| -> &str {-                                    // HIR asm doesn't preserve the original alias string of the explicit register,-                                    // so we have to retrieve it from AST-                                    let (op, _): &(InlineAsmOperand, Span) = &asm.operands[idx];-                                    if let Some(ast::InlineAsmRegOrRegClass::Reg(reg_sym)) =-                                        op.reg()-                                    {-                                        reg_sym.as_str()-                                    } else {-                                        unreachable!("{op:?} is not a register operand");-                                    }-                                };+                                let reg1_name = op+                                    .reg()+                                    .and_then(|reg| reg.source_name())+                                    .expect("{op:?} has no source register name");++                                let reg2_name = op2+                                    .reg()+                                    .and_then(|reg| reg.source_name())+                                    .expect("{op2:?} has no source register name");                                  self.dcx().emit_err(RegisterConflict {                                     op_span1: op_sp,                                     op_span2: op_sp2,-                                    reg1_name: reg_str(idx),-                                    reg2_name: reg_str(idx2),+                                    reg1_name: reg1_name.as_str(),+                                    reg2_name: reg2_name.as_str(),                                     in_out,