io_uring & Zero-Copy - Submission/Completion Rings, Batching, sendfile & splice

// io_uring's shape, simulated: a submission ring (SQ) and completion ring (CQ)
// shared with the kernel. NOT real io_uring (needs liburing / a native binding);
// this models why batching cuts syscalls and why completions arrive out of order.
type Sqe = { op: "read" | "write" | "accept"; fd: number; userData: number };
type Cqe = { userData: number; res: number };

class Ring {
  sq: Sqe[] = []; cq: Cqe[] = [];
  enterCalls = 0;                         // io_uring_enter(2) syscalls
  submit(sqe: Sqe) { this.sq.push(sqe); }  // just a memory write: no syscall
  enter(latency: (s: Sqe) => number) {
    this.enterCalls++;                    // ONE syscall submits the whole batch
    const batch = this.sq.splice(0);
    // Kernel finishes ops in whatever order the devices complete them.
    batch.sort((x, y) => latency(x) - latency(y))
         .forEach(s => this.cq.push({ userData: s.userData, res: s.op === "write" ? 512 : 4096 }));
  }
  reap(): Cqe[] { return this.cq.splice(0); } // reading the CQ is also syscall-free
}

const ring = new Ring();
const ops: Sqe[] = Array.from({ length: 64 }, (_, i) => ({
  op: (["read", "write", "accept"] as const)[i % 3], fd: 10 + i, userData: i,
}));
ops.forEach(o => ring.submit(o));
ring.enter(s => (s.fd * 37) % 11);       // fake per-op device latency
const done = ring.reap();
console.log(`ops=${ops.length} io_uring_enter calls=${ring.enterCalls} (epoll+read/write would be ~${ops.length + 1})`);
console.log("first 5 completions by user_data:", done.slice(0, 5).map(c => c.userData).join(","));
console.log("completions out of submit order:", done.some((c, i) => c.userData !== i));

ops=64 io_uring_enter calls=1 (epoll+read/write would be ~65)
first 5 completions by user_data: 1,12,23,34,45
completions out of submit order: true

# Zero-copy-ish transfer: read()+send() copies through user space;
# os.sendfile() lets the kernel move page-cache pages straight to the socket.
# Linux (and macOS for sockets). Python 3.8+.
import os, socket, tempfile, threading

payload = os.urandom(4 * 1024 * 1024)        # 4 MiB "static asset"
with tempfile.NamedTemporaryFile(delete=False) as f:
    f.write(payload); path = f.name

def drain(sock, out):
    got = bytearray()
    while chunk := sock.recv(1 << 16):
        got += chunk
    out.append(bytes(got))

def transfer(use_sendfile: bool):
    a, b = socket.socketpair()
    out = []
    t = threading.Thread(target=drain, args=(b, out)); t.start()
    user_copies = 0
    with open(path, "rb") as f:
        if use_sendfile:
            offset, size = 0, os.path.getsize(path)
            while offset < size:              # kernel copies file -> socket; no user buffer
                offset += os.sendfile(a.fileno(), f.fileno(), offset, size - offset)
        else:
            while chunk := f.read(1 << 16):   # kernel -> user buffer (copy 1)
                user_copies += len(chunk)
                a.sendall(chunk)              # user buffer -> kernel socket (copy 2)
    a.shutdown(socket.SHUT_WR); t.join(); a.close(); b.close()
    return out[0] == payload, user_copies

ok1, c1 = transfer(use_sendfile=False)
ok2, c2 = transfer(use_sendfile=True)
os.unlink(path)
print(f"read+send : intact={ok1} bytes copied through user space={c1}")
print(f"sendfile  : intact={ok2} bytes copied through user space={c2}")

read+send : intact=True bytes copied through user space=4194304
sendfile  : intact=True bytes copied through user space=0