Support > 4GB of chained arenas

src/arena.c

@@ -5,8 +5,8 @@
 
 static MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size, U32 page_size)
 {
-    size_t aligned_size        = AlignUpPow2(size, page_size);
+    U32 aligned_size        = AlignUpPow2(size, page_size);
-    size_t aligned_commit_size = AlignUpPow2(commit_size, page_size);
+    U32 aligned_commit_size = AlignUpPow2(commit_size, page_size);
 
     MemoryBlock *block = memory_reserve(aligned_size);
     Assert(block != NULL);
@@ -17,9 +17,9 @@ static MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size, U32 page_siz
     block->pos           = MemoryBlock_Header_Size;
     block->base_pos      = 0;
     block->prev          = NULL;
-    block->committed_pos = aligned_commit_size;
+    block->committed_end = aligned_commit_size;
 
-    ASAN_POISON_MEMORY_REGION(&block->base, block->size);
+    ASAN_POISON_MEMORY_REGION(block->base, block->size);
     ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
     return block;
 }
@@ -62,7 +62,7 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     Assert(IsPow2(align));
 
     MemoryBlock *block = arena->current;
-    U32 start_pos = AlignUpPow2(block->pos, align);  // might align past block->size
+    U32 start_pos = AlignUpPow2(block->pos, align);  // might align past block->size, handled in below check
     U32 available = block->size - start_pos;
 
     if (start_pos > block->size || available < size) {
@@ -87,14 +87,15 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     Assert(end_pos <= block->size);
 
     U8 *mem = &block->base[start_pos];
-    if (block->committed_pos < end_pos) {
+    if (block->committed_end < end_pos) {
         // Commit more memory
         U32 aligned_end_pos   = AlignUpPow2(start_pos + size, arena->page_size);
-        U32 aligned_size      = RoundUpToMultiple(aligned_end_pos - block->committed_pos, arena->commit_size);
+        U32 aligned_size      = RoundUpToMultiple(aligned_end_pos - block->committed_end, arena->commit_size);
-        aligned_size = Min(aligned_size, block->size - block->committed_pos);
+        aligned_size = Min(aligned_size, block->size - block->committed_end);
 
-        memory_commit(&block->base[block->committed_pos], aligned_size);
+        memory_commit(&block->base[block->committed_end], aligned_size);
-        block->committed_pos  += aligned_size;
+        block->committed_end  += aligned_size;
+        Assert(block->committed_end <= block->size);
     }
     block->pos  = end_pos;
 
@@ -102,7 +103,7 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     return mem;
 }
 
-void arena_pop_to(Arena *arena, U32 abs_pos)
+void arena_pop_to(Arena *arena, U64 abs_pos)
 {
     MemoryBlock *block = arena->current;
     abs_pos = Max(MemoryBlock_Header_Size, abs_pos);
@@ -114,10 +115,10 @@ void arena_pop_to(Arena *arena, U32 abs_pos)
             memory_free(block->base, block->size);
             arena->current = prev;
         } else {
-            U32 new_pos = abs_pos - block->base_pos;
+            U64 new_pos = abs_pos - block->base_pos;
             new_pos = Max(MemoryBlock_Header_Size, new_pos);
             // Disallow arbirary pops to positions that previously were not commited.
-            Assert(new_pos <= block->committed_pos);
+            Assert(new_pos <= block->committed_end);
             block->pos = new_pos;
             ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
             break;

src/arena.h

@@ -17,7 +17,7 @@ struct MemoryBlock {
     U32 size;           // Block size, page aligned
     U32 pos;            // start of next allocation
     U64 base_pos;       // absolute position of base relative to the first linked arena
-    U32 committed_pos;  // end of committed region. Will be page aligned
+    U32 committed_end;  // end of committed region. Will be page aligned
     MemoryBlock *prev;
 };
 
@@ -34,7 +34,7 @@ struct Arena {
 typedef struct ArenaCheckpoint ArenaCheckpoint;
 struct ArenaCheckpoint {
     Arena *arena;
-    U32 absolute_pos;
+    U64 absolute_pos;
 };
 #ifndef ArenaParams_Default
 #define ArenaParams_Default { .size = MB(32), .commit_size = KB(64) }
@@ -49,11 +49,12 @@ void arena_free(Arena *arena);
 void *arena_push(Arena *arena, U32 size, U32 align);
 
 #define arena_push_type(arena, type) arena_push(arena, (U32)sizeof(type), alignof(type))
+// Invalid for arrays > U32
 #define arena_push_array_of(arena, type, len) arena_push(arena, (U32) (sizeof(type) * (len)), alignof(type))
 
 ArenaCheckpoint arena_temp_begin(Arena *arena);
 void arena_temp_end(ArenaCheckpoint *checkpoint);
-void arena_pop_to(Arena *arena, U32 abs_pos);
+void arena_pop_to(Arena *arena, U64 abs_pos);
 void arena_reset(Arena *arena);
 
 static INLINE U32 memoryblock_available(const MemoryBlock *block)
@@ -61,7 +62,7 @@ static INLINE U32 memoryblock_available(const MemoryBlock *block)
     return block->size - block->pos;
 }
 
-static INLINE U32 arena_used(const Arena *arena)
+static INLINE U64 arena_used(const Arena *arena)
 {
     const MemoryBlock *block = arena->current;
     return block->base_pos + block->pos;