Cache page size

src/arena.c

@@ -3,10 +3,10 @@
 #include "platform.h"
 
 
-MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size)
+static MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size, U32 page_size)
 {
-    size_t aligned_size        = AlignUpToPage(size);
-    size_t aligned_commit_size = AlignUpToPage(commit_size);
+    size_t aligned_size        = AlignUpPow2(size, page_size);
+    size_t aligned_commit_size = AlignUpPow2(commit_size, page_size);
 
     MemoryBlock *block = memory_reserve(aligned_size);
     Assert(block != NULL);
@@ -19,27 +19,29 @@ MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size)
     block->prev          = NULL;
     block->committed_pos = 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)
@@ -71,7 +73,7 @@ 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;
@@ -87,7 +89,7 @@ void *arena_push(Arena *arena, U32 size, U32 align)
     U8 *mem = &block->base[start_pos];
     if (block->committed_pos < end_pos) {
         // Commit more memory
-        U32 aligned_end_pos   = AlignUpToPage(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);
         aligned_size = Min(aligned_size, block->size - block->committed_pos);
 

src/arena.h

@@ -36,8 +36,12 @@ struct ArenaCheckpoint {
     Arena *arena;
     U32 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);
@@ -51,8 +55,6 @@ ArenaCheckpoint arena_temp_begin(Arena *arena);
 void arena_temp_end(ArenaCheckpoint *checkpoint);
 void arena_pop_to(Arena *arena, U32 abs_pos);
 void arena_reset(Arena *arena);
-MemoryBlock *memoryblock_allocate(U32 size, U32 commit_size);
-
 
 static INLINE U32 memoryblock_available(const MemoryBlock *block)
 {

src/platform.h

@@ -10,20 +10,3 @@ 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 AlignUpToPage(size_t value)
-{
-    U32 page_size = platform_page_size();
-    size_t aligned_value = AlignUpPow2(value, page_size);
-
-    return aligned_value;
-}
-
-static INLINE size_t AlignDownToPage(size_t value)
-{
-    U32 page_size = platform_page_size();
-    size_t aligned_value= AlignDownPow2(value, page_size);
-
-    return aligned_value;
-}