Umber Networks · Fi-Wi-L4S Whitepaper
The natural standards venue for scheduling a contended Fi-Wi network is the IETF, not IEEE 802.11: the mechanisms are L3/L4 machinery, above the air interface that 802.11 governs, and the credible path is running code plus an Internet-Draft, the QUIC and L4S pattern. Umber intends to propose an IETF working group for this work. The asks of transport engineers are specific: review the grant semantics and their congestion-control interaction, attack the clock-discipline exchange, run the code, and lend the statements of interest a chartering effort needs. Section 9 gives the details.
The client's 802.11 MAC arbitrates whenever its transmit queue is non-empty. Nothing above the MAC can suspend arbitration directly; the only state in which the MAC is guaranteed quiet is an empty FIFO. Every mechanism in this note is therefore an instrument for manufacturing the absence of payload at all instants outside a grant, so that the transition from FIFO-empty to FIFO-non-empty happens only when the Concentrator intends it.
The target is not zero arbitrations. An 802.11ax trigger frame does not eliminate arbitration either: the AP wins one EDCA contention, and the triggered responses follow within SIFS (the short interframe space, a fixed 16 µs turnaround in the 5 GHz OFDM PHYs, too short for any competing station to begin contending), consolidating N stations' arbitrations into one. Consolidation, not elimination, is the correct emulation target, and it gives us the figure of merit for everything below: arbitrations per delivered aggregate (equivalently, arbitrations per delivered megabyte at fixed offered load). A secondary consequence of consolidation is that when grants are non-overlapping, the surviving arbitrations occur on an idle medium, so each one costs only an AIFS deferral (the arbitration interframe space, a per-access-category wait of a few tens of microseconds) plus a random backoff, rather than risking a collision. Per-transmission overhead remains; contention losses largely do not.
Native 802.11ax trigger-based uplink, in which the AP's Trigger frame solicits a trigger-based (TB) PPDU response from the client, requires PHY and MAC support that the installed base does not have and will not have for years. Coverage is gated by silicon replacement cycles, and even among shipping 11ax clients, trigger support quality is uneven and UORA (UL OFDMA-based Random Access), the trigger mechanism through which a station announces demand the scheduler does not yet know about, is essentially unused.
Most of the trigger machinery is also more than this system needs. Its weight serves simultaneous multi-user uplink: resource unit (RU) allocation, per-STA power pre-correction toward a target RSSI, tight timing and frequency pre-synchronization, and commanded MCS (modulation and coding scheme) all exist so that several clients' TB PPDUs arrive at the AP aligned in time, frequency, and power. Fi-Wi does not require simultaneity within a channel. Its scheduling unit is the TXOP (transmit opportunity), a whole-channel time grant to one station, which drops the synchronization, power-control, and RU-signaling burden entirely and leaves rate adaptation with the client as part of its autonomous execution of an eligibility decision. The frequency-domain multiplexing that RUs provide within a BSS, Fi-Wi obtains across the radio-head array instead: clients scheduled concurrently on different RRHs and channels against the same master timeline. The residual cost of time-only grants, per-station preamble and interframe-space overhead under many small uplink flows, is the case the full-aggregate-per-grant policy and echo scheduling exist to compress.
Triggers also scope a single BSS with the AP as scheduler; cross-BSS coordination waits on 11be MAPC and 11bn coordinated scheduling, which at fleet scale is a 2030s proposition. Software coverage iterates in months. The mechanisms in this note run on silicon that has already shipped, and when trigger and MAPC primitives do arrive, they slot in as actuators under the same control plane rather than replacing it.
There is no protocol mechanism by which a node in the forwarding path installs state in an endpoint's kernel. SO_TXTIME and TCP_TX_DELAY are syscalls, not protocols: the resulting departure time lives in skb->tstamp, which has no wire representation and dies at the NIC. This is the Earliest Departure Time (EDT) model of pacing, in which each packet carries a "not before" timestamp decided in the sender's stack and enforced by the sender's own qdisc or NIC launch-time hardware; EDT is a host-stack construct with no existence in any IP or TCP header. The contrast with the MAC is exact: 802.11 gives the network an in-band control channel into the client's transmit machinery (EDCA parameter sets, TWT agreements, triggers), while IP was designed with essentially none. The path-visible knobs are the receive window, ACK arrival timing, one ECN bit, and the timing of our own downlink. That asymmetry, a rich control plane at L2 and a near-empty one at L3/L4, is the gap this program fills.
It follows that the FIFO empty-to-non-empty instant is writable from exactly three positions. From the path, we can only induce the transition by shaping the inputs endpoints already respond to. From code resident on the client, we can set it directly; that is the client library. From the MAC, triggers and TWT let client firmware honor a grant sent over the air. Sections 4 through 7 develop the first two; the MAC stratum is covered in the existing H3 lever set.
For client uplink TCP flows, the Concentrator sits on the return path and controls two clocks the client's sender obeys. The first is the receive window: hold the advertised right edge fixed (the window must never be retracted, per RFC 7323), then advance it by W bytes at time T. The client's TCP releases approximately W bytes, the firmware aggregates them, and one arbitration fires. A grant is therefore a window delta released at a transmit time we own. The second is ACK release timing, which clocks the sender's own transmission engine; for downlink-heavy traffic the same primitive appears as echo scheduling, sizing and timing our downlink bursts so the client emits one reflexive ACK aggregate per grant instead of dribbling ACKs that each arbitrate.
Two structural limits apply. First, this stratum is millisecond TDM with dithered edges, not a SIFS-bound trigger: the reopen signal must cross the air (on our scheduled downlink, so that arbitration is ours), then transit the client's NAPI and GRO, TCP, TSQ, driver ring, and firmware aggregation. Grant-to-burst latency is hundreds of microseconds to milliseconds with real jitter, which is why every closed gate must reopen dithered. Second, congestion control interacts with burst shape. A window-limited, ACK-clocked sender such as CUBIC releases the delta as one burst, which is exactly what full-aggregate-per-arbitration wants. BBR paces at its estimated rate through fq, so a W-byte grant trickles out as several partial aggregates, each arbitrating, unless the grant cadence is what BBR's pacing converges to. This tension against the uplink pacing ask in the existing working note is a specific test item for the Fi-Wi Evaluation Platform (FWEP), the conducted RF rig used for controlled A/B measurement, since it may invert which congestion control behaves better under window gating.
A floor on the consolidation ratio is set by traffic no L3/L4 mechanism can gate: zero-window probes from the persist timer (the gate itself generates arbitrations if held too long), ARP and ND, DHCP renewals, mDNS and SSDP chatter, DNS, TCP keepalives, power-save nulls, and management frames. These are low duty cycle but irreducible from above the MAC; silencing them requires Quiet-element or NAV sculpting, which belongs to the MAC stratum. QUIC and UDP flows are also outside this stratum's reach: encrypted flow control (MAX_DATA) cannot be rewritten in the path, which is precisely the population the client library addresses.
Every scheme above and below needs a shared timebase, and Wi-Fi already distributes one. Each associated STA disciplines a hardware 1 MHz TSF counter to the BSS via beacon timestamps inserted at PHY transmit time and captured at PHY receive time: a free, protocol-mandated, hardware-timestamped synchronization service to every client, including unmodified ones. TSF crystals are spec'd to 100 ppm, but beacon discipline re-anchors clients roughly every 102.4 ms, so a client wanders at most a few microseconds between corrections. That is noise against millisecond slots and a manageable term for sub-millisecond ones.
The Concentrator owns the mapping matrix. Each RRH's TSF is a distinct domain, and the PCIe fronthaul gives us what no Ethernet-backhauled AP has: register-level access to each radio's TSF with microsecond-bounded read latency and no timing protocol on the fronthaul at all. TSF sampling on the MT7915 under mt76 is already confirmed working. Periodic cross-timestamps of each RRH TSF against the host clock yield a per-RRH affine map (offset plus drift) into one master timeline. Grants, DMA starts, quiet intervals, and TWT service periods are computed in master time and translated per-BSS at emission. Because clients only ever see local-BSS TSF values, a roam between radio heads is a re-affine at the Concentrator and nothing about grant semantics changes.
Three consequences follow. First, the strata compose: TWT, Quiet elements, and NAV are specified in TSF time natively, so the induced-gate schedule, the library grant schedule, and the MAC levers share one timeline instead of two schedulers fighting; a TWT service period and a window-reopen instant can be the same appointment. Second, cross-RRH scheduling becomes global: since all RRH domains map to master time, grants to clients on different radio heads can be made non-overlapping across an interference domain, which is the claim no autonomous-AP architecture can make. Third, guard bands become measured quantities: the RRH hardware-timestamps uplink arrivals in TSF, so for every grant we observe release at T and first MPDU on air at T plus delta, with delta decomposing into client stack jitter plus arbitration residency. Dither and guard bands are then adapted per client from measured distributions rather than set conservatively.
The client side of the map is the one new piece of engineering. Userspace cannot portably read the NIC's TSF register, so the library disciplines a virtual clock through our own protocol: downlink grants carry TSF emission times, SPAN exports TSF-stamped uplink arrivals per packet, and the library runs a min-filtered offset estimator over many samples. This is PTP logic riding our telemetry channel instead of its own protocol, and it inherits PTP's delay-attack threat model, addressed in Section 6.
Rather than waiting for the installed base to grow trigger-capable MACs, we move the scheduling control plane into a userspace protocol over UDP, deployed the way QUIC was deployed: by controlling one end (the Concentrator) and making the other end an installable library. The protocol carries three things. Grants: an id, an absolute TSF-domain start time, and an air-time budget, a scheduled TXOP in effect, with a byte-size hint for the L4 release and eligibility-window semantics rather than commanded instants, consistent with the actuator model in which a grant shapes the radio's autonomous contention process. Telemetry: per-packet EDCA state (access category, backoff, retries, aggregate position, grant id) plus TSF arrival stamps, exported IOAM-style end to end. Clock discipline: the cross-timestamp exchange from Section 5.
Design constraints that are load-bearing from day one. Grants and telemetry must be authenticated inside an encrypted session: a spoofed grant is a targeted denial of service, spoofed telemetry poisons the scheduler, and per-packet EDCA state is an RF fingerprint that must never travel in cleartext. Everything after a minimal invariant header is encrypted for the anti-ossification reason QUIC established: what middleboxes cannot parse, they cannot calcify. The clock-discipline exchange must tolerate an attacker delaying packets, the standard PTP threat, which the min-filter and plausibility bounds on drift partially address and which the security review should treat explicitly. Client capability (release precision tier, Section 7) is declared in the handshake but treated as a hint: the scheduler classifies each client's actual obedience empirically from grant-to-air distributions and sizes guard bands from measurement, which is the correct trust model for a network scheduling hardware it does not own.
Non-participating clients require nothing and lose nothing: they receive induced shaping and MAC-stratum treatment. Participants measurably beat them on tail latency, and the telemetry proves the delta per client, which is the adoption incentive. The standards venue and deployment path are the ones this document leads with: the IETF, through running code plus an Internet-Draft. One sequencing note: the provisional-versus-defensive-publication decision must be made before any I-D posts, because a draft is prior art against us from the day it publishes.
io_uring solves timed release. The primitive is a linked chain: an absolute-time TIMEOUT SQE (IORING_TIMEOUT_ABS with the ETIME_SUCCESS flag, so expiry counts as success and does not cancel the chain) linked to a SENDMSG SQE. The kernel fires the send at T from hrtimer context with no userspace wakeup, removing the scheduler-jitter term that makes woken-thread release millisecond-class under load and reaching tens-of-microseconds accuracy. Critically, the timing happens above the socket, before the packet enters the egress path, so it works on Wi-Fi netdevs regardless of the mac80211 wake_tx_queue behavior that routes around fq and etf; nothing downstream needs to honor a timestamp because the packet does not exist until T. Multishot recv serves the grant and telemetry channel, and registered buffers serve the payload path, so the library's entire I/O reduces to arming a schedule and harvesting completions. The hard limit is Android, where io_uring is seccomp-restricted for app-domain processes; io_uring is therefore the Linux tier (CPE, set-tops, enterprise endpoints, our own gear, the rig). Verify the minimum kernel version for ETIME_SUCCESS on target platforms during implementation.
eBPF splits into three uses with different verdicts. As lab instrumentation (fentry and tracepoint decomposition of grant-to-air latency per stack layer) it is valuable and correctly scoped lab-only, and the cross-distro deployment objection raised in review is irrelevant there. As a tc-egress tstamp writer it is weak on Wi-Fi specifically: the clsact hook executes even on noqueue devices, so BPF can observe, mark, and drop, but it cannot hold a packet, and enforcement requires a qdisc the wake_tx_queue path may never consult. Whether a manually attached fq is honored varies by driver and must be verified per target; treat this path as unreliable pending that verification. The underused third role is struct_ops: a BPF congestion control module that reads grants from a map the userspace library populates and shapes cwnd and pacing so TCP releases full-aggregate bursts on the grant clock. That is grant obedience for unmodified TCP applications on cooperative Linux hosts, with no kernel patches, and it extends the protocol's reach beyond our own UDP transport. Recent kernels additionally allow qdiscs to be implemented as BPF struct_ops where an enforcement qdisc is viable.
The resulting client tiers, which the protocol encodes and the telemetry verifies: tier one, Linux endpoints and Umber hardware, io_uring release plus BPF struct_ops, tens-of-microseconds obedience; tier two, phone applications, userspace timed sendmsg inside the library, hundreds of microseconds to milliseconds, tolerant of Doze and timer coalescing, with grant schedules deliberately aligned to TWT service periods so scheduled release doubles as a battery feature; tier three, unmodified clients, induced scheduling only. The Concentrator itself needs neither vehicle; DPDK owns release timing there.
The primary metric is arbitrations per delivered megabyte at fixed offered load, measured across four conditions on identical H-matrix settings: open loop, rwnd-gated, echo-scheduled, and library-granted. Secondary measurements: the grant-to-air delta distribution per client and per tier, which feeds guard-band adaptation; the CUBIC-versus-BBR burst-shape comparison under window gating from Section 4; and the residual-arbitration floor from ungateable traffic. This ties into Experiment 0's regime characterization, since consolidation gains should be read against the contention-efficiency and goodput-rollover regimes already defined.
The reference load generator is iperf2. The per-packet SCM_TXTIME plumbing already exists in the UDP path (writemsg_delay_tos), and an io_uring timed-burst engine on the isochronous frame clock would emit the quantized-EDT traffic shape with in-kernel release timing and no qdisc dependency, doubling as the reference implementation of grant obedience before the library ships. Two source-level checks while that work is open: which clockid the SO_TXTIME setsockopt passes, since strict etf and hardware LaunchTime enforce against the PHC rather than CLOCK_MONOTONIC; and whether the cmsg path requests late-packet error reporting, since for rig work we must know whether late packets were sent late or silently dropped, or arbitration counts will be misattributed.
Cellular settled the underlying question: scheduled MACs beat contended MACs at density, and C-RAN centralized the scheduler because vantage wins. The Concentrator has the vantage (every queue, every flow's L4 state, every RRH, the WAN side, one master clock), the actuation (L4 levers and MAC levers together), and the compute; the client MAC remains the microsecond executor of eligibility decisions planned at millisecond scale. Wi-Fi never got the control plane that makes this possible, and 802.11 cannot supply it because the missing machinery is above L2. This protocol is the retrofit, and it is not Wi-Fi-specific in principle: it is an L3/L4 scheduling control plane for a contended last hop, with TSF as the timebase Wi-Fi happens to distribute for free. The Concentrator without it is a better AP. With it, it is the scheduler for the building.
For IETF engineers, the bottom line repeated from the front: we intend to propose a working group, and chartering one takes demonstrated energy, not just a good idea. The transport community has spent the last decade building exactly the instruments this system composes: EDT-based pacing, L4S signaling, QUIC's userspace deployment model, IOAM-style telemetry. What remains is to aim them at the hop where the queues actually form. The path runs through the standard gate: a problem-statement draft and a non-WG mailing list, a side meeting, then a BoF with implementations and statements of interest behind it, then a charter. The specific asks: review the grant semantics and their congestion-control interaction, since the window-gating question in Section 4 is open and may invert current assumptions; scrutinize the clock-discipline exchange against PTP-class threat models before the security section of any draft hardens; run the code, since iperf2 carries the release-scheduling machinery today and the reference grant-obedient generator is being built in the open; and if the contended last hop is your problem too, say so on the record, because a BoF is judged by who shows up with the problem. Until a charter exists, the early drafts land in TSVWG and CCWG for the transport interactions and IPPM for the per-packet telemetry, with the Internet-Draft following the running code, in the order the tradition prescribes. If you schedule packets for a living, the contended last hop is the queue you have not scheduled yet. Come schedule it with us.