1
Single-Connection Mixed-Criticality Transport with CATS: Bounded Guarantees, Three Structural Limits, and a QUIC Escape
arXiv:2606.16924v1 [cs.NI] 15 Jun 2026
Syed Muhammad Aqdas Rizvi Independent Researcher Alumnus, Lahore University of Management Sciences (LUMS) Karachi, Pakistan [email protected] | [email protected]
Abstract—Mixed-criticality applications, such as satellite terminals, industrial telemetry-and-control, embedded systems, tactical, and other constrained mixed-criticality links, often multiplex a small, latency-critical message class and bulk traffic over a single commodity transport connection. A single FIFO connection can starve the critical class under load. The obvious alternative, opening parallel connections, costs an additional five-tuple (often blocked by carrier-grade NAT, port budgets, and operator policy) and is not always available; when the critical class is light, two connections can also be bandwidth-fair only in aggregate rather than single-flow fair. We present CATS (Conductordriven Asymmetric Transport Scheme), a sender-side, receivertransparent transport-layer priority scheme over commodity TCP: a Conductor assigns each message a priority class and just-intime sequence numbers, governed by a credit-based shaper. CATS provides the one combination its alternatives cannot: deterministic non-starvation together with single-flow fairness, plus a provable bounded per-class delay. We then show that, crucially, CATS-over-TCP is not a taillatency mechanism, and why. Three structural barriers bound single-connection in-band priority at three layers: the in-order sequence space (head-of-line blocking), the shared congestion window (cross-class coupling), and the per-flow granularity of network QoS (in-band priority is invisible to it). The same barriers explain why fair-queuing and even the modern lowlatency standard L4S cannot help a single connection, and why two parallel connections reduce the latency tail at the cost of an additional flow. We give CATS-over-QUIC as the principled escape: independent streams with per-stream isolation under aggregatecoupled congestion control self-isolate at the endpoint, attaining the guarantees on one fair flow. An ns-3 evaluation across loss, contention, and handover regimes, and a QUIC proof-of-concept, support every claim, including the negative ones. Index Terms—transport priority, mixed-criticality, QUIC, satellite networking, congestion control, fair queuing
I. I NTRODUCTION Many systems carry two very different kinds of traffic over a single transport connection: a small, latency-critical class (control commands, coordination messages, model-routing decisions) interleaved with bulk transfers such as logs, model weights, sensor dumps, or media. This pattern is the norm in settings where a second connection is costly or unavailable: satellite and non-terrestrial terminals behind carrier-grade NAT, embedded and industrial endpoints with tight socket and port budgets, and existing single-socket applications that cannot be
re-architected. In these settings the critical class and the bulk class are not separable into independent network flows; they share one byte stream, one congestion controller, and one path. A single first-in-first-out connection serves this mix badly. Under load the critical class queues behind the bulk backlog and starves: in our experiments a FIFO connection delivers0 of 300 critical messages within the measurement window under sustained contention, because the head of the send buffer is perpetually bulk data. The obvious remedy is to give the critical class its own parallel connection. This works, but at a cost that is easy to overlook: N parallel connections require N separate five-tuples, which are blocked by carrier-grade NAT, tight socket and port budgets, single-socket application constraints, and operator policy, and may be unavailable in practice. When the critical class is light, the parallel-connection setup can still look bandwidth-fair in aggregate; in our measurements, the Jain fairness index is 0.84 for two connections versus ≈1.0 for one, reflecting a thin-flow accounting effect rather than a fundamental improvement in end-to-end fairness. Two connections are bandwidth-fair when the critical class is light; CATS is single-flow-fair unconditionally, regardless of class bandwidths. This paper asks what a single connection can guarantee for mixed-criticality traffic, and just as importantly what it fundamentally cannot. CATS and its guarantees. We present CATS (Conductordriven Asymmetric Transport Scheme), a sender-side, receivertransparent transport-layer priority scheme over commodity TCP. A Conductor tags each application message with a priority class and assigns sequence numbers just in time, so a newlyarriving high-priority message takes the next transmission slot rather than queuing behind buffered bulk bytes. A two-threshold credit-based shaper governs how classes share the connection. CATS needs no receiver changes, no new congestion-control algorithm, and no kernel modifications. On one connection it provides the combination no alternative offers at once: deterministic non-starvation (the critical class always makes progress, 300/300 delivered where FIFO delivers 0/300), singleflow fairness (exactly one TCP-fair flow), and a provable bounded per-class delay (Theorem 1). Among single-flow-fair options, CATS is the only non-starving one. The core concept of CATS originally appeared in [1], with the further theory detailed
2
in the extended text [2]; the just-in-time architecture, the threebarrier structural result, and the QUIC escape developed here are completely new. CATS’s limits. CATS-over-TCP is, however, not a taillatency champion and the reason is structural rather than an artifact of our design. Under cross-traffic, two parallel connections win the critical-class tail by 4–8×, and they win it under handover as well. We trace this to three structural barriers that bound any single-connection in-band priority scheme, each at a different layer: (B1) Sequence space. One in-order byte stream: a lowpriority loss head-of-line-blocks the critical class for at least a round trip, no matter how the sender schedules, because in-order delivery is enforced at the receiver. • (B2) Congestion control. One shared congestion window: a bulk-triggered loss contracts it and so delays the critical class too, by a quantifiable coupling term ∆cc = 2 RTT(1 − β). • (B3) Network-queue granularity. Network QoS (fairqueuing, DSCP AQM, L4S): this schedules at flow granularity; a single connection is one five-tuple, so its inband priority is invisible to the network, which therefore cannot isolate the critical class even when asked. •
B3 explaining why fair-queuing and L4S cannot help a single connection (Section IV). • CATS-over-QUIC, the principled escape via endpoint self-isolation (independent streams + per-stream-isolated aggregate CC), with a proof-of-concept validating the structural bypass and identifying per-stream isolation under aggregate-coupled CC as the precise requirement (Section VI). • A multi-regime evaluation (ns-3 across loss, contention, and handover; plus the QUIC PoC) delineating exactly where single-connection priority helps and where it does not (Sections V, VI). Section II scopes the use-case envelope; Section III presents the CATS design; Section IV develops the per-class delay bound and three structural barriers; Section V evaluates CATS-overTCP across five regimes; Section VI presents CATS-over-QUIC and the proof-of-concept; Sections VII–IX discuss related work, limitations, and conclusions. II. M OTIVATION AND U SE -C ASE E NVELOPE
We are precise about when single-connection in-band priority is the relevant tool, because that envelope is narrow and it shapes every design choice and every experiment that follows. The traffic: we consider two classes sharing one connection: These bite at three layers and explain the three distinct a critical class P0 of small, sporadic, latency-sensitive messages findings of the loss tail (B1), the contention coupling (B2), and (control, coordination, acknowledgement, routing decisions the counter-intuitive (B3): adding fair-queuing at the bottleneck on the order of a few hundred bytes each), and a bulk makes a single connection’s position worse, because it grants a class P4 of throughput-oriented transfers that is essentially parallel-connection competitor per-flow isolation while leaving always backlogged (logs, weights, media, sensor data). In our in-band priority unserved (and L4S, classifying by per-flow experiments P0 is 200-byte messages generated at 10 msg/s; marking, is no different). The barriers are properties of a P4 is a 50 MB perpetual backlog. The classes are applicationsingle TCP connection. Two connections clear B2 and B3 meaningful but not network-separable: the application has one but at the cost of N five-tuples; CATS-over-QUIC clears B1 socket, and the two classes are interleaved bytes on one stream. with independent streams and B2 with per-stream isolation Why one connection is the binding constraint: opening a under aggregate-coupled congestion control, self-isolating at second connection for the critical class is the textbook answer, the endpoint so it no longer needs the network, thus rendering B3 moot from above, all on one fair flow. A proof-of-concept and where it is feasible and its extra share acceptable it is hard confirms the structural bypass (a flat critical-class tail under loss: to beat. But it is frequently not feasible: carrier-grade NAT ≈27 ms p99.9 vs. ≈307 ms over TCP (per-seed-median p99.9), that limits or rewrites flows, tight socket and port budgets on CCA-independent) and pins the precise requirement: per-stream embedded endpoints, single-socket applications that cannot be re-architected, or operator policy that permits one flow. Even isolation under aggregate-coupled congestion control. where feasible, it costs N five-tuples (blocked by carrier-grade On scope. We report the regimes where two connections NAT, port budgets, and operator policy) and is bandwidth-fair beat CATS rather than around them: CATS-over-TCP’s value is only when the critical class is light (a heavier critical class non-starvation, fairness, and a bounded floor on one connection, would consume a second share). Single-connection priority competitive on latency only as the dominant flow, and a is the tool for the case where one must, or should, present a guarantor of completeness, not of the tail. single flow to the network. Contributions: Why constrained links sharpen the problem: low-Earth• CATS, a sender-side, receiver-transparent priority scheme orbit (LEO) and non-terrestrial networks, cellular backhaul, over commodity TCP, providing deterministic non- and constrained IoT links are where this matters most: they starvation with single-flow fairness, together with a combine meaningful loss, elevated round-trip times, and provable bound on per-class delay, via a credit-based- periodic disruption, which make the FIFO baseline fail and the shaper model and a just-in-time sequencing realization extra-connection alternative most costly. Disruption is, for LEO, (Sections III, IV). periodic: Starlink hands over every 15 s, producing latency • A three-barrier structural result across the sequence spikes and loss bursts that confuse congestion control [3]; our space (B1), congestion window (B2), and network-queue handover experiments use an explicit outage model aligned granularity (B3), bounding single-connection in-band to this cadence. CATS is orthogonal to the handover-aware priority, with B2 quantifying the contention coupling and congestion control this community has converged on: those
3
repair the controller’s reaction to a handover, while CATS arbitrates priority within a connection; the two compose, and we treat them as complementary. The envelope, stated: CATS-over-TCP is worth deploying when (i) the application multiplexes a small critical class with bulk over (ii) a single connection that cannot be split into independent flows, on (iii) a constrained link where loss and disruption make FIFO starvation real, and where (iv) presenting more than one flow to the network is impossible or undesirable. Outside this envelope (when a second connection is free and its extra share is acceptable, or when the link is uncongested and lossless), the problem is either better solved by parallel connections or not a problem at all. Everything below is evaluated against this envelope, and Section V reports where even inside it the single connection is beaten on latency. III. CATS D ESIGN CATS adds priority to a single commodity-TCP connection entirely at the sender, with an unmodified receiver and an unmodified congestion controller. It has three elements: the Conductor, which assigns priority and arbitrates the connection; a credit-based shaper, which governs how classes share transmission; and just-in-time sequencing, which integrates the priority decision into the TCP send path. Throughout this paper, CATS-over-TCP refers to this just-in-time (JIT) integratedsender design. It supersedes the original interceptor/feeder architecture of [1], which arbitrated priority in a shim above the socket and therefore could not prevent the send-buffer queuing that JIT eliminates, and we treat that earlier design as legacy throughout. The Conductor: the application submits messages tagged with a priority class. The Conductor maintains a per-class queue and decides, at each transmission opportunity, which class’s data is sent next. Because all classes ride one TCP connection, the receiver reassembles a single ordered byte stream with no awareness of priority. CATS is invisible on the wire beyond ordinary TCP and requires no receiver cooperation. Credit-based shaper and non-starvation: sending strictly in priority order would starve the bulk class and, under adversarial arrival patterns, destabilize the connection. CATS instead governs class arbitration with a credit-based shaper using two thresholds (a hysteresis band): a class accrues credit over time and spends it to transmit, and the two-threshold band bounds how long any class waits before it is served. This yields deterministic non-starvation: every class is served within a bounded interval, so the critical class makes progress even against a perpetually-backlogged bulk class (where FIFO delivers none of it), and a provable bounded per-class delay developed in Section IV. Just-in-time sequencing: a subtle failure mode defeats naive sender-side priority, which is that if the Conductor selects a high-priority message but the TCP send buffer already holds a backlog of bulk bytes with assigned sequence numbers, the high-priority message still waits behind that backlog, because TCP transmits in sequence number order. CATS closes this gap by assigning TCP sequence numbers just in time: at the moment a message is handed to the transmission path, not
when it is enqueued, so a newly-arriving critical message takes the next on-wire slot rather than queuing behind the buffered bulk backlog. This integrated-sender design removes the sendbuffer latency floor measured in Fig. 1; the remaining floor is the fundamental per-class delay bound of Section IV. Optional mitigations: beyond the core JIT design, CATS admits optional add-ons, namely DSCP marking for managed networks, message duplication/FEC, and packet-level redundancy. These are separable from the core architecture and required by none of its guarantees. We evaluate them in Section V and find that only duplication/FEC earns its complexity, and only at loss rates ≥2%. DSCP is inert without AQM-aware hardware and, by the network-queue barrier (Section IV), cannot help a single connection in any case. We keep all three out of the core and treat them as deployment options. What CATS does not require, and does not change: CATS uses commodity TCP and is agnostic to the congestioncontrol algorithm: it runs unchanged over BBR and CUBIC, and composes with specialized controllers (e.g., LEO handoveraware controllers). These properties are what make CATS deployable today; as the next section shows, they also bound what it can achieve. IV. T HEORY This section states what CATS guarantees on a single connection, and then—the paper’s core—what single-connection in-band priority scheme can achieve. The guarantees and the barriers are two sides of one fact: a single commodity connection is one in-order sequence space, one congestion window, and one network-visible flow. We name the three barriers B1 (sequence space), B2 (congestion control), and B3 (network queue), and we are deliberate about their epistemic status: B1 is a deterministic lower bound (Theorem 2), B2 is a quantified coupling bound (Lemma 3), and B3 is an architectural barrier witnessed empirically, not a deductive theorem. A. Model and Guarantees Model: one TCP connection carries K priority classes. The Conductor assigns each class a credit rate ri , an upper threshold Hi , and a lower threshold Li ; class i transmits when its credit balance is positive. Let R be the bottleneck link rate, dprop the one-way propagation delay, Bc the maximum per-class buffer occupancy, MSS the maximum segment size, and b0 the per-class lower credit threshold. Under a Gilbert-Elliott loss model with burst parameter p, let Lloss denote the expected extra delay per loss event. Bounded per-class delay: Theorem 1 (Per-class delay bound). Under the CATS creditbased shaper, the worst-case delivery time of a critical-class (P0) message is bounded by Bc + MSS + b0 + dprop + Lloss + ∆cc , (1) R where ∆cc = 2 RTT(1 − β) is the congestion-coupling term (β is the CC’s multiplicative decrease factor; BBR: β ≈ 0.75, CUBIC: β = 0.7, NewReno: β = 0.5). D0 ≤
4
At the ns-3 topology (5 Mbps, OWD = 25 ms, BBR), the TABLE I D ESIGN SPACE : SINGLE - CONNECTION MECHANISMS VS . STRUCTURAL loss-only floor D0,loss (setting ∆cc = 0) ≈28 ms; the full BARRIERS . bound with BBR coupling D0,cc ≈ 53 ms (∆cc = 25 ms for B1= SEQ - SPACE ; B2=CC- COUPLING ; B3= NETWORK - QUEUE ; RTT = 50 ms, β = 0.75). Section V-B shows the measured JIT “ MOOT ”= ENDPOINT SELF - ISOLATION RENDERS NETWORK TREATMENT IRRELEVANT. floor agrees with D0,loss (Fig. 1). Non-starvation, conditioned on connection liveness: the Scheme B1 B2 B3 Fair / Non-starving two-threshold band guarantees that every class is served within FIFO-TCP bounded bounded N/A Yes / No a bounded interval whenever the connection is making progress. CATS-JIT-TCP mitigated bounded No Yes / Yes This is the formal counterpart of the empirical 300/300-vs-0/300 Two-conn TCP Yes Yes Yes No / Yes CATS-over-QUIC Yes partial∗ moot Yes / Yes result. Scope: non-starvation is a scheduling-layer guarantee conditional on the connection having transmission opportunities. ∗ PoC: shared CC cleared by per-stream isolation under aggregate-coupled CC. It does not override a connection-level congestion collapse (B2’s unbounded regime), in which the window is driven to zero and no class can be served. Section V-E exhibits this case a) Barrier B3 (Network-Queue Granularity): Network at high round-trip times. On one connection that is making QoS schedulers (FqCoDel, DSCP-aware AQM, class-based progress, CATS is the only scheme that is both single-flow-fair weighted fair queuing, and the modern low-latency standard and non-starving. L4S [4]–[6]) classify and schedule at flow (five-tuple) granularity. A single connection, TCP or QUIC, presents exactly B. Three Structural Barriers on a Single Connection one five-tuple; its in-band priority signal (a CATS tag, a QUIC B1—Sequence-space barrier (Theorem 2). stream identifier) lives inside the payload (after encryption, in Theorem 2 (Sequence-space barrier). On a single TCP QUIC’s case) and is invisible to the network. Therefore a single connection (or any single in-order stream), critical-class connection’s critical class receives no per-priority treatment message m is delivered no earlier than the last ACK of every from network-layer QoS, even when the operator configures byte b with seq(b) < seq(m). If any such byte b is lost, P0 prioritization. We state this as a structural barrier and support it delivery is delayed by at least one retransmission round: two ways. Empirically (Section V-D): introducing FqCoDel at delivery_time(m) ≥ recv _time(last byte before m)+1 RTT. the bottleneck widens a two-connection competitor’s advantage The crucial consequence is that JIT, or any other sender-side over a single CATS connection. Architecturally: L4S classifies scheduler, cannot avoid B1: the sender controls transmission by per-flow ECN marking, so the same conclusion applies, that order, but not the receiver’s in-order delivery. Escape: in- is, B3 is a statement about all flow-granular network QoS. FQ dependent sequence spaces (separate streams or unreliable slot counts confirm the mechanism: CATS-JIT occupies 1+K datagrams), which only a multi-stream transport (QUIC) or slots under K background flows; two-conn occupies 2+K (Section V-D). Escape: none at the network for a single flow; multiple connections provide. per-priority network isolation requires distinct flow identifiers B2—Congestion-control barrier (Lemma 3). (multiple connections, each an additional five-tuple). The way Lemma 3 (CC-independence barrier). On a single connection out is not to make the network see priority, but to no longer with shared congestion window, a congestion event that reduces need it to (Section VI). the window by factor (1 − β) imposes an additional delay ∆cc = 2 RTT(1 − β) on all priority classes simultaneously, including P0, regardless of sequence-space isolation. Derivation: at steady state, cwnd ss ≈ 2 · R · RTT; a multiplicative decrease by (1 − β) creates a surplus of cwnd ss (1 − β) unacknowledged bytes; the time to drain the surplus at rate R is 2 RTT(1 − β). Two points matter. First, B2 bites even when B1 is solved: independent streams remove head-of-line blocking but still share one congestion controller, so a bulk loss still throttles the critical class, which is why independent streams are necessary but not sufficient. Second, the nominal coupling ∆cc does not bound the rare congestion-collapse regime (window driven to near-zero), which is effectively unbounded until recovery; Section V-E exhibits this at high RTT under handover, and the QUIC PoC exhibits it in one of twenty seeds (Section VI-B). Escape: per-stream isolation under a shared aggregate controller. B3—Network-queue barrier (architectural, witnessed empirically).
C. The Three Barriers Together, and the Escape The three barriers bound single-connection in-band priority at three independent layers and cleanly separate the design space (Table I). FIFO on one connection fails B1, B2, and B3, and starves the critical class. CATS-over-TCP provides non-starvation, single-flow fairness, and the bounded floor, but remains bounded by all three on latency, which is why, as Section V reports, two connections beat it on the tail. Two parallel connections clear B2 and B3 but require N five-tuples instead of one. CATS-over-QUIC clears B1 with independent stream sequence spaces and B2 with per-stream isolation under aggregate-coupled congestion control, achieving endpoint selfisolation; once the endpoint self-isolates, it no longer needs the network to isolate it, rendering B3 moot from above. (QUIC streams are not network-visible flow identifiers, one encrypted five-tuple; this is not B3 defeated by visibility, but B3 made irrelevant.) This is achieved on one connection (one flow’s fair share). CATS-over-QUIC is thus the only point in the design space that is simultaneously single-connection, network-fair, non-
5
P0 control latency with analytical delay bounds BBR + shallow buffer
log scale
10 1
CCDF [P(D0 > x)]
100
10 2
JIT-only JIT+Mitigated Two-conn T6 per-msg D0(k=1) = 1027 ms T6 D0+CC(k=1) = 1052 ms (+25 ms) T6 eps_GE(k=1) = 0.0050 (tail prob.)
T6 per-msg D0(k=2) = 2027 ms T6 D0+CC(k=2) = 2052 ms (+25 ms) T6 eps_GE(k=2) = 0.0000 (tail prob.) T6 per-msg D0(k=3) = 3027 ms T6 D0+CC(k=3) = 3052 ms (+25 ms) T6 eps_GE(k=3) = 0.0000 (tail prob.)
10 3
10 4 102
P0 control latency (ms)
log scale
103
Fig. 1. P0 critical-class latency CCDF (BBR/shallow buffer, 30 seeds). CATSJIT collapses the legacy interceptor/feeder floor from ≈187 ms to ≈94 ms, matching the analytical bound D0,loss ≈ 28 ms (dashed). FIFO: 0/300 critical messages delivered (not shown). Shaded bands: cross-seed variance.
starving, and free of all three latency barriers. Section VI instantiates it and validates the structural bypass.
JIT sequencing is what makes it so. The legacy interceptor/feeder design carries a send-buffer floor of ≈187 ms (p50, BBR/shallow) that JIT removes, collapsing the critical-class median to ≈94 ms (BBR; ≈78 ms CUBIC); the floor is now the analytical per-class bound D0 , not the buffer. Against two connections in this regime, CATS-JIT is competitive at the median and p99: per-seed-median p99 = 272 ms vs. two-conn 314 ms (BBR/shallow; CATS-JIT wins both). Two connections win only the deep tail: pooled p99.9 = 531 vs. 1,112 ms; pooled CVaR95 = 187 vs. 295 ms (complete seeds, 30×300 messages, BBR/shallow); see Fig. 1 for the full CCDF. The baseline starves: a single FIFO connection delivers 0 of 300 critical messages, where CATS delivers 300/300. The takeaway: uncontended and single-connection, CATS-JIT is competitive on latency through p99 and uniquely non-starving; two connections win only the deep tail (p99.9 and CVaR95). The rest of this section shows that the moment we leave this regime, the comparison changes sharply. C. Fairness and the Cost of Parallel Connections
Under cross-traffic, two connections win the critical-class tail. With K=1 background flow, two-conn p99 (240 ms) is 4.7× better than CATS-JIT (1,116 ms), measured against a Jain fairness index of 0.671 vs. CATS-JIT’s 0.996. This low Jain index is a thin-flow accounting artifact: the thin P0 connection (≈16 kbps) underuses its nominal share, and the background flow absorbs the slack; the two-connection side’s aggregate takes approximately one fair share. Two connections are bandwidth-fair for this thin critical class; CATS is unconditionally single-flow-fair regardless of class bandwidths. The real cost of two connections is flow count: A. Setup All experiments use ns-3 (release 3.38) with a dumbbell two five-tuples, blocked by carrier-grade NAT, port budgets, topology: 5 Mbps bottleneck, 25 ms one-way propagation delay and operator policy. CATS-JIT, by construction one TCP-fair (50 ms base RTT), Gilbert-Elliott 0.5% bursty loss (mean burst flow, stays fair while its critical-class latency degrades under length 10 packets), and shallow-buffer BBR or deep-buffer the same contention. FIFO again delivers 0/300. The tradeoff CUBIC. P0 is 200 B messages at 10 msg/s (300 messages is that for a light critical class, both approaches are bandwidthtotal per run); P4 is a 50 MB perpetual backlog. Schemes fair, but two connections are faster on the tail and cost an compared: CATS-JIT (the JIT-only design), two independent additional five-tuple; CATS is single-flow-fair unconditionally connections (“two-conn”), single FIFO (“FIFO”), and CATS- and can be opened where only one connection is permitted. legacy (interceptor/feeder, for the JIT-floor comparison only). The natural question is whether a fair-queued network closes Seed counts: 30 for E16, 20 for X1/X5, 40 for handover; 20 the gap further. It does not. for the QUIC PoC. Reporting convention (survivorship bias): a seed with D. Managed Queuing Does Not Rescue a Single Connection incomplete delivery contains only its early, fast messages; (B3) the slow tail is absent, so including such seeds biases tail We expected per-flow fair-queuing to neutralize two-conn’s percentiles low. We therefore report all tail statistics (p99, advantage. The result is the opposite, and it is the empirical face p99.9) over complete-delivery seeds only (nrecv = nsent ), and of barrier B3. Introducing FqCoDel widens two-conn’s lead report the incomplete-seed count separately as a first-class (Fig. 2): at K=4 background flows, two-conn’s critical-class reliability metric. This correction matters materially only in the p50 improves from 154 ms to 42 ms (−73%) while CATS-JIT’s high-RTT/high-loss handover regime; across E16, X1, X5, and is unchanged or slightly worse (280 ms to 333 ms, +19%); at the QUIC PoC all seeds deliver completely. Where corrections p99, two-conn (385 → 312 ms) stays roughly 4× ahead of apply (Section V-E), they make the single connection’s tail CATS-JIT (1,569 → 1,452 ms) under both queue disciplines. worse, reinforcing, not weakening, the reported findings. The mechanism is exactly B3: FqCoDel isolates per flow, so two-conn’s two five-tuples land in two separate fair queues, B. Single-Connection Latency and the JIT Floor giving its critical flow per-flow isolation, while CATS-JIT’s On a single connection with no competing cross-traffic single five-tuple keeps both classes in one queue where fair(CATS’s home regime), CATS-JIT is latency-competitive, and queuing cannot tell them apart. Meanwhile the bandwidth V. E VALUATION : CATS OVER TCP We evaluate CATS-over-TCP across the regimes of its envelope (single-connection latency, contention, managed queuing, handover, and loss) and report, in each, both what CATS guarantees and where two connections beat it. The throughline is the one the theory predicts: CATS is competitive on latency only when it is the dominant flow, its value is non-starvation and fairness, and the three barriers are visible in the data.
6
P0 tail latency CCDF: DropTail vs FqCoDel, K=4 background flows 20 seeds; dashed = FqCoDel, solid = DropTail CATS-JIT / DropTail (X1 baseline) CATS-JIT / FqCoDel Two-conn / DropTail (X1 baseline) Two-conn / FqCoDel
CCDF (1 - CDF), log scale
100
10 1
10 2
10 3
former (Section IV-A). Two connections avoid it precisely because a stall on one does not stall the other, the same flowcount independence that makes them each a separate five-tuple (Section V-C). The reading is not that CATS-over-TCP has a handover niche, but that the sweep characterizes the singleconnection envelope: priority on one TCP connection is viable at LEO round-trip times and fails at MEO/GEO ones. That is the sharpest motivation for the QUIC escape of Section VI. F. Loss, CCA-Agnosticism, and One Application
0
500
1000
1500
2000
2500
3000
3500
Three brief results complete the envelope. Under increasing loss, a FIFO baseline’s critical-class delivery collapses while 5 Mbps / 25 ms OWD, GE 0.5% loss. FIFO: 0 P0 delivered under contention (not shown). CATS-JIT and FIFO share one FQ slot (single flow). CATS holds. CATS is also agnostic to the congestion controller Fig. 2. X5: P0 latency CCDF with DropTail vs. FqCoDel (K=4 (results hold under both BBR and CUBIC) and composes background flows, 20 seeds). FqCoDel widens two-conn’s lead (p50: with specialized controllers, including LEO handover-aware 154 ms → 42 ms, −73%) while CATS-JIT’s p50 is unchanged or slightly worse controllers, rather than competing with them. Finally, as one (280 ms → 333 ms, +19%). Two-conn Jain = 0.838 under both disciplines (unchanged Jain; thin-flow artifact, not a bandwidth grab). FIFO: 0/300 concrete application (not the paper’s claim), applying CATS to delivered. web page loading, where the critical class is render-blocking resources, improves a transfer-completion proxy by up to 78.7% (worst-case scenario, reverse-priority enqueue). This picture is unchanged: two-conn’s Jain index stays 0.84 (thinis a delivery-time proxy, not a Web Vitals measurement, and flow artifact; the two connections together take one aggregate we report it only to ground the mechanism. share) and CATS-JIT’s is ≈1.0. On a managed link, the case for CATS-over-TCP rests entirely on fairness and non-starvation, VI. CATS OVER QUIC: T HE E SCAPE not on the tail; no network QoS, FqCoDel or L4S, changes Section IV-C placed CATS-over-QUIC as the only point that for a single flow. in the design space that clears all three barriers on a single fair flow. Here we substantiate that placement with a proof-ofE. Handover: The Single-Connection Envelope, and Why QUIC concept, and develop the realization it requires. Under link handover, modeled as explicit outages aligned to the Starlink cadence (Section II), we sweep round-trip time A. Endpoint Self-Isolation across orbit regimes (LEO through GEO) and report two things: The argument is structural. QUIC carries independent stream where single-connection priority works, and where it does not. sequence spaces, so a loss on the bulk stream cannot headTwo connections win the critical-class tail at every RTT, and of-line-block the critical stream, clearing B1. With per-stream by a growing margin: 1.85× at RTT ≈20 ms (OWD=10 ms) isolation (priority-weighted aggregate CC), a bulk loss event no to 4.49× at RTT ≈600 ms (OWD=300 ms) (all p99 values longer contracts the critical class’s window allocation, clearing complete-seeds-only medians; see Section V-A). CATS-overB2. And once the endpoint isolates the critical class this way, TCP wins the tail nowhere. Its only advantage is delivery it no longer needs the network to do so, making B3 moot from completeness, and that advantage is confined to the LEO regime above, not because QUIC streams are network-visible (they are and is slight. not: one encrypted five-tuple), but because no network-layer At the 40-seed canonical LEO point (OWD=20 ms, R11): isolation is required. All of this holds on one connection (one CATS-JIT completes all 40/40 seeds (0/40 incomplete) where flow’s congestion-fair share). two connections drop one seed (seed 12: 288/300 delivered, 1/40 incomplete); FIFO delivers 0/300 in every seed. However, at the same RTT, two-conn wins the tail: median p99 792 ms B. Proof-of-Concept vs. 1,668 ms (ratio 2.11×). Setup: aioquic 1.3.0, a userspace UDP relay injecting GilbertThis completeness edge inverts as RTT grows: beyond LEO, Elliott 0.5% bursty loss (no kernel privileges required), 20 single-connection TCP degrades sharply (50% of seeds incom- seeds, three modes: (a) streams: P0 on one stream, P4 bulk on plete at OWD=150 ms, RTT ≈300 ms), while two connections another; (b) datagrams: P0 as QUIC DATAGRAM frames [7]; stay complete across the range (0/20 incomplete at all OWD (c) conductor-streams: Conductor-paced streams with larger points). FIFO delivers 0/300 at every RTT. frames. This high-RTT collapse is barrier B2 in its unbounded The structural bypass holds (Fig. 4). Independent streams regime (Section IV-B). During a handover at high RTT, a remove head-of-line blocking, and the datagram tail is flat: single-connection RTO chain drives the congestion window critical-class p99.9 is ≈27 ms (median over 19/20 seeds) against toward zero, and the credit-based shaper cannot help, because ≈307 ms over TCP (per-seed-median p99.9; cf. pooled p99.9 there are no transmission opportunities for any class; the = 1,112 ms in §V-B). This result is a structural B1-bypass failure is one of connection liveness, not of scheduling, and demonstration in which datagrams trade reliability for the flat the per-class non-starvation guarantee is conditioned on the tail (5,942/6,000 messages delivered across 20 seeds, 99.0%); P0 control-message latency (ms)
7
P0 control latency under Starlink-cadence handover: orbit-regime RTT sweep CATS-JIT (1 flow) vs Two-conn (2 flows) vs FIFO. GE 0.5%% loss, BBR, 5 Mbps bottleneck. (ii) Delivery completeness vs RTT Fraction of seeds with incomplete P0 delivery
(i) P0 p99 tail latency vs RTT across orbit regimes 1.0
103
102 CATS-JIT (single conn.) Two-conn T1 bound (cats-jit, conservative) +-1 sigma cross-seed band LEO (RTT 20-60 ms) MEO (RTT 100-150 ms) GEO (RTT 500-650 ms)
101
100 100
200
300
400
500
RTT (ms)
600
Completeness failure fraction (seeds with <300/300 P0 delivered)
P0 p99 latency (ms, log scale)
104
FIFO: 0/300 delivered (all seeds, all RTTs)
0.8 cats-jit: 10/20 fail at GEO-trans.
0.6
CATS-JIT (single conn.) Two-conn FIFO
0.4 0.2
two-conn: 1/40 fails at LEO
0.0
100
200
300
RTT (ms)
400
500
600
Explicit-outage model (Starlink cadence, t=15/30 s). SndBuf=128 KB (shallow). GEO (OWD=300 ms): SndBuf/BDP~3.4%% (buffer-limited, ~210 Kbps eff. bulk). Two-conn wins tail at every RTT. CATS edge: completeness + fairness (Jain~1.0).
(a) RTT sweep: P0 p99 tail and completeness-failure rate vs RTT (sub-panels (i) / (ii)). P0 p99 distribution across seeds at LEO / MEO / GEO orbit regimes Explicit-outage model, GE 0.5%% loss, BBR, shallow buffer. Dotted verticals = median p99 (matches paper text). FIFO: 0/300 delivered. LEO (OWD=20 ms, RTT~50 ms) SndBuf/BDP=4.19
100 med.p99 =792 ms
CCDF of per-seed P0 p99 (fraction of seeds exceeding x)
MEO (OWD=50 ms, RTT~110 ms) SndBuf/BDP=1.91
CATS-JIT (single conn.) (n=40) Two-conn (n=39)
100
CATS-JIT (single conn.) (n=20) Two-conn (n=20)
med.p99 =1668 ms
GEO (OWD=300 ms, RTT~610 ms) SndBuf/BDP=0.34
100
med.p99med.p99 =882 ms=2238 ms
CATS-JIT (single conn.) (n=19) Two-conn (n=20)
med.p99 =1732 ms
med.p99 =7777 ms
10 1 10 1
10 1
FIFO: 0/300 delivered (all seeds)
1000
1500
FIFO: 0/300 delivered (all seeds)
2000 2500 Per-seed P0 p99 (ms)
3000
3500
0
2000
4000
FIFO: 0/300 delivered (all seeds)
6000 8000 10000 12000 14000 16000 Per-seed P0 p99 (ms)
5000
10000 15000 20000 Per-seed P0 p99 (ms)
25000
30000
(b) LEO/MEO/GEO anchor CCDFs (OWD = 20/50/300 ms, 40/20/20 seeds); CCDF of per-seed p99 across seeds. Fig. 3. Round-12 RTT sweep across orbit regimes (Gilbert-Elliott 0.5% loss, dynamic handover, 20 seeds each OWD point). Two connections win the critical-class tail at every RTT, by a growing margin (1.85× at RTT ≈20 ms to 4.49× at RTT ≈600 ms). CATS-JIT’s completeness edge is LEO-confined and slight (0/40 incomplete at OWD=20 ms; two-conn 1/40); it inverts at OWD=150 ms (10/20 incomplete, ≈50%). FIFO: 0/300 delivered at every RTT. Section V-E discusses the 40-seed canonical (OWD=20 ms) LEO result.
must-arrive critical traffic uses the reliable streams mode (p99.9 median 112.6 ms, bounded by ∆cc until per-stream isolation). The effect is not an artifact of the congestion controller: rerunning under both NewReno and CUBIC yields the same head-of-line-free shape, so the bypass is structural, not CCAspecific. One result matters more than the flat tail: the case where it breaks. In 1 of 20 seeds (seed 6), a connection-level congestion collapse (window driven to near-zero for ≈600 ms) stalls even independent datagrams (638 ms). Independent streams bypass per-stream flow control but not connection-level congestion control. This is barrier B2 in its rare, unbounded regime (Section IV-B), and it identifies the precise requirement for the escape to be complete: per-stream isolation from connectionlevel congestion collapse, which today’s QUIC does not provide directly.
The streams p99.9 (median 112.6 ms) slightly exceeds the loss-only bound (102.7 ms) by ∆cc ≈ 25 ms; the CC-corrected bound (≈128 ms) holds at the median, confirming Lemma 3. We are explicit about the PoC’s limits: the relay is userspace, not a kernel emulator; aioquic is a reference stack, not production; and since aioquic’s controller (NewReno) differs from the ns-3 baseline (BBR), we compare tail shape and structural effects, not absolute latency.
C. The Realization: Priority-Weighted Coupled Congestion Control The requirement from Section VI-B, per-stream isolation from connection-level congestion, must be met without the extra-flow overhead of parallel connections. Independence per stream is therefore the wrong primitive.
8
P0 tail latency: QUIC modes vs TCP baselines (5 Mbps / 50 ms RTT, GE 0.5% bursty loss)
100
QUIC-streams (p99.9 typ. 113 ms) QUIC-datagrams (p99.9 typ. 27 ms) QUIC-cond-streams (p99.9 typ. 106 ms) CATS-JIT (TCP) (p99.9 typ. 307 ms) two-conn (TCP) (p99.9 typ. 439 ms)
CCDF (1 - CDF)
10 1
10 2
10 3
10 4
0
200
400
600
800
1000
P0 control-message latency (ms)
1200
1400
1600
QUIC: aioquic NewReno CC + Python UDP relay (GE loss + token-bucket). TCP: ns-3 BBR+shallow; CCA and emulator differ, tail shape valid but median not directly comparable. cond-streams uses 4096 B LP frames (vs 200 B for streams/datagrams); latency not directly comparable. QUIC-datagrams: 5942/6000 P0 delivered (99.0%, GE 0.5% loss); flat tail for delivered msgs only. CCDF = pooled (all seeds). Dotted verticals = per-seed median p99.9 (typ. run; CC-collapse seeds inflate pooled tail).
Fig. 4. QUIC PoC: P0 critical-class latency CCDF (aioquic 1.3.0, GE 0.5% loss, 20 seeds, NewReno CC). Datagrams: flat tail at ≈27 ms p99.9 in 19/20 seeds; seed 6 (CC collapse): 638 ms. Streams: p99.9 median 112.6 ms, above loss-only bound (102.7 ms) by ∆cc ≈ 25 ms (B2, BBR). TCP baseline (E16 cats-jit): per-seed-median p99.9 ≈307 ms. B2’s CC-collapse case visible in seed 6 across all modes.
for integrated terrestrial-satellite networks [17]; we differ in contributing a semantic priority-to-path mapping with boundeddelay guarantees. Low-latency and QoS in the network: AQM and fairqueuing (CoDel, FqCoDel) and L4S [4]–[6] reduce queuing delay at flow granularity, which is precisely barrier B3. Rather than competing with CATS, L4S witnesses B3, confirming the barrier is a property of all flow-granular network QoS. Deadline-aware and priority transport: deadline-aware TCP variants (D2TCP [18], DTP [19]) and opportunisticretransmission and proactive-loss-recovery approaches target latency-sensitive flows but operate across flows or modify the wire protocol/receiver; CATS is single-connection, senderside, and receiver-transparent. Application-layer priorities (RFC 9218 [9]) schedule but do not touch congestion control. Extensible-kernel-transport work (eTran [20]) provides the eBPF data-path substrate on which a production CATS-overQUIC (with the per-stream coupled controller of Section VI-C) would most naturally be built.
The right primitive is hierarchical, coupled congestion VIII. L IMITATIONS AND F UTURE W ORK control. One connection-level controller estimates the aggregate The high-RTT limit of the TCP realization: CATS-overfair sending rate, keeping the connection one flow’s share at TCP’s guarantees are most useful at LEO round-trip times; the the bottleneck, and a priority-weighted allocator partitions that handover sweep (Section V-E) shows that at MEO/GEO roundaggregate window across priority buckets, charging congestiontrip times single-connection TCP suffers severe completeness induced reductions to low-priority buckets first while the critical failure (50% of seeds at RTT ≈300 ms), a connection-liveness class holds a protected reservation. This decouples the two collapse the per-class shaper cannot prevent. This bounds the concerns cleanly: fairness is handled once, at the aggregate; deployable envelope of the TCP realization to lower-RTT links isolation is handled by the within-connection partition. It is and is a direct argument for the QUIC realization. one fair flow, internally priority-scheduled. What the simulator cannot show: ns-3 resets transport MPTCP’s coupled congestion control [8] performs exactly state for every scheme across a modeled outage, so the regime this aggregate-fairness trick across subflows; our design applies where a single connection should beat parallel connections at the same coupling across priority buckets. And the gap is handover (preserved congestion state and SACK across the explicit in the standards: RFC 9218 [9] governs scheduling but disruption) is not observable here. Realizing and measuring that deliberately leaves congestion control untouched, so priorityadvantage requires connection migration (MPTCP or QUIC). aware CC is open territory. The status of B3: barrier B3 is an architectural and Even perfect partitioning does not give the critical class empirically-witnessed statement about flow-granular network zero latency: it remains bounded below by D0 of Theorem 1, QoS, not a deductive theorem, and we present it as such; a carried into QUIC, not eliminated. fully formal treatment over a defined class of work-conserving per-flow schedulers is open. VII. R ELATED W ORK Unvalidated and unbuilt pieces: the DSCP mitigation Priority-aware QUIC congestion control: PCC Priorrequires AQM-aware hardware we did not test; by B3 it cannot ity [10] folds stream priorities into a performance-oriented help a single connection regardless. Most importantly, the CC utility function and proves proportional-bandwidth alper-stream coupled congestion controller of Section VI-C is location by priority. CATS differs in objective: we target specified but not built: a production CATS-over-QUIC in quiche latency isolation, a provable bounded per-class delay, and or mvfst, with per-stream isolation atop a single aggregate fair a protected critical-class reservation (deadline-determinism), controller, is the central next system. rather than bandwidth proportionality. Stream-scheduling work (FStream [11], XLINK [12], MS-HS [13]) arbitrates which IX. C ONCLUSION stream sends, not how the congestion window is partitioned; We set out to ask what a single commodity connection can the window-allocation question of Section VI-C, with its creditguarantee for mixed-criticality traffic, and what it fundamentally based-shaper bound, is the gap they leave open. LEO/NTN transport: the community has converged on cannot. The answer is a clean separation. CATS, a senderhandover-aware congestion control, freezing the congestion side, receiver-transparent, just-in-time priority scheme over window across the periodic handover [3], [14]–[16]. CATS commodity TCP, delivers the one combination its alternatives is orthogonal: it arbitrates priority within a connection, while cannot: deterministic non-starvation together with single-flow those repair the controller’s reaction to a handover. Closest to fairness, while also providing a provable bound on perour multipath direction is mobility-aware multipath-QUIC CC class delay. But it is not a tail-latency mechanism, and we
9
showed why through three structural barriers (the in-order sequence space, the shared congestion window, and the per-flow granularity of network QoS) that bound any single-connection in-band priority scheme at three layers, and that explain, respectively, the critical-class tail under loss, the coupling under contention, and the inability of fair-queuing or L4S to help. Two parallel connections clear two of the three barriers but require an additional five-tuple and are bandwidth-fair only when the critical class is light; CATS-over-QUIC clears all three by self-isolating at the endpoint (independent streams with per-stream isolation under aggregate-coupled congestion control) on a single fair flow, and a proof-of-concept confirms the structural bypass while pinning the precise requirement: perstream isolation under aggregate-coupled congestion control, realized without sacrificing single-flow fairness. That escape is also a program. The realization it calls for—per-stream, priority-weighted coupled congestion control that preserves single-flow fairness while isolating the critical class, extended across the multiple paths of a multi-orbit (LEO + MEO + GEO) terminal—is the natural next step for deterministic mixed-criticality transport on exactly the satellite and non-terrestrial links where it matters most. R EFERENCES [1] S. M. A. Rizvi, “A Case for CATS: A Conductor-driven Asymmetric Transport Scheme for Semantic Prioritization,” in 2025 6th International Conference on Innovative Computing (ICIC). IEEE, 2025. [Online]. Available: https://doi.org/10.1109/ICIC68258.2025.11413235 [2] ——, “A Case for CATS: A Conductor-driven Asymmetric Transport Scheme for Semantic Prioritization,” 2026, extended version of [1]. [Online]. Available: https://doi.org/10.48550/arxiv.2603.13945 [3] Z. Lai, Z. Li, Q. Wu, H. Li, W. Liu, Y. Liu, X. Xie, Y. Li, and J. Liu, “Mind the Misleading Effects of LEO Mobility on End-to-End Congestion Control,” in Proceedings of the 23rd ACM Workshop on Hot Topics in Networks, ser. HotNets ’24. New York, NY, USA: Association for Computing Machinery, 2024, pp. 34–42. [Online]. Available: https://doi.org/10.1145/3696348.3696867 [4] B. Briscoe, K. D. Schepper, M. Bagnulo, and G. White, “Low Latency, Low Loss, and Scalable Throughput (L4S) Internet Service: Architecture,” RFC 9330, Jan. 2023. [Online]. Available: https://www.rfc-editor.org/info/rfc9330 [5] K. D. Schepper and B. Briscoe, “The Explicit Congestion Notification (ECN) Protocol for Low Latency, Low Loss, and Scalable Throughput (L4S),” RFC 9331, Jan. 2023. [Online]. Available: https://www.rfc-editor. org/info/rfc9331 [6] K. D. Schepper, B. Briscoe, and G. White, “Dual-Queue Coupled Active Queue Management (AQM) for Low Latency, Low Loss, and Scalable Throughput (L4S),” RFC 9332, Jan. 2023. [Online]. Available: https://www.rfc-editor.org/info/rfc9332 [7] T. Pauly, E. Kinnear, and D. Schinazi, “An Unreliable Datagram Extension to QUIC,” RFC 9221, Mar. 2022. [Online]. Available: https://www.rfc-editor.org/info/rfc9221 [8] C. Raiciu, M. J. Handley, and D. Wischik, “Coupled Congestion Control for Multipath Transport Protocols,” RFC 6356, Oct. 2011. [Online]. Available: https://www.rfc-editor.org/info/rfc6356 [9] K. Oku and L. Pardue, “Extensible Prioritization Scheme for HTTP,” RFC 9218, Jun. 2022. [Online]. Available: https://www.rfc-editor.org/ info/rfc9218 [10] Z. Chen, K. Cai, J. Zhang, and X. Zhu, “PCC Priority: A Priority-Aware Bandwidth Allocation Framework for QUIC,” IEEE Networking Letters, vol. 5, no. 4, pp. 279–283, 2023. [Online]. Available: https://doi.org/10.1109/LNET.2023.3269054 [11] X. Shi, L. Wang, F. Zhang, and Z. Liu, “FStream: Flexible Stream Scheduling and Prioritizing in Multipath-QUIC,” in 2019 IEEE 25th International Conference on Parallel and Distributed Systems (ICPADS), 2019, pp. 921–924. [Online]. Available: https: //doi.org/10.1109/ICPADS47876.2019.00136
[12] Z. Zheng, Y. Ma, Y. Liu, F. Yang, Z. Li, Y. Zhang, J. Zhang, W. Shi, W. Chen, D. Li, Q. An, H. Hong, H. H. Liu, and M. Zhang, “XLINK: QoE-driven multi-path QUIC transport in large-scale video services,” in Proceedings of the 2021 ACM SIGCOMM 2021 Conference, ser. SIGCOMM ’21. New York, NY, USA: Association for Computing Machinery, 2021, pp. 418–432. [Online]. Available: https://doi.org/10.1145/3452296.3472893 [13] X. Liang, B. Zhao, W. Peng, and T. Wang, “Towards Effective Multipath Scheduling with Multipath QUIC in Heterogeneous Paths,” in 2022 10th International Conference on Information Systems and Computing Technology (ISCTech), 2022, pp. 472–479. [Online]. Available: https://doi.org/10.1109/ISCTech58360.2022.00079 [14] L. Jiang, Y. Zhang, Y. Hu, Y. Cui, and X. Zhang, “StarTCP: Handover-aware Transport Protocol for Starlink,” in Proceedings of the 8th Asia-Pacific Workshop on Networking, ser. APNet ’24. New York, NY, USA: Association for Computing Machinery, 2024, p. 169170. [Online]. Available: https://doi.org/10.1145/3663408.3665803 [15] V. Kamel, J. Zhao, D. Li, and J. Pan, “StarQUIC: Tuning Congestion Control Algorithms for QUIC over LEO Satellite Networks,” in Proceedings of the 2nd International Workshop on LEO Networking and Communication, ser. LEO-NET ’24. New York, NY, USA: Association for Computing Machinery, 2024, pp. 43–48. [Online]. Available: https://doi.org/10.1145/3697253.3697271 [16] X. Cao and X. Zhang, “SaTCP: Link-Layer Informed TCP Adaptation for Highly Dynamic LEO Satellite Networks,” in IEEE INFOCOM 2023 - IEEE Conference on Computer Communications, 2023, pp. 1–10. [Online]. Available: https://doi.org/10.1109/INFOCOM53939.2023. 10228914 [17] W. Yang, L. Cai, S. Shu, and J. Pan, “Mobility-Aware Congestion Control for Multipath QUIC in Integrated Terrestrial Satellite Networks,” IEEE Transactions on Mobile Computing, vol. 23, no. 12, pp. 11 620–11 634, 2024. [Online]. Available: https://doi.org/10.1109/TMC.2024.3397164 [18] B. Vamanan, J. Hasan, and T. Vijaykumar, “Deadline-aware datacenter tcp (d2tcp),” in Proceedings of the ACM SIGCOMM 2012 Conference on Applications, Technologies, Architectures, and Protocols for Computer Communication, ser. SIGCOMM ’12. New York, NY, USA: Association for Computing Machinery, 2012, pp. 115–126. [Online]. Available: https://doi.org/10.1145/2342356.2342388 [19] H. Shi, Y. Cui, F. Qian, and Y. Hu, “Dtp: Deadline-aware transport protocol,” in Proceedings of the 3rd Asia-Pacific Workshop on Networking, ser. APNet ’19. New York, NY, USA: Association for Computing Machinery, 2019, pp. 1–7. [Online]. Available: https://doi.org/10.1145/3343180.3343191 [20] Z. Chen, Q. Meng, C. Lao, Y. Liu, F. Ren, M. Yu, and Y. Zhou, “etran: extensible kernel transport with ebpf,” in Proceedings of the 22nd USENIX Symposium on Networked Systems Design and Implementation, ser. NSDI ’25. USA: USENIX Association, 2025. [Online]. Available: https://doi.org/10.5555/3767955.3767977