nupp.mem.arena

A paged allocator of struct rows whose pages never move.

Rows are handed out in order from fixed-size pages of one struct type. A page is allocated once and stays where it is, so a row reference is good for as long as the arena is; growth adds a page beside the others rather than moving anything. A reset rewinds to the first row of the first page and keeps every page, which is what makes the next epoch allocation-free.

local arena = nupp.mem.arena

local struct Impact
    x: float
    y: float
end

local impacts = arena.newArena(Impact, 256)
local impact = impacts:acquire() -- zero-filled
impact.x = 1.5
impacts:release(impact)
impacts:reset() -- rewinds; the page stays

Every acquired row reads as zero, whether it is fresh or one a reset made available again. A release ends that row's lease and nothing more: the cursor does not rewind until reset, and reset refuses while any lease is live, so a row that is out is never handed out twice. Releasing a row that is not live in this arena raises without changing its lease count.

Storage comes from the cstorage capability, so the module is available on native LuaJIT and on the Wasm and browser backends, and refused by portable. Table-backed record instances are nupp.util.Pool.

record arena.Arena<S> ...

element: any

width: integer

pageSize: integer

pageList: {S[?]}

rows: {{S}}

pageIndex: integer

cursor: integer

usedCount: integer

liveCount: integer

leases: table

acquire: function(exclusive self: Arena<S>): S

release: function(exclusive self: Arena<S>, row: S): nil

reset: function(exclusive self: Arena<S>): nil

pages: function(self: Arena<S>): integer

used: function(self: Arena<S>): integer

live: function(self: Arena<S>): integer

function arena.newArena<S>(witness: Type<S>, pageSize: integer?): arena.Arena<S>

local struct Cell
    value: int32
end

local cells = arena.newArena(Cell, 16)
assert(cells:pages() == 1 and cells:used() == 0)