Remove growing_arena and use base_arena

src/mem/arena/mem_arena.c

@@ -13,27 +13,12 @@
 
 #define ARENA_MINIMUM_CAPACITY 1024
 
-typedef struct base_arena BaseArena;
-struct base_arena {
+struct arena {
   u8 *buf;
   u8 *offset;
   u64 capacity;
-  BaseArena *prev;
-  BaseArena *next;
 };
 
-struct growing_arena {
-  BaseArena *active_arena;
-  u64 count;
-  u64 initial_capacity;
-};
-
-internal bool base_arena_init(BaseArena *arena, u64 capacity);
-internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
-                                        u64 alignment);
-internal void base_arena_clear(BaseArena *arena);
-internal void base_arena_destroy(BaseArena *arena);
-
 // PUBLIC API
 
 bool wapp_mem_arena_init(Arena **arena, u64 base_capacity) {
@@ -47,19 +32,18 @@ bool wapp_mem_arena_init(Arena **arena, u64 base_capacity) {
     return false;
   }
 
-  arena_ptr->active_arena = (BaseArena *)calloc(1, sizeof(BaseArena));
-  if (!(arena_ptr->active_arena)) {
+  u64 arena_capacity = base_capacity >= ARENA_MINIMUM_CAPACITY
+                           ? base_capacity
+                           : ARENA_MINIMUM_CAPACITY;
+
+  arena_ptr->buf = (u8 *)calloc(arena_capacity, sizeof(u8));
+  if (!(arena_ptr->buf)) {
     wapp_mem_arena_destroy(arena);
     return false;
   }
 
-  if (!base_arena_init(arena_ptr->active_arena, base_capacity)) {
-    wapp_mem_arena_destroy(arena);
-    return false;
-  }
-
-  arena_ptr->count = 1;
-  arena_ptr->initial_capacity = base_capacity;
+  arena_ptr->capacity = arena_capacity;
+  arena_ptr->offset = arena_ptr->buf;
 
   return true;
 }
@@ -69,130 +53,6 @@ void *wapp_mem_arena_alloc(Arena *arena, u64 size) {
 }
 
 void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
-  if (!arena || !(arena->active_arena)) {
-    return NULL;
-  }
-
-  void *output = base_arena_alloc_aligned(arena->active_arena, size, alignment);
-  if (!output) {
-    if (arena->active_arena->next) {
-      arena->active_arena = arena->active_arena->next;
-    } else {
-      arena->active_arena->next = (BaseArena *)calloc(1, sizeof(BaseArena));
-      if (!(arena->active_arena->next)) {
-        return NULL;
-      }
-
-      if (!base_arena_init(arena->active_arena->next,
-                           arena->initial_capacity)) {
-        free(arena->active_arena->next);
-        return NULL;
-      }
-
-      arena->active_arena->next->prev = arena->active_arena;
-      arena->active_arena = arena->active_arena->next;
-
-      ++(arena->count);
-    }
-
-    output = base_arena_alloc_aligned(arena->active_arena, size, alignment);
-    if (!output) {
-      return NULL;
-    }
-  }
-
-  memset(output, 0, size);
-
-  return output;
-}
-
-void wapp_mem_arena_clear(Arena *arena) {
-  if (!arena) {
-    return;
-  }
-
-  BaseArena *last_active = NULL;
-  while (arena->active_arena) {
-    base_arena_clear(arena->active_arena);
-
-    last_active = arena->active_arena;
-
-    arena->active_arena = arena->active_arena->prev;
-  }
-
-  arena->active_arena = last_active;
-}
-
-void wapp_mem_arena_destroy(Arena **arena) {
-  if (!arena) {
-    return;
-  }
-
-  Arena *arena_ptr = *arena;
-  if (!arena_ptr) {
-    return;
-  }
-
-  BaseArena *current;
-  BaseArena *next;
-  BaseArena *prev;
-
-  current = arena_ptr->active_arena->next;
-  while (current) {
-    next = current->next;
-
-    base_arena_destroy(current);
-    free(current);
-
-    current = next;
-  }
-
-  current = arena_ptr->active_arena->prev;
-  while (current) {
-    prev = current->prev;
-
-    base_arena_destroy(current);
-    free(current);
-
-    current = prev;
-  }
-
-  base_arena_destroy(arena_ptr->active_arena);
-
-  free(arena_ptr->active_arena);
-  arena_ptr->active_arena = NULL;
-
-  arena_ptr->count = 0;
-  arena_ptr->initial_capacity = 0;
-
-  free(*arena);
-  *arena = NULL;
-}
-
-// INTERNAL FUNCTIONS
-
-internal bool base_arena_init(BaseArena *arena, u64 capacity) {
-  if (!arena || arena->buf || capacity == 0) {
-    return false;
-  }
-
-  u64 arena_capacity =
-      capacity >= ARENA_MINIMUM_CAPACITY ? capacity : ARENA_MINIMUM_CAPACITY;
-
-  arena->buf = (u8 *)calloc(arena_capacity, sizeof(u8));
-  if (!(arena->buf)) {
-    return false;
-  }
-
-  arena->capacity = arena_capacity;
-  arena->offset = arena->buf;
-  arena->prev = arena->next = NULL;
-
-  return true;
-}
-
-internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
-                                        u64 alignment) {
   if (!arena) {
     return NULL;
   }
@@ -206,10 +66,12 @@ internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
 
   arena->offset = output + size;
 
+  memset(output, 0, size);
+
   return (void *)output;
 }
 
-internal void base_arena_clear(BaseArena *arena) {
+void wapp_mem_arena_clear(Arena *arena) {
   if (!arena) {
     return;
   }
@@ -218,16 +80,19 @@ internal void base_arena_clear(BaseArena *arena) {
   arena->offset = arena->buf;
 }
 
-internal void base_arena_destroy(BaseArena *arena) {
+void wapp_mem_arena_destroy(Arena **arena) {
   if (!arena) {
     return;
   }
 
-  if (arena->buf) {
-    free(arena->buf);
+  Arena *arena_ptr = *arena;
+  if (arena_ptr->buf) {
+    free(arena_ptr->buf);
   }
 
-  arena->buf = arena->offset = NULL;
-  arena->capacity = 0;
-  arena->prev = arena->next = NULL;
+  arena_ptr->buf = arena_ptr->offset = NULL;
+  arena_ptr->capacity = 0;
+
+  free(*arena);
+  *arena = NULL;
 }

src/mem/arena/mem_arena.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif // __cplusplus
 
-typedef struct growing_arena Arena;
+typedef struct arena Arena;
 
 bool wapp_mem_arena_init(Arena **arena, u64 base_capacity);
 void *wapp_mem_arena_alloc(Arena *arena, u64 size);