Sep 16, 2026

Don't set nf_conntrack_max if it's already larger than neededGo · 43 + / 30 −

Introduces 5 new declarations in pkg/proxy/conntrack/sysctls.go.

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

pkg/proxy/conntrack/sysctls.go ↗ · 2 files

@@ -128,39 +152,28 @@ func getConntrackMax(ctx context.Context, config *kubeproxyconfig.KubeProxyConnt 	return 0, nil } -// detectNumCPU returns the CPU count used to size nf_conntrack_max. That limit+type realConntrackConfigurer struct {+	sys sysctl.Interface+}++// DetectNumCPU returns the CPU count used to size nf_conntrack_max. That limit // is host-wide, so it must be based on the node's CPU count, not runtime.NumCPU(): // runtime.NumCPU() honors the process cpuset and undercounts when kube-proxy // runs under a static CPU policy. cpuset.NumCPU() reads the node's online CPU // count from sysfs instead, falling back to runtime.NumCPU() if it can't.-func detectNumCPU() int {+func (rct realConntrackConfigurer) DetectNumCPU() int { 	if n, err := cpuset.NumCPU(); err == nil && n > 0 { 		return n 	} 	return runtime.NumCPU() } -type realConntrackConfigurer struct {+func (rct realConntrackConfigurer) GetMax(_ context.Context) (int, error) {+	return rct.sys.GetSysctl("net/netfilter/nf_conntrack_max") }  func (rct realConntrackConfigurer) SetMax(ctx context.Context, max int) error {-	logger := klog.FromContext(ctx)-	logger.Info("Setting nf_conntrack_max", "nfConntrackMax", max)-	if err := rct.setIntSysCtl(ctx, "nf_conntrack_max", max); err != nil {-		return err-	}-

Fix non-deterministic encoding of syntax contextsRust · 87 + / 59 −

Introduces 4 new declarations in compiler/rustc_span/src/hygiene.rs.

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

compiler/rustc_span/src/hygiene.rs ↗ · 5 files

@@ -1337,58 +1381,51 @@ impl HygieneEncodeContext {                 h_ctxt.borrow().latest_ctxts             ); -            let mut mut_hctxt = h_ctxt.borrow_mut();-             // Consume the current round of syntax contexts.             // It's fine to iterate over a HashSet, because the serialization of the table             // that we insert data into doesn't depend on insertion order.             #[allow(rustc::potential_query_instability)]-            let latest_ctxts = { mem::take(&mut mut_hctxt.latest_ctxts) }.into_iter();+            let latest_contexts = { mem::take(&mut h_ctxt.borrow_mut().latest_ctxts) }.into_iter(); -            HygieneData::with(|data| {-                for ctxt in latest_ctxts {-                    if !mut_hctxt.serialized_ctxts.insert(ctxt) {-                        continue;-                    }--                    all_ctxt_data.push((ctxt.0, data.syntax_context_data[ctxt.0 as usize].key()));-                }-            });--            drop(mut_hctxt);--            for (idx, ctxt_key) in all_ctxt_data.drain(..) {-                encode_ctxt(encoder, idx, &ctxt_key);+            for (idx, ctxt) in latest_contexts {+                let key = HygieneData::with(|data| data.syntax_context_data[ctxt.0 as usize].key());+                encode_ctxt(encoder, idx, &key);             } -            let mut mut_hctxt = h_ctxt.borrow_mut();-

fix(asr): warm up Numba RNNT and TDT losses before trainingPython · 116 + / 1 −

Introduces 7 new declarations in nemo/collections/asr/parts/numba/rnnt_loss/rnnt_pytorch.py.

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

nemo/collections/asr/parts/numba/rnnt_loss/rnnt_pytorch.py ↗ · 6 files

@@ -552,6 +583,51 @@ def __init__(         self.sigma = sigma         self.omega = omega +    def warmup(self, device: Union[str, torch.device]) -> bool:+        """Warm both TDT and RNNT CUDA branches with float32 contiguous inputs before allocating training activations.++        Preserves random states and the configured loss; returns False on CPU.+        """+        device = torch.device(device)+        if device.type != 'cuda':+            return False++        def warmup():+            # Non-singleton dimensions preserve the contiguous production array layout.+            labels_count = 3+            frames = max(8, (labels_count + 1) * max(self.durations))+            vocabulary_size = max(2, self.blank + 1)+            label = 1 if self.blank == 0 else 0+            for omega in (-1.0, 2.0):+                # Force each branch even when random.uniform returns an endpoint.+                loss = TDTLossNumba(+                    blank=self.blank,+                    durations=list(self.durations),+                    reduction='mean',+                    fastemit_lambda=self.fastemit_lambda,+                    clamp=self.clamp,+                    sigma=self.sigma,+                    omega=omega,+                )+                acts = torch.zeros(+                    (2, frames, labels_count + 1, vocabulary_size + len(self.durations)),+                    device=device,+                    dtype=torch.float32,

model : add support for HrmTextForCausalLM (DFM Mimir 1B)C++ · 281 + / 1 −

Introduces 5 new declarations in src/models/hrm-text.cpp.

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

src/models/hrm-text.cpp ↗ · 16 files

@@ -0,0 +1,213 @@+#include "models.h"++// HRM-Text: alternating low/high transformer stacks over the same token stream.+// Reference: HrmTextModel in transformers, DFM Mimir 1B.++void llama_model_hrm_text::load_arch_hparams(llama_model_loader & ml) {+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps);+    ml.get_key(LLM_KV_EMBEDDING_SCALE, hparams.f_embedding_scale, false);++    ml.get_key(LLM_KV_HRM_LAYERS_PER_STACK, hparams.n_hrm_layers_per_stack);+    ml.get_key(LLM_KV_HRM_H_CYCLES, hparams.n_hrm_h_cycles);+    ml.get_key(LLM_KV_HRM_L_CYCLES, hparams.n_hrm_l_cycles);++    // prefix-LM prefill is not implemented (causal attention only); kept for round-trip+    ml.get_key(LLM_KV_HRM_PREFIX_LM, hparams.hrm_prefix_lm, false);++    GGML_ASSERT(hparams.n_hrm_layers_per_stack > 0);+    GGML_ASSERT(hparams.n_hrm_h_cycles > 0);+    GGML_ASSERT(hparams.n_hrm_l_cycles > 0);++    // the GGUF block count is the expanded cache-slot count+    const uint32_t n_slot = hparams.n_hrm_layers_per_stack * hparams.n_hrm_h_cycles * (hparams.n_hrm_l_cycles + 1);+    GGML_ASSERT(hparams.n_layer() == n_slot);++    switch (hparams.n_embd) {+        case 1536:+            type = LLM_TYPE_1B;+            break;+        default:+            type = LLM_TYPE_UNKNOWN;+    }+}+

vfs: write RealFSProvider files to open fdJavaScript · 89 + / 11 −

Introduces 2 new declarations in lib/internal/vfs/providers/real.js.

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

lib/internal/vfs/providers/real.js ↗ · 2 files

@@ -175,12 +193,72 @@ class RealFileHandle extends VirtualFileHandle {    writeFileSync(data, options) {     this.#checkClosed('write');-    fs.writeFileSync(this.#realPath, data, options);+    fs.writeFileSync(this.#fd, data, options);+  }++  // Writes the whole buffer at the descriptor's current position, at most+  // kWriteFileMaxChunkSize per call, the way writeFileHandle() does.+  async #writeAll(buffer, signal) {+    let written = 0;+    while (written < buffer.byteLength) {+      checkAborted(signal);+      const { bytesWritten } = await this.write(+        buffer,+        written,+        MathMin(kWriteFileMaxChunkSize, buffer.byteLength - written),+        null);+      written += bytesWritten;+    }+  }++  #fsync() {+    this.#checkClosed('fsync');+    return new Promise((resolve, reject) => {+      fs.fsync(this.#fd, (err) => {+        if (err) reject(err);+        else resolve();+      });+    });   }    async writeFile(data, options) {