std.heap

bump arena; growable (64 KiB chunks), reserved, or over a fixed buffer

MemError

pub MemError :: errors {
    out_of_memory,
}

• out_of_memory: OS alloc failed, or fixed/reserved cap full

Arena

pub Arena :: struct {
    first: usize,
    head: usize,
    mode: u8,
}

first oldest chunk, head current bump chunk, mode an ARENA_* value

Mark

pub Mark :: struct {
    chunk: usize,
    used: usize,
}

saved bump position for restore

make

pub make :: fn() -> Arena

reserves nothing until the first alloc

reserve

pub reserve :: fn(max: usize) -> Arena

max bytes of address space, committed lazily; pointers never move

fixed

pub fixed :: fn(buf: []u8) -> Arena

no syscalls, can’t grow; buf must outlive the arena

alloc_bytes

pub alloc_bytes :: fn(self: *Arena, n: usize) -> []u8

aborts on exhaustion

try_alloc_bytes

pub try_alloc_bytes :: fn(self: *Arena, n: usize) -> []u8 ! MemError

.out_of_memory instead of aborting

alloc

pub alloc :: fn($T: type, self: *Arena, n: usize) -> []T

16-byte aligned; aborts on exhaustion

try_alloc

pub try_alloc :: fn($T: type, self: *Arena, n: usize) -> []T ! MemError

fallible alloc

alloc_one

pub alloc_one :: fn($T: type, self: *Arena) -> *T

aborts on exhaustion

dupe

pub dupe :: fn($T: type, self: *Arena, src: []const T) -> []T

copy into the arena; aborts on exhaustion

new

pub new :: fn($T: type, self: *Arena) -> *T

zone spellings of alloc_one / alloc

new_slice

pub new_slice :: fn($T: type, self: *Arena, n: usize) -> []T

reset

pub reset :: fn(self: *Arena)

rewind, keep chunks, O(1); everything allocated before is invalid

mark

pub mark :: fn(self: *Arena) -> Mark

for restore; invalid after the next reset/deinit

restore

pub restore :: fn(self: *Arena, m: Mark)

frees everything since m for reuse; chunks are kept

deinit

pub deinit :: fn(self: *Arena)

memory back to the OS (fixed: just cleared); reusable after