Fix miniarena

src/arena.c

@@ -132,9 +132,9 @@ void arena_reset_to(Arena *arena, U64 total_offset)
     }
 }
 
-ArenaCheckpoint arena_temp_begin(Arena *arena)
+ATemp arena_temp_begin(Arena *arena)
 {
-    ArenaCheckpoint checkpoint = {};
+    ATemp checkpoint = {};
     checkpoint.arena           = arena;
     checkpoint.total_offset    = arena_used(arena);
     arena->checkpoint_level++;
@@ -142,7 +142,7 @@ ArenaCheckpoint arena_temp_begin(Arena *arena)
     return checkpoint;
 }
 
-void arena_temp_end(ArenaCheckpoint *checkpoint)
+void arena_temp_end(ATemp *checkpoint)
 {
     Arena *arena = checkpoint->arena;
     Assert(arena->checkpoint_level > 0);

src/arena.h

@@ -30,8 +30,8 @@ struct Arena {
     S32 checkpoint_level;
 };
 
-typedef struct ArenaCheckpoint ArenaCheckpoint;
+typedef struct ATemp ATemp;
-struct ArenaCheckpoint {
+struct ATemp {
     Arena *arena;
     U64 total_offset;
 };
@@ -51,8 +51,8 @@ void *arena_push(Arena *arena, U32 size, U32 align);
 // 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);
+ATemp arena_temp_begin(Arena *arena);
-void arena_temp_end(ArenaCheckpoint *checkpoint);
+void arena_temp_end(ATemp *checkpoint);
 void arena_reset_to(Arena *arena, U64 total_offset);
 void arena_reset(Arena *arena);
 

src/main.c

@@ -68,7 +68,7 @@ static void arena_test_2(void)
     printf("Allocated ptr %p\n", ptr);
 
     arena_dump(&arena);
-    ArenaCheckpoint checkpoint = arena_temp_begin(&arena);
+    ATemp checkpoint = arena_temp_begin(&arena);
     ptr = arena_push(&arena, MB(4)+3, 8);
     MemoryZero(ptr, MB(2));
 
@@ -77,7 +77,7 @@ static void arena_test_2(void)
     ptr = arena_push(&arena, commit_size , 8);
     MemoryZero(ptr, commit_size  );
 
-    ArenaCheckpoint checkpoint2 = arena_temp_begin(&arena);
+    ATemp checkpoint2 = arena_temp_begin(&arena);
     ptr = arena_push(&arena, 64, 8);
     MemoryZero(ptr, 64);
 
@@ -162,12 +162,41 @@ static void arena_test_4(void)
 
     arena_free(&arena);
 }
+void miniarena_test1(void)
+{
+    #define  arena_size  4096
+    MARENA_DEFINE(arena, arena_size, 8);
+    int i;
+    for (i = 0; ; i++) {
+        void *ptr = marena_push(&arena, 1);
+        if (ptr == NULL) {
+            break;
+        }
+    }
 
+    printf("miniarena_test1,size %u pushed %d bytes first_free %u\n", arena.size, i, arena.first_free);
+    marena_reset(&arena);
+    MTemp checkpoint = marena_temp_begin(&arena);
+
+    void *ptr = marena_push(&arena, arena_size);
+    Assert(ptr != NULL);
+    Assert(arena.first_free == arena_size);
+    MemoryZero(ptr, arena_size);
+    marena_temp_end(&checkpoint);
+
+    printf("miniarena_test1,size %u bytes first_free %u\n", arena.size, arena.first_free);
+
+    Assert(arena.first_free == 0);
+
+
+
+}
 int main(int argc, char *argv[])
 {
     // arena_test_1();
-    arena_test_2();
+    // arena_test_2();
-    arena_test_3();
+    // arena_test_3();
-    arena_test_4();
+    // arena_test_4();
+    miniarena_test1();
 }
 

src/mini_arena.h

@@ -8,22 +8,22 @@ struct MArena {
     U8 *base;         // start of buffer
     U32 first_free;   // next alloc point
     U32 size;
-    S32 checkpoint_level;  // level of marenatmp_begin nesting
+    S32 checkpoint_level;  // level of marena_temp_begin nesting
 };
 
-typedef struct MArenaCheckpoint MArenaCheckpoint;
+typedef struct MTemp MTemp;
-struct MArenaCheckpoint {
+struct MTemp {
     U32 offset;
     MArena *arena;
 };
 
 #define MARENA_STATIC_INITIALIZER(data) MARENA_INITIALIZER((data), sizeof(data))
-#define MARENA_INITIALIZER(data, size) {.base = (data), .base = (data), .first_free = 0, .size = (U32)sizeof(data), checkpoint_level = 0}
+#define MARENA_INITIALIZER(data, size_) {.base = (data), .first_free = 0, .size = (U32)size_, .checkpoint_level = 0}
 #define MARENA_DEFINE(var_name, size, alignment_)  \
-    struct {                                        \
+    struct { \
-        _Alignas(alignment_) U8 memory[size]; \
+        _Alignas(alignment_) U8 memory[size];\
-    } var_name##_arena_memory;                      \
+    } var_name##_marena_memory; \
-    MArena var_name = MARENA_STATIC_INITIALIZER(var_name##_arena_memory.memory)
+    MArena var_name = MARENA_STATIC_INITIALIZER(var_name##_marena_memory.memory)
 
 
 
@@ -35,9 +35,9 @@ static INLINE void marena_init(MArena *arena, void *memory, U32 size)
     arena->size       = size;
 }
 
-static INLINE MArenaCheckpoint marenatmp_begin(MArena *arena)
+static INLINE MTemp marena_temp_begin(MArena *arena)
 {
-    MArenaCheckpoint checkpoint = {};
+    MTemp checkpoint = {};
 
     checkpoint.arena  = arena;
     checkpoint.offset = arena->first_free;
@@ -46,7 +46,7 @@ static INLINE MArenaCheckpoint marenatmp_begin(MArena *arena)
     return checkpoint;
 }
 
-static INLINE void marenatmp_end(MArenaCheckpoint *state)
+static INLINE void marena_temp_end(MTemp *state)
 {
     MArena *arena = state->arena;
     Assert(arena->checkpoint_level > 0);