Searcharxiv⌕ Search
Home/Archive/arXiv

arXiv · 2611.04454

Trustworthiness as a Measurement Structure for Task Conformance in 6G Service Chains

Bin Han·Xintong Ling·Muxia Sun·Hans D. Schotten
View original source ↗Read source document ↗Export metadata ↓

Abstract

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.

Explore related subjects

cs.PF

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Bin Han, Xintong Ling, Muxia Sun, Hans D. Schotten. 2026-11-03. Trustworthiness as a Measurement Structure for Task Conformance in 6G Service Chains. https://arxiv.org/abs/2611.04454

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

arXiv2026

The Unreported Variable:Collector Selectivity in Data Placement Evaluation

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.

cs.PF↗
arXiv2026

Warpline: Binary-Level Tracing and Unified Evidence for Agentic GPU Kernel Optimization

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.

cs.PF↗
arXiv2026

Software Design Patterns for Latency Measurements with eBPF in SDN Environments

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.

cs.PF↗