Support > 4GB of chained arenas

src/arena.c

@@ -3,10 +3,10 @@
 #include "platform.h"
 
 
-MemoryBlock *memoryblock_allocate(size_t size, size_t commit_size)
+static MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size, U32 page_size)
 {
-    size_t aligned_size        = AlignToPageEnd(size);
+    U32 aligned_size        = AlignUpPow2(size, page_size);
-    size_t aligned_commit_size = AlignToPageEnd(commit_size);
+    U32 aligned_commit_size = AlignUpPow2(commit_size, page_size);
 
     MemoryBlock *block = memory_reserve(aligned_size);
     Assert(block != NULL);
@@ -17,38 +17,43 @@ MemoryBlock *memoryblock_allocate(size_t size, size_t commit_size)
     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_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
     return block;
 }
 
 void arena_init(Arena *arena, const ArenaParams *params)
 {
+    U32 page_size = platform_page_size();
     Assert(params->size > MemoryBlock_Header_Size);
-    Assert(params->size < (U32_Max -  platform_page_size())); // Reserving last piece so our math doesn't overflow
+    Assert(params->size < (U32_Max -  page_size)); // Reserving last piece so our math doesn't overflow
     Assert(params->commit_size > 0);
+    Assert(params->commit_size <= params->size);
 
-    MemoryBlock *block = memoryblock_allocate(params->size, params->commit_size);
+
-    ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
+    MemoryBlock *block = memoryblock_allocate(params->size, params->commit_size, page_size);
 
     arena->flags            = params->flags;
     arena->checkpoint_level = 0;
     arena->current          = block;
     arena->block_size       = params->size;
     arena->commit_size      = params->commit_size;
+    arena->page_size        = page_size;
 
-    ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
 }
 
 void arena_free(Arena *arena)
 {
     MemoryBlock *block = arena->current;
-
+    Assert(arena->checkpoint_level == 0);
     while (block != NULL) {
         MemoryBlock *prev = block->prev;
         memory_free(block->base, block->size);
         block = prev;
     }
+    arena->current = NULL;
 }
 
 void *arena_push(Arena *arena, U32 size, U32 align)
@@ -57,10 +62,10 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     Assert(IsPow2(align));
 
     MemoryBlock *block = arena->current;
-    U32 start_pos = AlignUpPow2(block->pos, align);
+    U32 start_pos = AlignUpPow2(block->pos, align);  // might align past block->size, handled in below check
     U32 available = block->size - start_pos;
 
-    if (available < size) {
+    if (start_pos > block->size || available < size) {
         U32 block_size = arena->block_size; // original user requested size
         U32 new_commit_size = arena->commit_size;
         if (size > block_size - MemoryBlock_Header_Size) {
@@ -68,7 +73,9 @@ void *arena_push(Arena *arena, U32 size, U32 align)
             new_commit_size = block_size;
         }
 
-        MemoryBlock *new_block  = memoryblock_allocate(block_size, new_commit_size);
+        MemoryBlock *new_block  = memoryblock_allocate(block_size, new_commit_size, arena->page_size);
+        // base_pos tracks the virtual absolute position within an arena
+        // This is not a contiguous space, we use it to free blocks when popping the arena
         new_block->base_pos     = block->base_pos + block->size;
         new_block->prev         = block;
         arena->current          = new_block;
@@ -80,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   = AlignToPageEnd(start_pos + size);
+        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); // Note(nos): Is this actually right ?
+        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;
 
@@ -95,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);
@@ -107,9 +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);
-            Assert(new_pos <= block->committed_pos);
+            // Disallow arbirary pops to positions that previously were not commited.
+            Assert(new_pos <= block->committed_end);
             block->pos = new_pos;
             ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
             break;
@@ -119,9 +128,9 @@ void arena_pop_to(Arena *arena, U32 abs_pos)
     }
 }
 
-ArenaCheckPoint arena_temp_begin(Arena *arena)
+ArenaCheckpoint arena_temp_begin(Arena *arena)
 {
-    ArenaCheckPoint checkpoint = {};
+    ArenaCheckpoint checkpoint = {};
     checkpoint.arena           = arena;
     checkpoint.absolute_pos    = arena_used(arena);
     arena->checkpoint_level++;
@@ -129,7 +138,7 @@ ArenaCheckPoint arena_temp_begin(Arena *arena)
     return checkpoint;
 }
 
-void arena_temp_end(ArenaCheckPoint *checkpoint)
+void arena_temp_end(ArenaCheckpoint *checkpoint)
 {
     Arena *arena = checkpoint->arena;
     Assert(arena->checkpoint_level > 0);

src/arena.h

@@ -2,7 +2,7 @@
 #include "base_core.h"
 
 
-typedef U32 ArenaFlags; // no flags defined yets
+typedef U32 ArenaFlags; // no flags defined yet
 
 typedef struct ArenaParams ArenaParams;
 struct ArenaParams {
@@ -14,54 +14,55 @@ struct ArenaParams {
 typedef struct MemoryBlock MemoryBlock;
 struct MemoryBlock {
     U8 *base;
-    U32 size;
+    U32 size;           // Block size, page aligned
-    U32 pos;          // start of next allocation
+    U32 pos;            // start of next allocation
-    U32 base_pos;     // absolute position of base relative to the first linked arena
+    U64 base_pos;       // absolute position of base relative to the first linked arena
-    U32 committed_pos;
+    U32 committed_end;  // end of committed region. Will be page aligned
     MemoryBlock *prev;
 };
 
 typedef struct Arena Arena;
 struct Arena {
     MemoryBlock *current;
-    U32 block_size;
+    U32 block_size;     // requested block size
-    U32 commit_size;
+    U32 commit_size;    // requested commit size
+    U32 page_size;      // cached page size
     ArenaFlags flags;
     S32 checkpoint_level;
 };
 
-typedef struct ArenaCheckPoint ArenaCheckPoint;
+typedef struct ArenaCheckpoint ArenaCheckpoint;
-struct ArenaCheckPoint {
+struct ArenaCheckpoint {
     Arena *arena;
-    U32 absolute_pos;
+    U64 absolute_pos;
 };
+#ifndef ArenaParams_Default
+#define ArenaParams_Default { .size = MB(32), .commit_size = KB(64) }
+#endif
 
 StaticAssert(sizeof(MemoryBlock) <= 64);
+// Try keep start of user memory at a cacheline
 #define MemoryBlock_Header_Size 64u
 
-
-
 void arena_init(Arena *arena, const ArenaParams *params);
-
 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);
+ArenaCheckpoint arena_temp_begin(Arena *arena);
-void arena_temp_end(ArenaCheckPoint *checkpoint);
+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);
-MemoryBlock *memoryblock_allocate(size_t size, size_t commit_size);
-
 
 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;

src/base_core.h

@@ -41,10 +41,11 @@ typedef unsigned __int128 U128;
 #define U32_Max     ((U32)0xffffffff)
 #define U64_Max     ((U64)0xffffffffffffffffULL)
 
-#define  U8_Min     ((U8) 0x80)
+// Duh ..
-#define U16_Min     ((U16)0x8000)
+#define  U8_Min     ((U8)0x0)
-#define U32_Min     ((U32)0x80000000)
+#define U16_Min     ((U16)0x0)
-#define U64_Min     ((U64)0x8000000000000000ULL)
+#define U32_Min     ((U32)0x0)
+#define U64_Min     ((U64)0x0)
 
 #define  S8_Max     ((S8) 0x7f)
 #define S16_Max     ((S16)0x7fff)
@@ -163,7 +164,7 @@ typedef unsigned __int128 U128;
  * @param y denominator
  * @return x rounded down nearest multiple of y
  */
-#define RounDownToMultiple(x, y) ((x) / (y) * (y))
+#define RoundDownToMultiple(x, y) ((x) / (y) * (y))
 #define Clamp(val, min, max) (((val) < (min)) ? (min) : ((val) > (max)) ? (max) : (val))
 
 #ifdef __GNUC__

src/main.c

@@ -13,7 +13,7 @@ void arena_dump(const Arena *arena)
         printf("base:        %p\n", block->base);
         printf("size:        %u\n", block->size);
         printf("pos:         %u\n", block->pos);
-        printf("base_pos:    %u\n", block->base_pos);
+        printf("base_pos:    %lu\n",block->base_pos);
         printf("prev: %p\n", block->prev);
         puts("-----Arena  end-");
         block = block->prev;
@@ -21,6 +21,7 @@ void arena_dump(const Arena *arena)
 }
 static void arena_test_1(void)
 {
+    TRACEF("\n");
     ArenaParams arena_params = {};
     U32 arena_size = MB(1) + MemoryBlock_Header_Size;
     U32 commit_size = KB(8);
@@ -47,6 +48,8 @@ static void arena_test_1(void)
 
 static void arena_test_2(void)
 {
+    TRACEF("\n");
+
     ArenaParams arena_params = {};
     U32 arena_size = MB(1) + MemoryBlock_Header_Size;
     U32 commit_size = KB(16);
@@ -62,7 +65,7 @@ static void arena_test_2(void)
     printf("Allocated ptr %p\n", ptr);
 
     arena_dump(&arena);
-    ArenaCheckPoint checkpoint = arena_temp_begin(&arena);
+    ArenaCheckpoint checkpoint = arena_temp_begin(&arena);
     ptr = arena_push(&arena, MB(2), 8);
     MemoryZero(ptr, MB(2));
 
@@ -71,7 +74,7 @@ static void arena_test_2(void)
     ptr = arena_push(&arena, commit_size , 8);
     MemoryZero(ptr, commit_size  );
 
-    ArenaCheckPoint checkpoint2 = arena_temp_begin(&arena);
+    ArenaCheckpoint checkpoint2 = arena_temp_begin(&arena);
     ptr = arena_push(&arena, 64, 8);
     MemoryZero(ptr, 64);
 
@@ -89,15 +92,18 @@ static void arena_test_2(void)
     arena_pop_to(&arena, 1089);
     arena_dump(&arena);
     arena_pop_to(&arena, 0);
-
+    ptr = arena_push(&arena, MB(1), 8);
+    MemoryZero(ptr, MB(1));
     arena_free(&arena);
 }
 
 static void arena_test_3(void)
 {
+    TRACEF("\n");
+
     ArenaParams arena_params = {};
     U32 arena_size = KB(97) + MemoryBlock_Header_Size;
-    U32 commit_size = KB(32);
+    U32 commit_size = KB(97);
     arena_params.size = arena_size;
     arena_params.commit_size = commit_size;
     Arena arena;
@@ -116,7 +122,7 @@ static void arena_test_3(void)
 
 int main(int argc, char *argv[])
 {
-    //arena_test_1();
+    arena_test_1();
-    //arena_test_2();
+    arena_test_2();
     arena_test_3();
 }

src/platform.c

@@ -13,7 +13,6 @@ U32 platform_page_size(void)
     return getpagesize();
 }
 
-
 void *platform_malloc(size_t size)
 {
     return malloc(size);
@@ -24,22 +23,28 @@ void platform_free(void *mem)
     free(mem);
 }
 
-
+void *memory_allocate_and_commit(size_t size)
-void *memory_allocate(size_t size)
 {
-    Assert(IsPow2(size));
+    Assert(IsPageAligned(size));
 
     void *mem = mmap(0, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS  | MAP_PRIVATE, -1, 0);
-    TRACEF("memory_allocate size=%zu mem=%p\n", size, mem);
+    TRACEF("memory_allocate size=%7zu mem=%p\n", size, mem);
     if (mem == MAP_FAILED) {
         mem = NULL;
+    } else {
+        int rc = madvise(mem, size, MADV_POPULATE_WRITE);
+        if (rc != 0) {
+            munmap(mem, size);
+            mem = NULL;
+        }
     }
+
     return mem;
 }
 
 void memory_free(void *mem, size_t size)
 {
-    TRACEF("        memory_free     size=%zu mem=%p\n", size, mem);
+    TRACEF("        memory_free     size=%7zu mem=%p\n", size, mem);
     Assert(IsPageAligned((uintptr_t)mem));
     Assert(IsPageAligned(size));
     int rc = munmap(mem, size);
@@ -51,7 +56,7 @@ void *memory_reserve(size_t size)
 {
     Assert(IsPageAligned(size));
     void *mem = mmap(0, size, PROT_NONE, MAP_ANONYMOUS  | MAP_PRIVATE, -1, 0);
-    TRACEF("memory_reserve  size=%zu mem=%p\n", size, mem);
+    TRACEF("memory_reserve  size=%7zu mem=%p\n", size, mem);
     if (mem == MAP_FAILED) {
         mem = NULL;
     }
@@ -62,7 +67,7 @@ void memory_commit(void *mem, size_t size)
 {
     Assert(IsPageAligned((uintptr_t)mem));
     Assert(IsPageAligned(size));
-    TRACEF("memory_commit   size=%zu mem=%p\n", size, mem);
+    TRACEF("memory_commit   size=%7zu mem=%p\n", size, mem);
 
     int rc;
     rc = mprotect(mem, size, PROT_READ | PROT_WRITE);
@@ -73,7 +78,7 @@ void memory_commit(void *mem, size_t size)
 
 void memory_decommit(void *mem, size_t size)
 {
-    TRACEF("memory_decommit size=%zu mem=%p\n", size, mem);
+    TRACEF("memory_decommit size=%7zu mem=%p\n", size, mem);
     Assert(IsPageAligned((uintptr_t)mem));
     Assert(IsPageAligned(size));
     int rc;

src/platform.h

@@ -4,26 +4,9 @@
 void *platform_malloc(size_t size);
 U32 platform_page_size(void);
 
-void *memory_allocate(size_t size);
+void *memory_allocate_and_commit(size_t size);
 void *memory_reserve(size_t size);
 void memory_commit(void *mem, size_t size);
 void memory_decommit(void *mem, size_t size);
 
 void memory_free(void *mem, size_t size);
-
-
-static INLINE size_t AlignToPageEnd(size_t value)
-{
-    U32 page_size = platform_page_size();
-    size_t aligned_value = AlignUpPow2(value, page_size);
-
-    return aligned_value;
-}
-
-static INLINE size_t AlignToPageStart(size_t value)
-{
-    U32 page_size = platform_page_size();
-    size_t aligned_value= AlignDownPow2(value, page_size);
-
-    return aligned_value;
-}