std.io_uring — Asynchrones I/O (io_uring)

import std.io_uring;

io_uring ist der moderne Linux-Mechanismus für asynchrones I/O (Kernel 5.1+). SQEs (Submission Queue Entries) werden in einen Ring-Puffer geschrieben, den Kernel dann unabhängig abarbeitet. Abschlüsse erscheinen als CQEs (Completion Queue Entries) im CQ-Ring. Syscall-Overhead wird durch den gemeinsamen mmap-Speicher minimiert.

→ std.net.epoll · std.fs · Rohspeicher

import std.io_uring;

fn main(): int64 {
    var ring: int64 := IoUringCreate(8);
    if (ring = 0) { return -1; }

    var sqe: int64 := IoUringGetSQE(ring);
    if (sqe = 0) { IoUringFree(ring); return -1; }
    IoUringSQESetNop(sqe, 42);

    IoUringSubmit(ring);

    var cqe: int64 := IoUringWaitCQE(ring);
    var res: int64 := IoUringCQEResult(cqe);
    var ud:  int64 := IoUringCQEUserData(cqe);
    IoUringCQESeen(ring, cqe);

    IoUringFree(ring);
    return 0;
}

import std.io_uring;
import std.alloc;
import std.fs;

fn AsyncRead(path: pchar, outBuf: int64, bufLen: int64): int64 {
    var fd: int64 := OpenFile(path, 0);
    if (fd < 0) { return fd; }

    var ring: int64 := IoUringCreate(4);
    if (ring = 0) { CloseFile(fd); return -12; }

    var sqe: int64 := IoUringGetSQE(ring);
    IoUringSQESetRead(sqe, fd, outBuf, bufLen, 0, 1);
    IoUringSubmit(ring);

    var cqe: int64 := IoUringWaitCQE(ring);
    var res: int64 := IoUringCQEResult(cqe);
    IoUringCQESeen(ring, cqe);

    IoUringFree(ring);
    CloseFile(fd);
    return res;  // Anzahl gelesener Bytes oder negatives errno
}

import std.io_uring;
import std.alloc;

fn MultiWrite(fd: int64, buf1: int64, len1: int64,
                          buf2: int64, len2: int64): int64 {
    var ring: int64 := IoUringCreate(8);
    if (ring = 0) { return -12; }

    // Zwei Writes in den Ring stellen
    var sqe1: int64 := IoUringGetSQE(ring);
    IoUringSQESetWrite(sqe1, fd, buf1, len1, 0, 100);

    var sqe2: int64 := IoUringGetSQE(ring);
    IoUringSQESetWrite(sqe2, fd, buf2, len2, len1, 200);

    // Beide abschicken, auf beide warten
    IoUringSubmitAndWait(ring, 2);

    var result: int64 := 0;
    var i: int64 := 0;
    while (i < 2) {
        var cqe: int64 := IoUringPeekCQE(ring);
        if (cqe != 0) {
            var res: int64 := IoUringCQEResult(cqe);
            if (res < 0) { result := res; }
            IoUringCQESeen(ring, cqe);
        }
        i := i + 1;
    }

    IoUringFree(ring);
    return result;
}

• Kernel 5.1+: io_uring ist auf älteren Kerneln nicht verfügbar. IoUringCreate gibt 0 zurück wenn sys_io_uring_setup fehlschlägt.
• Ring-Größe: Der Kernel rundet entries auf die nächste Zweierpotenz. Für einzelne Operationen reicht IoUringCreate(4).
• CQE-Seen: Nach dem Verarbeiten einer CQE muss IoUringCQESeen aufgerufen werden, sonst bleibt der Ring blockiert.
• SQE-Reihenfolge: Operationen werden asynchron ausgeführt; Reihenfolge ist nicht garantiert. Für sequentielle Abhängigkeiten: IOSQE_IO_LINK-Flag setzen (nicht in diesem Wrapper implementiert).
• SINGLE_MMAP: Ab Kernel 5.4 teilen SQ und CQ eine gemeinsame mmap-Region (IORING_FEAT_SINGLE_MMAP). Der Wrapper erkennt und handhabt das automatisch.
• offset -1 bei Sockets: Für Sockets und Pipes muss offset auf -1 gesetzt werden (aktuelle Position, kein seekbares Medium).

Letzte Aktualisierung: 2026-06-05