mem_arena.c

Go to the documentation of this file.

 
#include "memory/mem_arena.h"
#include "memory/mem_os.h"

static void *
arena_push_internal(Arena *arena, usize size, usize alignment)
{
    ASSERT(IS_POW2_OR_ZERO(alignment) && "alignment must be a power of 2");
 
    // Align the current position up to the requested boundary.
    usize current_pos = ALIGN_UP_POW2(arena->pos, alignment);
    usize next_pos    = current_pos + size;
 
    // Guard: prevent overflowing past the total reserved capacity.
    if (next_pos > arena->cap) {
        ASSERT(0 && "Arena OOM: allocation exceeds reserved capacity");
        return NULL;
    }
 
    // Commit more physical RAM if the allocation would exceed what we have.
    if (next_pos > arena->cmt) {
        // Round the required commit up to our chunk granularity.
        usize needed   = next_pos - arena->cmt;
        usize cmt_size = ALIGN_UP_POW2(needed, ARENA_COMMIT_SIZE);
        // Clamp so we never try to commit past the reservation ceiling.
        usize cmt_clamped = MIN(cmt_size, arena->cap - arena->cmt);
 
        b32 ok = os_mem_commit(arena->base + arena->cmt, cmt_clamped);
        if (!ok) {
            ASSERT(0 && "Arena OOM: OS refused to commit physical RAM");
            return NULL;
        }
 
        arena->cmt += cmt_clamped;
    }
 
    void *result = arena->base + current_pos;
    arena->pos   = next_pos;
    return result;
}
 
Arena
arena_create(usize reserve_size)
{
    Arena arena = {0};
    arena.base  = (u8 *)os_mem_reserve(reserve_size);
    if (arena.base != NULL) {
        arena.cap = reserve_size;
    }
    return arena;
}
 
void
arena_release(Arena *arena)
{
    if (arena->base != NULL) {
        os_mem_release(arena->base, arena->cap);
        arena->base = NULL;
        arena->cap  = 0;
        arena->pos  = 0;
        arena->cmt  = 0;
    }
}
 
void *
arena_push(Arena *arena, usize size)
{
    return arena_push_internal(arena, size, ARENA_DEFAULT_ALIGN);
}
 
void *
arena_push_zero(Arena *arena, usize size)
{
    void *result = arena_push_internal(arena, size, ARENA_DEFAULT_ALIGN);
    if (result != NULL) {
        MEM_ZERO(result, size);
    }
    return result;
}
 
void *
arena_push_aligned(Arena *arena, usize size, usize alignment)
{
    void *result = arena_push_internal(arena, size, alignment);
    if (result != NULL) {
        MEM_ZERO(result, size);
    }
    return result;
}
 
void
arena_pop_to(Arena *arena, usize pos)
{
    // Clamp so that a pos > arena->pos cannot accidentally advance the offset.
    usize clamped = MIN(pos, arena->pos);
    arena->pos    = clamped;
}
 
void
arena_clear(Arena *arena)
{
    arena_pop_to(arena, 0);
}
 
ArenaTemp
arena_temp_begin(Arena *arena)
{
    ArenaTemp temp;
    temp.arena = arena;
    temp.pos   = arena->pos;
    return temp;
}
 
void
arena_temp_end(ArenaTemp temp)
{
    arena_pop_to(temp.arena, temp.pos);
}