High-Performance Network I/O: io_uring, Kernel-Bypass & XDP

1. Problem & Context

Over the past decade, data center hardware has undergone an unprecedented revolution:

• Network Interface Cards (NICs): Upgraded from $1\text{ Gbps}$ to $100\text{ Gbps}$, $200\text{ Gbps}$, and $400\text{ Gbps}$.
• Storage Devices (NVMe SSDs): Capable of delivering over $1,500,000\text{ IOPS}$ per drive with sub-10 microsecond latencies.

However, software applications running on traditional Linux POSIX APIs (read(2), write(2), epoll(7)) fail to exploit this hardware capacity, hitting what systems researchers call the System Call Wall:

1. The System Call Overhead (KPTI & Meltdown Mitigation):
   • Entering the Linux kernel via syscall and returning via sysret costs between $150\text{ ns}$ and $800\text{ ns}$ per transition due to Kernel Page Table Isolation (KPTI), TLB flushes, and register saves.
   • At $100\text{ Gbps}$ line rate with standard 64-byte packets, a server receives 148 million packets per second (one packet every $6.7\text{ ns}$). Paying $500\text{ ns}$ per syscall makes line-rate processing mathematically impossible.
2. The Double Memory Copy:
   • The NIC DMA writes packets to kernel memory (sk_buff).
   • The OS network stack inspects IP/TCP headers.
   • The read() syscall copies payload bytes across the kernel boundary into user memory via copy_to_user(), consuming memory bus bandwidth.
3. epoll Readiness Bottlenecks (The C10M Problem):
   • epoll tells you when a socket has data ready to read, but requires subsequent read() calls to fetch it.
   • High connection churn forces expensive epoll_ctl syscalls to add, modify, or delete file descriptors in the kernel red-black tree.

To achieve maximum line-rate performance, modern systems software relies on Zero-Syscall Shared-Memory Rings (io_uring) and Kernel-Bypass Packet Engines (XDP and AF_XDP).

2. Mental Model & Architectural Abstraction

The architectural evolution of network I/O:

[ Tier 1: Traditional POSIX epoll ]
User Space       [ read() ] ────> [ User Buffer ]
                    │ Context Switch (sysenter / sysexit)
────────────────────┼────────────────────────────────────────────────────────
Kernel Space     [ sk_buff ] ───> copy_to_user() ───> Netfilter / iptables
                    │ DMA
Hardware         [ NIC Rx Ring ] (Max: ~2-4M Packets/sec per core)

[ Tier 2: Linux io_uring (Shared-Memory Rings) ]
User Space       [ Submission Queue (SQ) ]  <──>  [ Completion Queue (CQ) ]
                    ▲ Shared Memory (mmap)           │
                    │ Zero Context Switches (SQPOLL) │
────────────────────┼────────────────────────────────┼───────────────────────
Kernel Space     [ SQPOLL Kernel Thread ] ───────────┘
                 Batched async dispatch directly to sockets/files

[ Tier 3: eXpress Data Path (XDP) & AF_XDP Zero-Copy ]
User Space       [ UMEM Shared Memory Chunk Pool ] <── (Zero Copy Read)
                    ▲ Direct Pointer Mapping
────────────────────┼────────────────────────────────────────────────────────
Kernel / Driver  [ eBPF XDP Program ] (Driver Hook)
                    ├── XDP_DROP (DDoS mitigation at wire speed)
                    └── XDP_REDIRECT ──> [ AF_XDP Socket Ring ]
Hardware         [ NIC Hardware Rx Descriptor ] (25M+ Packets/sec per core!)

The fundamental mental shift is moving from synchronous function calls to shared-memory circular ring queues:

• The application and the operating system communicate by producing and consuming descriptors in pre-allocated circular buffers mapped into both user and kernel address space.
• Hardware DMA targets user-accessible memory directly, completely eliminating CPU kernel-to-user memory copies.

3. Core Terminology & Guarantees

4. System Architecture & Component Anatomy

SYSTEM ARCHITECTURE BLUEPRINTCOMPUTER ARCHITECTURE

⤢Expand

ARCHITECTURAL FLOW · STEP 1 OF 3

1. The POSIX Syscall Bottleneck & User / Kernel Transitions

Establishes the ingress and structural boundary across The POSIX Syscall Bottleneck & User / Kernel Transitions: sysenter / sysexit CPU cost 150ns - 800ns per syscall (KPTI); NIC DMA -> sk_buff in kernel copy_to_user() -> User buffer; epoll_ctl() syscall per socket Readiness notification, not async IO.

Architectural Invariant: Batch submissions: multiple I/O requests submitted via 1 syscall (or 0 with SQPOLL).

ARCHITECTURAL FLOW · STEP 2 OF 3

2. Completion Queue (CQ) Ring & IORING_SETUP_SQPOLL (Zero-Syscall Mode)

Coordinates core data-plane execution and state transitions through Completion Queue (CQ) Ring & IORING_SETUP_SQPOLL (Zero-Syscall Mode): Kernel posts Completion Queue Entries (CQE) containing results/return codes User reaps completions directly from memory without entering kernel; Dedicated kernel polling thread continually checks Submission Queue tail Application writes SQEs without calling enter() system call; Result: 100 percent zero-syscall async storage and network execution.

Architectural Invariant: Redirects packet raw payload directly to User UMEM ring Zero-Copy, Kernel-Bypass.

ARCHITECTURAL FLOW · STEP 3 OF 3

3. I/O Architecture Performance & Hardware Abstraction Spectrum & Tier 1: Standard POSIX / epoll

Enforces durability, state convergence, and output verification across I/O Architecture Performance & Hardware Abstraction Spectrum & Tier 1: Standard POSIX / epoll: Full kernel network stack, iptables, socket buffers; Throughput: ~1 to 3 Million Packets / Sec; Context switch and double copy on every read/write.

Architectural Invariant: Bypasses entire OS kernel network stack.

Deep Component Breakdown:

1. The io_uring Shared-Memory Rings:
   • Initialized via io_uring_setup(entries, &params).
   • The kernel returns file descriptors and memory offsets used by the application to mmap(2) three memory regions:
     • SQ Ring: Tracks head, tail, and array of indices into the SQE table.
     • SQE Array: The array of 64-byte submission descriptors.
     • CQ Ring: Tracks head, tail, and array of 16-byte io_uring_cqe completion structs.
   • Lockless Single-Producer Single-Consumer (SPSC): The application updates sq->tail; the kernel reads sq->head. The kernel updates cq->tail; the application reads cq->head.
2. eBPF XDP Actions:
   • An eBPF program is compiled into bytecode and loaded into the NIC driver via ip link set dev eth0 xdp obj xdp_prog.o.
   • For every incoming frame, the driver invokes the eBPF program, which returns one of five deterministic actions:
     • XDP_DROP: Discard packet instantly in hardware ring (ideal for line-rate SYN flood / UDP DDoS absorption).
     • XDP_TX: Bounce packet back out the same interface (ideal for ultra-low-latency L4 load balancing).
     • XDP_REDIRECT: Forward frame to another interface or directly to an AF_XDP socket.
     • XDP_PASS: Pass frame up to the standard Linux TCP/IP network stack.
     • XDP_ABORTED: Error condition; drops packet and increments eBPF tracepoints.

5. Detailed Request Flows & Protocols

5.1 io_uring Asynchronous Zero-Syscall Flow (SQPOLL)

Userspace Application            Shared SQ Ring (RAM)         Kernel SQPOLL Thread          Hardware (NVMe / NIC)
          │                               │                             │                             │
          ├── 1. Populate SQE ───────────>│                             │                             │
          │   (opcode: READ, fd, buf)     │                             │                             │
          │                               │                             │                             │
          ├── 2. Advance sq->tail in RAM  │                             │                             │
          │   (NO SYSTEM CALL EMITTED!)   │                             │                             │
          │                               ├── 3. Poll detects tail > head                             │
          │                               │      Advances sq->head ────>│                             │
          │                               │                             ├── 4. Issues DMA command ───>│
          │                               │                             │<── 5. Hardware DMA Complete─┤
          │                               │                             │                             │
          │                               │<── 6. Writes CQE to CQ Ring ┤                             │
          │                               │      Advances cq->tail      │                             │
          │                               │                             │                             │
          ├── 7. App checks cq->head != tail                                                          │
          │   Reaps result from RAM!      │                                                           │

1. Descriptor Construction: The application writes an io_uring_sqe struct into the shared SQ array in user memory.
2. Commit via Pointer Store: The application advances the sq->tail pointer using a store-release memory barrier. No system call is executed.
3. Kernel Detection: The dedicated SQPOLL kernel thread, polling in a tight loop, observes tail > head. It consumes the SQE and submits the operation directly to the block device or network subsystem.
4. Hardware Completion: The storage controller or NIC DMA completes the I/O.
5. Completion Notification: The kernel posts an io_uring_cqe struct into the shared CQ ring and advances cq->tail.
6. Result Harvesting: The application compares cq->head with cq->tail in RAM, reaps the completed buffer, and advances cq->head. Entire round-trip executed with zero context switches.

6. Mathematical Modeling & Hardware Physics

6.1 The 100GbE Line-Rate Math

For a $100\text{ Gbps}$ Ethernet interface transmitting minimum-size 64-byte packets (84 bytes on the wire including 8-byte preamble, 4-byte CRC, and 12-byte inter-packet gap):

On a $3.0\text{ GHz}$ CPU core: $$\text{Available Clock Cycles Per Packet}=6.72\text{ ns}\times 3.0\text{ cycles/ns}\approx 20\text{ CPU cycles!}$$

A single POSIX system call consumes over 300 cycles. Therefore, processing line-rate 100GbE packets via POSIX system calls is physically impossible regardless of software optimization. Only kernel-bypass (XDP / AF_XDP) executing within a 20-cycle window can process packets at wire speed.

7. Production TypeScript Implementation

This self-contained TypeScript simulation implements:

1. SubmissionQueue: Shared-memory circular ring buffer for async requests.
2. CompletionQueue: Shared-memory circular ring buffer for results.
3. IoUringEngine: Simulated kernel worker polling SQ and emitting CQEs without syscalls.
4. XDPFilter: In-driver packet filter demonstrating line-rate DDoS absorption.

Execute with: npx tsx network-io-capstone.ts

/**
 * ARCHITECTURE STUDY: High-Performance Network I/O — io_uring & XDP
 * Complete architectural simulation: io_uring SQ/CQ Shared-Memory Rings,
 * Zero-Syscall Submissions, and eBPF XDP Wire-Speed Packet Filtering.
 */

// ==========================================
// 1. io_uring Ring Data Structures
// ==========================================

export enum IoOpcode {
  READ = 0,
  WRITE = 1,
  ACCEPT = 2,
  SEND = 3,
}

export interface SQE {
  opcode: IoOpcode;
  fd: number;
  buffer: string;
  userData: number; // Unique tag to correlate response
}

export interface CQE {
  userData: number;
  result: number; // Bytes transferred or error code
}

export class SharedMemoryRing {
  public readonly capacity: number;
  public sq: SQE[] = [];
  public cq: CQE[] = [];
  public sqHead: number = 0;
  public sqTail: number = 0;
  public cqHead: number = 0;
  public cqTail: number = 0;

  constructor(capacity: number = 16) {
    this.capacity = capacity;
  }

  // Application writes to SQ in shared memory (Zero Syscall)
  submitSQE(sqe: SQE): boolean {
    if (this.sqTail - this.sqHead >= this.capacity) {
      return false; // Submission queue full
    }
    this.sq[this.sqTail % this.capacity] = sqe;
    this.sqTail++; // Store-release in RAM
    return true;
  }

  // Application reaps from CQ in shared memory (Zero Syscall)
  reapCQE(): CQE | null {
    if (this.cqHead === this.cqTail) {
      return null; // Empty completion queue
    }
    const cqe = this.cq[this.cqHead % this.capacity];
    this.cqHead++;
    return cqe;
  }
}

// ==========================================
// 2. Kernel Engine (Simulated SQPOLL Thread)
// ==========================================

export class IoUringKernelEngine {
  private ring: SharedMemoryRing;
  public totalProcessed: number = 0;

  constructor(ring: SharedMemoryRing) {
    this.ring = ring;
  }

  // Simulated kernel background polling thread
  pollSQAndExecute(): void {
    while (this.ring.sqHead < this.ring.sqTail) {
      const sqe = this.ring.sq[this.ring.sqHead % this.ring.capacity];
      this.ring.sqHead++;

      // Execute simulated I/O
      let resBytes = 0;
      if (sqe.opcode === IoOpcode.READ) resBytes = 4096;
      else if (sqe.opcode === IoOpcode.SEND) resBytes = sqe.buffer.length;

      // Post CQE to completion ring
      this.ring.cq[this.ring.cqTail % this.ring.capacity] = {
        userData: sqe.userData,
        result: resBytes,
      };
      this.ring.cqTail++;
      this.totalProcessed++;
    }
  }
}

// ==========================================
// 3. eBPF XDP Wire-Speed Packet Filter
// ==========================================

export enum XdpAction {
  XDP_DROP = 0,
  XDP_PASS = 1,
  XDP_TX = 2,
  XDP_REDIRECT = 3,
}

export interface RawPacket {
  srcIp: string;
  dstPort: number;
  payload: string;
}

export class XdpDriverEngine {
  private blockedIps: Set<string> = new Set();
  public droppedPackets: number = 0;
  public passedPackets: number = 0;
  public afXdpRedirects: number = 0;

  blockIp(ip: string): void {
    this.blockedIps.add(ip);
  }

  // Executes inside NIC driver before sk_buff allocation
  processPacket(pkt: RawPacket): XdpAction {
    // 1. Line-rate DDoS Drop check
    if (this.blockedIps.has(pkt.srcIp)) {
      this.droppedPackets++;
      return XdpAction.XDP_DROP; // Wire-speed hardware discard
    }

    // 2. High-performance AF_XDP Zero-Copy redirect
    if (pkt.dstPort === 8080) {
      this.afXdpRedirects++;
      return XdpAction.XDP_REDIRECT; // Bypasses standard Linux TCP/IP stack
    }

    // 3. Pass to regular Linux network stack
    this.passedPackets++;
    return XdpAction.XDP_PASS;
  }
}

// ==========================================
// 4. Execution & Verification Harness
// ==========================================

export function runNetworkIoDemo() {
  console.log("=== ARCHITECTURE STUDY: io_uring & XDP Kernel-Bypass ===");

  // 1. Setup io_uring shared memory rings
  const ring = new SharedMemoryRing(8);
  const kernel = new IoUringKernelEngine(ring);

  console.log("\n[1] Submitting Batched I/O Requests via io_uring Shared Memory:");
  ring.submitSQE({ opcode: IoOpcode.READ, fd: 3, buffer: "", userData: 101 });
  ring.submitSQE({ opcode: IoOpcode.READ, fd: 4, buffer: "", userData: 102 });
  ring.submitSQE({ opcode: IoOpcode.SEND, fd: 5, buffer: "HTTP/1.1 200 OK\r\n\r\n", userData: 103 });

  console.log(`  Submitted 3 SQEs to shared RAM without issuing syscalls.`);
  console.log(`  Ring state: SQ Head = ${ring.sqHead}, SQ Tail = ${ring.sqTail}`);

  // Kernel SQPOLL consumes requests
  console.log("\n[2] Kernel SQPOLL Thread Consumes and Completes Requests:");
  kernel.pollSQAndExecute();
  console.log(`  Kernel processed ${kernel.totalProcessed} I/O events.`);
  console.log(`  Ring state: CQ Head = ${ring.cqHead}, CQ Tail = ${ring.cqTail}`);

  // Userspace reaps completions from RAM
  console.log("\n[3] Userspace Reaping CQEs from Shared Memory (Zero Syscall):");
  let cqe: CQE | null;
  while ((cqe = ring.reapCQE()) !== null) {
    console.log(`  Reaped CQE -> UserData Tag: ${cqe.userData}, Result Bytes: ${cqe.result}`);
  }

  // 2. Setup eBPF XDP Driver
  console.log("\n[4] eBPF XDP Wire-Speed Packet Filter (DDoS Absorption):");
  const xdp = new XdpDriverEngine();
  xdp.blockIp("198.51.100.44"); // Malicious DDoS source

  const incomingTraffic: RawPacket[] = [
    { srcIp: "10.0.0.1", dstPort: 80, payload: "Standard GET /" },
    { srcIp: "198.51.100.44", dstPort: 80, payload: "SYN FLOOD ATTACK" },
    { srcIp: "10.0.0.2", dstPort: 8080, payload: "High-Speed RPC payload" },
  ];

  for (const pkt of incomingTraffic) {
    const action = xdp.processPacket(pkt);
    console.log(`  Packet from ${pkt.srcIp}:${pkt.dstPort} -> XDP Action: ${XdpAction[action]}`);
  }

  console.log(`\n  XDP Metrics: Dropped at wire = ${xdp.droppedPackets}, AF_XDP Redirects = ${xdp.afXdpRedirects}, Standard Linux Stack = ${xdp.passedPackets}`);
  console.log("\n=== High-Performance Network I/O Simulation Complete. Invariants Verified. ===");
}

runNetworkIoDemo();

8. Real-World Case Studies

8.1 Cloudflare (DDoS Mitigation via XDP & eBPF)

• Defends against terabit-scale volumetric DDoS attacks using in-driver XDP filters.
• Implements L4Drop: drops over 100 million malicious packets per second before the packets can touch Linux sk_buff structures or consume server CPU.

8.2 Meta (Katran Layer 4 Load Balancer)

• Open-source L4 network load balancer powering all incoming traffic to Facebook and Instagram.
• Completely implemented as an eBPF XDP program returning XDP_TX (bouncing forwarded packets directly back out the NIC) using consistent hashing, replacing millions of dollars of proprietary hardware load balancers.

8.3 Qdrant & TigerBeetle (io_uring in Production)

• TigerBeetle: Financial accounting database built in Zig; uses io_uring exclusively for both NVMe storage I/O and network replication, achieving hundreds of thousands of transactions/second with strict deterministic latency.
• Qdrant: High-performance vector database; uses io_uring for fast asynchronous payload index lookups on local NVMe SSDs.

9. Edge Cases, Failure Modes & Antipatterns

9.1 Ring Buffer Overflow & Backpressure

• Failure Mode: If an application produces SQEs faster than the hardware controller can process them, sqTail - sqHead hits ring capacity, and subsequent submissions are rejected.
• Remediation: Monitor IORING_SQ_NEED_WAKEUP. If the kernel SQPOLL thread sleeps due to idle inactivity, the application must issue one explicit io_uring_enter() call to re-awaken the kernel thread.

9.2 Memory Pinning and Locked Memory Quotas (RLIMIT_MEMLOCK)

• Failure Mode: io_uring and AF_XDP pin shared memory pages in physical RAM to prevent OS swapping during direct NIC DMA. If process RLIMIT_MEMLOCK is too low, io_uring_setup fails with ENOMEM.
• Remediation: Set ulimit -l unlimited or configure appropriate LimitMEMLOCK in systemd service definitions.

9.3 Spectre/Meltdown Syscall Flushes in Container Sandboxes

• Failure Mode: Running traditional POSIX web servers inside container runtimes with strict seccomp filtering multiplies syscall latency by $2\times -3\times$ as the kernel inspects every single syscall argument.
• Remediation: Transition container network ingress to io_uring or AF_XDP, which minimize seccomp filter evaluations by eliminating syscall invocations.

10. Observability, Metrics & Production Telemetry

11. Guided Hands-On Lab / Engineering Exercises

Lab 1: Implement an io_uring Batched Read Pipeline

• Objective: Use SharedMemoryRing to submit 10 concurrent file chunk reads in a single batch.
• Deliverable: Verify that all 10 operations complete with matching userData tags without emitting 10 separate synchronous calls.

Lab 2: Write an eBPF XDP Rate-Limiter in TypeScript

• Objective: Extend XdpDriverEngine with a token bucket per client IP.
• Deliverable: If an IP transmits $>100\text{ packets/sec}$, return XDP_DROP; otherwise return XDP_PASS. Verify that malicious bursts are dropped at wire speed.

Lab 3: Simulate AF_XDP UMEM Zero-Copy Chunk Allocation

• Objective: Implement a pre-allocated UMEM array of 64 memory buffers.
• Deliverable: Simulate NIC DMA writing directly into free UMEM chunks and userspace releasing chunks back to the fill ring.

export function runBatchedReadPipeline(): void {
  const ring = new SharedMemoryRing(16);
  const kernel = new IoUringKernelEngine(ring);

  // Enqueue 10 SQEs in a single memory batch (userData tags 1000..1009)
  for (let i = 0; i < 10; i++) {
    const ok = ring.submitSQE({
      opcode: IoOpcode.READ,
      fd: 42,
      buffer: '',
      userData: 1000 + i,
    });
    if (!ok) throw new Error(`SQ ring overflow at index ${i}`);
  }

  // Single SQPOLL pass drains all 10 submissions and posts 10 CQEs
  kernel.pollSQAndExecute();

  const completedTags: number[] = [];
  let cqe: CQE | null;
  while ((cqe = ring.reapCQE()) !== null) {
    if (cqe.result !== 4096) throw new Error(`Short read on tag ${cqe.userData}`);
    completedTags.push(cqe.userData);
  }
  console.log(`Reaped ${completedTags.length}/10 batched CQEs (tags ${completedTags[0]}..${completedTags[9]})`);
}

export class XdpTokenBucketRateLimiter {
  private readonly ratePerSec = 100;
  private readonly burstCapacity = 100;
  private readonly buckets = new Map<string, { tokens: number; lastRefillMs: number }>();

  public filterPacket(pkt: RawPacket, nowMs: number): XdpAction {
    let bucket = this.buckets.get(pkt.srcIp);
    if (!bucket) {
      bucket = { tokens: this.burstCapacity, lastRefillMs: nowMs };
      this.buckets.set(pkt.srcIp, bucket);
    } else {
      const elapsedSec = Math.max(0, (nowMs - bucket.lastRefillMs) / 1000);
      bucket.tokens = Math.min(this.burstCapacity, bucket.tokens + elapsedSec * this.ratePerSec);
      bucket.lastRefillMs = nowMs;
    }

    if (bucket.tokens < 1.0) {
      return XdpAction.XDP_DROP; // Wire-speed discard before sk_buff allocation
    }
    bucket.tokens -= 1.0;
    return XdpAction.XDP_PASS;
  }
}

export class AfXdpUmemPool {
  private readonly chunks: Uint8Array[];
  public readonly fillRing: number[] = []; // Free chunk indices gifted from userspace -> NIC
  public readonly rxRing: { chunkIdx: number; length: number }[] = []; // Populated by NIC DMA

  constructor(chunkCount = 64, chunkBytes = 2048) {
    this.chunks = Array.from({ length: chunkCount }, () => new Uint8Array(chunkBytes));
    // Initially gift all 64 UMEM chunks to the kernel/NIC Fill Ring
    for (let i = 0; i < chunkCount; i++) this.fillRing.push(i);
  }

  public nicDmaReceive(frame: Uint8Array): boolean {
    const chunkIdx = this.fillRing.shift();
    if (chunkIdx === undefined) return false; // af_xdp_rx_empty_drops++
    this.chunks[chunkIdx].set(frame);         // Direct hardware DMA into UMEM
    this.rxRing.push({ chunkIdx, length: frame.byteLength });
    return true;
  }

  public userspaceConsumeAndRecycle(): number {
    let processed = 0;
    while (this.rxRing.length > 0) {
      const desc = this.rxRing.shift()!;
      // Zero-copy read directly from this.chunks[desc.chunkIdx].subarray(0, desc.length)
      this.fillRing.push(desc.chunkIdx); // Return chunk index to Fill Ring for reuse
      processed++;
    }
    return processed;
  }
}

12. Comprehensive Summary & Decision Framework

Network I/O Architecture Selection Matrix

Production Deployment Checklist

1. Linux Kernel Version: Deploy Linux kernel $\ge 5.15$ LTS for mature, bug-fixed io_uring network socket support.
2. Locked Memory Limits: Verify RLIMIT_MEMLOCK is configured to accommodate all registered fixed buffers and UMEM rings.
3. SQPOLL CPU Affinity: When enabling IORING_SETUP_SQPOLL, pin the kernel polling thread to an isolated CPU core (sq_thread_cpu) to prevent CPU context switching.
4. XDP Driver Mode: Ensure NIC drivers support Native XDP (e.g., mlx5 for Mellanox, i40e for Intel) rather than Generic XDP to achieve hardware-level performance.

13. Authoritative References & Version Context

• Jens Axboe (2019), “Efficient IO with io_uring”, Meta / Linux Kernel Whitepaper — kernel.dk/io_uring.pdf
• Data Plane Development Kit (DPDK) Core Architecture Manual — doc.dpdk.org/guides/prog_guide/
• Toke Høiland-Jørgensen et al. (2018), “The eXpress Data Path: Fast Programmable Packet Processing in the Linux Kernel”, ACM CoNEXT ‘18 — doi.org/10.1145/3281411.3281443
• Version Context: io_uring features reflect Linux kernel 5.10 LTS / 6.1+ LTS; DPDK references target DPDK 23.11 LTS and Linux XDP eBPF kernels.