Formatting issue

src/arena.h

@@ -39,7 +39,7 @@ struct ATemp {
     U64 total_offset;
 };
 #ifndef ArenaOptions_Default
-#define ArenaOptions_Default (&(ArenaOptions){ .size = MB(32), .commit_size = KB(64) })
+#define ArenaOptions_Default ((ArenaOptions){ .size = MB(32), .commit_size = KB(64) })
 #endif
 
 StaticAssert(sizeof(MemoryBlock) <= 64);

src/main.c

@@ -195,7 +195,9 @@ static void arena_test_allocator_interface(void)
     MemoryZero(ptr, page_size);
     printf("test_4: allocated %u bytes page-aligned at %p\n", page_size, ptr);
 
+    allocator_free_all(&allocator);
     arena_free(&arena);
+
 }
 
 static void arena_test_decommit(void)
@@ -248,14 +250,15 @@ void miniarena_test1(void)
     Assert(arena.first_free == arena_size);
     MemoryZero(ptr, arena_size);
     marena_temp_end(&checkpoint);
+    Assert(arena.first_free == 0);
+    U32 *val = marena_push_type(&arena, U32);
+    *val = 0xa0b0c0d0;
+    printf("marena val 0x%x\n", *val);
 
     printf("miniarena_test1,size %u bytes first_free %u\n", arena.size, arena.first_free);
-
-    Assert(arena.first_free == 0);
-
-
-
+    Assert(arena.first_free == sizeof(U32));
 }
+
 typedef struct PoolTest PoolTest;
 struct PoolTest{
     U32 n;
@@ -268,7 +271,7 @@ void apool_test(void)
     TRACEF("\n");
 
     Arena arena;
-    arena_init(&arena, ArenaOptions_Default);
+    arena_init(&arena, &ArenaOptions_Default);
     Allocator allocator = arena_allocator(&arena);
     APool *pool = apool_create_ex(&allocator, 16, sizeof(PoolTest), alignof(PoolTest));
     PoolTest *list = NULL;
@@ -306,15 +309,64 @@ void apool_test(void)
     for (PoolTest *p = list; p; p = p->next){
         printf("Pooltest %u\n",p->n);
     }
+    allocator_free_all(&allocator);
     arena_free(&arena);
 }
 
+void apool_test_miniarena(void)
+{
+    TRACEF("\n");
+
+    MArena arena;
+    U8 data[4096];
+    marena_init(&arena, data, sizeof data);
+    Allocator allocator = marena_allocator(&arena);
+    APool *pool = apool_create_ex(&allocator, 16, sizeof(PoolTest), alignof(PoolTest));
+    PoolTest *list = NULL;
+    for (U32 i = 0; i < U32_Max; i++) {
+        PoolTest *pt = apool_alloc(pool);
+        if (pt == NULL){
+            break;
+        }
+        pt->n = i;
+        pt->next = list;
+        list = pt;
+    }
+    for (PoolTest *p = list; p; p = p->next){
+        printf("Pooltest %u\n",p->n);
+    }
+
+    PoolTest *next;
+    U32 count = 0;
+    for (PoolTest *p = list; count < 7 && p; p = next){
+        count++;
+        next = p->next;
+        printf("Pooltest freeing %u\n",p->n);
+        apool_free(pool, p);
+    }
+    list = NULL;
+    for (U32 i = 0; i < U32_Max; i++) {
+        PoolTest *pt = apool_alloc(pool);
+        if (pt == NULL){
+            break;
+        }
+        pt->n = i;
+        pt->next = list;
+        list = pt;
+    }
+    for (PoolTest *p = list; p; p = p->next){
+        printf("Pooltest %u\n",p->n);
+    }
+    allocator_free_all(&allocator);
+}
+
+
 void apool_test_autogrow(void)
 {
     TRACEF("\n");
 
     Arena arena;
-    arena_init(&arena, ArenaOptions_Default);
+    arena_init(&arena, &ArenaOptions_Default);
     Allocator allocator = arena_allocator(&arena);
 
     APool *pool = apool_create(&allocator, APOOL_AUTOGROW, PoolTest);
@@ -354,18 +406,23 @@ void apool_test_autogrow(void)
         printf("Pooltest %u\n",p->n);
     }
 
+    allocator_free_all(&allocator);
+    arena_free(&arena);
+
 }
 
 int main(int argc, char *argv[])
 {
-    // arena_test_1();
-    // arena_test_2();
-    // arena_test_3();
-    // arena_test_4();
+    arena_test_1();
+    arena_test_2();
+    arena_test_3();
+    arena_test_4();
     arena_test_decommit();
     arena_test_allocator_interface();
-    // miniarena_test1();
+    miniarena_test1();
     apool_test();
     apool_test_autogrow();
+    apool_test_miniarena();
+
 }
 

src/mini_arena.h

@@ -54,12 +54,6 @@ static INLINE void marena_temp_end(MTemp *state)
     arena->temp_level--;
 }
 
-#define marena_push_type(allocator, type_)\
-        marenaalloc_aligned((allocator), sizeof(type_), _Alignof(type_))
-#define marena_push_array(allocator, type_, nr_elements_)\
-        marenaalloc_aligned((allocator), (nr_elements_) * (U32)sizeof(type_), _Alignof(type_))
-
-
 static INLINE void *marena_push(MArena *arena, U32 size)
 {
     if (size > arena->size - arena->first_free) {
@@ -90,6 +84,12 @@ static INLINE void *marena_push_aligned(MArena *arena, U32 size, U32 align)
     return base;
 }
 
+#define marena_push_type(arena, type_)\
+        marena_push_aligned((arena), sizeof(type_), _Alignof(type_))
+#define marena_push_array(arena, type_, nr_elements_)\
+        marena_push_aligned((arena), (nr_elements_) * (U32)sizeof(type_), _Alignof(type_))
+
+
 static INLINE void marena_reset(MArena *arena)
 {
     arena->first_free = 0;

src/platform.c

@@ -34,9 +34,9 @@ static void *platform_allocator_func(Allocator *allocator, AllocOperation operat
             free(memory);
             return NULL;
 
-            case Alloc_Op_Free_All:
-                free(memory);;
-                return NULL;
+        case Alloc_Op_Free_All:
+            NotImplemented;
+            return NULL;
     }
 
     Assert(false);

src/pool.h

@@ -3,17 +3,17 @@
 
 typedef union APoolElement APoolElement;
 union APoolElement {
-    APoolElement *next;          // offset from start to next free block (when not allocated)
+    APoolElement *next;       // offset from start to next free block (when not allocated)
 };
 
 typedef struct APool APool;
 struct APool {
     APoolElement *free_list;  // free list
-    U8 *start;         // start of user buffer
+    U8 *start;                // start of user buffer
     Allocator *allocator;
-    U32 element_size;    // aligned size of each block
-    U32 n_elements;      // total number of blocks
-    U32 align;         // alignment
+    U32 element_size;         // aligned size of each block
+    U32 n_elements;           // total number of blocks
+    U32 align;                // alignment
 };
 enum {
     APOOL_AUTOGROW = 0