Paper deep dive

eBandit: Kernel-Driven Reinforcement Learning for Adaptive Video Streaming

Mahdi Alizadeh

Year: 2026Venue: arXiv preprintArea: cs.NIType: PreprintEmbeddings: 15

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 96%

Last extracted: 4/14/2026, 1:46:01 AM

Summary

eBandit is a framework that improves Adaptive Bitrate (ABR) streaming by moving network monitoring and policy selection into the Linux kernel using eBPF. By utilizing a lightweight epsilon-greedy Multi-Armed Bandit (MAB) that operates on real-time TCP metrics (RTT, delivery rate), eBandit dynamically selects the best ABR heuristic, outperforming static policies in both synthetic and real-world mobile network conditions.

Entities (5)

eBandit · framework · 100%eBPF · technology · 100%Linux Kernel · system-component · 99%Adaptive Bitrate · technique · 98%Multi-armed bandit · algorithm · 95%

Relation Signals (3)

eBandit → utilizes → eBPF

confidence 100% · We present eBandit, a framework that relocates both network monitoring and ABR algorithm selection into the Linux kernel using eBPF.

eBandit → implements → Multi-armed bandit

confidence 95% · A lightweight epsilon-greedy Multi-Armed Bandit (MAB) runs inside a sockops program

eBandit → optimizes → Adaptive Bitrate

confidence 95% · eBandit: Kernel-Driven Reinforcement Learning for Adaptive Video Streaming

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:User-space Adaptive Bitrate (ABR) algorithms cannot see the transport layer signals that matter most, such as minimum RTT and instantaneous delivery rate, and they respond to network changes only after damage has already propagated to the playout buffer. We present eBandit, a framework that relocates both network monitoring and ABR algorithm selection into the Linux kernel using eBPF. A lightweight epsilon-greedy Multi-Armed Bandit (MAB) runs inside a sockops program, evaluating three ABR heuristics against a reward derived from live TCP metrics. On an adversarial synthetic trace eBandit achieves $416.3 \pm 4.9$ cumulative QoE, outperforming the best static heuristic by $7.2\%$. On 42 real-world sessions eBandit achieves a mean QoE per chunk of $1.241$, the highest across all policies, demonstrating that kernel-resident bandit learning transfers to heterogeneous mobile conditions.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

14,261 characters extracted from source content.

Expand or collapse full text

eBandit: Kernel-Driven Reinforcement Learning for Adaptive Video Streaming Mahdi Alizadeh University of Southern CaliforniaLos AngelesCAUSA malizade@usc.edu (2026) Abstract. User-space Adaptive Bitrate (ABR) algorithms cannot see the transport layer signals that matter most, such as minimum RTT and instantaneous delivery rate, and they respond to network changes only after damage has already propagated to the playout buffer. We present eBandit, a framework that relocates both network monitoring and ABR algorithm selection into the Linux kernel using eBPF. A lightweight epsilon-greedy Multi-Armed Bandit (MAB) runs inside a sockops program, evaluating three ABR heuristics against a reward derived from live TCP metrics. On an adversarial synthetic trace eBandit achieves 416.3±4.9416.3± 4.9 cumulative QoE, outperforming the best static heuristic by 7.2%7.2\%. On 42 real-world sessions eBandit achieves a mean QoE per chunk of 1.2411.241, the highest across all policies, demonstrating that kernel-resident bandit learning transfers to heterogeneous mobile conditions. †copyright: none†journalyear: 2026†conference: ACM SIGCOMM 2026; August 2026; Stockholm, Sweden†booktitle: ACM SIGCOMM 2026, August 2026, Stockholm, Sweden 1. Introduction The explosive growth of video-on-demand and live streaming has made adaptive bitrate (ABR) selection one of the most performance-critical decisions on the Internet. Every time a user watches a video, a client-side algorithm must choose the quality of the next segment based on its estimate of available bandwidth. Get it wrong, and the viewer suffers rebuffering stalls or unnecessary quality drops. Yet today’s ABR algorithms make this decision entirely in user space, often inside a browser sandbox that has no access to low-level network signals. Meanwhile, the Linux kernel already tracks fine-grained TCP state, such as smoothed RTT and per-ACK delivery rate, that would let ABR react faster and more accurately. Our core motivation follows naturally from this observation. If the operating system already knows the network state, the ABR decision should be made there. Modern ABR clients execute entirely in user space, relying on application-layer proxies such as throughput estimates and buffer level as surrogates for the true network state. This architecture suffers from two compounding problems. First, an observability gap separates the kernel from user space. By the time a throughput drop or RTT spike propagates to the application layer, one or more video segments have already been requested at an inappropriate bitrate and the playout buffer has begun to drain. The kernel’s TCP control block maintains sub-millisecond RTT measurements and per-ACK delivery-rate samples that are simply invisible to user-space sockets, creating an order-of-magnitude timing gap between the kernel’s view and the application’s. Second, individual heuristics are brittle because no single static ABR policy dominates across all network conditions. Throughput-based schemes (yin2015mpc, ) over-react on jittery links; buffer-based schemes (huang2014bba, ) stall catastrophically after cliff-edge capacity drops; and utility-maximizing controllers such as BOLA (spiteri2016bola, ) lag behind rapid regime shifts. A recent measurement study by Yan et al. (yan2020puffer, ) confirms this at scale, showing that in-situ conditions determine which algorithm wins on any given session, making a static choice inherently suboptimal. We argue that policy selection should happen where TCP state is natively visible. To this end we present eBandit, a framework built on the Linux eBPF subsystem (vieira2020ebpf, ) that (i) monitors TCP connections at socket-event granularity via a sockops program, (i) computes a per-RTT reward from raw kernel metrics using integer arithmetic only, and (i) runs an epsilon-greedy Multi-Armed Bandit (MAB) entirely in kernel space to select the ABR policy that performs best in the current network regime. The user-space client becomes a thin executor that polls a shared eBPF map at chunk boundaries and dispatches to whichever policy the kernel has elected, with zero recompilation and sub-microsecond overhead. eBPF programs run in a sandboxed, JIT-compiled environment attached to kernel hooks, providing zero-copy, zero-context-switch access to TCP control-block fields such as srtt_us, delivery rate, and bytes delivered, all of which are invisible to user-space sockets. The epsilon-greedy MAB is deliberately chosen over deeper RL models (abbasloo2020orca, ): its state is three ⟨count,total⟩ ,\,total pairs (one per arm) and its update is a single integer addition, fitting within eBPF stack and instruction limits. A warm-start variant bootstraps from a small held-out trace set to skip the cold-start exploration penalty in production. Unlike learned ABR systems (mao2017pensieve, ) that require heavy offline training and are difficult to update once deployed, eBandit learns continuously from live traffic and can adapt to new network regimes without retraining. By combining the kernel-residence of recent eBPF systems (zhou2023electrode, ; miano2023sketching, ) with online bandit learning, eBandit occupies a design point between static heuristics and heavyweight neural ABR. 2. System Design & Approach Figure 1. eBandit evaluation. (A) Adversarial three-phase bandwidth trace (jitter → cliff → rocket). (B) Cumulative QoE on the adversarial trace, averaged over 10 seeds; shaded bands are ±1σ± 1σ. (C) Mean QoE per chunk on 42 Norway HSDPA sessions (± ); eBandit (warm) achieves the highest score. Kernel-Space Component. A sockops eBPF program is attached to the root cgroup, hooking into ACTIVE_ESTABLISHED_CB (to subscribe new connections to RTT callbacks) and RTT_CB (to receive per-RTT measurements). On every RTT callback the program reads three fields from the bpf_sock_ops context, namely srtt_us, rate_delivered, and rate_interval_us, and computes a normalized reward using integer arithmetic only (the BPF verifier forbids floating-point): (1) rt=wr⋅mint+wd⋅dtdmaxwr+wd,r_t= w_r· rtt_ rtt_t\;+\;w_d· d_td_ w_r+w_d, where minrtt_ is the running minimum RTT, dmaxd_ is the running maximum delivery rate, and wr=6w_r=6, wd=4w_d=4 weight latency (60%) more heavily than throughput (40%). All values are scaled by a constant S=1000S=1000 to preserve precision in fixed-point; the result rt∈[0, 1000]r_t∈[0,\,1000]. This reward is attributed to whichever ABR arm is currently active (recorded in a per-IP BPF_MAP_TYPE_HASH entry keyed by the remote IPv4 address) and accumulated into the arm’s ⟨pull_count,total_reward⟩ \_count,\,total\_reward entry in a global BPF_MAP_TYPE_ARRAY of three arms. The epsilon-greedy selection step executes using only 32-bit integer arithmetic to respect eBPF’s verifier constraints; stochastic arm selection is seeded from bpf_get_prandom_u32(). Arm comparison avoids division entirely via cross-multiplication so that r¯i>r¯j r_i> r_j iff totali×countj>totalj×countitotal_i×count_j>total_j×count_i, and the loop over three arms is manually unrolled because the BPF verifier rejects backward-edge loops in BCC-compiled programs. A shock detection heuristic augments the MAB: when the 2-chunk rolling bandwidth average increases by >2.5×>2.5×, the agent overrides exploration and selects the Throughput arm for a cooldown window. This mechanism is currently in user-space simulation; kernel-side porting is planned. User-space component. The video client implements three independent policy modules: Throughput (harmonic-mean estimator, window 3, following (yin2015mpc, )), BOLA (buffer-aware utility maximization (spiteri2016bola, ) with adaptive safety margin), and Hybrid BBA+ (buffer thresholds gated by a bandwidth cap, extending (huang2014bba, )). At each chunk boundary the client issues a single bpf_map_lookup_elem call (sub-microsecond) to read the elected arm ID and dispatches to the corresponding module. Policy switching is stateless and no ABR internal state is carried across arm transitions. A warm-start path pre-populates the MAB’s reward accumulators from a small held-out trace set, eliminating the cold-start exploration phase in latency-sensitive deployments. Because warm-start only adjusts initial counts in the bandit’s map entries, it adds no runtime overhead. Overhead. The dominant cost is the per-RTT eBPF callback, which executes entirely in kernel space without a context switch. Based on published BPF JIT characterisation (miano2023sketching, ; zhou2023electrode, ), we estimate the full callback (reward computation + arm update) at ≈ 300 ns, which is two orders of magnitude below a user-space /proc/net/tcp poll (≈ 10–50 µs). The per-chunk bpf_map_lookup_elem adds <<1 µs, negligible relative to a 2.5 s chunk duration. 3. Evaluation We evaluate eBandit against three static baselines (Throughput-Based, Buffer-Based (BBA) (huang2014bba, ), and Hybrid BBA+) using a purpose-built adversarial synthetic trace and the standard Norway HSDPA mobile dataset (riiser2013, ) (Figure 1). All evaluations use a faithful Python simulation of the kernel MAB logic (identical reward function, epsilon-greedy policy, and arm-selection rules), enabling reproducible experiments over diverse trace corpora without requiring root access. We adopt the log-utility QoE model of Pensieve (mao2017pensieve, ): (2) QoE=log2⁡(bt150)−λ⋅rebuf−μ⋅|Δlog2⁡b|,QoE= _2\! ( b_t150 )-λ·rebuf-μ·| _2b|, with λ=4.3λ=4.3 and μ=2.0μ=2.0. Adversarial synthetic trace. eBandit outperforms the best static heuristic by 7.2% and avoids the catastrophic stalls of buffer-based schemes. The trace (Figure 1A) stresses each heuristic’s known failure mode in three phases. In Phase 1 (Jitter, chunks 1–40), bandwidth oscillates between 4.5 and 0.8 Mbps, making throughput estimates volatile. In Phase 2 (Cliff, chunks 41–120), capacity drops to 200 kbps; buffer-based schemes, having filled the buffer, select high-bitrate segments and stall catastrophically (huang2014bba, ). In Phase 3 (Rocket, chunks 121–180), capacity surges to 9 Mbps; eBandit’s shock detector promotes the Throughput arm for aggressive quality ramp-up. eBandit (ε∗=0.05 ^*=0.05) achieves cumulative QoE of 416.3±4.9416.3± 4.9, versus 388.5388.5 for Throughput, 316.7316.7 for Hybrid, and 292.6±57.4292.6± 57.4 for Buffer-Based, which is 7.2%7.2\% above the best static policy (Figure 1B). Real-world traces. On mobile traces, eBandit (warm) achieves the highest mean QoE per chunk among all evaluated policies. We evaluate on 42 sessions drawn from bus, tram, train, and ferry subsets of the Norway HSDPA dataset (riiser2013, ), withholding 8 traces for warm-start calibration. Epsilon is fixed at 0.100.10 (the Pensieve default (mao2017pensieve, )) and not tuned on HSDPA data to avoid circularity. eBandit (warm) achieves a mean QoE per chunk of 1.2411.241, compared with 1.2261.226 for cold-start, 1.2241.224 for Throughput, 1.2001.200 for Hybrid, and 0.2730.273 for Buffer-Based (Figure 1C). A paired Wilcoxon signed-rank test confirms that the warm-start advantage over the best static baseline (Throughput) is statistically significant (p=0.001p=0.001). The warm-start prior biases toward BOLA, which exploits the sustained medium-bandwidth corridors common in Norwegian urban transit, mirroring the Puffer (yan2020puffer, ) finding that small in-situ data can decisively shift policy selection without full retraining. 4. Conclusion and Future Work eBandit demonstrates that relocating ABR policy selection into the Linux kernel via eBPF is both practical and impactful, composing complementary heuristics without manual threshold engineering. Future work includes a Contextual Bandit (alt2019cba, ) upgrade, Mahimahi evaluation, and porting shock detection into eBPF. References (1) S. Abbasloo, C.-Y. Yen, and H. J. Chao. Classic meets modern: A pragmatic learning-based congestion control for the Internet. In Proc. ACM SIGCOMM, p. 632–647, 2020. (2) B. Alt, T. Ballard, R. Steinmetz, H. Koeppl, and A. Rizk. CBA: Contextual quality adaptation for adaptive bitrate video streaming. In Proc. IEEE INFOCOM, p. 1–9, 2019. (3) M. Ghasemi, D. Lorenzi, M. Dolati, F. Tashtarian, S. Gorinsky, and C. Timmerer. Receiving kernel-level insights via eBPF: Can ABR algorithms adapt smarter? In Proc. WüWoWAS, 2025. (4) T.-Y. Huang, R. Johari, N. McKeown, M. Trunnell, and M. Watson. A buffer-based approach to rate adaptation: Evidence from a large video streaming service. In Proc. ACM SIGCOMM, p. 187–198, 2014. (5) H. Mao, R. Netravali, and M. Alizadeh. Neural adaptive video streaming with Pensieve. In Proc. ACM SIGCOMM, p. 197–210, 2017. (6) S. Miano, A. Sanaee, F. Risso, and G. Antichi. Fast in-kernel traffic sketching in eBPF. ACM SIGCOMM Comput. Commun. Rev., 53(1):2–9, 2023. (7) H. Riiser, P. Vigmostad, C. Griwodz, and P. Halvorsen. Commute path bandwidth traces from 3G networks: Analysis and applications. In Proc. ACM MMSys, p. 114–118, 2013. (8) K. Spiteri, R. Urgaonkar, and R. K. Sitaraman. BOLA: Near-optimal bitrate adaptation for online videos. In Proc. IEEE INFOCOM, p. 1–9, 2016. (9) M. A. M. Vieira, M. S. Castanho, R. D. G. Pacífico, E. R. S. Santos, E. P. M. Câmara Júnior, and L. F. M. Vieira. Fast packet processing with eBPF and XDP: Concepts, code, challenges, and applications. ACM Comput. Surv., 53(1):16:1–16:36, 2020. (10) F. Y. Yan, H. Ayers, C. Zhu, S. Fouladi, J. Hong, K. Zhang, P. Levis, and K. Winstein. Learning in situ: A randomized experiment in video streaming. In Proc. USENIX NSDI, p. 495–510, 2020. (11) X. Yin, A. Jindal, V. Sekar, and B. Sinopoli. A control-theoretic approach for dynamic adaptive video streaming over HTTP. In Proc. ACM SIGCOMM, p. 325–338, 2015. (12) Y. Zhou, Z. Wang, S. Dharanipragada, and M. Yu. Electrode: Accelerating distributed protocols with eBPF. In Proc. USENIX NSDI, p. 1597–1613, 2023.

Instant research discovery