arXane › Computer Science › Computer Science
Wednesday, 4 November 2026: 4 new papers, 4 cross-lists and 3 replacements in Performance (cs.PF), in arXiv's order, with full abstracts. The same papers as arXiv's own listing, set as a newspaper; every title links to arXiv.
A solid-state drive cannot overwrite data in place, so it cleans full blocks by copying out still-valid data, costing speed and lifetime. Interfaces such as NVMe Flexible Data Placement (FDP) let the host label data by expected lifetime so data dying together is stored together, and published schemes report cutting these copies by 20--75%. Those studies rarely state which blocks the drive chooses to clean. Varying only this choice in simulation, we show it decides how much a label is worth: label value peaks when the drive searches moderately for blocks holding little valid data, falls when it always takes the block with the least, and turns negative when it ignores how much valid data blocks hold. This holds in 47 of 48 synthetic configurations, and one real mail-server trace shows the same shape at about half the magnitude. Priced as spare capacity, a two-class label is worth 65% more spare when each scheme runs at its best setting, but becomes a net loss at 20% label error, typical of learned classifiers. Labels stating which data die together keep most of their value at 16 FDP handles and gain as cleaning improves. Evaluations must report the drive's cleaning policy.
LLM agents are becoming GPU kernel engineers, but they still tune kernels without seeing where the time goes. Hardware profilers report how busy each unit was, not where each warp's time went; intra-kernel tracers can show it, but only with hand-placed probes and a recompilation that alters the very kernel being measured. We present Warpline, which gives agents this view automatically while leaving the kernel essentially unchanged. Warpline analyzes the binary to decide which events to record and inserts probes into the binary itself without recompilation or any manual step. It then aligns the trace with hardware profiling data on one unified timeline. Because it needs only the binary, it can regenerate this evidence for every new version of the kernel at whatever level the agent edits it (source, IR, or PTX), closing the optimization loop without human intervention. On NVIDIA B200, across 35 kernels in Triton, CuTe DSL, and CUDA C++, Warpline adds a median overhead of 1.2% and leaves a median 99.9% of executed instructions unchanged, whereas existing tracers have median overheads of 1.6% to 13.2% and leave only 4.6% to 32.7% unchanged. Warpline also traces closed-source kernels, which these tracers cannot. On 10 SOL-ExecBench problems, agents using Warpline spend less time and fewer model requests than a bare coding agent and NVIDIA's Kernel Design Agents (KDA), yet lead both after every round in geometric mean and reach a 7.69$\times$ geometric-mean speedup, against 6.94$\times$ and 6.13$\times$. Two case studies further demonstrate that Warpline reveals hidden bottlenecks and provides actionable optimization insights.
A 6G service crosses a chain of stages from different vendors, and its contract binds class-conditioned guarantees at the terminal interface: in the packet relay chain studied here, a priority class is owed a timely-delivery rate and a loss ceiling. We define trustworthiness as conformance of the delivered per-class distribution of outcomes to the contract and develop the measurement structure this forces. Two results fix its form: a discrepancy that treats outcomes interchangeably cannot express contract preferences, and no single expectation-valued score that determines the contracted terminal expectations can be carried from stage to stage once two or more contracted indicators remain independent at some stage. The minimal record is one signed number per independent contracted indicator, which the downstream design data carry to the terminal exactly; classical scalar trust models are the single-indicator case. The terminal deviation splits exactly into per-stage contributions. Transition logs at a stage estimate its contribution without reconstructing its full deployed behavior, a stage at its design behavior is flagged at most at a declared rate whatever traffic it receives, and the estimates bracket each stage's share of the terminal deviation at explicit confidence. In the three-relay chain, a relay that either deprioritizes premium traffic or has degraded capacity violates the same clause with identical contracted evidence: the transition audit localizes the relay in 300 of 300 windows and brackets its share of the deviation, and a diagnostic separates the causes.
This work proposes, implements, and evaluates a modular architecture based on software design patterns applied to latency measurement in Software-Defined Networks (SDN) using the Extended Berkeley Packet Filter (eBPF) and the Express Data Path (XDP). Unlike approaches that focus solely on measurement precision, this study examines how design patterns can structure observability systems in an extensible and maintainable way while preserving data-plane efficiency. The proposed architecture applies the Observer, Strategy, and Factory Method patterns to modularize the metric collection and analysis pipeline, allowing dynamic integration of policies and data sinks. The experimental environment was implemented with Mininet, Python agents, and eBPF/XDP programs, and was evaluated in terms of processing time, overhead, and evolution effort. The results show that the introduction of design patterns shows no clear evidence of measurable performance degradation, maintaining continuous measurements with a minimum of 5% overhead. The findings suggest that software engineering practices may be applied to the construction of eBPF-based monitoring and observability systems.
Two-tier LLM serving escalates selected requests from a small model to a large one, but prompt-based routers cannot see whether retrieved evidence supports an answer, and they treat the GPU cost of an escalation as constant. We study TRIAGE, which conditions escalation on a post-generation reliability state and on a load-dependent GPU price, and we report both what held and what did not on one A40 serving Qwen2.5-7B and 32B (AWQ) under VLLM. Escalation cost rose 21.9x from 1 to 10 requests/s but showed no monotone dependence on KV-cache headroom, and a pre-registered claim that the reliability state detects corrupted evidence (AUROC>=0.70) was falsified at 0.571, although any prompt-only router scores exactly 0.500 by construction. Post hoc, a semantic evidence judge raised detection to 0.846 (0.926 on never-served items) and predicted wrong small-model answers at AUROC 0.90-0.96 on RGB and three RouterBench model pairs; the resulting cascade stayed within about 3 pp of GPT-4 at 79.5% lower API cost for GPT-3.5->GPT-4, yet fell below random routing for open-model pairs with 2-3x price ratios. End to end, the 7B->32B pair showed only a +2.88 pp held-out gap, so the allocator rightly declined to escalate and the headline is a null that a small pre-launch gate failed to expose.
The Ethereum ecosystem offers the most widespread support for Decentralised Applications (DApps), with over 120 networks currently documented as using variants of the Ethereum Virtual Machine (EVM) for core execution logic. The ERC-4337 standard provides convenient access to DApps for users who do not possess the required cryptocurrency or prefer flexible authorisation of DApp actions. The infrastructure for ERC-4337 implementation can be deployed on any EVM network. However, to aggregate user requests and submit them to the EVM network, ERC-4337 requires operating a bundler, an additional component. Recently, the potential use of ERC-4337 was boosted by another standard, EIP-7702, which can enable ERC-4337 utility for any existing user account. However, the use of the combined EIP-7702/ERC-4337 pattern remains considerably low at less than 6% of EIP-7702 activity. We believe that this underutilisation is at least partly caused by the low number of existing bundling services and their popularity, currently fewer than 15 publicly documented. Expanding the number of bundler nodes would benefit the ecosystem but would introduce operational costs, part of which is represented by the added nodes' power consumption. In this paper, we provide a thorough view of the bundling power consumption aspect using server-grade infrastructure, evaluating both CPU and RAM consumption, as well as the overhead of container-based deployments specific to production environments.
Under expert parallelism, mixture-of-experts (MoE) layers pay all-to-all token dispatch, grouped GEMMs, and a combine step in every layer. In decode each rank holds only 1-256 tokens: dispatch latency and weight traffic dominate while tensor-core utilization is inherently low. In fused operators such as DeepGEMM's Mega MoE, dispatch and computation overlap only by sharing every SM: dispatch warps compete with TMA/MMA and epilogue warps for registers, shared memory, and issue slots; every phase shares one CTA resource budget, synchronization spans the whole SM array, and every replay ends with a workspace-clean pass and a cross-rank barrier. We present GC-MoE, an open-source FP8/FP4 MoE inference operator for NVIDIA Hopper and Blackwell GPUs that uses CUDA Green Contexts to split the device into a small communication partition and a large compute partition. Each role gets its own kernel, resource budget, and synchronization domain, so dispatch and GEMM tune independently. A three-node CUDA Graph (four on Hopper with fused shared experts) launches the dispatch and grouped-GEMM kernels as concurrent roots; a token-ring handshake starts computation on the first filled ring blocks, and double-buffered receive counters remove the trailing cross-rank barrier between replays. The compute partition runs operand-swapped tcgen05 block-scaled MMA on Blackwell and register-A WGMMA with in-register FP4 decoding on Hopper, with fused SwiGLU, requantization, and optional shared experts. On 8 H20 GPUs GC-MoE accelerates DeepSeek-V4.1-Flash decode by 1.188x on average on both the routed and shared-expert suites (peaks 1.296x and 1.353x); on 8 B300 GPUs it accelerates GLM-5.2 and DeepSeek-V4.1-Flash by 1.106x (1.123x with fused shared experts, peak 1.209x), beating Mega MoE at all 54 measured points at matched accuracy. GC-MoE reserves only 20 of 148 SMs on B300 for dispatch.
Serverless computing is a popular approach to application deployment without having to manage the underlying infrastructure. Its most common implementation is Function-as-a-Service (FaaS), in which applications are structured as fine-grained functions. FaaS providers face non-trivial tasks in the management of their platforms, including cold starts, auto-scaling, and scheduling. The design of optimized platforms requires an accurate understanding of realistic serverless workloads. However, existing research and platforms rely on insights from single, often outdated datasets. In this work, we conduct a large-scale, cross-platform comparative analysis of eight publicly available FaaS workload traces from major cloud providers (Alibaba, Azure, Huawei, IBM) and a scientific computing platform (Globus). We provide a comprehensive and up-to-date view of the serverless ecosystem by characterizing key dimensions such as invocation patterns, latency, cold start behavior, and resource utilization. Our analysis shows that although invocation patterns remain universal, execution times have shortened, shifting the performance bottleneck toward platform scheduling and dependency management. We also observe an architectural shift toward "Serverless 2.0" models, where concurrent, long-lived containers are increasingly utilized to bypass cold start penalties. Furthermore, we found resource over-provisioning and extreme skew in user request volumes. These findings provide actionable insights for designing more efficient FaaS platforms, informing improved approaches to targeted cold start mitigation, predictive resource management, and dependency-aware scheduling.