docs/WinTer/test__memory_8c_source.html

#include "memory/mem_allocator.h"

#include "memory/mem_arena.h"


#include "test_harness.h"


TEST_CASE(arena_allocation)

{

    Arena a = arena_create(GB(1));

    EXPECT(a.base != NULL);

    EXPECT(a.cap == GB(1));

    EXPECT(a.pos == 0);

    EXPECT(a.cmt == 0);


    // Push a single int. arena_push_zero aligns to ARENA_DEFAULT_ALIGN (8),

    // so pos advances to sizeof(int) == 4, not 8 (alignment affects the

    // *start* of the next allocation, not the current one).

    int *num = PUSH_STRUCT(&a, int);

    *num     = 42;

    EXPECT(a.pos == 4);

    EXPECT(*num == 42);


    // Physical RAM should now be committed in at least one 64 KB chunk.

    EXPECT(a.cmt >= ARENA_COMMIT_SIZE);


    // Push an array and verify zero-initialization.

    int *arr = PUSH_ARRAY(&a, int, 10);

    EXPECT(arr[0] == 0);

    EXPECT(arr[9] == 0);


    // pos was 4 after the int. Next alloc aligns up to 8, then adds 10*4=40 -> pos == 48.

    EXPECT(a.pos == 48);


    arena_clear(&a);

    EXPECT(a.pos == 0); // pos resets; committed RAM stays mapped.


    arena_release(&a);

    EXPECT(a.base == NULL);

    EXPECT(a.cap == 0);

}


TEST_CASE(arena_aligned_push)

{

    Arena a = arena_create(MB(1));

    EXPECT(a.base != NULL);


    // Bump pos to a non-aligned starting point by pushing 1 byte.

    u8 *byte = (u8 *)arena_push(&a, 1);

    EXPECT(byte != NULL);


    // Push with 16-byte alignment (e.g., for SIMD).

    float *simd = PUSH_ARRAY_ALIGNED(&a, float, 4, 16);

    EXPECT(simd != NULL);

    EXPECT(((usize)simd & 15) == 0); // pointer must be 16-byte aligned

    EXPECT(simd[0] == 0.0f);     // must be zeroed


    arena_release(&a);

}


TEST_CASE(arena_temp)

{

    Arena a = arena_create(MB(1));

    EXPECT(a.base != NULL);


    int *persistent  = PUSH_STRUCT(&a, int);

    *persistent  = 99;

    usize pos_before = a.pos;


    ArenaTemp tmp = arena_temp_begin(&a);


    u8 *scratch = PUSH_ARRAY(&a, u8, 512);

    EXPECT(scratch != NULL);

    EXPECT(a.pos > pos_before);


    arena_temp_end(tmp);

    EXPECT(a.pos == pos_before); // must snap back

    EXPECT(*persistent == 99);   // persistent alloc survives


    arena_release(&a);

}


TEST_CASE(arena_allocator_interface)

{

    Arena     a    = arena_create(MB(1));

    Allocator ally = arena_allocator(&a);


    int *val = (int *)allocator_alloc(&ally, sizeof(int));

    EXPECT(val != NULL);

    EXPECT(*val == 0); // zero-initialized

    *val = 7;

    EXPECT(*val == 7);


    allocator_free(&ally, val, sizeof(int)); // no-op, must not crash


    usize old_size = sizeof(int) * 4;

    usize new_size = sizeof(int) * 8;

    int  *arr      = (int *)allocator_alloc(&ally, old_size);

    arr[0]         = 1;

    arr[3]         = 4;


    int *grown = (int *)allocator_realloc(&ally, arr, old_size, new_size);

    EXPECT(grown != NULL);

    EXPECT(grown[0] == 1); // old data copied

    EXPECT(grown[3] == 4);

    EXPECT(grown[4] == 0); // new bytes zeroed

    EXPECT(grown[7] == 0);


    arena_release(&a);

}


allocator_free
INTERNAL void allocator_free(Allocator *a, void *ptr, usize size)
Frees a previously allocated block through the allocator.
Definition mem_allocator.h:140

allocator_realloc
INTERNAL void * allocator_realloc(Allocator *a, void *ptr, usize old_size, usize new_size)
Resizes a previously allocated block through the allocator.
Definition mem_allocator.h:160

arena_allocator
INTERNAL Allocator arena_allocator(Arena *arena)
Constructs an Allocator interface backed by an existing Arena.
Definition mem_allocator.h:220

allocator_alloc
INTERNAL void * allocator_alloc(Allocator *a, usize size)
Allocates size zero-initialized bytes through the allocator.
Definition mem_allocator.h:124

arena_create
Arena arena_create(usize reserve_size)
Creates and initializes a new arena, reserving virtual address space.
Definition mem_arena.c:60

arena_release
void arena_release(Arena *arena)
Releases the entire arena back to the OS, invalidating all pointers into it.
Definition mem_arena.c:71

arena_temp_end
void arena_temp_end(ArenaTemp temp)
Restores the arena to the position saved in temp.
Definition mem_arena.c:132

PUSH_ARRAY
#define PUSH_ARRAY(arena, type, count)
Allocates and zero-initializes an array of count elements on the arena.
Definition mem_arena.h:252

ARENA_COMMIT_SIZE
#define ARENA_COMMIT_SIZE
The granularity at which physical RAM is committed from the OS (64 KB).
Definition mem_arena.h:75

PUSH_STRUCT
#define PUSH_STRUCT(arena, type)
Allocates and zero-initializes a single struct on the arena.
Definition mem_arena.h:237

PUSH_ARRAY_ALIGNED
#define PUSH_ARRAY_ALIGNED(arena, type, count, alignment)
Allocates a zero-initialized array with an explicit power-of-2 alignment.
Definition mem_arena.h:269

arena_clear
void arena_clear(Arena *arena)
Resets the arena to empty by setting pos back to 0.
Definition mem_arena.c:117

arena_push
void * arena_push(Arena *arena, usize size)
Allocates size bytes from the arena, aligned to ARENA_DEFAULT_ALIGN.
Definition mem_arena.c:83

arena_temp_begin
ArenaTemp arena_temp_begin(Arena *arena)
Saves the current arena position as a rewind checkpoint.
Definition mem_arena.c:123

u8
uint8_t u8
Definition base_types.h:22

MB
#define MB(x)
Definition base_types.h:84

GB
#define GB(x)
Definition base_types.h:85

usize
size_t usize
Definition base_types.h:43

mem_allocator.h
Generic allocator interface (vtable) for polymorphic memory allocation.

mem_arena.h
High-performance Virtual Memory Linear (Arena) Allocator.

Allocator
A generic allocator backed by function pointers (vtable).
Definition mem_allocator.h:108

Arena
Represents a linear memory arena backed by OS virtual memory.
Definition mem_arena.h:83

Arena::cap
usize cap
Definition mem_arena.h:85

Arena::base
u8 * base
Definition mem_arena.h:84

Arena::pos
usize pos
Definition mem_arena.h:86

Arena::cmt
usize cmt
Definition mem_arena.h:87

ArenaTemp
A saved checkpoint into an arena, used for scoped temporary allocations.
Definition mem_arena.h:105

test_harness.h
A lightweight, dependency-free unit testing harness.

EXPECT
#define EXPECT(cond)
Evaluates a condition. If it fails, prints the file/line and increments the fail count.
Definition test_harness.h:18

TEST_CASE
#define TEST_CASE(name)
Defines a test case function.
Definition test_harness.h:30