PeeR: First-Class Scheduling for Latency-Critical eBPF Applications

This repository contains the source code and evaluation scripts for PeeR (OSDI '26).

PeeR is an eBPF runtime that makes latency-critical eBPF programs (e.g., XDP request handlers) preemptable and schedulable while preserving their low-overhead execution model. PeeR instruments the eBPF JIT to insert lightweight budget checks at helper-call boundaries; programs that exceed their budget yield, save their execution state to a continuation, and resume on per-CPU worker kthreads under a two-level scheduling hierarchy integrated with sched_ext.

If you use PeeR, please cite the reference below.

Repository structure

PeeR
|-- linux/            : Linux kernel v6.16 with PeeR (CONFIG_PEER)
|   |-- net/core/peer.c              : continuation + worker-kthread runtime
|   |-- kernel/bpf/peer_sched.c      : scheduler integration
|   |-- kernel/peer/                 : sysfs control interface
|   |-- arch/x86/net/bpf_jit_comp.c  : JIT budget-check + yield instrumentation
|   |-- tools/sched_ext/scx_peer.*   : sched_ext macro-scheduler
|   \-- tools/sched_ext/peer-policies/ : micro-scheduler policies (FIFO, SRPT, WRR, ...)
|-- eval/             : evaluation harness (Python, uv)
|   |-- client/loadgen/  : open-loop load generator (Rust, Caladan-based)
|   |-- memcached/       : Memcached experiments
|   |-- redis/           : Redis experiments
|   \-- common/          : shared config and orchestration
|-- scripts/          : kernel build + install scripts
|-- paper.pdf         : the OSDI '26 paper
\-- README.md

Hardware setup

Experiments use two machines connected by a dedicated network:

• Server: runs the PeeR kernel.
• Client: runs loadgen, an open-loop Poisson load generator.

The paper's evaluation used two 28-core Intel Xeon Gold 5420+ servers with Mellanox ConnectX-7 400 Gbps NICs. The artifact also runs on CloudLab: we use a two-node c6620 cluster (Utah) running Ubuntu 24.04.

Getting started

Clone onto both machines (on CloudLab, into the temporary disk):

cd /mydata
git clone https://github.com/hipersys-team/PeeR.git
cd PeeR

1. Build and install the PeeR kernel (server)

./scripts/install_deps_server.sh
./scripts/install_kernel.sh

install_kernel.sh builds Debian packages from linux/ (about 5 minutes on 56 threads), installs them, and stages a one-shot boot into the PeeR kernel, so an unattended power cycle falls back to the stock kernel:

sudo grub-reboot "Advanced options for Ubuntu>Ubuntu, with Linux 6.16.0-peer"
sudo reboot

After reboot, verify:

uname -r                 # 6.16.0-peer...
ls /sys/kernel/peer/     # PeeR sysfs interface

2. Build the load generator (client)

./scripts/install_deps_client.sh
./scripts/install_loadgen.sh

This builds Caladan (under eval/client/loadgen/caladan/) and the Rust loadgen binary. loadgen requires a nightly Rust toolchain; the script installs one via rustup.

3. Configure the harness

cp eval/common/constants.example.py eval/common/constants.py
# edit: hostnames, experiment-network IPs, NIC names, repo paths, SSH key

4. Run experiments

Experiment drivers live under eval/; see eval/README.md for the per-experiment entry points (Redis and Memcached GET/SCAN head-of-line blocking, TPC-C scheduling policies, colocation/fair-sharing, and preemption-overhead microbenchmarks).

Citation

@inproceedings{peer-osdi26,
  author    = {Jeremy Carin and Ben Holmes and Weiyang Wang and Ankit Bhardwaj and Manya Ghobadi},
  title     = {{PeeR}: {First-Class} Scheduling for {Latency-Critical} {eBPF} Applications},
  booktitle = {20th USENIX Symposium on Operating Systems Design and Implementation (OSDI 26)},
  year      = {2026},
  isbn      = {978-1-939133-55-7},
  address   = {Seattle, WA},
  pages     = {2465--2482},
  url       = {https://www.usenix.org/conference/osdi26/presentation/carin},
  publisher = {USENIX Association},
  month     = jul
}

License

The linux/ tree is GPL-2.0 (see linux/COPYING). Third-party components (Caladan, SPDK, DPDK, memcached) retain their original licenses in their respective directories.