Distributed protocols such as Paxos are fundamental to achieving high reliability and strong consistency in modern distributed systems. However, widely deployed implementations suffer from substantial data-path overhead, especially when built on the standard kernel networking stack. Programmable Data-Path Accelerators (DPAs) in modern DPUs offer new opportunities to accelerate data-path processing for distributed protocols, but effectively offloading such processing remains challenging due to hardware constraints and software complexity. We present Chariot, a set of DPA-based optimizations for distributed protocols. First, Chariot introduces a DPA-based broadcast mechanism that encapsulates data-path complexity behind simple APIs and offloads message transmission to the DPA, exploiting parallel execution to accelerate broadcasting. Second, Chariot provides a DPA-based quorum confirmation mechanism that selectively intercepts acknowledgment packets and performs quorum confirmation on the DPA, reducing hostside processing overhead. Our evaluation shows that Chariot improves the throughput of a classic Multi-Paxos replication protocol by up to $2.2 \times$. Index Terms-Data-Path Accelerator, Distributed Protocols
Delivering high-quality live video to millions of users is challenging, and performance can be impacted by a wide range of components in the ecosystem (e.g., CDNs, ISPs, protocols) as well as how these components interact with each other. In this paper, our primary contribution is Beagle, a novel system for root-causing performance anomalies in the video streaming context. As part of Beagle, we developed custom interpretable ML models based on mechanisms used by domain experts (e.g., filters based on rules and a graph relating those rules). Leveraging pre-training and few-shot learning, Beagle supports automatic learning and adaptation of rule thresholds and graph relationships from limited ground truth information. Evaluations with real-world dataset of live streaming sessions from a popular streaming service show (i) Beagle significantly outperforms alternatives including Gradient Boosted Decision Trees, and a Deep Neural Network approach; and (ii) Beagle is effective in auto-tuning production expert designed system for root cause identification. Even with less than ten root causes to learn from, Beagle reduces the Mistake Rate made by expert configured rules by nearly an order of magnitude.
Early anomaly detection in networked sensing is crucial for maintaining the Quality of Service (QoS), especially under strict False Positive Rate (FPR) budgets where alarms must be early and reliable. Existing methods typically learn normal spatiotemporal patterns from multi-node sensing streams and raise alarms using reconstruction deviations in a one-class manner. However, in real freeway monitoring, anomalies exhibit complex spatiotemporal propagation and the early anomaly signals are sparse. Meanwhile, traffic streams contain diverse normal fluctuations that may look abnormal, making them hard to distinguish from real incidents. Together, these factors make anomaly propagation hard to capture under strict low-FPR earlywarning settings. To address these challenges, we propose SE-STGAE, a shapelet-enhanced spatiotemporal graph autoencoder. It first uses shapelets to extract localized segment-level precursors, then integrates temporal precursors with propagationaware spatial dependencies to improve robustness to normal fluctuations, and finally applies a tail-emphasized Top-K scoring rule with pure-normal calibration for reliable early alarming. Extensive experiments on real-world freeway datasets show consistent gains over state-of-the-art baselines across datasets and FPR budgets, delivering earlier detection with localized evidence.
Network research often relies on high fidelity emulation, but constructing greenfield environments still requires substantial manual effort. LLM agents face a gap between intent and implementation: long contexts, weak validation, and uniform model use make it difficult to translate intent into working emulator state. We present Nice, a closed-loop multi-agent framework that constructs greenfield emulations from natural language intents. Nice combines a hierarchical supervisor and worker architecture with context isolation, closed-loop verification for state grounding and self-healing, dual-layer experience memory, and adaptive LLM routing. On a 30-task benchmark, Nice increases success rate from 3.3% to 90.0%, reduces average model cost from ${\$}$0.045 to ${\$}$0.034 per task relative to the variant without routing, and improves first pass rate from 46.7% to 76.7%.
Large language model (LLM) inference is increasingly deployed in heterogeneous environments, demanding efficient serving across diverse hardware platforms and backend engines. While existing load balancers and specialized serving systems facilitate request routing, they still suffer from various limitations, manifested in metric misalignment and observability gaps of black-box backends, non-linear performance degradation under heterogeneity, and conflicting multi-objective optimization goals. To solve these problems, we propose UPServe, a backendagnostic proxy designed for stateless LLM serving, which features three key designs: (1) a phase-aware cost modeling to estimate inference costs without relying on engine internals, (2) a unified score-based scheduling mechanism that integrates phase-aware concurrency and hardware speed normalization to handle heterogeneous non-linear degradation, and (3) an online scheduling algorithm named Phase-Aware Weighted Least Connections (PA-WLC) that drives adaptive dispatching to balance tail latency and aggregate throughput. Finally, we implement UPServe as a transparent proxy and conduct experiments for evaluations in heterogeneous environments. Comparison results demonstrate that UPServe significantly outperforms existing baselines, which reduces tail latency by up to 2.6$\times$ (P99 TTFT) and 2.1$\times$ (P99 TPOT), and improves aggregate throughput by up to 16%. Besides, UPServe operates without modifying inference engine internals, and incurs a negligible scheduling overhead of less than 0.3 ms per request.
In mobile crowdsensing (MCS), participants often drop out, requiring their unfinished tasks to be migrated to othersa process known as task migration. However, existing work rarely addresses how to properly handle the residual data from exiting participants, leading to low data utilization and degraded quality, which harms MCS Quality of Service (QoS). To tackle this, we propose H2I, a data inheritance method based on handover-state encoding. H2I first introduces a hierarchical data quality assessment framework: a point-level layer uses taskembedded multi-head attention to estimate collection quality for each record, while a grid-level layer employs an Attention U-Net to assess credibility using spatial context. These scores jointly guide data correction. We find that quality assessment alone cannot distinguish natural variations caused by task migration from true anomalies, often causing over-smoothing. To solve this, H2I incorporates handover-state encoding, which models the spatiotemporal proximity and historical observation states of the exiting participant and the successor. A gated fusion mechanism then uses this encoding to control the direction and scale of correction. Extensive simulations show that H2I outperforms existing methods in MAE, $\mathbf{R}^{\mathbf{2}}$, and other metrics, significantly improving data quality during task migration.
Deploying Large Language Models (LLMs) at the extreme edge is hindered by severe resource constraints. While serverless computing offers scale-to-zero efficiency, existing request-level frameworks cannot accommodate the stateful, compute-intensive nature of LLMs. Achieving true elasticity requires Token-Level Statelessness, currently bottlenecked by static model redundancy, rigid GPU allocation, and high statemigration I/O overhead. We propose StarkServe, a serverless inference system that co-designs hardware-aware algorithms with system-level scheduling. StarkServe employs an adaptive skipping mechanism to dynamically prune redundant sublayers at runtime, a multi-tenant GPU runtime enabling fine-grained spatial multiplexing, and an elastic state dispatcher that orchestrates anticipatory KV cache movement to overlap I/O with computation. Experimental results demonstrate that StarkServe significantly reduces end-to-end latency and memory footprint compared to state-of-the-art serverless baselines while preserving generation quality.
Sketches can achieve resource-efficient and highaccurate network measurement (NM) with configurable resourceperformance trade-offs. Due to network dynamics, network measurement points (i.e., the switches deployed with sketches) need to reallocate dynamically to cover full traffic. However, using existing approaches to migrate sketches leads to unacceptable latency and resource overhead. In this paper, we propose PSM, a framework for timely and resource-efficient sketch migration. For timeliness, PSM utilizes a protocol that is able to access sketch counters and migrate them in parallel using background traffic. To ensure migration without direct traffic, we leverage programmable switches’ mirroring and recirculation functions to generate packets. For resource efficiency, PSM uses bitmap structures and hardware-friendly computations to track the migration progress and verify integrity. We implement PSM on Intel Tofino2 switches and compare PSM with three state-of-theart approaches through extensive experiments. Results indicate that PSM achieves timely and resource-efficient sketch migration.
With the growing demand for data privacy, secure multi-party computation (MPC) has been widely adopted across various applications. However, existing frameworks incur substantial communication overhead due to their inherently multi-round interactions and remain vulnerable to man-in-the-middle (MitM) attacks. To address these limitations, this paper introduces DP-MPC, a framework that offloads MPC to the programmable data plane with low-overhead communication and lightweight security verification. Specifically, (1) we design a DP-MPC protocol that transforms multi-round MPC interactions into a single round of in-network aggregation, drastically reducing communication overhead; (2) we implement line-rate execution of three fundamental MPC operation types and maintain per-session state directly within the data plane pipeline, achieving high-performance MPC offloading; (3) we integrate a lightweight hash-based verification mechanism to proactively defend against MitM attacks. Experimental results demonstrate that DP-MPC reduces communication overhead by two orders of magnitude, achieves microsecond level end-to-end latency, and effectively mitigates MitM attacks.
Emulating high-mobility networks presents a fundamental trade-off between fidelity and flexibility. While existing software methods prioritizing flexibility lack performance fidelity, hardware-based approaches conversely suffer from limited flexibility. In this paper, we propose ReMu, which achieves scalable network emulation by interconnecting software nodes via dynamic links with an architecture of offloading data plane emulation to an FPGA NIC. ReMu utilizes match-action tables to dynamically assign link models and parameters to each packet, and schedules these packets using multi-level calendar queues for precise link emulation. Experimental results on Xilinx UltraScale U250 FPGA demonstrate that ReMu achieves delay control with standard deviation below $4.5 \mu \mathrm{~s}$, loss rate error around 0.35%, and complete flow isolation even with $1 \mu \mathbf{s}$ delay differences. Furthermore, ReMu reduces link model system calls by up to $6 \times$ compared to software emulators while supporting dynamic link reconfiguration during emulation.
The proliferation of short-video platforms has catalyzed the demand for interactive Video Question Answering (Video QA), where users seek immediate, context-aware answers during playback. While Video Large Language Models (Video LLMs) enable such interactivity, deploying them presents a fundamental resource dichotomy: cloud-based execution suffers from high latency and operational costs, whereas end-side resources are insufficient for heavy reasoning. Existing computation offloading schemes, typically driven by data size or bandwidth, fail to address the semantic heterogeneity of QA tasks, leading to suboptimal Quality of Experience (QoE). To bridge this gap, we propose IntentVQA, a cloud-end collaborative system that decouples reasoning capability from interaction latency. Unlike rigid offloading, IntentVQA introduces a semantic-aware hybrid execution framework. It dynamically orchestrates queries based on intent complexity-dispatching open-ended reasoning to the cloud while processing factual atomic tasks on the end side. To enable precise yet lightweight dispatching, we design a Semantic Router, which fuses textual embeddings with video profiles to predict the QoE utility of execution paths without heavy inference overhead. Furthermore, to resolve the semantic gap between flexible user queries and rigid end-side operators, we develop a Bidirectional Alignment Adapter. This module translates natural language into executable inputs and reconstructs raw outputs into conversational responses via a distillation-based generator. Extensive experiments demonstrate that IntentVQA significantly reduces interaction latency while maintaining high response accuracy, validating its effectiveness in optimizing QoE for interactive video streaming.
Sketch-based measurement has become a fundamental primitive for monitoring network traffic and supporting performance-critical data center applications. However, existing approaches for deploying sketches on DPUs either underutilize DPU hardware capabilities or suffer from degraded accuracy due to limited Arm-side processing capacity and multi-core contention. In particular, most designs directly port host-side sketch implementations to the DPU Arm subsystem, introducing excessive forwarding overhead and hardware pressure. In this paper, we present Duet, an efficient and accurate sketch-based measurement on DPUs. Duet adopts a layered measurement architecture that dynamically schedules flows between Arm-based sketches and the DPU hardware forwarding pipeline according to traffic characteristics. Heavy flows are offloaded to hardware tables to leverage line-rate processing and relieve Arm-side contention, while light flows are retained in software sketches to avoid excessive hardware table updates. To further address crosslayer aggregation and multi-core concurrency challenges, Duet incorporates a zeroing mechanism and lock-free optimizations to ensure measurement consistency and accuracy. We implement Duet on an NVIDIA BlueField-2 DPU and conduct extensive experiments on a real testbed. Experimental results demonstrate that, compared with traditional sketch-based measurement approaches, Duet improves throughput by a factor of approximately $7.1 \times$, packet rate by a factor of approximately $28.9 \times$, and measurement accuracy by approximately 50.1%.
Deploying large DNNs on edge devices is severely hindered by strict hardware constraints. Multi-device collaborative inference mitigates this bottleneck. However, existing frameworks struggle in heterogeneous edge environments. They rely on inaccurate theoretical metrics and ignore memory bottlenecks, causing out-of-memory failures. Furthermore, they isolate model partitioning from hardware configurations like dynamic frequency scaling. This isolation yields suboptimal latency and energy trade-offs. To address these challenges, we propose CoInfer, a collaborative edge inference framework, which jointly optimizes model partitioning, device allocation, and frequency scaling. To model hardware heterogeneity, CoInfer introduces a lightweight predictor. This predictor fuses neural network attributes with microarchitectural features to accurately estimate inference latency. Guided by these profiles, a two-level scheduler orchestrates task execution. The upper tier explores the global frequency space. Concurrently, the lower tier executes a memory-constrained hierarchical graph search to identify optimal routing paths. For fault tolerance, CoInfer integrates an adaptive backtracking mechanism to rapidly recover from unexpected node failures. Experiments on a 20 -node cluster show CoInfer reduces scheduling overhead by 42%, and saves up to 46.4% of inference time when device fails unexpectedly. Code is available at the GitHub repository.
Modern cloud data center networks (DCNs) often span tens of thousands of switches, challenging configuration verification, even for the state-of-the-art simulation-based configuration verification tools. While prior work has accelerated individual stages of the verification pipeline, these fragmented optimizations fall short of addressing the end-to-end scalability bottlenecks inherent in hyper-scale networks. To address this, we present sNetVeri, a scalable simulation-based configuration verifier for hyper-scale DCNs, built on the key insight that networks are often highly structured and compressible. Unlike prior compression methods tied to specific destinations, sNetVeri introduces a destination-independent one-shot compression strategy with formal correctness guarantees. sNetVeri further improves scalability through two designs: (1) a Dijkstra-based BGP simulation algorithm augmented with a withdrawal mechanism to support both monotonic and non-monotonic configurations, and (2) a highly parallel data-plane verification framework that operates directly on the shared compressed topology. Extensive evaluations on both production DCNs from Huawei Cloud and synthetic topologies demonstrate that sNetVeri scales efficiently to networks with over 10,000 switches while maintaining accuracy in controlplane simulation and data-plane verification.
Root Cause Analysis (RCA) is pivotal for ensuring the reliability of microservice systems. Traditional RCA approaches are often limited by the scarcity of labeled data and insufficient interpretability. Recently, Large Language Model (LLM)-based agents have emerged as a promising direction for automated RCA, thanks to their broad knowledge, strong reasoning, and orchestration capabilities. However, the absence of diverse labeled datasets, standardized tools, and systematic assessment of agent patterns hinders the rigorous evaluation of RCA agents. To address these issues, we propose RCAgentBench, the first agent-oriented benchmark tailored for microservice RCA. First, we construct a multimodal RCA dataset, covering metrics, logs, and traces, and manually annotate each case with reasoning keywords to enable comprehensive evaluation of agent performance. Second, we introduce standardized tools and agent patterns to support reproducible evaluation and decouple tool capabilities from agent reasoning power. Finally, we explore different experimental settings across a diverse spectrum of LLMs, spanning from small-scale open-source models to frontier closed-source models, and provide actionable insights for the future design of RCA agents. All evaluation framework code has been made publicly available at: https://github.com/CSTCloudOps/RCAgentBench.
The vast IPv6 address space renders exhaustive scanning computationally infeasible. We present DeepScan6, a hybrid discovery framework integrating three components: ensemble-based seed preprocessing, a novel Context Expansion (CEX) mechanism, and a tolerance-based incremental learning module. CEX performs prefix-by-prefix IID sequence analysis within individual /64 prefixes and generates candidates through prioritized interpolation and extrapolation. The incremental learning module selectively incorporates newly discovered addresses via lightweight iterative updates, enabling self-improvement across rounds without full retraining. DeepScan6 achieves a 75-77% hit rate on heterogeneous seed sets, outperforming nine baseline methods by 22.1-72.1%. Deployed at scale, it yields 10,139,214 new active addresses beyond the IPv6Hitlist across 1,232 ASes in 92 countries. Measurement reveals severe address concentration (top-3 ASes: 49.89%), extreme subnet sparsity (86.8% of /64 subnets contain one address), 20.87% high-risk IID patterns, and 42.01% of HTTPS-responsive addresses simultaneously exposing HTTP.
LLM-driven agent workflows increasingly invoke tools that trigger side effects in external systems. When these workflows encounter timeouts or crash mid-execution, the outcome can become uncertain. Naive retries may duplicate actions, while partial effects can leave residual state that complicates incident diagnosis and repair. We observe that current agent stacks lack an explicit, replayable boundary between LLM reasoning and tool execution. This makes postmortem analysis either unsafe by re-executing effects or low-fidelity by losing execution context. We present DelAct, a tri-plane orchestration runtime that introduces a replayable boundary decoupling deliberation from actuation. DelAct comprises three cooperating planes: a control plane that maintains session state and orchestrates next steps without performing side effects; a data plane that routes all tool invocations through commitment-hash governance, binding each intent to a stable identifier for idempotent execution, in-doubt verification, and compensation rollback; and an observability plane that persists an append-only event log enabling deterministic replay and replay-to-live forking with lineage tracking. We evaluate DelAct on a Ticket/Invoice workflow under injected timeout and partial-failure faults. The results demonstrate that full governance eliminates timeout-induced duplicate writes and removes residual writes after failures (with duplicate/residual statistics aggregated over the E1 fault-injection runs), achieving a 66.5 ms mean rollback MTTR (Mean Time to Repair), while incurring predictable tail-latency overhead due to durable logging and governance checks.
Sketch-based measurement is fundamental for real-time network monitoring, but performing efficient, high-fidelity compression for distributed sketch aggregation remains a critical bottleneck. Current methods present a severe trade-off: grouping-based techniques (e.g., Elastic, Hokusai) are fast but incur unbounded errors, while clustering-based approaches improve accuracy at the cost of prohibitive latency, making neither suitable for real-time control loops. This paper introduces LightRanger (LR), a lightweight compression mechanism designed to break the above trade-off. LightRanger is built on two key designs: (1) real-time value-range grouping, which dynamically sets grouping intervals using observed global extrema to enable low-distortion, uniform bucket mapping; and (2) adaptive bitmap pruning, which strategically reduces transmission overhead under strict bandwidth limits while preserving essential statistical structure. Evaluated across real-world traces (i.e., CAIDA, MAWI, Zipf, and Webdocs) and standard sketches including Count-Min (CM) Sketch, Count-Mean-Min (CMM) Sketch, Conversation-Update (CU) Sketch, and CSM Sketch, LightRanger reduces average relative error by up to $8.92 \times$ over Elastic and $38.59 \times$ over Hokusai, while running $37.23 \times$ faster than clustering-based methods. By decoupling accuracy from latency, LR makes high-fidelity, real-time sketch aggregation practical for bandwidth-constrained distributed monitoring.
Serverless computing has emerged as a dominant cloud paradigm that enhances development efficiency and reduces operational costs. Serialization and deserialization are key operations in these systems. However, these processes may contribute up to 98% of the total latency, making the host compute-bound. Recent serialization-free approaches, such as RMMap, eliminate serialization overhead by directly mapping memory between functions in distributed serverless systems. Nevertheless, transferring raw memory produces large payloads and imposes significant network demands, rendering the process bandwidth-bound. To address these challenges, we propose HyperLink, a networkassisted system that unifies the benefits of both compute-bound and bandwidth-bound approaches. HyperLink offloads intensive serialization tasks (e.g., data compression) to programmable switches, while the host employs a lightweight memory mapping mechanism. It features a parallel striped storage module for efficient compression dictionary management, a latency-aware adaptive encoder that balances compression delays with compression ratios, and a dependency-gated parallel decoder that decouples packet-level decoding into block-level processing to enhance throughput. Experimental results show that HyperLink reduces latency by up to $\mathbf{6 8. 1 2 \%}$ and achieves $\mathbf{8. 2 5} \times$ throughput compared to state-of-the-art solutions.
