Rework Arena into chain of MemoryBlock

src/arena.c

@@ -2,79 +2,77 @@
 #include "base_core.h"
 #include "platform.h"
 
-static INLINE U32 arena_absolute_pos(const Arena *arena)
+
+MemoryBlock *memoryblock_allocate(size_t size)
 {
-    const Arena *current = arena->current;
-    return current->base_pos + current->pos;
+    void *base = memory_allocate(size);
+    Assert(base != NULL);
+
+    MemoryBlock *block = (MemoryBlock *)base;
+    block->base      = (U8 *)base;
+    block->size      = size;
+    block->pos       = MemoryBlock_Header_Size;
+    block->base_pos  = 0;
+    block->prev      = NULL;
+
+    return block;
 }
 
-Arena *arena_alloc(const ArenaParams *params)
+void arena_init(Arena *arena, const ArenaParams *params)
 {
-    Assert(params->size > ARENA_HEADER_SZ);
-    Assert(params->size < (U32_Max -  ARENA_HEADER_SZ - 1));
+    Assert(params->size > MemoryBlock_Header_Size);
+    Assert(params->size < (U32_Max -  MemoryBlock_Header_Size - 1));
 
-    void *base;
-    base = memory_allocate(params->size);
-    Assert(base != NULL);
-    ASAN_UNPOISON_MEMORY_REGION(base, ARENA_HEADER_SZ);
+    MemoryBlock *block = memoryblock_allocate(params->size);
+    ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
 
-    Arena *arena = (Arena *)base;
-    arena->base     = (U8 *)base;
-    arena->current  = arena;
-    arena->size     = params->size;
-    arena->pos      = ARENA_HEADER_SZ;
-    arena->base_pos = 0;
-    arena->flags    = params->flags;
-    arena->prev     = NULL;
+    arena->flags            = params->flags;
     arena->checkpoint_level = 0;
+    arena->current          = block;
+    arena->requested_size   = params->size;
 
-    ASAN_POISON_MEMORY_REGION(&arena->base[arena->pos], arena_available(arena));
-    return arena;
+    ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
 }
 
 void arena_free(Arena *arena)
 {
-    Arena *it = arena->current;
+    MemoryBlock *block = arena->current;
 
-    while (it != NULL) {
-        Arena *prev = it->prev;
-        memory_free(it->base, it->size);
-        it = prev;
+    while (block != NULL) {
+        MemoryBlock *prev = block->prev;
+        memory_free(block->base, block->size);
+        block = prev;
     }
 }
 
 void *arena_push(Arena *arena, U32 size, U32 align)
 {
-    Assert(size < (U32_Max - align - ARENA_HEADER_SZ - 1));
+    Assert(size < (U32_Max - align - MemoryBlock_Header_Size - 1));
     Assert(IsPow2(align));
 
-    Arena *current = arena->current;
-    U32 start_pos = AlignUpPow2(current->pos, align);
-    U32 available = arena_available(current);
+    MemoryBlock *block = arena->current;
+    U32 start_pos = AlignUpPow2(block->pos, align);
+    U32 available = memoryblock_available(block);
 
     if (available < size) {
-        U32 new_size = arena->size; // original user requeted size
+        U32 new_size = arena->requested_size; // original user requeted size
         if (new_size < size) {
-            new_size = AlignUpPow2(size + ARENA_HEADER_SZ,align);
+            new_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
         }
 
-        ArenaParams new_params  = {};
-        new_params.flags        = current->flags;
-        new_params.size         = new_size;
-
-        Arena *new_arena    = arena_alloc(&new_params);
-        new_arena->base_pos = current->base_pos + current->size;
-        new_arena->prev     = current;
-        arena->current      = new_arena;
-        current             = new_arena;
-        start_pos           = AlignUpPow2(current->pos, align);
+        MemoryBlock *new_block  = memoryblock_allocate(new_size);
+        new_block->base_pos     = block->base_pos + block->size;
+        new_block->prev         = block;
+        arena->current          = new_block;
+        block                   = new_block;
+        start_pos               = AlignUpPow2(block->pos, align);
     }
 
     U32 end_pos = start_pos + size;
-    Assert(end_pos <= current->size);
+    Assert(end_pos <= block->size);
 
-    U8 *mem     = &current->base[start_pos];
-    current->pos  = end_pos;
+    U8 *mem     = &block->base[start_pos];
+    block->pos  = end_pos;
 
     ASAN_UNPOISON_MEMORY_REGION(mem, size);
     return mem;
@@ -82,34 +80,35 @@ void *arena_push(Arena *arena, U32 size, U32 align)
 
 void arena_pop_to(Arena *arena, U32 abs_pos)
 {
-    Arena *current = arena->current;
-    abs_pos = Max(ARENA_HEADER_SZ, abs_pos);
-    while (current) {
-        Arena *prev = current->prev;
+    MemoryBlock *block = arena->current;
+    abs_pos = Max(MemoryBlock_Header_Size, abs_pos);
+    while (block) {
+        MemoryBlock *prev = block->prev;
 
-        if (current->base_pos >= abs_pos) {
-            ASAN_UNPOISON_MEMORY_REGION(current->base, current->size); // needed as we use malloc
-            memory_free(current->base, current->size);
+        if (block->base_pos >= abs_pos) {
+            ASAN_UNPOISON_MEMORY_REGION(block->base, block->size);
+            memory_free(block->base, block->size);
             arena->current = prev;
         } else {
-            U32 new_pos = abs_pos - current->base_pos;
+            U32 new_pos = abs_pos - block->base_pos;
+            new_pos = Max(MemoryBlock_Header_Size, new_pos);
             // Note, when doing commit/release, new_pos <= current->pos
             // is the right thing . shouldn't be able to pop to larger than what's already commited
-            Assert(new_pos <= current->size);
-            current->pos = new_pos;
-            ASAN_POISON_MEMORY_REGION(&current->base[current->pos], arena_available(arena));
+            Assert(new_pos <= block->size);
+            block->pos = new_pos;
+            ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
             break;
         }
 
-        current = prev;
+        block = prev;
     }
 }
 
 ArenaCheckPoint arena_temp_begin(Arena *arena)
 {
     ArenaCheckPoint checkpoint = {};
-    checkpoint.arena = arena;
-    checkpoint.absolute_pos = arena_absolute_pos(arena);
+    checkpoint.arena           = arena;
+    checkpoint.absolute_pos    = arena_used(arena);
     arena->checkpoint_level++;
 
     return checkpoint;