test_memory.c

#include "memory/mem_allocator.h"
#include "memory/mem_arena.h"
#include "test/test.h"
 
TEST_CASE(mem_arena_allocation)
{
    MemArena a = mem_arena_create(GB(1));
    EXPECT_FATAL(a.base != NULL);
    EXPECT(a.reserve == GB(1));
    EXPECT(a.pos == 0);
    EXPECT(a.commit == 0);
 
    // Push a single int. The allocator aligns the *start* of this allocation
    // to MEM_ARENA_ALIGNMENT (8), but pos only advances by sizeof(int) == 4
    // bytes of actual data. So pos == 4, not 8.
    int *num = PUSH_STRUCT(&a, int);
    EXPECT_FATAL(num != NULL);
    *num = 42;
    EXPECT(a.pos == 4);
    EXPECT(*num == 42);
 
    // Physical RAM should now be committed in at least one 64 KB chunk.
    EXPECT(a.commit >= KB(64));
 
    // Push an array and verify zero-initialization.
    int *arr = PUSH_ARRAY(&a, int, 10);
    EXPECT_FATAL(arr != NULL);
    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);
 
    mem_arena_clear(&a);
    EXPECT(a.pos == 0); // pos resets; committed RAM stays mapped.
 
    mem_arena_release(&a);
    EXPECT(a.base == NULL);
    EXPECT(a.reserve == 0);
}
 
TEST_CASE(mem_arena_aligned_push)
{
    MemArena a = mem_arena_create(MB(1));
    EXPECT_FATAL(a.base != NULL);
 
    // Bump pos to a non-aligned starting point by pushing 1 byte.
    u8 *byte = (u8 *)mem_arena_push(&a, 1);
    EXPECT_FATAL(byte != NULL);
 
    // Push with 16-byte alignment (e.g., for SIMD).
    float *simd = PUSH_ARRAY_ALIGNED(&a, float, 4, 16);
    EXPECT_FATAL(simd != NULL);
    EXPECT(((usize)simd & 15) == 0); // pointer must be 16-byte aligned
    EXPECT(simd[0] == 0.0f);     // must be zeroed
 
    mem_arena_release(&a);
}
 
TEST_CASE(mem_arena_temp)
{
    MemArena a = mem_arena_create(MB(1));
    EXPECT_FATAL(a.base != NULL);
 
    int *persistent = PUSH_STRUCT(&a, int);
    EXPECT_FATAL(persistent != NULL);
    *persistent  = 99;
    usize pos_before = a.pos;
 
    MemArenaTemp tmp = mem_arena_temp_begin(&a);
 
    u8 *scratch = PUSH_ARRAY(&a, u8, 512);
    EXPECT_FATAL(scratch != NULL);
    EXPECT(a.pos > pos_before);
 
    mem_arena_temp_end(tmp);
    EXPECT(a.pos == pos_before); // must snap back
    EXPECT(*persistent == 99);   // persistent alloc survives
 
    mem_arena_release(&a);
}
 
TEST_CASE(mem_arena_allocator_interface)
{
    MemArena     a    = mem_arena_create(MB(1));
    MemAllocator ally = mem_arena_allocator(&a);
 
    int *val = (int *)mem_alloc(&ally, sizeof(int));
    EXPECT_FATAL(val != NULL);
    EXPECT(*val == 0); // zero-initialized
    *val = 7;
    EXPECT(*val == 7);
 
    mem_free(&ally, val, sizeof(int)); // no-op, must not crash
 
    usize old_size = sizeof(int) * 4;
    usize new_size = sizeof(int) * 8;
    int  *old_arr  = (int *)mem_alloc(&ally, old_size);
    EXPECT_FATAL(old_arr != NULL);
    old_arr[0] = 1;
    old_arr[3] = 4;
 
    int *grown = (int *)mem_realloc(&ally, old_arr, old_size, new_size);
    EXPECT_FATAL(grown != NULL);
    EXPECT(grown != old_arr); // arena realloc must always return a new pointer
    EXPECT(grown[0] == 1);    // old data copied
    EXPECT(grown[3] == 4);
    EXPECT(grown[4] == 0); // new bytes zeroed
    EXPECT(grown[7] == 0);
 
    mem_arena_release(&a);
}