std.mmap_ext

Erweiterte Memory-Operationen (WP-9): Ergänzt das Basis-mmap/munmap um Größenänderung (mremap), Zugriffshinweise an den Kernel (madvise), Synchronisierung memory-gemappter Dateien (msync), In-Memory-Dateien ohne Filesystem (memfd_create), RAM-Pinning (mlock) und Residency-Prüfung (mincore).

→ Standard Library · std.alloc · std.fs_ext

Weitere Hilfsfunktionen:

import std.mmap_ext;
import std.alloc;

// mmap-basierter Puffer der ohne Kopie wachsen kann.
fn GrowBuffer(addr: int64, oldSize: int64, newSize: int64): int64 {
    var newAddr := MmapResize(addr, oldSize, newSize);
    if (newAddr < 0) { return -1; }
    // WICHTIG: newAddr kann != addr sein — alten Pointer nicht mehr verwenden!
    return newAddr;
}

import std.mmap_ext;

fn ProcessLargeFile(addr: int64, size: int64): void {
    // Kernel wird Seiten aggressiv prefetchen
    MmapAdvise(addr, size, MADV_SEQUENTIAL);

    // Nach dem Verarbeiten: physikalischen RAM freigeben
    MmapFreePages(addr, size);
}

import std.mmap_ext;
import std.fs_ext;
import std.io;

fn CreateSharedMem(size: int64): int64 {
    var fd := MemFdCreate("shm_worker", MFD_CLOEXEC);
    if (fd < 0) { return -1; }

    // Größe festlegen
    Ftruncate(fd, size);

    // Mapping erstellen (PROT_READ|WRITE = 3, MAP_SHARED = 1)
    var addr := mmap(0, size, 3, 1, fd, 0);
    close(fd);   // fd kann nach mmap geschlossen werden
    return addr;
}

import std.mmap_ext;
import std.alloc;

fn LockCriticalBuffer(size: int64): int64 {
    // size muss Vielfaches von PAGE_SIZE sein
    var addr := mmap(0, size, 3, 34, -1, 0);  // PROT_RW, MAP_PRIVATE|ANON
    if (addr < 0) { return -1; }

    // Seiten vorwärts anfassen (erzwingt Seitenzuteilung)
    MmapAdvise(addr, size, MADV_WILLNEED);

    // RAM fixieren — kein Swapping mehr
    MemLock(addr, size);

    return addr;
}

fn UnlockAndFree(addr: int64, size: int64): void {
    MemUnlock(addr, size);
    munmap(addr, size);
}

import std.mmap_ext;
import std.alloc;
import std.io;

fn PrintResidency(addr: int64, size: int64): void {
    var pages  := (size + PAGE_SIZE - 1) / PAGE_SIZE;
    var vecOut := alloc(pages);

    MemInCore(addr, size, vecOut);

    var inRam: int64 := 0;
    var i: int64 := 0;
    while (i < pages) {
        if ((peek8(vecOut + i) & 1) != 0) { inRam := inRam + 1; }
        i := i + 1;
    }

    PrintLn("Seiten im RAM: " + IntToStr(inRam) + " / " + IntToStr(pages));

    free(vecOut, pages);
}

• MmapResize gibt eine neue Adresse zurück — den alten Zeiger danach nicht mehr dereferenzieren.
• MmapFreePages (MADV_DONTNEED) gibt nur physikalischen RAM frei; das virtuelle Mapping bleibt erhalten und wird beim nächsten Zugriff mit Nullen neu befüllt.
• MFD_ALLOW_SEALING ermöglicht es, nach dem Befüllen das Mapping read-only zu versiegeln — nützlich für unveränderliche Shared-Memory-Objekte.
• MemLock schlägt mit -ENOMEM fehl wenn das Prozess-Limit (RLIMIT_MEMLOCK) erreicht ist; Root hat standardmäßig kein Limit.
• addr und len müssen bei allen Funktionen auf PAGE_SIZE (4096) ausgerichtet sein.

• std.alloc — Basis-Speicherverwaltung (mmap/munmap-basiert)
• std.fs_ext — Fstat, Ftruncate (für memfd-Workflow)
• std.fs — Dateizugriff für dateibasierte Mappings
• std.sched — CPU-Affinität (ergänzt RAM-Pinning bei Echtzeit-Anforderungen)

Letzte Aktualisierung: 2026-06-05