std.ipc_sysv — SysV IPC (Shared Memory, Semaphore, Message Queues)

import std.ipc_sysv;

SysV IPC ist der klassische POSIX-Mechanismus für Inter-Prozess-Kommunikation: gemeinsamer Speicher (Shared Memory), Semaphore und Message Queues. Alle Objekte werden über Integer-Keys identifiziert, nicht über Pfade.

→ std.ns · std.os · Handles und Dateideskriptoren

import std.ipc_sysv;
import std.io;

fn main(): int64 {
    // Segment anlegen: IPC_PRIVATE + IPC_CREAT + Rechte 0o666
    var shmId: int64 := ShmCreate(IPC_PRIVATE, 4096, IPC_CREAT | 438);
    if (shmId < 0) { return shmId; }

    // In Adressraum einblenden
    var mem: int64 := ShmAttach(shmId, 0, 0);
    if (mem < 0) { ShmDelete(shmId); return mem; }

    // Daten schreiben/lesen
    poke64(mem, 42);
    var v: int64 := peek64(mem);

    // Aufräumen
    ShmDetach(mem);
    ShmDelete(shmId);
    return 0;
}

import std.ipc_sysv;

fn main(): int64 {
    // Mutex-Semaphore anlegen (1 Semaphore, Initialwert 1)
    var semId: int64 := SemCreate(IPC_PRIVATE, 1, IPC_CREAT | 438);
    if (semId < 0) { return semId; }
    SemSetVal(semId, 0, 1);  // Semaphore 0 auf Wert 1 setzen

    // Kritischen Abschnitt schützen
    SemWait(semId, 0);   // Lock
    // ... kritischer Abschnitt ...
    SemPost(semId, 0);   // Unlock

    SemDelete(semId);
    return 0;
}

import std.ipc_sysv;
import std.alloc;

fn main(): int64 {
    var mqId: int64 := MsgQueueCreate(IPC_PRIVATE, IPC_CREAT | 438);
    if (mqId < 0) { return mqId; }

    // Senden: 8 Bytes mtype-Header + 16 Bytes Nutzdaten
    var sendBuf: int64 := alloc(24);
    poke64(sendBuf, 1);          // mtype = 1 (muss > 0)
    poke64(sendBuf + 8, 0x1234); // Nutzdaten
    poke64(sendBuf + 16, 0x5678);
    MsgSend(mqId, sendBuf, 16, 0);

    // Empfangen
    var recvBuf: int64 := alloc(24);
    var n: int64 := MsgRecv(mqId, recvBuf, 16, 1, 0);
    // n = 16, recvBuf+8 = Nutzdaten

    free(sendBuf, 24);
    free(recvBuf, 24);
    MsgQueueDelete(mqId);
    return 0;
}

• IPC_PRIVATE: Erstellt ein Objekt das nicht über einen Integer-Key von anderen Prozessen gefunden werden kann — geeignet für Eltern-Kind-Kommunikation (vor dem fork()).
• Schlüssel-Konflikte: Bei festem Key und IPC_CREAT ohne IPC_EXCL wird ein bestehendes Objekt geöffnet — kann zu unerwarteten Verbindungen mit anderen Prozessen führen.
• msgbuf-Layout: Die ersten 8 Bytes des Puffers sind immer der mtype (int64, muss > 0). Die size-Parameter in MsgSend/MsgRecv zählen ohne diesen Header.
• Persistenz: SysV-IPC-Objekte überleben den Prozess — explizites ShmDelete/SemDelete/MsgQueueDelete ist nötig. Vergessene Objekte sichtbar mit: ipcs.
• Alternative: Für moderne Anwendungen bevorzugt mmap + Datei oder POSIX-Semaphore (sem_open).

Letzte Aktualisierung: 2026-06-06