mem_arena.c

Go to the documentation of this file.

 
#include "memory/mem_arena.h"
#include "memory/mem_allocator.h" // Needed for the Allocator bridge
#include "memory/mem_os.h"
#include <string.h>
 
#define MEM_ARENA_COMMIT_SIZE KB(64)
 
static void *
mem_arena_push_internal(MemArena *arena, usize size, usize alignment)
{
    ASSERT(IS_POW2(alignment) && "alignment must be a non-zero power of 2");
 
    usize current_pos = ALIGN_UP_POW2(arena->pos, alignment);
 
    if (size > arena->reserve - current_pos) {
        ASSERT(0 && "Arena OOM: allocation exceeds reserved capacity");
        return NULL;
    }
 
    usize next_pos = current_pos + size;
 
    if (next_pos > arena->commit) {
        usize needed      = next_pos - arena->commit;
        usize cmt_size    = ALIGN_UP_POW2(needed, MEM_ARENA_COMMIT_SIZE);
        usize cmt_clamped = MIN(cmt_size, arena->reserve - arena->commit);
 
        b32 ok = mem_os_commit(arena->base + arena->commit, cmt_clamped);
        if (!ok) {
            ASSERT(0 && "Arena OOM: OS refused to commit physical RAM");
            return NULL;
        }
        arena->commit += cmt_clamped;
    }
 
    void *result = arena->base + current_pos;
    arena->pos   = next_pos;
    return result;
}
 
MemArena
mem_arena_create(usize reserve_size)
{
    MemArena arena = {0};
    arena.base     = (u8 *)mem_os_reserve(reserve_size);
    if (arena.base != NULL) {
        arena.reserve = reserve_size;
    }
    return arena;
}
 
void
mem_arena_release(MemArena *arena)
{
    if (arena->base != NULL) {
        mem_os_release(arena->base, arena->reserve);
        arena->base    = NULL;
        arena->reserve = 0;
        arena->pos     = 0;
        arena->commit  = 0;
    }
}
 
void *
mem_arena_push(MemArena *arena, usize size)
{
    return mem_arena_push_internal(arena, size, MEM_ARENA_ALIGNMENT);
}
 
void *
mem_arena_push_zero(MemArena *arena, usize size)
{
    void *result = mem_arena_push_internal(arena, size, MEM_ARENA_ALIGNMENT);
    if (result != NULL) {
        MEM_ZERO(result, size);
    }
    return result;
}
 
void *
mem_arena_push_aligned(MemArena *arena, usize size, usize alignment)
{
    void *result = mem_arena_push_internal(arena, size, alignment);
    if (result != NULL) {
        MEM_ZERO(result, size);
    }
    return result;
}
 
void
mem_arena_pop_to(MemArena *arena, usize pos)
{
    ASSERT(pos <= arena->pos && "mem_arena_pop_to: pos is ahead of current position");
    usize clamped = MIN(pos, arena->pos);
    arena->pos    = clamped;
}
 
void
mem_arena_clear(MemArena *arena)
{
    mem_arena_pop_to(arena, 0);
}
 
void
mem_arena_clear_and_decommit(MemArena *arena)
{
    if (arena->commit > 0) {
        mem_os_decommit(arena->base, arena->commit);
        arena->commit = 0;
    }
    arena->pos = 0;
}
 
char *
mem_arena_push_cstr(MemArena *arena, const char *str, usize len)
{
    char *buf = (char *)mem_arena_push_zero(arena, len + 1);
    if (buf != NULL) {
        MEM_COPY(buf, str, len);
        buf[len] = '\0';
    }
    return buf;
}
 
MemArenaTemp
mem_arena_temp_begin(MemArena *arena)
{
    MemArenaTemp temp;
    temp.arena = arena;
    temp.pos   = arena->pos;
    return temp;
}
 
void
mem_arena_temp_end(MemArenaTemp temp)
{
    mem_arena_pop_to(temp.arena, temp.pos);
}

 
static void *
mem_arena_alloc_impl(MemAllocMode mode, void *ctx, usize size, void *old_ptr)
{
    MemArena *arena = (MemArena *)ctx;
    (void)old_ptr; // Arenas don't use the old pointer for frees/reallocs
 
    switch (mode) {
    case MEM_ALLOC_MODE_ALLOC:
        return mem_arena_push_zero(arena, size);
    case MEM_ALLOC_MODE_FREE:
        // Arenas do not free individual allocations!
        return NULL;
    case MEM_ALLOC_MODE_REALLOC:
        // Reallocating in an arena just means pushing a brand new block.
        // (The mem_realloc wrapper in mem_allocator.h handles copying the old data).
        return mem_arena_push_zero(arena, size);
    case MEM_ALLOC_MODE_FREE_ALL:
        mem_arena_clear(arena);
        return NULL;
    }
    return NULL;
}
 
MemAllocator
mem_arena_allocator(MemArena *arena)
{
    MemAllocator alloc;
    alloc.fn  = mem_arena_alloc_impl;
    alloc.ctx = arena;
    return alloc;
}