std.net.epoll

epoll & I/O-Multiplexing (WP-5): Überwacht beliebig viele Dateideskriptoren auf Ereignisse (lesbar, schreibbar, Fehler) ohne Polling. Ein einzelner EpollWait-Aufruf blockiert bis mindestens ein fd bereit ist und gibt nur die aktiven Events zurück. Enthält außerdem eventfd — eine thread-sichere fd-basierte Signalisierung.

→ Standard Library · std.net.socket · std.inotify

import std.net.epoll;
import std.net.socket;
import std.alloc;
import std.io;

fn RunLoop(listenFd: int64): void {
    var ep := EpollCreate();
    EpollAdd(ep, listenFd, EPOLLIN, listenFd);

    var buf: int64 := alloc(EPOLL_EVENT_SIZE * 64);

    var running: bool := true;
    while (running) {
        var n := EpollWait(ep, buf, 64, -1);
        var i: int64 := 0;
        while (i < n) {
            var fd    := EpollEventFd(buf, i);
            var flags := EpollEventFlags(buf, i);

            if (fd == listenFd) {
                var clientFd := Accept(listenFd, 0, 0);
                EpollAdd(ep, clientFd, EPOLLIN, clientFd);
            } else {
                if ((flags & EPOLLIN) != 0) {
                    // Daten vom Client lesen...
                }
                if ((flags & EPOLLHUP) != 0) {
                    EpollDel(ep, fd);
                    close(fd);
                }
            }
            i := i + 1;
        }
    }

    free(buf, EPOLL_EVENT_SIZE * 64);
    close(ep);
}

import std.net.epoll;
import std.inotify;
import std.alloc;

fn WatchWithEpoll(path: pchar): void {
    var ep  := EpollCreate();
    var ifd := InotifyCreate();
    InotifyWatch(ifd, path, IN_CREATE | IN_MODIFY | IN_DELETE);

    // inotify-fd in epoll registrieren
    EpollAdd(ep, ifd, EPOLLIN, ifd);

    var evBuf:  int64 := alloc(EPOLL_EVENT_SIZE * 8);
    var inBuf:  int64 := alloc(4096);

    var n := EpollWait(ep, evBuf, 8, 5000);  // max. 5 Sekunden warten
    if (n > 0) {
        var bytes := InotifyRead(ifd, inBuf, 4096);
        // Events verarbeiten...
    }

    free(evBuf, EPOLL_EVENT_SIZE * 8);
    free(inBuf, 4096);
    close(ifd);
    close(ep);
}

import std.net.epoll;
import std.thread;

// Thread A: wartet auf Signal
fn Worker(efd: int64): void {
    var ep := EpollCreate();
    EpollAdd(ep, efd, EPOLLIN, efd);

    var buf: int64 := alloc(EPOLL_EVENT_SIZE);
    EpollWait(ep, buf, 1, -1);   // blockiert bis Signal
    EventFdRead(efd);             // Zähler zurücksetzen
    free(buf, EPOLL_EVENT_SIZE);
    close(ep);
}

// Thread B: sendet Signal
fn Notifier(efd: int64): void {
    // ... Arbeit erledigen ...
    EventFdSignal(efd);   // weckt Worker
}

fn Main(): void {
    var efd := EventFdCreate(0, EFD_CLOEXEC);
    // Threads starten, efd übergeben...
    close(efd);
}

import std.net.epoll;
import std.alloc;

// fd wird nach erstem Event automatisch aus epoll entfernt.
// Für erneutes Warten: EpollMod mit EPOLLIN | EPOLLONESHOT aufrufen.
fn WaitOnce(fd: int64): void {
    var ep := EpollCreate();
    EpollAdd(ep, fd, EPOLLIN | EPOLLONESHOT, fd);

    var buf: int64 := alloc(EPOLL_EVENT_SIZE);
    EpollWait(ep, buf, 1, -1);
    free(buf, EPOLL_EVENT_SIZE);
    close(ep);
}

• Im Edge-Triggered-Modus (EPOLLET) muss der fd bis zum EAGAIN vollständig geleert werden — sonst werden keine weiteren Events gemeldet.
• EPOLLERR und EPOLLHUP sind immer aktiv und müssen nicht explizit in events gesetzt werden.
• EPOLLONESHOT erfordert nach jedem Event ein EpollMod, um den fd wieder zu aktivieren.
• Ein eventfd-fd kann selbst in eine epoll-Instanz eingehängt werden und wird bei EPOLLIN angezeigt sobald der Zähler > 0 ist.
• EpollEventData und EpollEventFd lesen denselben Offset — EpollEventFd maskiert nur auf 32 Bit.

• std.net.socket — TCP/UDP-Sockets
• std.inotify — Dateisystemüberwachung (epoll-kompatibel)
• std.mqueue — Message Queues (epoll-kompatibel)
• std.signals — signalfd (epoll-kompatibel)
• std.thread — Threads mit Mutex/Bedingungsvariablen

Letzte Aktualisierung: 2026-06-05