# scheduling

Scheduling is the computing technique of determining which computational task, process, or thread runs on a processor and for how long when tasks compete for finite processing resources.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Context as a Resource

DevFeed: [Context as a Resource](<https://devfeed.tech/articles/context-as-a-resource-145662.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.26346>)

Author: Xufei Tian, Han Hu, Wenli Du

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [bus](<https://devfeed.tech/tags/bus.md>), [cells](<https://devfeed.tech/tags/cells.md>), [completion](<https://devfeed.tech/tags/completion.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [context](<https://devfeed.tech/tags/context.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [events](<https://devfeed.tech/tags/events.md>), [gate](<https://devfeed.tech/tags/gate.md>), [generative](<https://devfeed.tech/tags/generative.md>), [handoffs](<https://devfeed.tech/tags/handoffs.md>), [interface](<https://devfeed.tech/tags/interface.md>), [linear](<https://devfeed.tech/tags/linear.md>), [resource](<https://devfeed.tech/tags/resource.md>)

### AI overview

ClonAct proposes routerless management of concurrent agent contexts, using a non-generative Context MMU, in-place Context Cells, a footprint-aware Synaptic Bus with an isolated trial merge gate, and a wave-flushed Shared Trunk. The abstract reports that the merge gate raises true-conflict repository merge success from a 33.3% three-run mean to 63.3%; ClonAct reaches that rate with 45.9% fewer prompt tokens and avoids router collapse on compact models. Across three multi-stream benchmarks and three model families, it also matches the best reported completion rate under continuous surges (95.0%), with the lowest median wait and no timed-out status checks. These are abstract-level claims; the supplied text gives no further benchmark methodology or results.

### Source excerpt

arXiv:2611.26346v1 Announce Type: new Abstract: Managing concurrent tasks across separate agent sessions quickly exhausts human attention, motivating always-on personal agents behind a single continuous interface. Yet when every context shares identical frozen backbone weights, funneling interleaved dialogues and external events into one linear session induces cross-topic constraint bleed and head-of-line stalling. Conversely, router-ticket hierarchies incur lossy prose handoffs, heavy routing overhead, and blind merges - collapsing true-conflict repository merges to a 33.3% three-run mean despite high isolated branch passes. Rather than scheduling anthropomorphic roles, we introduce ClonAct, a routerless architecture that virtualizes context blocks directly through a pluggable single-pass non-generative Context MMU, in-place Context Cells, a footprint-aware Synaptic Bus with an isolated trial merge gate, and a wave-flushed Shared Trunk. Across three programmatic multi-stream benchmarks and three model families, our portable trial merge gate lifts true-conflict merges to 63.3%, while ClonAct's routerless virtualization attains this ceiling with 45.9% fewer prompt tokens and prevents compact-model router collapse. Under continuous surge streams, ClonAct matches top completion (95.0%) with the lowest median wait and zero timed-out status checks.

## HEL: A Heterogeneous Extensible Layer for GPU-Resident Runtime Orchestration

DevFeed: [HEL: A Heterogeneous Extensible Layer for GPU-Resident Runtime Orchestration](<https://devfeed.tech/articles/hel-a-heterogeneous-extensible-layer-for-gpu-resident-runtime-orchestration-146118.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.24830>)

Author: Agnieszka M. {\\L}upi\\'nska, Serban D. Porumbescu, John D. Owens

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [hpx](<https://devfeed.tech/topics/hpx.md>), [microsoft-work-graphs](<https://devfeed.tech/topics/microsoft-work-graphs.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [compression](<https://devfeed.tech/tags/compression.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [latency](<https://devfeed.tech/tags/latency.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [performance](<https://devfeed.tech/tags/performance.md>), [runtime](<https://devfeed.tech/tags/runtime.md>)

### AI overview

HEL is a GPU-resident runtime built from stateful services that persist for an application's lifetime. Applications spawn coroutine-like tasks, which the runtime schedules on a spatially partitioned GPU alongside the application. It supports synchronous and asynchronous tasks, runtime dependencies, batched submissions, and automatic retries. Producer-consumer and host-RPC benchmarks, plus a PFPL compression case study, report performance advantages on underutilized GPUs and when HEL can hide task latency. The excerpt does not provide measurements or comparisons with other runtimes.

### Source excerpt

arXiv:2610.24830v2 Announce Type: replace Abstract: We describe a GPU-resident runtime system, HEL, built on stateful services that persist throughout the lifespan of a user application. A HEL programmer expresses a workload as an application that spawns coroutine-like tasks, which are then scheduled and run by the HEL runtime. HEL supports synchronous and asynchronous tasks, tasks with runtime dependencies, batched task submission, and automatic retries. Applications and tasks run alongside each other on the spatially partitioned GPU. Using producer-consumer and host-RPC benchmarks together with a PFPL compression case study, we show that HEL demonstrates a performance advantage for underutilized GPUs and for scenarios where HEL enables hiding task latency.

## Locality-Aware Scheduling for Stream Processing Applications in Serverless Environments

DevFeed: [Locality-Aware Scheduling for Stream Processing Applications in Serverless Environments](<https://devfeed.tech/articles/locality-aware-scheduling-for-stream-processing-applications-in-serverless-environments-142973.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23879>)

Author: Tianyu Qi, Maria A. Rodriguez, Rajkumar Buyya

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [stream-processing](<https://devfeed.tech/topics/stream-processing.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [Data pipelines](<https://devfeed.tech/topics/data-pipelines.md>)

Tags: [balance](<https://devfeed.tech/tags/balance.md>), [chaining](<https://devfeed.tech/tags/chaining.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [data-pipelines](<https://devfeed.tech/tags/data-pipelines.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [function](<https://devfeed.tech/tags/function.md>), [function-as-a-service](<https://devfeed.tech/tags/function-as-a-service.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [latency](<https://devfeed.tech/tags/latency.md>), [local](<https://devfeed.tech/tags/local.md>), [locality](<https://devfeed.tech/tags/locality.md>), [monitors](<https://devfeed.tech/tags/monitors.md>), [network](<https://devfeed.tech/tags/network.md>), [operator](<https://devfeed.tech/tags/operator.md>), [operators](<https://devfeed.tech/tags/operators.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [routing](<https://devfeed.tech/tags/routing.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [stream-processing](<https://devfeed.tech/tags/stream-processing.md>)

### AI overview

LcSched targets a locality tradeoff in stateful serverless stream pipelines: keeping each operator's state with its execution can force chained invocations to cross workers, raising latency and I/O overhead. The distributed strategy aims to run chained invocations locally while ensuring they access state on the same worker, and monitors runtime workload to balance workers. The abstract reports up to 3.6x higher throughput and up to 79% lower end-to-end latency than the state-of-the-art distributed scheduling strategy for stateful serverless environments.

### Source excerpt

arXiv:2611.23879v1 Announce Type: new Abstract: Stateful Serverless (Function-as-a-Service) environment are increasingly used for stream processing applications. These applications are often structured as pipelines where data flows through a sequence of distinct processing operators. Many operators are stateful and require access to the processing state during execution. To address this, stateful serverless platforms introduce state servers on worker nodes, co-locating state with computation to dramatically reduce access latency. In serverless, these data pipelines are realized by chaining function invocations, passing the processed data from one function to the next. To reduce network overhead, state-of-the-art scheduling approaches employ a distributed worker-level scheduling model, routing locally generated chained requests directly to destination workers, bypassing centralized schedulers. However, these approaches always co-locate state and execution for the same operator in the same worker, which forces most invocations to the next operator to be transferred across workers, thereby increasing both latency and I/O overhead. As a result, this paper proposes LcSched, a novel distributed scheduling strategy tailored for stream processing applications in stateful serverless environments. LcSched seeks to maximise local execution of chained function invocations while ensuring that each execution accesses its state from the local worker. It also monitors workload at runtime to maintain workload balance between workers. Experimental results show that LcSched improves throughput by up to 3.6x and reduces end-to-end latency by up to 79% compared to the state-of-the-art distributed scheduling strategy for stateful serverless environments.

## Continuum: Boundary-State-Aware Deterministic Scheduling in Dynamic LEO Networks

DevFeed: [Continuum: Boundary-State-Aware Deterministic Scheduling in Dynamic LEO Networks](<https://devfeed.tech/articles/continuum-boundary-state-aware-deterministic-scheduling-in-dynamic-leo-networks-142998.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24021>)

Author: Siqi Yang, Zonghui Li, Chaoqun You, Yue Gao

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [boundary](<https://devfeed.tech/tags/boundary.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [framework](<https://devfeed.tech/tags/framework.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [jitter](<https://devfeed.tech/tags/jitter.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leo](<https://devfeed.tech/tags/leo.md>), [low-earth-orbit](<https://devfeed.tech/tags/low-earth-orbit.md>), [mission](<https://devfeed.tech/tags/mission.md>), [networks](<https://devfeed.tech/tags/networks.md>), [node](<https://devfeed.tech/tags/node.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [performance](<https://devfeed.tech/tags/performance.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [timing](<https://devfeed.tech/tags/timing.md>), [topology](<https://devfeed.tech/tags/topology.md>), [traffic](<https://devfeed.tech/tags/traffic.md>), [transmission](<https://devfeed.tech/tags/transmission.md>)

### AI overview

Continuum uses boundary-state-aware rolling-horizon scheduling for time-triggered traffic in dynamic LEO networks. At topology transitions, it carries forward buffered-node and arrival-time information, then jointly optimizes remaining routes and transmission slots. The approach refines latency to improve timing consistency while preserving original timing constraints. In ablations, boundary-state inheritance improved schedulability by up to 16.6 percentage points, while joint alignment reduced mean jitter by 10.9-37.7 times. The abstract also reports scalability experiments on workloads of up to 10,000 flows, but gives no synthesis performance results.

### Source excerpt

arXiv:2611.24021v1 Announce Type: new Abstract: Low Earth Orbit (LEO) constellations support mission-critical services requiring bounded latency and predictable delivery. However, conventional snapshot-based schedulers discard the forwarding progress of unfinished time-triggered traffic across topology transitions, degrading schedulability and timing consistency. We present Continuum, aboundary-state-aware rolling-horizon scheduling framework. Continuum inherits buffered-node and arrival-time information, jointly optimizing remaining routes and transmission slots, and refines latency to improve timing consistency while preserving original timing constraints. Ablations show up to 16.6 percentage points higher schedulability from boundary-state inheritance and a 10.9-37.7 times reduction in mean jitter from joint alignment. Scalability experiments evaluate synthesis performance for workloads of up to 10K flows.

## A Runtime System for Mitigating Crossbar Port Contention on SM-Partitioned GPUs

DevFeed: [A Runtime System for Mitigating Crossbar Port Contention on SM-Partitioned GPUs](<https://devfeed.tech/articles/a-runtime-system-for-mitigating-crossbar-port-contention-on-sm-partitioned-gpus-142983.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24458>)

Author: Ziwen Wang, Qi Luo, Kunlin Li, Changxi Liu, Dongsheng Wang, Yun Chen

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [GPU optimization](<https://devfeed.tech/topics/gpu-optimization.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [CUDA](<https://devfeed.tech/topics/cuda.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory-bandwidth](<https://devfeed.tech/tags/memory-bandwidth.md>), [port](<https://devfeed.tech/tags/port.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [sm](<https://devfeed.tech/tags/sm.md>), [system](<https://devfeed.tech/tags/system.md>), [throughput](<https://devfeed.tech/tags/throughput.md>)

### AI overview

GPCPlace mitigates crossbar-port contention that persists when CUDA Green Contexts partition GPU workloads across SMs. Spreading workloads across GPCs can make latency-critical requests queue behind background requests at shared ports; packing them into separate GPCs avoids that contention but reduces the ports available to latency-critical requests and can limit bandwidth. Since neither placement is consistently faster, GPCPlace profiles workloads on the target GPU to estimate slowdowns and dynamically chooses between spreading and packing. It hooks CUDA driver kernel launches to set SM masks without application changes. In 112 workload cases across 14 GPUs, it improved latency-critical performance over Green Contexts by up to 1.15x on average and 2.38x maximum, without degrading throughput.

### Source excerpt

arXiv:2611.24458v1 Announce Type: new Abstract: To avoid scheduling delays when running concurrent workloads on a GPU, Streaming Multiprocessor (SM) partitioning mechanisms such as CUDA Green Contexts restrict each workload to separate SMs. Despite this partitioning, concurrent workloads still significantly slow down latency-critical workloads, which recent studies attribute to shared L2 cache and memory contention. However, contention also occurs at the crossbar ports connecting each Graphics Processing Cluster (GPC) of SMs to the L2 cache, as all SMs in a GPC share one port. Green Contexts spread workloads across GPCs, placing concurrent workloads in the same GPCs and forcing latency-critical memory requests to queue behind background requests. Packing workloads into separate GPCs avoids this contention, but forces latency-critical memory requests through fewer ports, limiting memory bandwidth. Consequently, neither spreading nor packing is always faster across workloads and GPUs. Based on these observations, we present GPCPlace, a runtime system that dynamically selects between spreading and packing by profiling workloads on the target GPU to estimate both slowdowns, and hooks kernel launches in the CUDA driver to set SM masks without application modifications. Across 14 GPUs and 112 workload cases, GPCPlace speeds up latency-critical workloads by up to 1.15x on average and 2.38x maximum over Green Contexts without degrading throughput.

## DexAttention: Distributed Sparse Attention through Rapid Online Planning and Persistent GPU Execution

DevFeed: [DexAttention: Distributed Sparse Attention through Rapid Online Planning and Persistent GPU Execution](<https://devfeed.tech/articles/dexattention-distributed-sparse-attention-through-rapid-online-planning-and-persistent-gpu-execution-142968.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23512>)

Author: Sirui Chen, Xuehai Qian

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [distributed-training](<https://devfeed.tech/topics/distributed-training.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [attention](<https://devfeed.tech/tags/attention.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [execution](<https://devfeed.tech/tags/execution.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [online](<https://devfeed.tech/tags/online.md>), [planning](<https://devfeed.tech/tags/planning.md>), [sparse-attention](<https://devfeed.tech/tags/sparse-attention.md>)

### AI overview

DexAttention co-designs online planning and persistent GPU execution to reduce communication and per-operation overhead in distributed sparse attention. Its GPU accelerated, topology aware assigner balances compute and communication; a greedy scheduler orders coarse operations, while persistent kernels enforce fine grained dependencies and dispatch ready tasks. This separates detailed synchronization from planning and supports overlap without repeated attention launches. The framework supports static and dynamic per head masks across multiple attention kernels. On a four node, 16 GPU cluster, it reports a 1.39x geometric mean end to end training speedup over the fastest applicable baseline across 11 configurations. For dynamic video attention, it reports 2.11-2.37x speedups over Ring Attention, including planning.

### Source excerpt

arXiv:2611.23512v1 Announce Type: new Abstract: Sparse attention reduces computation, but distributed execution may still transfer unnecessary data and incur substantial per-operation overhead. Mask-aware assignment and scheduling can reduce these costs, but replanning for dynamic masks must be cheaper than the execution time it saves. We present DexAttention, a distributed sparse attention system that co-designs fast online planning with persistent execution. Its assigner uses GPU-accelerated, topology-aware clustering to balance computational load and reduce communication. A lightweight greedy scheduler orders coarse communication and computation operations, while a persistent kernel on each GPU enforces fine-grained dependencies and dispatches ready tasks. This division keeps detailed synchronization out of planning while enabling overlap without repeated attention launches. The framework supports static and dynamic per-head masks across multiple attention compute kernels. On a four-node, 16-GPU cluster, DexAttention achieves a $1.39\times$ geometric-mean end-to-end training speedup over the fastest applicable baseline across 11 configurations. For dynamic video attention, it achieves $2.11$--$2.37\times$ speedups over Ring Attention including planning.

## Utilization shows how busy a node is. PSI shows which workloads are waiting.

DevFeed: [Utilization shows how busy a node is. PSI shows which workloads are waiting.](<https://devfeed.tech/articles/utilization-shows-how-busy-a-node-is-psi-shows-which-workloads-are-waiting-141940.md>)

Original publisher: [Read original article](<https://www.groundcover.com/blog/utilization-shows-how-busy-a-node-is-psi-shows-which-workloads-are-waiting>)

Author: Anais Dotis

Published: 2026-11-18T10:03:00Z

Content type: article

Language: en

Sources: [Ground Cover](<https://devfeed.tech/sources/ground-cover.md>)

Topics: [cgroups](<https://devfeed.tech/topics/cgroups.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [cloud service outage management](<https://devfeed.tech/topics/cloud-service-outage-management.md>)

Tags: [aws-fargate](<https://devfeed.tech/tags/aws-fargate.md>), [byoc](<https://devfeed.tech/tags/byoc.md>), [cgroup-v2](<https://devfeed.tech/tags/cgroup-v2.md>), [checkout](<https://devfeed.tech/tags/checkout.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [delay](<https://devfeed.tech/tags/delay.md>), [ebpf](<https://devfeed.tech/tags/ebpf.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [kubelet](<https://devfeed.tech/tags/kubelet.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-1-36](<https://devfeed.tech/tags/kubernetes-1-36.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [node](<https://devfeed.tech/tags/node.md>), [waiting](<https://devfeed.tech/tags/waiting.md>)

### AI overview

PSI measures time workloads stall while waiting for CPU, memory, or I/O, revealing contention that utilization averages can miss. It reports "some" (at least one task stalled) and "full" (all non-idle tasks stalled) over 10-, 60-, and 300-second windows and as cumulative stall time. Kubernetes 1.36 exposes PSI at node, Pod, and container levels through the Summary API and `/metrics/cadvisor`; it requires Linux kernel 4.20+, cgroup v2, and kernel PSI enabled, and is unavailable on Windows. Kubernetes exposes the signal for monitoring but does not use it for scheduling, autoscaling, or eviction decisions. PSI can identify a stalled workload but not the cause, so interpreting it requires time-aligned usage data from neighboring workloads. The text says groundcover does not yet collect PSI or use it in Autonomous Infrastructure; both are described as roadmap work.

### Source excerpt

CPU or memory usage data does not show whether any workload is delayed because it cannot get CPU, memory or I/O when it needs it, and that delay is what users experience as latency and failed requests. Pressure Stall Information (PSI) measures the delay directly, and as of Kubernetes 1.36 the kubelet exposes it as a stable feature.

## Your CPU limits aren't stopping noisy neighbors

DevFeed: [Your CPU limits aren't stopping noisy neighbors](<https://devfeed.tech/articles/your-cpu-limits-aren-t-stopping-noisy-neighbors-141936.md>)

Original publisher: [Read original article](<https://www.groundcover.com/blog/cpu-limits-arent-stopping-noisy-neighbors>)

Author: Anais Dotis

Published: 2026-11-18T10:00:00Z

Content type: article

Language: en

Sources: [Ground Cover](<https://devfeed.tech/sources/ground-cover.md>)

Topics: [cgroups](<https://devfeed.tech/topics/cgroups.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [autoscaling](<https://devfeed.tech/topics/autoscaling.md>), [Performance Testing](<https://devfeed.tech/topics/performance-testing.md>)

Tags: [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-infrastructure](<https://devfeed.tech/tags/autonomous-infrastructure.md>), [bin-packing](<https://devfeed.tech/tags/bin-packing.md>), [byoc](<https://devfeed.tech/tags/byoc.md>), [cfs](<https://devfeed.tech/tags/cfs.md>), [cgroup](<https://devfeed.tech/tags/cgroup.md>), [cgroups](<https://devfeed.tech/tags/cgroups.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [combined](<https://devfeed.tech/tags/combined.md>), [congestion-control](<https://devfeed.tech/tags/congestion-control.md>), [container](<https://devfeed.tech/tags/container.md>), [containers](<https://devfeed.tech/tags/containers.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpu-time](<https://devfeed.tech/tags/cpu-time.md>), [groundcover](<https://devfeed.tech/tags/groundcover.md>), [latency](<https://devfeed.tech/tags/latency.md>), [limits](<https://devfeed.tech/tags/limits.md>), [memory](<https://devfeed.tech/tags/memory.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [oom](<https://devfeed.tech/tags/oom.md>)

### AI overview

Node-level contention explains why accurate per-workload sizing can still leave a cluster unstable: scheduling uses requests, while independently chosen P95 requests do not account for workloads peaking together. Under CPU contention, requests set proportional CPU weight; CPU limits impose quotas that can throttle a container even when other cores are idle. Memory has no proportional sharing: exceeding a limit can trigger an immediate OOM kill, while node pressure can lead to evictions or OOM kills. The post presents groundcover Autonomous Infrastructure as addressing this by using node-level CPU and memory history to identify overlapping peaks, adjust requests within operator-defined bounds, and apply changes to running Pods. It also says this requires high-resolution, per-container history linked to node and workload, and describes groundcover's eBPF sensor and BYOC storage as its collection approach.

### Source excerpt

This post explains what a noisy neighbor is, why CPU requests (not CPU limits) determine how CPU time is divided under contention, and why memory contention ends in OOM kills and evictions instead of added latency. It then explains why sizing each workload at a percentile of its own usage still overloads nodes, and how groundcover's Autonomous Infrastructure addresses that.

## ReBoT-MiCS: Reliability-Aware Bounding Time for Enhancing Timing Behavior of Embedded Mixed-Criticality Systems

DevFeed: [ReBoT-MiCS: Reliability-Aware Bounding Time for Enhancing Timing Behavior of Embedded Mixed-Criticality Systems](<https://devfeed.tech/articles/rebot-mics-reliability-aware-bounding-time-for-enhancing-timing-behavior-of-embedded-mixed-criticality-systems-139610.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22588>)

Author: Mohammad Abbasinia, Behnaz Ranjbar, Akash Kumar

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Embedded Systems](<https://devfeed.tech/topics/embedded-systems.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cs-ce](<https://devfeed.tech/tags/cs-ce.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [design](<https://devfeed.tech/tags/design.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [mc](<https://devfeed.tech/tags/mc.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [qos](<https://devfeed.tech/tags/qos.md>), [rebot](<https://devfeed.tech/tags/rebot.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [scheme](<https://devfeed.tech/tags/scheme.md>), [selection](<https://devfeed.tech/tags/selection.md>), [switches](<https://devfeed.tech/tags/switches.md>), [switching](<https://devfeed.tech/tags/switching.md>), [time](<https://devfeed.tech/tags/time.md>), [timing](<https://devfeed.tech/tags/timing.md>)

### AI overview

ReBoT-MiCS selects low-criticality worst-case execution-time bounds at design time, jointly accounting for processor utilization, quality of service, mode-switch probability, and probabilistic reliability constraints under a transient-fault exposure model. The approach treats execution-time bounds as part of reliability reasoning, where prior approaches described in the abstract typically handled reliability separately through fault-tolerance mechanisms. Experiments on synthetic and embedded benchmarks report utilization improvements of up to 27.6% and 11.67% on average, with mode-switch probability bounded by up to 5.48% while meeting specified reliability constraints. The abstract does not provide further details on the method or benchmark setup.

### Source excerpt

arXiv:2611.22588v1 Announce Type: cross Abstract: In Mixed-Criticality (MC) systems, considering multiple Worst-Case Execution Times (WCETs) for the same task, corresponding to different system operation modes, presents a fundamental challenge in MC system design. Identifying suitable WCETs for lower (LO) criticality system operational modes is inherently difficult. Tight low WCET values may trigger frequent mode switches that degrade Quality-of-Service (QoS) by dropping/degrading the lower-criticality tasks and reducing their functionality. However, more conservative values reduce resource efficiency. Moreover, low WCET selection affects exposure assumptions under the adopted transient-fault model, which is used in reliability-aware scheduling analysis. Although some studies have considered low WCET determination to make a reasonable trade-off between processor utilization, mode switching probability and QoS, reliability constraints are typically addressed separately through fault-tolerance mechanisms. This separation overlooks the opportunity to use execution-time bounds as part of design-time reasoning about exposure-related reliability constraints. In this regard, we propose a reliability-aware analytical scheme, named ReBoT-MiCS, to determine low WCETs at design time, jointly balancing utilization, QoS, mode switches, and probabilistic reliability constraints of each task criticality level under a transient-fault exposure model. Experiments conducted with various synthetic and embedded benchmarks demonstrate the efficacy of the proposed scheme, in which utilization can be improved by up to 27.6% and 11.67% on average, while bounding the mode switching probability by up to 5.48%, and satisfying the specified reliability constraints

## CodeReel: Accelerating Code-to-Video Agents with Exact Frame Reuse and Blocking-Aware Scheduling

DevFeed: [CodeReel: Accelerating Code-to-Video Agents with Exact Frame Reuse and Blocking-Aware Scheduling](<https://devfeed.tech/articles/codereel-accelerating-code-to-video-agents-with-exact-frame-reuse-and-blocking-aware-scheduling-140098.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22967>)

Author: Junyi Shen, Yao Lu

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [caching](<https://devfeed.tech/tags/caching.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [codex-cli](<https://devfeed.tech/tags/codex-cli.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cv](<https://devfeed.tech/tags/cs-cv.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-mm](<https://devfeed.tech/tags/cs-mm.md>), [execution](<https://devfeed.tech/tags/execution.md>), [frame](<https://devfeed.tech/tags/frame.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [pixels](<https://devfeed.tech/tags/pixels.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [time](<https://devfeed.tech/tags/time.md>), [training](<https://devfeed.tech/tags/training.md>), [video](<https://devfeed.tech/tags/video.md>), [video-agents](<https://devfeed.tech/tags/video-agents.md>), [videos](<https://devfeed.tech/tags/videos.md>)

### AI overview

CodeReel reduces coding agents' wait for video builds by reusing frames based on their drawing commands, even when frames move in time, and scheduling checks before an idle-priority render. It reuses work from failed builds while rendering, though scheduling uses CPU to return results sooner. In the EditLoop benchmark, it cuts wait time 36.3% versus Rebuild, a warm pipeline with parallel rendering, and 57.9% versus Sequential. For time-shifting edits, it renders 43.9% of frames, close to the 43.0% with new pixels; Manim-style caching renders 99.8%. Real-agent median wait per build was 0.62x Rebuild in Claude Code and 0.67x in Codex CLI. The abstract reports gains across five models and two frameworks.

### Source excerpt

arXiv:2611.22967v1 Announce Type: cross Abstract: Coding agents make videos by writing and refining programs in a build--inspect--edit loop. A finished film costs a median of $2.85 in model calls and 11 minutes, over a third of that time in builds that block the agent. We find that much of this time is avoidable, for two reasons. First, 37.5% of the frames of a session's later films were drawn before, many shifted in time or inside an edited scene. Second, half of the builds stop at a check, where the agent needs only the verdict, but which builds stop is unknown until the checks finish. We present CodeReel, a training-free execution layer behind agents' existing commands. Exact frame reuse keys each frame by its drawing commands, regardless of its position in time, and reuses each frame whose key recurs. Blocking-aware scheduling runs the checks first and starts the render alongside them, at idle priority, unless the session's recent builds make a pass unlikely. Scheduling spends CPU to answer sooner and reuse returns it; exact keys let later versions use frames rendered for a failed one as the agent thinks. We introduce EditLoop, a benchmark of replayable agent sessions whose films are checked against renders from scratch. On it, CodeReel cuts the agent's wait by 36.3% against Rebuild, a warm pipeline with parallel rendering, and by 57.9% against Sequential, today's step-by-step pipeline. On time-shifting edits its reuse renders 43.9%, close to the 43.0% whose pixels are new, while Manim-style caching renders 99.8%. With real agents, the median wait per build is 0.62x Rebuild's in Claude Code, on topics never used in development, and 0.67x in Codex CLI. The gain holds for five models and two frameworks.

## JigSLO: Solving the Resource Puzzle for Efficient Multi-LLM Serving

DevFeed: [JigSLO: Solving the Resource Puzzle for Efficient Multi-LLM Serving](<https://devfeed.tech/articles/jigslo-solving-the-resource-puzzle-for-efficient-multi-llm-serving-140374.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2509.06261>)

Author: Kyungmin Bin, Seungbeom Choi, Jimyoung Son, Jieun Choi, Daseul Bae, Daehyeon Baek, Kihyo Moon, Minsung Jang, Hyojung Lee

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [Multi-GPU](<https://devfeed.tech/topics/multi-gpu.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [cache](<https://devfeed.tech/tags/cache.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [chat](<https://devfeed.tech/tags/chat.md>), [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [compute](<https://devfeed.tech/tags/compute.md>), [context](<https://devfeed.tech/tags/context.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [decode](<https://devfeed.tech/tags/decode.md>), [generation](<https://devfeed.tech/tags/generation.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [kv-cache](<https://devfeed.tech/tags/kv-cache.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-serving](<https://devfeed.tech/tags/llm-serving.md>), [prefill](<https://devfeed.tech/tags/prefill.md>), [resources](<https://devfeed.tech/tags/resources.md>)

### AI overview

JigSLO models how memory-bandwidth contention from co-located heterogeneous LLM instances affects latency, estimating it from contended and uncontended periods using standalone profiles. It schedules prefill and decode as separate instances, jointly choosing tensor parallelism, compute share, batch configuration, and co-location to meet latency targets while maximizing throughput. Its resource manager shares weights, pools KV cache, and transfers it between prefill and decode instances. Across chat, code-generation, and long-context summarization datasets, the paper reports average gains of 2.3x in SLO attainment and 1.2x in throughput over state-of-the-art baselines; on long-context workloads, it matches their best attainment with half the GPUs.

### Source excerpt

arXiv:2509.06261v3 Announce Type: replace Abstract: GPU spatial sharing co-locates instances with complementary demands, such as compute-bound prefill and memory-bound decode, promising cost-efficient multi-LLM serving. Prior systems partition compute and coordinate shared memory capacity, but do not model bandwidth contention among co-located instances of heterogeneous LLMs. This contention makes each instance's latency depend on the memory-access patterns of its co-runners, even when its own resource allocation remains unchanged. Drawing on extensive measurements, we find that the latency impact of bandwidth contention can be captured by a time-shared memory-access model with contended and uncontended periods, so the overall latency can be analytically estimated as a time-weighted average of the latency estimates for these periods. We propose JigSLO, a contention-aware multi-LLM serving system that manages memory resources and schedules each model's prefill and decode phases as separate instances, treating their co-location as a placement decision. Its contention-aware predictor estimates per-instance latency under any co-location from standalone profiles alone. Guided by these predictions, its placement algorithm jointly selects each instance's tensor parallelism, compute share, and batch configuration, pairing complementary memory-access patterns to maximize throughput within each model's latency targets. JigSLO's shared resource manager complements this on the capacity side, sharing weights, pooling KV cache, and transferring it between prefill and decode instances. Across three datasets covering chat, code generation, and long-context summarization, JigSLO outperforms state-of-the-art baselines by $2.3\times$ in SLO attainment and $1.2\times$ in throughput on average, matching their best attainment with half the GPUs on long-context workloads.

## Solver-Free and Cost-Aware Online Scheduling of AI Data Center Tasks

DevFeed: [Solver-Free and Cost-Aware Online Scheduling of AI Data Center Tasks](<https://devfeed.tech/articles/solver-free-and-cost-aware-online-scheduling-of-ai-data-center-tasks-139988.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22239>)

Author: Xin Qin, Dawei Qiu, Fei Teng

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-data-center](<https://devfeed.tech/tags/ai-data-center.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [data-center](<https://devfeed.tech/tags/data-center.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [electricity](<https://devfeed.tech/tags/electricity.md>), [energy](<https://devfeed.tech/tags/energy.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [online](<https://devfeed.tech/tags/online.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [priority](<https://devfeed.tech/tags/priority.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [timing](<https://devfeed.tech/tags/timing.md>)

### AI overview

The proposed solver-free online rule assigns each arriving task a start period, using a dual-decomposition-inspired approach to reduce electricity cost within operational constraints. It shifts flexible tasks toward lower-price periods while keeping high-priority tasks on schedule. Simulations using an A100 GPU trace (3,456 GPUs and 1,343 tasks) reportedly kept GPU and CPU use within capacity and achieved lower cost and much less computation time than a multi-timescale optimization benchmark. These findings are limited to the reported simulations.

### Source excerpt

arXiv:2611.22239v1 Announce Type: cross Abstract: AI data centers receive computing tasks continuously, whereas solver-based optimization takes time to run and electricity is priced per settlement period. This paper bridges this timing gap through a solver-free online optimization rule inspired by dual decomposition. The rule assigns each task a start period upon arrival to optimize energy cost subject to operational constraints, shifting flexible tasks toward low-price periods while keeping high-priority tasks on schedule. Simulations on the A100 GPU trace (3,456 GPUs, 1,343 tasks) show that the proposed rule keeps GPU and CPU use within capacity while scheduling tasks at low cost. Compared with a multi-timescale optimization benchmark, it achieves a lower cost and, because it needs no solver, much less computation time.

## TeleChat to Xing4: Advancing Frontier Agentic Models on Domestic Chips and Frameworks

DevFeed: [TeleChat to Xing4: Advancing Frontier Agentic Models on Domestic Chips and Frameworks](<https://devfeed.tech/articles/telechat-to-xing4-advancing-frontier-agentic-models-on-domestic-chips-and-frameworks-139966.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22115>)

Author: Xingchen AGI Lab, :, Baotian Hu, Bingkai Yang, Boyang Wang, Changzai Pan, Chao Lyu, Chao Wang, Chen Li, Chenshuo Pan, Chenyu Lin, Chenyuan Zhang, Chongming Liu, Dawei Fan, Di Wu, Dong Guo, Dong Li, Do

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [post-training](<https://devfeed.tech/topics/post-training.md>), [sharding](<https://devfeed.tech/topics/sharding.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [activation](<https://devfeed.tech/tags/activation.md>), [affinity](<https://devfeed.tech/tags/affinity.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [ascend](<https://devfeed.tech/tags/ascend.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [attention](<https://devfeed.tech/tags/attention.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [chips](<https://devfeed.tech/tags/chips.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [models](<https://devfeed.tech/tags/models.md>)

### AI overview

Xing 4 extends the TeleChat lineage with architecture and infrastructure designed for Ascend. The report examines sparse activation, attention design, model depth and width, and speculative decoding as ways to balance capacity against computation, memory access, and execution overhead. MindSpore HyperParallel combines topology-aware hybrid sharding, distributed optimizer execution, and long-sequence and activation-memory management; CPU affinity and core isolation reduce host scheduling interference. These mechanisms supported pretraining a 285B-parameter model on 8,192 Ascend 910C cards. For agent post-training, TeleGym links execution, evaluation, and trajectory construction to policy optimization. Disaggregated asynchronous execution, bounded oversampling, and partial rollout address tasks with different durations while maintaining trajectory continuity across policy updates.

### Source excerpt

arXiv:2611.22115v1 Announce Type: new Abstract: We present Xing 4, a series of large language models that extends the TeleChat lineage through coordinated advances in model architecture and training infrastructure on Ascend. This report describes the design principles and systems engineering behind the series, spanning architecture selection, large-scale pretraining, and reasoning and agentic post-training. We study how sparse activation, attention design, model depth and width, and speculative decoding balance model capacity with computation, memory access, and execution overhead. Our pretraining infrastructure builds on MindSpore HyperParallel, combining topology-aware hybrid sharding, efficient distributed optimizer execution, and coordinated management of long-sequence workloads and activation memory. CPU affinity and core isolation further reduce host scheduling interference. Together, these mechanisms support the pretraining of a 285B-parameter model on 8,192 Ascend 910C cards, providing a concrete setting for the architectural and systems studies. For post-training, we introduce TeleGym, a unified agent execution platform that connects execution, evaluation, and trajectory construction to policy optimization. Disaggregated asynchronous execution, bounded oversampling, and partial rollout accommodate heterogeneous task durations while preserving trajectory continuity across policy updates. Together, these advances establish an Ascend-oriented training foundation for the continued development of Xing 4 across model scales and increasingly demanding reasoning and agent workloads.

## What to know about the Fivetran async provider in Airflow | Blog | Fivetran

DevFeed: [What to know about the Fivetran async provider in Airflow | Blog | Fivetran](<https://devfeed.tech/articles/what-to-know-about-the-fivetran-async-provider-in-airflow-blog-fivetran-140242.md>)

Original publisher: [Read original article](<https://wf.fivetran.com/blog/introducing-the-new-fivetran-async-provider-in-airflow>)

Author: Jimmy Hooker

Published: 2026-11-18T04:07:11Z

Content type: article

Language: en

Sources: [Fivetran Blog](<https://devfeed.tech/sources/fivetran-blog.md>)

Topics: [async](<https://devfeed.tech/topics/async.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [airflow](<https://devfeed.tech/tags/airflow.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [async](<https://devfeed.tech/tags/async.md>), [aws](<https://devfeed.tech/tags/aws.md>), [bigquery](<https://devfeed.tech/tags/bigquery.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [blog](<https://devfeed.tech/tags/blog.md>), [callback](<https://devfeed.tech/tags/callback.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [code](<https://devfeed.tech/tags/code.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [complete](<https://devfeed.tech/tags/complete.md>), [completion](<https://devfeed.tech/tags/completion.md>), [component](<https://devfeed.tech/tags/component.md>), [components](<https://devfeed.tech/tags/components.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [condition](<https://devfeed.tech/tags/condition.md>), [connectors](<https://devfeed.tech/tags/connectors.md>), [data](<https://devfeed.tech/tags/data.md>), [fivetran](<https://devfeed.tech/tags/fivetran.md>)

### AI overview

The Fivetran async provider lets Airflow 2.2+ wait for connector syncs without occupying worker slots. In the standard setup, each `FivetranSensor` holds a worker slot while polling, which can leave other tasks queued. Airflow's triggerer instead monitors deferred tasks asynchronously in a single Python process, then signals the scheduler when the target status is reached. The provider offers `FivetranSensorAsync` to wait for a sync and `FivetranOperatorAsync` to start a sync and monitor it through completion; both are used in DAGs similarly to their standard counterparts. Install it with `pip install airflow-provider-fivetran-async`. The excerpt says examples are available in the provider and Astronomer Registry.

### Source excerpt

Fivetran Airflow provider developed by Astronomer allows data engineers to run Fivetran data syncs more efficiently in Airflow 2.2+

## How we raised Databricks cluster rate limits by 7.5x

DevFeed: [How we raised Databricks cluster rate limits by 7.5x](<https://devfeed.tech/articles/how-we-raised-databricks-cluster-rate-limits-by-7-5-139643.md>)

Original publisher: [Read original article](<https://www.databricks.com/blog/how-we-raised-databricks-cluster-rate-limits-75>)

Author: Heqing Ya; Tan Zhang; Ankit Batra; Abhishek Rai

Published: 2026-11-18T02:30:31Z

Content type: article

Language: en

Sources: [Databricks](<https://devfeed.tech/sources/databricks.md>)

Topics: [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>), [databricks](<https://devfeed.tech/topics/databricks.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [account](<https://devfeed.tech/tags/account.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [added](<https://devfeed.tech/tags/added.md>), [after](<https://devfeed.tech/tags/after.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [all](<https://devfeed.tech/tags/all.md>), [allows](<https://devfeed.tech/tags/allows.md>), [also](<https://devfeed.tech/tags/also.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [compute](<https://devfeed.tech/tags/compute.md>), [compute-platform](<https://devfeed.tech/tags/compute-platform.md>), [databricks](<https://devfeed.tech/tags/databricks.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [limits](<https://devfeed.tech/tags/limits.md>), [platform](<https://devfeed.tech/tags/platform.md>), [team](<https://devfeed.tech/tags/team.md>)

### AI overview

Databricks raised default cluster-creation request-rate limits 7.5x by adding adaptive concurrency control for the longer provisioning workflows behind each API call. Each active workflow holds a slot through VM provisioning and dependency waits; health signals such as provisioning latency and thread-pool saturation guide the slot limit. When capacity falls, accepted requests queue and start more slowly; as conditions recover, concurrency increases cautiously. The fixed API rate limit remains a guardrail for exceptionally high traffic. This separates capacity management from request-rate enforcement, but a successful API response does not promise an immediate launch or fixed completion time. Queues need bounded size and wait times, and retries need backoff and attempt limits; concurrency limits cannot restore an unavailable dependency. The reported rollout raised default limits 7.5x, reduced cluster-creation rate-limit errors by more than 99.99% in the stated scope, and removed over a hundred customer-specific overrides in scope. Since the increase, few customers have hit the higher limits and no new manual overrides have been added.

### Source excerpt

As part of the Compute Platform team at Databricks, we turn cloud infrastructure...

## Can Agentic LLMs Write Task-Based Parallel Code? A Study of OpenMP Tasking, HPX, StarPU and TTG

DevFeed: [Can Agentic LLMs Write Task-Based Parallel Code? A Study of OpenMP Tasking, HPX, StarPU and TTG](<https://devfeed.tech/articles/can-agentic-llms-write-task-based-parallel-code-a-study-of-openmp-tasking-hpx-starpu-and-ttg-136981.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.19105>)

Author: Linus Bantel, Anna-Lena Roth, Tim Th\\"uring, Jonas Posner, Dirk Pfl\\"uger

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [hpx](<https://devfeed.tech/topics/hpx.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [hpx](<https://devfeed.tech/tags/hpx.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [openmp](<https://devfeed.tech/tags/openmp.md>), [parallel](<https://devfeed.tech/tags/parallel.md>)

### AI overview

The study finds that model capability strongly shapes whether agentic LLMs can produce useful task-based C++ parallel code. Five locally hosted open-weight models iteratively edited, compiled, and ran seven HPC kernels across OpenMP Tasking, HPX, StarPU, TTG, and a serial baseline. Three models produced correct, genuinely task-parallel kernels in 57-82% of cases; two rarely compiled their code or succeeded. Among capable models, OpenMP Tasking and HPX were most reliable, StarPU close behind, and TTG trailed. The best generated matrix multiplication and factorization kernels matched or exceeded multithreaded OpenBLAS/LAPACK. But correctness alone overstated parallel quality: some nominally parallel kernels were serial, and serialized task graphs and poor task granularity were common. The abstract does not provide further detail on individual kernels or scaling and memory results.

### Source excerpt

arXiv:2611.19105v1 Announce Type: new Abstract: Task-based programming offers more expressive power than loop-level parallelism, but the runtimes providing it differ widely in API style, maturity, and the amount of public code to learn from. This paper asks how well LLM agents write C++ for four of them: OpenMP Tasking, HPX, StarPU, and TTG. Instead of single one-shot prompts, we use an agentic workflow in which the model edits files, compiles, and runs its kernels until it reproduces a reference output. Five locally hosted open-weight LLM implement seven HPC kernels, including matrix multiplication, Cholesky and LU factorization, in all four frameworks and a serial baseline to verify their understanding of the problem in general. Every kernel is evaluated independently for correctness at each concurrency level, strong scaling, and peak memory. Model capability dominates the outcome: three models produce correct, genuinely task-parallel kernels in 57-82% of the cases, while two models rarely compile their own code and almost never succeed. For the capable models, OpenMP Tasking and HPX are handled most reliably, StarPU is close behind, and TTG trails. The best generated GEMM and factorization kernels match or exceed the multithreaded OpenBLAS/LAPACK reference. However, correctness overstates parallel quality: several "parallel" kernels contain no parallelism at all; and serialized task graphs and unsuitable task granularity remain common.

## Multi-LLM Agentic AI at the Edge: Joint Agent Scheduling and Resource Allocation

DevFeed: [Multi-LLM Agentic AI at the Edge: Joint Agent Scheduling and Resource Allocation](<https://devfeed.tech/articles/multi-llm-agentic-ai-at-the-edge-joint-agent-scheduling-and-resource-allocation-137630.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.20915>)

Author: Yuanyan Song, Kezhi Wang, Xinmian Xu, Yongmin Li

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [supervisor agent pattern](<https://devfeed.tech/topics/supervisor-agent-pattern.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [hierarchical agent systems](<https://devfeed.tech/topics/hierarchical-agent-systems.md>), [Operations research and optimization](<https://devfeed.tech/topics/operations-research-and-optimization.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-ai-architecture](<https://devfeed.tech/tags/agentic-ai-architecture.md>), [agentic-workflows](<https://devfeed.tech/tags/agentic-workflows.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-architecture](<https://devfeed.tech/tags/ai-architecture.md>), [ai-at-the-edge](<https://devfeed.tech/tags/ai-at-the-edge.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [approximation](<https://devfeed.tech/tags/approximation.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [convex](<https://devfeed.tech/tags/convex.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [edge](<https://devfeed.tech/tags/edge.md>), [energy](<https://devfeed.tech/tags/energy.md>), [llm](<https://devfeed.tech/tags/llm.md>), [resource](<https://devfeed.tech/tags/resource.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>)

### AI overview

The paper proposes an edge architecture in which a supervisor splits user requests into subtasks and dispatches them to worker agents through parallel or serial workflows, with a two-level retry mechanism. To reduce energy use while meeting latency and QoS constraints, an alternating-optimization scheme jointly handles agent selection and resource allocation. The parallel workflow allocates bandwidth; the serial workflow allocates service time using KKT conditions. Both address retrieval and agent selection, using SCA, Lagrangian relaxation, and Gale-Shapley or LLM-based algorithms. Simulations report lower energy consumption than benchmark schemes, and experiments using Qwen and Llama report improved task success rates.

### Source excerpt

arXiv:2611.20915v1 Announce Type: new Abstract: In this paper, an edge-enabled multi-large language model (LLM) agentic AI architecture is proposed, where one supervisor AI agent and multiple worker AI agents cooperatively execute users' requests at the edge. The supervisor AI agent decouples the user request into a series of sub-tasks and dynamically dispatches them to LLM-equipped worker AI agents via two agentic workflows, i.e., parallel and serial workflows, with a two-level retry mechanism to enhance execution reliability. To prolong the service duration of worker AI agents, the energy minimization problems are formulated by jointly considering AI agent selection and resource allocation, subject to task execution latency and quality of service (QoS) constraints. A resource allocation scheme based on alternating optimization (AO) is proposed. Specifically, for the parallel workflow, the scheme decouples the original problem into bandwidth allocation, retrieval selection and AI agent selection sub-problems, which are iteratively solved by the proposed successive convex approximation (SCA), Lagrangian relaxation (LR), and Gale-Shapley (GS) or LLM-based algorithms, respectively. For the serial workflow, the problem is similarly decoupled into service time allocation, retrieval selection and AI agent selection sub-problems; the optimal service time allocation is obtained via Karush-Kuhn-Tucker (KKT) conditions, while the latter two sub-problems are addressed by extending the proposed algorithms to the serial scenario. Simulation results show that the proposed resource allocation scheme can reduce system energy consumption compared with other benchmarks, while experiments on a multi-LLM agentic AI system based on Qwen and Llama demonstrate improved task execution success rates.

## A Comprehensive Survey on Orbital Edge Computing: Systems, Applications, and Algorithms

DevFeed: [A Comprehensive Survey on Orbital Edge Computing: Systems, Applications, and Algorithms](<https://devfeed.tech/articles/a-comprehensive-survey-on-orbital-edge-computing-systems-applications-and-algorithms-136958.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2306.00275>)

Author: Changhao Wu, Yuanchun Li, Mengwei Xu, Chongbin Guo, Zengshan Yin, Weiwei Gao, Chuanxiu Chi

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Operations research and optimization](<https://devfeed.tech/topics/operations-research-and-optimization.md>)

Tags: [2023](<https://devfeed.tech/tags/2023.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [applications](<https://devfeed.tech/tags/applications.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [communication](<https://devfeed.tech/tags/communication.md>), [computing](<https://devfeed.tech/tags/computing.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [design](<https://devfeed.tech/tags/design.md>), [earth](<https://devfeed.tech/tags/earth.md>), [edge](<https://devfeed.tech/tags/edge.md>), [edge-computing](<https://devfeed.tech/tags/edge-computing.md>), [low-earth-orbit](<https://devfeed.tech/tags/low-earth-orbit.md>), [management](<https://devfeed.tech/tags/management.md>), [mobility](<https://devfeed.tech/tags/mobility.md>), [network](<https://devfeed.tech/tags/network.md>), [network-design](<https://devfeed.tech/tags/network-design.md>), [offloading](<https://devfeed.tech/tags/offloading.md>), [survey](<https://devfeed.tech/tags/survey.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

Orbital edge computing (OEC) uses commercial off-the-shelf hardware on satellites to enable computing in orbit. This survey reviews research from 2000 to 2023 on network design, computation offloading, resource allocation, performance analysis, and optimization, with focus areas including protocol optimization and mobility management. It identifies moving low-Earth-orbit satellites and constrained communication, computation, and storage resources as challenges for task scheduling. The abstract says the survey also highlights technological challenges and future directions; it does not detail specific algorithms or findings.

### Source excerpt

arXiv:2306.00275v3 Announce Type: replace Abstract: The number of satellites, especially those operating in low-earth orbit (LEO), is exploding in recent years. Additionally, the use of COTS hardware into those satellites enables a new paradigm of computing: orbital edge computing (OEC). OEC entails more technically advanced steps compared to single-satellite computing. This feature allows for vast design spaces with multiple parameters, rendering several novel approaches feasible. The mobility of LEO satellites in the network and limited resources of communication, computation, and storage make it challenging to design an appropriate scheduling algorithm for specific tasks in comparison to traditional ground-based edge computing. This article comprehensively surveys the significant areas of focus in orbital edge computing, which include protocol optimization, mobility management, and resource allocation. This article provides the first comprehensive survey of OEC. Previous survey papers have only concentrated on ground-based edge computing or the integration of space and ground technologies. This article presents a review of recent research from 2000 to 2023 on orbital edge computing that covers network design, computation offloading, resource allocation, performance analysis, and optimization. Moreover, having discussed several related works, both technological challenges and future directions are highlighted in the field.

## Making Preemption Productive in Long-Output LLM Serving

DevFeed: [Making Preemption Productive in Long-Output LLM Serving](<https://devfeed.tech/articles/making-preemption-productive-in-long-output-llm-serving-136988.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.20106>)

Author: Ziji Shi, Xinyi Wan, Chaoyi Ruan, Guangxing Huang, Min Lin, Jialin Li

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [admission](<https://devfeed.tech/tags/admission.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [engine](<https://devfeed.tech/tags/engine.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpu-memory](<https://devfeed.tech/tags/gpu-memory.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [hidden-states](<https://devfeed.tech/tags/hidden-states.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-serving](<https://devfeed.tech/tags/llm-serving.md>), [llms](<https://devfeed.tech/tags/llms.md>), [math](<https://devfeed.tech/tags/math.md>), [memory](<https://devfeed.tech/tags/memory.md>), [p99](<https://devfeed.tech/tags/p99.md>), [pool](<https://devfeed.tech/tags/pool.md>), [protection](<https://devfeed.tech/tags/protection.md>), [qwen3](<https://devfeed.tech/tags/qwen3.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [serving](<https://devfeed.tech/tags/serving.md>)

### AI overview

Stint addresses KV thrashing, where preempted long-output requests repeatedly lose and recover state while making little progress. It preserves fixed-length KV snapshots in a CPU pool, uses fused gather/scatter transfers with double buffering, readmits older stalled requests, protects their next decoding turn, and uses hidden-state estimates of remaining output to select preemption victims. In olympiad-math replays with Qwen3-32B on H200 GPUs, requests paused no more than 50 seconds; p99 time per output token fell 50.7% versus recomputation in the same engine, and the replay finished 10.7% sooner with 12.0% higher throughput. These results are specific to the described replay evaluation.

### Source excerpt

arXiv:2611.20106v1 Announce Type: new Abstract: Reasoning LLMs generate long outputs whose key--value (KV) caches occupy GPU memory for minutes. When memory fills, the server preempts requests, and a preempted request can repeatedly lose and recover its state while producing little new output. We call this behavior KV thrashing. In certain cases, existing systems leave more than a fifth of requests stalled for over a minute. Because preemption cannot be avoided without delaying admission, we ask how to make it productive. We present Stint, a serving system that preserves a preempted request's work, bounds how long it waits, and gives it fresh output after it returns. Stint stores fixed-length KV snapshots in a contiguity-first CPU pool with an exact-extent allocator, and moves them with fused K/V gather/scatter kernels and double buffering. Age-based readmission brings stalled requests back, and protection gives them a turn of fresh decoding before another preemption. Remaining-length estimates from decoding hidden states guide victim selection. On olympiad-math replays with Qwen3-32B on H200 GPUs, no request pauses for more than 50 seconds under Stint and p99 time per output token falls by 50.7\% relative to recomputation in the same engine. The replay as a whole finishes 10.7\% sooner (12.0\% higher throughput), because the requests that baselines starve no longer finish last.

## Practice Is Not Free: Measuring the Embodied Cost of Reset-Free Robot Practice

DevFeed: [Practice Is Not Free: Measuring the Embodied Cost of Reset-Free Robot Practice](<https://devfeed.tech/articles/practice-is-not-free-measuring-the-embodied-cost-of-reset-free-robot-practice-138970.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.19979>)

Author: Vedant Telrandhe, Sushil Sharma

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [FIRST](<https://devfeed.tech/topics/first.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [act](<https://devfeed.tech/tags/act.md>), [actuator](<https://devfeed.tech/tags/actuator.md>), [cost](<https://devfeed.tech/tags/cost.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ro](<https://devfeed.tech/tags/cs-ro.md>), [failures](<https://devfeed.tech/tags/failures.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [ledger](<https://devfeed.tech/tags/ledger.md>), [measuring](<https://devfeed.tech/tags/measuring.md>), [reset](<https://devfeed.tech/tags/reset.md>), [retry](<https://devfeed.tech/tags/retry.md>), [robot](<https://devfeed.tech/tags/robot.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>)

### AI overview

A low-cost testbed measures the time, joint travel, and human interventions incurred by reset-free robot practice. In 51 minutes of hardware trials, a fixed retry limit did not significantly reduce execution time lost to failures compared with a feasibility rule (36% versus 27%) and saved no robot time. Logs showed no evidence that failures clustered, so an immediate retry was no more likely to fail; much of the retry condition's extra human time came from cubes knocked out of reach. Replaying a cost-aware scheduler on the logs recovered the sensible choice without a hand-set retry limit. The authors also report that concentrating demonstrations in a smaller workspace raised success there from 8/20 to 10/10.

### Source excerpt

arXiv:2611.19979v1 Announce Type: cross Abstract: When a robot practices without human resets, every attempt still costs wall-clock time, actuator wear, and sometimes a person's attention, yet the schedulers that decide what to practice next treat attempts as free. We present an open, low-cost testbed for measuring these costs: a self-built SO-101 arm runs two demonstration-trained ACT policies that reset each other, with a vision-based success detector and a ledger that records the time, joint travel, and human interventions of every attempt. We formulate cost-aware practice scheduling, in which task selection is rewarded by measured competence gain net of embodied cost, and specify in advance the comparison that will test it. Its first two conditions, run on hardware for 51 minutes of robot time, show that a fixed retry limit did not reduce the share of execution time lost to failures (36%, against 27% for a feasibility rule; not significant) and saved no robot time. The logs suggest why: failures showed no sign of clustering, so a retry right after a failure was as likely to succeed as any other attempt. The ledger also shows that most of the retry rule's extra human time came from cubes knocked out of reach rather than from the rule itself, and a cost-aware rule replayed on the logs recovers the sensible choice without a hand-set limit. We also report lessons from building the system, including a coverage effect in which concentrating demonstrations in a smaller workspace raised success there from 8/20 to 10/10.

## NVIDIA Expands Slurm to Bring Quantum Computing Into Supercomputing

DevFeed: [NVIDIA Expands Slurm to Bring Quantum Computing Into Supercomputing](<https://devfeed.tech/articles/nvidia-expands-slurm-to-bring-quantum-computing-into-supercomputing-136626.md>)

Original publisher: [Read original article](<https://blogs.nvidia.com/blog/slurm-quantum-computing-supercomputing/>)

Author: Sam Stanwyck

Published: 2026-11-16T16:00:47Z

Content type: release

Language: en

Sources: [NVIDIA](<https://devfeed.tech/sources/nvidia-blog.md>)

Topics: [Quantum Computing](<https://devfeed.tech/topics/quantum-computing.md>), [Supercomputing](<https://devfeed.tech/topics/supercomputing.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [GPU](<https://devfeed.tech/topics/gpu.md>)

Tags: [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [computing](<https://devfeed.tech/tags/computing.md>), [deployments](<https://devfeed.tech/tags/deployments.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [quantum-computing](<https://devfeed.tech/tags/quantum-computing.md>), [slurm](<https://devfeed.tech/tags/slurm.md>), [software](<https://devfeed.tech/tags/software.md>), [supercomputing](<https://devfeed.tech/tags/supercomputing.md>)

### AI overview

Slurm's expansion is intended to reduce the bespoke work required to connect quantum processors (QPUs) to supercomputing centers. QPU builders can configure a single hardware interface in a file and reuse integrations across deployments; centers can add processors to existing scheduling and resource-management workflows. The expansion supports QRMI and QDMI, is being adopted by Alice & Bob, IBM, IQM, Pasqal, Quantinuum and MQSC, and is planned for Slurm 26.11. The excerpt also describes CUDA-Q platform updates, including quantum error-correction prototyping, fault-tolerant primitives, reusable application components and pulse-shaping tools. These are presented as parts of NVIDIA's open quantum-GPU platform; the excerpt does not establish comparative performance across providers or tools.

### Source excerpt

Quantum processor deployments at supercomputing centers have grown nearly sevenfold over the past five years, with nearly 30 supercomputing centers around the world now in the process of deploying over 50 quantum processors. Many of these centers use Slurm to run scientific supercomputing workloads, so expanding its support for quantum processors builds on familiar workflows [...]

## SC26: IBM shows progress in bringing quantum & HPC together

DevFeed: [SC26: IBM shows progress in bringing quantum & HPC together](<https://devfeed.tech/articles/sc26-ibm-shows-progress-in-bringing-quantum-hpc-together-136374.md>)

Original publisher: [Read original article](<https://research.ibm.com/blog/sc26>)

Author: Rafi Letzter

Published: 2026-11-16T16:00:00Z

Content type: news

Language: en

Sources: [IBM Research](<https://devfeed.tech/sources/ibm-research.md>)

Topics: [Quantum Computing](<https://devfeed.tech/topics/quantum-computing.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Supercomputing](<https://devfeed.tech/topics/supercomputing.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [ibm](<https://devfeed.tech/topics/ibm.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [accelerators](<https://devfeed.tech/tags/accelerators.md>), [amd](<https://devfeed.tech/tags/amd.md>), [co-design](<https://devfeed.tech/tags/co-design.md>), [conference](<https://devfeed.tech/tags/conference.md>), [decoder](<https://devfeed.tech/tags/decoder.md>), [error-correction](<https://devfeed.tech/tags/error-correction.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [ibm](<https://devfeed.tech/tags/ibm.md>), [news](<https://devfeed.tech/tags/news.md>), [partners](<https://devfeed.tech/tags/partners.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [quantum-error-correction-mitigation](<https://devfeed.tech/tags/quantum-error-correction-mitigation.md>), [quantum-systems](<https://devfeed.tech/tags/quantum-systems.md>), [sc26](<https://devfeed.tech/tags/sc26.md>), [tools](<https://devfeed.tech/tags/tools.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

IBM and partners are integrating quantum processors into established HPC workflows through scheduler tools, hybrid computing platforms, and reusable managed workflows. QRMI lets Slurm jobs request a QPU alongside CPUs and GPUs, while IBM and NVIDIA are integrating it with Slurm HRES. In research, an SQD calculation of an iron-sulfur cluster on RIKEN's ROQUO supercomputer came within 4.3 millihartree of DMRG, 79x closer than the team's earlier result; a separate quantum-HPC workflow simulated protein-ligand complexes up to 12,635 atoms. For error-correction research, IBM and AMD's open-source Pelagos uses Triton on AMD and NVIDIA GPUs to simulate decoder tests, running up to 97x faster than a single CPU core and scaling across multiple GPUs. IBM also describes managed quantum-classical workflows and options ranging from a free Open Plan to paid credits, Flex Plan access, or dedicated on-premises systems. The excerpt reports a planned IBM-NVIDIA-Fermilab co-design platform and does not provide its launch date.

### Source excerpt

At SC26 in Chicago, IBM and partners show how quantum computers are integrating into workflows and tools that the supercomputing workforce already runs.

## How Mitts Makes Parallel Rust Builds Faster Than Cargo

DevFeed: [How Mitts Makes Parallel Rust Builds Faster Than Cargo](<https://devfeed.tech/articles/how-mitts-makes-parallel-rust-builds-faster-than-cargo-135516.md>)

Original publisher: [Read original article](<https://hackernoon.com/how-mitts-makes-parallel-rust-builds-faster-than-cargo?source=rss>)

Author: Alexander Panasenko

Published: 2026-11-16T05:00:02Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [builds](<https://devfeed.tech/topics/builds.md>), [developer-productivity](<https://devfeed.tech/topics/developer-productivity.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [build-systems](<https://devfeed.tech/tags/build-systems.md>), [builds](<https://devfeed.tech/tags/builds.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [cargo-alternatives](<https://devfeed.tech/tags/cargo-alternatives.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [content-addressed-caching](<https://devfeed.tech/tags/content-addressed-caching.md>), [distributed-build-caching](<https://devfeed.tech/tags/distributed-build-caching.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-build-isolation](<https://devfeed.tech/tags/rust-build-isolation.md>), [rust-worktrees](<https://devfeed.tech/tags/rust-worktrees.md>), [rustls](<https://devfeed.tech/tags/rustls.md>), [worktrees](<https://devfeed.tech/tags/worktrees.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

In a study of twelve `rustls` worktrees on Linux x86_64, Mitts completed the batch in 9.3 seconds, compared with 3 min 42 s for plain Cargo and 3 min 59 s for warm sccache; shared-cache priming was excluded. Mitts reuses eligible completed compilation results across separate worktrees using action keys based on tracked inputs, while keeping each workspace's outputs separate. The reported gains vary by workload: Cargo often wins a single cold build and can be faster for edits within a large crate, where incremental compilation helps. A shared `CARGO_TARGET_DIR` failed a correctness check involving a deliberately failing test. Mitts is pre-release, supports Linux and macOS, and does not yet support Windows, cross-compilation beyond the host target, or remote/team caches. The excerpt reports three-repeat medians and cautions that build-script staging is not an OS sandbox.

### Source excerpt

12 rustls worktrees on Linux x86_64: Cargo 3 min 42 s, Mitts 9.3 s. How shared caches reuse build work, and where Cargo still wins.

## Inferring Sensitive Events in Multi-Mode Cyber-Physical Systems via Scheduling Side Channels

DevFeed: [Inferring Sensitive Events in Multi-Mode Cyber-Physical Systems via Scheduling Side Channels](<https://devfeed.tech/articles/inferring-sensitive-events-in-multi-mode-cyber-physical-systems-via-scheduling-side-channels-136036.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17761>)

Author: Yifan Cai, Linh Thi Xuan Phan

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [cyber resiliency](<https://devfeed.tech/topics/cyber-resiliency.md>), [Robotics](<https://devfeed.tech/topics/robotics.md>), [Embedded Systems](<https://devfeed.tech/topics/embedded-systems.md>)

Tags: [attack](<https://devfeed.tech/tags/attack.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [cyber-physical-systems](<https://devfeed.tech/tags/cyber-physical-systems.md>), [defense](<https://devfeed.tech/tags/defense.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [events](<https://devfeed.tech/tags/events.md>), [multi-mode](<https://devfeed.tech/tags/multi-mode.md>), [route](<https://devfeed.tech/tags/route.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [security](<https://devfeed.tech/tags/security.md>), [side-channels](<https://devfeed.tech/tags/side-channels.md>), [timing](<https://devfeed.tech/tags/timing.md>)

### AI overview

Mode changes in multi-mode cyber-physical systems can leak physical events through scheduling interference: an unprivileged co-resident observer uses its own execution timing and, on multicore platforms, core assignment to infer the active mode. The proposed STAMP attack requires no task parameters or scheduling-policy knowledge and works whether modes are exposed. In the reported evaluations, it identified ZoneMinder modes with 94.7% accuracy on unseen hardware using under 0.5% of one core, and classified seven Oxford RobotCar route segments with 86.0% accuracy on unseen platforms using ROS 2 AMCL. Schedule randomization reduced detection recall to 0.53 while only 53.9% as many jobs finished on time; at noise ε=10, on-time completion fell to 14.4% and new leakage appeared in 14.1% of tasksets. These results describe the abstract's evaluations, not full-paper coverage.

### Source excerpt

arXiv:2611.17761v1 Announce Type: new Abstract: Many cyber-physical systems (CPS) are multi-mode: they switch between operating modes with different tasksets and timing parameters in response to physical events or user activity. We show that these mode changes create a timing side channel: by altering the interference experienced by co-running tasks, they let an unprivileged co-resident observer infer sensitive events, such as a homeowner's arrival or a vehicle's route, from its own execution timing and, on multicore platforms, its core assignment. Existing schedule-based attacks and defenses miss this channel because they assume single-mode systems or target a specific, known victim task. We present STAMP, a lightweight attack that needs no knowledge of task parameters or scheduling policy, and works whether or not the system exposes its modes. On a ZoneMinder home-security deployment, STAMP identifies the modes with 94.7% accuracy on unseen hardware, using under 0.5% of one core. On ROS 2 AMCL with the Oxford RobotCar dataset, it identifies which of seven route segments a vehicle traversed with 86.0% accuracy on unseen platforms. A schedule-randomization defense lowers detection recall to 0.53, at which setting only 53.9% as many jobs finish on time. At higher noise ($\epsilon=10$), on-time job completion reduces to 14.4%, while introducing new leakage in 14.1% of the tasksets.

[Next page](<https://devfeed.tech/topics/scheduling.md?cursor=WyIyMDI2LTExLTE2VDA1OjAwOjAwKzAwOjAwIiwgImM1YzNhYTI1LTRhZTQtNGU2OS1hZjk0LTRhZjBlZmM0NjM2NiJd>)