Zero-Copy Kernel Datapaths: Building Thread-Per-Core Rust Services with io_uring

For over a decade, the default recipe for high-concurrency network services in Linux has been non-blocking sockets driven by epoll paired with a multi-threaded, work-stealing user-space scheduler (such as Go's runtime or Rust's default tokio multi-thread executor). While that model effortlessly handles tens of thousands of slow HTTP connections, it hits an architectural wall when pushed against 100GbE NICs and Gen5 NVMe storage arrays capable of $> 12\text{M IOPS}$.

At sub-microsecond inter-arrival times, the cost of epoll_wait syscalls, cross-core L1/L2 cache invalidations from work-stealing task migration, and kernel-to-user buffer copies consumes more CPU cycles than the application logic itself. Here is how we re-engineered our telemetry ingestion engine in Rust using a Thread-Per-Core Shared-Nothing Architecture powered by Linux io_uring.

Work-Stealing epoll vs. Shared-Nothing io_uring#

In a traditional work-stealing runtime, a socket readiness event woken on Core 0 may be stolen and executed by Core 7. Every task migration invalidates L1/L2 CPU caches and forces atomic reference-counting synchronization (Arc<Mutex<T>>) across NUMA boundaries.

By switching to io_uring:

1. Application and kernel communicate via twin lock-free ring buffers mapped into shared memory (mmap).
2. Operations (read, write, accept, splice) are submitted with zero system calls when SQPOLL mode is active.
3. Network packets are DMA-transferred directly into pre-registered page-aligned buffers.

Zero-Copy Socket Ingestion in Rust#

use io_uring::{opcode, types, IoUring};
use std::os::unix::io::RawFd;
 
pub struct UringWorker {
    ring: IoUring,
    buf_pool: Vec<Vec<u8>>,
}
 
impl UringWorker {
    pub fn submit_recv_multishot(&mut self, fd: RawFd, buf_group: u16) {
        let recv_e = opcode::RecvMulti::new(types::Fd(fd), buf_group)
            .build()
            .user_data(0xDEAD_BEEF);
 
        unsafe {
            self.ring
                .submission()
                .push(&recv_e)
                .expect("Submission queue ring full");
        }
        self.ring.submit().expect("Failed to flush SQ entries");
    }
}

Profiler Performance Metrics#

We benchmarked 100-byte UDP & TCP telemetry packet ingestion under sustained 100GbE network saturation:

Eliminating kernel boundary transitions unlocks line-rate packet ingestion with predictable sub-microsecond tail latencies on commodity Linux hardware.