Proper memory commitment

src/arena.c

@@ -3,17 +3,21 @@
 #include "platform.h"
 
 
-MemoryBlock *memoryblock_allocate(size_t size)
+MemoryBlock *memoryblock_allocate(size_t size, size_t commit_size)
 {
-    void *base = memory_allocate(size);
-    Assert(base != NULL);
+    size_t aligned_size        = AlignToPageEnd(size);
+    size_t aligned_commit_size = AlignToPageEnd(commit_size);
 
-    MemoryBlock *block = (MemoryBlock *)base;
-    block->base      = (U8 *)base;
-    block->size      = size;
-    block->pos       = MemoryBlock_Header_Size;
-    block->base_pos  = 0;
-    block->prev      = NULL;
+    MemoryBlock *block = memory_reserve(aligned_size);
+    Assert(block != NULL);
+    memory_commit(block, aligned_commit_size);
+
+    block->base          = (U8 *)block;
+    block->size          = aligned_size;
+    block->pos           = MemoryBlock_Header_Size;
+    block->base_pos      = 0;
+    block->prev          = NULL;
+    block->committed_pos = aligned_commit_size;
 
     return block;
 }
@@ -21,15 +25,17 @@ MemoryBlock *memoryblock_allocate(size_t size)
 void arena_init(Arena *arena, const ArenaParams *params)
 {
     Assert(params->size > MemoryBlock_Header_Size);
-    Assert(params->size < (U32_Max -  MemoryBlock_Header_Size - 1));
+    Assert(params->size < (U32_Max -  platform_page_size())); // keep last page for overflow detection
+    Assert(IsPow2(params->commit_size));
 
-    MemoryBlock *block = memoryblock_allocate(params->size);
+    MemoryBlock *block = memoryblock_allocate(params->size, params->commit_size);
     ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
 
     arena->flags            = params->flags;
     arena->checkpoint_level = 0;
     arena->current          = block;
-    arena->requested_size   = params->size;
+    arena->block_size       = params->size;
+    arena->commit_size      = params->commit_size;
 
     ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
 }
@@ -47,20 +53,22 @@ void arena_free(Arena *arena)
 
 void *arena_push(Arena *arena, U32 size, U32 align)
 {
-    Assert(size < (U32_Max - align - MemoryBlock_Header_Size - 1));
+    Assert(size < (U32_Max - platform_page_size()));
     Assert(IsPow2(align));
 
     MemoryBlock *block = arena->current;
     U32 start_pos = AlignUpPow2(block->pos, align);
-    U32 available = memoryblock_available(block);
+    U32 available = block->size - start_pos;
 
     if (available < size) {
-        U32 new_size = arena->requested_size; // original user requeted size
-        if (new_size < size) {
-            new_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
+        U32 block_size = arena->block_size; // original user requested size
+        U32 new_commit_size = arena->commit_size;
+        if (size > block_size - MemoryBlock_Header_Size) {
+            block_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
+            new_commit_size = block_size;
         }
 
-        MemoryBlock *new_block  = memoryblock_allocate(new_size);
+        MemoryBlock *new_block  = memoryblock_allocate(block_size, new_commit_size);
         new_block->base_pos     = block->base_pos + block->size;
         new_block->prev         = block;
         arena->current          = new_block;
@@ -71,7 +79,15 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     U32 end_pos = start_pos + size;
     Assert(end_pos <= block->size);
 
-    U8 *mem     = &block->base[start_pos];
+    U8 *mem = &block->base[start_pos];
+    if (block->committed_pos < end_pos) {
+        // Commit more memory
+        U32 aligned_end_pos   = AlignToPageEnd(start_pos + size);
+
+        U32 aligned_size      = RoundUpToMultiple(aligned_end_pos - block->committed_pos, arena->commit_size);
+        memory_commit(&block->base[block->committed_pos], aligned_size);
+        block->committed_pos  += aligned_size;
+    }
     block->pos  = end_pos;
 
     ASAN_UNPOISON_MEMORY_REGION(mem, size);
@@ -92,9 +108,7 @@ void arena_pop_to(Arena *arena, U32 abs_pos)
         } else {
             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 <= block->size);
+            Assert(new_pos <= block->committed_pos);
             block->pos = new_pos;
             ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
             break;