herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/src/util/hb_arena.c

@@ -0,0 +1,179 @@
+#include "../include/util/hb_arena.h"
+#include "../include/macros.h"
+#include "../include/util/hb_system.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#define hb_arena_for_each_page(allocator, page)                                                                        \
+  for (hb_arena_page_T* page = (allocator)->head; page != NULL; page = page->next)
+
+static inline size_t hb_arena_align_size(size_t size, size_t alignment) {
+  assert(size <= SIZE_MAX - (alignment - 1));
+
+  return ((size + (alignment - 1)) / alignment) * alignment;
+}
+
+static inline bool hb_arena_page_has_capacity(hb_arena_page_T* page, size_t required_size) {
+  assert(page->position <= page->capacity);
+
+  return page->position + required_size <= page->capacity;
+}
+
+static inline void* hb_arena_page_alloc_from(hb_arena_page_T* page, size_t size) {
+  assert(size > 0);
+  assert(page->position + size <= page->capacity);
+
+  void* result = &page->memory[page->position];
+  page->position += size;
+
+  return result;
+}
+
+static inline void hb_arena_page_reset(hb_arena_page_T* page) {
+  page->position = 0;
+}
+
+static inline void hb_arena_reset_pages_after(hb_arena_page_T* start_page) {
+  for (hb_arena_page_T* page = start_page; page != NULL; page = page->next) {
+    hb_arena_page_reset(page);
+  }
+}
+
+static bool hb_arena_append_page(hb_arena_T* allocator, size_t minimum_size) {
+  assert(minimum_size > 0);
+
+  size_t page_size = MAX(allocator->default_page_size, minimum_size);
+
+  assert(page_size <= SIZE_MAX - sizeof(hb_arena_page_T));
+  size_t total_size = page_size + sizeof(hb_arena_page_T);
+
+  hb_arena_page_T* page = hb_system_allocate_memory(total_size);
+  if (page == NULL) { return false; }
+
+  *page = (hb_arena_page_T) { .next = NULL, .capacity = page_size, .position = 0 };
+
+  if (allocator->head == NULL) {
+    allocator->head = page;
+    allocator->tail = page;
+  } else {
+    hb_arena_page_T* last = allocator->head;
+
+    while (last->next != NULL) {
+      last = last->next;
+    }
+
+    last->next = page;
+    allocator->tail = page;
+  }
+
+  return true;
+}
+
+bool hb_arena_init(hb_arena_T* allocator, size_t initial_size) {
+  assert(initial_size > 0);
+
+  allocator->head = NULL;
+  allocator->tail = NULL;
+  allocator->default_page_size = initial_size;
+  allocator->allocation_count = 0;
+
+  return hb_arena_append_page(allocator, initial_size);
+}
+
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size) {
+  assert(allocator->tail != NULL);
+  assert(size > 0);
+
+  size_t required_size = hb_arena_align_size(size, 8);
+
+  allocator->allocation_count++;
+
+  if (hb_arena_page_has_capacity(allocator->tail, required_size)) {
+    return hb_arena_page_alloc_from(allocator->tail, required_size);
+  }
+
+  for (hb_arena_page_T* page = allocator->tail->next; page != NULL; page = page->next) {
+    if (hb_arena_page_has_capacity(page, required_size)) {
+      allocator->tail = page;
+      return hb_arena_page_alloc_from(allocator->tail, required_size);
+    }
+  }
+
+  bool allocated = hb_arena_append_page(allocator, required_size);
+
+  if (!allocated) { return NULL; }
+
+  return hb_arena_page_alloc_from(allocator->tail, required_size);
+}
+
+size_t hb_arena_position(hb_arena_T* allocator) {
+  size_t total = 0;
+
+  hb_arena_for_each_page(allocator, page) {
+    total += page->position;
+  }
+
+  return total;
+}
+
+size_t hb_arena_capacity(hb_arena_T* allocator) {
+  size_t total = 0;
+
+  hb_arena_for_each_page(allocator, page) {
+    total += page->capacity;
+  }
+
+  return total;
+}
+
+void hb_arena_reset(hb_arena_T* allocator) {
+  hb_arena_for_each_page(allocator, page) {
+    hb_arena_page_reset(page);
+  }
+
+  allocator->tail = allocator->head;
+  allocator->allocation_count = 0;
+}
+
+void hb_arena_reset_to(hb_arena_T* allocator, size_t target_position) {
+  if (target_position == 0) {
+    hb_arena_reset(allocator);
+
+    return;
+  }
+
+  size_t accumulated = 0;
+
+  hb_arena_for_each_page(allocator, page) {
+    if (accumulated + page->capacity >= target_position) {
+      page->position = target_position - accumulated;
+      allocator->tail = page;
+
+      hb_arena_reset_pages_after(page->next);
+
+      return;
+    }
+
+    accumulated += page->capacity;
+    page->position = page->capacity;
+  }
+}
+
+void hb_arena_free(hb_arena_T* allocator) {
+  if (allocator->head == NULL) { return; }
+
+  for (hb_arena_page_T* current = allocator->head; current != NULL;) {
+    hb_arena_page_T* next = current->next;
+    size_t total_size = sizeof(hb_arena_page_T) + current->capacity;
+    hb_system_free_memory(current, total_size);
+
+    current = next;
+  }
+
+  allocator->head = NULL;
+  allocator->tail = NULL;
+  allocator->default_page_size = 0;
+}

data/src/util/hb_arena_debug.c

@@ -0,0 +1,237 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../include/util/hb_arena.h"
+
+#define ANSI_COLOR_GREEN "\033[32m"
+#define ANSI_COLOR_YELLOW "\033[33m"
+#define ANSI_COLOR_RED "\033[31m"
+#define ANSI_COLOR_RESET "\033[0m"
+
+#define UTF8_BULLET_OVERHEAD 2
+#define BOX_WIDTH 100
+
+static const char* get_usage_color(double percentage) {
+  if (percentage >= 90.0) {
+    return ANSI_COLOR_RED;
+  } else if (percentage >= 70.0) {
+    return ANSI_COLOR_YELLOW;
+  } else {
+    return ANSI_COLOR_GREEN;
+  }
+}
+
+static void format_bytes(size_t bytes, char* buffer, size_t buffer_size) {
+  if (bytes >= 1024 * 1024) {
+    snprintf(buffer, buffer_size, "%.2f MB", bytes / (1024.0 * 1024.0));
+  } else if (bytes >= 1024) {
+    snprintf(buffer, buffer_size, "%zu KB", bytes / 1024);
+  } else {
+    snprintf(buffer, buffer_size, "%zu B", bytes);
+  }
+}
+
+static void print_progress_bar(size_t used, size_t capacity, int width, const char* color) {
+  int filled = (int) ((double) used / (double) capacity * width);
+
+  printf("%s[", color);
+
+  for (int i = 0; i < width; i++) {
+    if (i < filled) {
+      printf("█");
+    } else {
+      printf("░");
+    }
+  }
+
+  printf("]%s", ANSI_COLOR_RESET);
+}
+
+static void print_box_top(void) {
+  printf("╔");
+  for (int i = 0; i < BOX_WIDTH; i++) {
+    printf("═");
+  }
+  printf("╗\n");
+}
+
+static void print_box_separator(void) {
+  printf("╠");
+  for (int i = 0; i < BOX_WIDTH; i++) {
+    printf("═");
+  }
+  printf("╣\n");
+}
+
+static void print_box_bottom(void) {
+  printf("╚");
+  for (int i = 0; i < BOX_WIDTH; i++) {
+    printf("═");
+  }
+  printf("╝\n");
+}
+
+static void print_box_line(const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  printf("║%s%*s║\n", line, BOX_WIDTH - length, "");
+}
+
+static void print_box_line_centered(const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  int total_padding = BOX_WIDTH - length;
+  int left_padding = total_padding / 2;
+  int right_padding = total_padding - left_padding;
+
+  printf("║%*s%s%*s║\n", left_padding, "", line, right_padding, "");
+}
+
+static void print_box_line_with_bullet(const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  printf("║%s%*s║\n", line, BOX_WIDTH - (length - UTF8_BULLET_OVERHEAD), "");
+}
+
+static void print_box_line_with_bullet_and_color(const char* color, const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  int visual_length = length - UTF8_BULLET_OVERHEAD - (int) strlen(color) - (int) strlen(ANSI_COLOR_RESET);
+  printf("║%s%*s║\n", line, BOX_WIDTH - visual_length, "");
+}
+
+void hb_arena_print_stats(const hb_arena_T* allocator) {
+  if (allocator->head == NULL) {
+    print_box_top();
+    print_box_line_centered("ARENA MEMORY LAYOUT");
+    print_box_separator();
+    print_box_line("  Arena is empty (not initialized)");
+    print_box_bottom();
+
+    return;
+  }
+
+  size_t num_pages = 0;
+  size_t total_capacity = 0;
+  size_t total_used = 0;
+  size_t fragmentation = 0;
+
+  for (const hb_arena_page_T* page = allocator->head; page != NULL; page = page->next) {
+    num_pages++;
+    total_capacity += page->capacity;
+    total_used += page->position;
+
+    if (page != allocator->tail && page->position < page->capacity) {
+      fragmentation += (page->capacity - page->position);
+    }
+  }
+
+  size_t total_available = total_capacity - total_used;
+  double usage_percentage = (double) total_used / (double) total_capacity * 100.0;
+  double fragmentation_percentage = (double) fragmentation / (double) total_capacity * 100.0;
+  const char* overall_color = get_usage_color(usage_percentage);
+
+  char capacity_string[32], used_string[32], available_string[32], fragmentation_string[32], default_size_string[32];
+  format_bytes(total_capacity, capacity_string, sizeof(capacity_string));
+  format_bytes(total_used, used_string, sizeof(used_string));
+  format_bytes(total_available, available_string, sizeof(available_string));
+  format_bytes(fragmentation, fragmentation_string, sizeof(fragmentation_string));
+  format_bytes(allocator->default_page_size, default_size_string, sizeof(default_size_string));
+
+  print_box_top();
+  print_box_line_centered("ARENA MEMORY LAYOUT");
+  print_box_separator();
+  print_box_line("  Statistics:");
+
+  print_box_line_with_bullet("    • Pages: %zu", num_pages);
+  print_box_line_with_bullet("    • Default Page Size: %s", default_size_string);
+  print_box_line_with_bullet("    • Total Capacity: %s", capacity_string);
+  print_box_line_with_bullet_and_color(
+    overall_color,
+    "    • Total Used: %s%s%s",
+    overall_color,
+    used_string,
+    ANSI_COLOR_RESET
+  );
+  print_box_line_with_bullet("    • Total Available: %s", available_string);
+  print_box_line_with_bullet_and_color(
+    overall_color,
+    "    • Usage: %s%.1f%%%s",
+    overall_color,
+    usage_percentage,
+    ANSI_COLOR_RESET
+  );
+  print_box_line_with_bullet("    • Allocations: %zu", allocator->allocation_count);
+  print_box_line_with_bullet("    • Fragmentation: %s", fragmentation_string);
+
+  if (fragmentation > 0) { print_box_line("      (%.1f%% skipped in non-tail pages)", fragmentation_percentage); }
+
+  print_box_separator();
+
+  size_t page_number = 0;
+
+  for (const hb_arena_page_T* page = allocator->head; page != NULL; page = page->next) {
+    double page_usage = (double) page->position / (double) page->capacity * 100.0;
+    const char* page_color = get_usage_color(page_usage);
+
+    char page_capacity_string[32], page_used_string[32];
+    format_bytes(page->capacity, page_capacity_string, sizeof(page_capacity_string));
+    format_bytes(page->position, page_used_string, sizeof(page_used_string));
+
+    if (page == allocator->tail) {
+      char header_line[256];
+      snprintf(header_line, sizeof(header_line), "  Page %zu @ %p ← CURRENT", page_number, (void*) page);
+      int visual_length = (int) strlen(header_line) - 2;
+      printf("║%s%*s║\n", header_line, BOX_WIDTH - visual_length, "");
+    } else {
+      print_box_line("  Page %zu @ %p", page_number, (void*) page);
+    }
+
+    char stats_line[128];
+    int stats_length =
+      snprintf(stats_line, sizeof(stats_line), "%s / %s (%.0f%%)", page_used_string, page_capacity_string, page_usage);
+
+    int bar_width = BOX_WIDTH - 4 - 2 - 2 - stats_length - 1;
+    int bar_with_brackets = bar_width + 2;
+
+    printf("║    ");
+    print_progress_bar(page->position, page->capacity, bar_width, page_color);
+    printf("  %s %*s║\n", stats_line, BOX_WIDTH - 4 - bar_with_brackets - 2 - stats_length - 1, "");
+
+    size_t unused = page->capacity - page->position;
+
+    if (unused > 0) {
+      char unused_string[32];
+      format_bytes(unused, unused_string, sizeof(unused_string));
+
+      if (page == allocator->tail) {
+        print_box_line("    Unused: %s (available for allocations)", unused_string);
+      } else {
+        print_box_line("    Unused: %s", unused_string);
+      }
+    }
+
+    printf("║%*s║\n", BOX_WIDTH, "");
+
+    page_number++;
+  }
+
+  print_box_bottom();
+}

data/src/{array.c → util/hb_array.c}

@@ -1,20 +1,19 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/macros.h"
-#include "include/memory.h"
+#include "../include/macros.h"
+#include "../include/util/hb_array.h"
 
-size_t array_sizeof(void) {
-  return sizeof(array_T);
+size_t hb_array_sizeof(void) {
+  return sizeof(hb_array_T);
 }
 
-array_T* array_init(const size_t capacity) {
-  array_T* array = safe_malloc(array_sizeof());
+hb_array_T* hb_array_init(const size_t capacity) {
+  hb_array_T* array = malloc(hb_array_sizeof());
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = nullable_safe_malloc(sizeof(void*) * capacity);
+  array->items = malloc(capacity * sizeof(void*));
 
   if (!array->items) {
     free(array);
@@ -24,7 +23,7 @@ array_T* array_init(const size_t capacity) {
   return array;
 }
 
-void array_append(array_T* array, void* item) {
+void hb_array_append(hb_array_T* array, void* item) {
   if (array->size >= array->capacity) {
     size_t new_capacity;
 
@@ -45,7 +44,7 @@ void array_append(array_T* array, void* item) {
     }
 
     size_t new_size_bytes = new_capacity * sizeof(void*);
-    void* new_items = safe_realloc(array->items, new_size_bytes);
+    void* new_items = realloc(array->items, new_size_bytes);
 
     if (unlikely(new_items == NULL)) { return; }
 
@@ -57,29 +56,29 @@ void array_append(array_T* array, void* item) {
   array->size++;
 }
 
-void* array_get(const array_T* array, const size_t index) {
+void* hb_array_get(const hb_array_T* array, const size_t index) {
   if (index >= array->size) { return NULL; }
 
   return array->items[index];
 }
 
-void* array_first(array_T* array) {
+void* hb_array_first(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[0];
 }
 
-void* array_last(array_T* array) {
+void* hb_array_last(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[array->size - 1];
 }
 
-void array_set(const array_T* array, const size_t index, void* item) {
+void hb_array_set(const hb_array_T* array, const size_t index, void* item) {
   if (index >= array->size) { return; }
 
   array->items[index] = item;
 }
 
-void array_remove(array_T* array, const size_t index) {
+void hb_array_remove(hb_array_T* array, const size_t index) {
   if (index >= array->size) { return; }
 
   for (size_t i = index; i < array->size - 1; i++) {
@@ -89,7 +88,7 @@ void array_remove(array_T* array, const size_t index) {
   array->size--;
 }
 
-size_t array_index_of(array_T* array, void* item) {
+size_t hb_array_index_of(hb_array_T* array, void* item) {
   for (size_t i = 0; i < array->size; i++) {
     if (array->items[i] == item) { return i; }
   }
@@ -97,37 +96,37 @@ size_t array_index_of(array_T* array, void* item) {
   return SIZE_MAX;
 }
 
-void array_remove_item(array_T* array, void* item) {
-  size_t index = array_index_of(array, item);
+void hb_array_remove_item(hb_array_T* array, void* item) {
+  size_t index = hb_array_index_of(array, item);
 
-  if (index != SIZE_MAX) { array_remove(array, index); }
+  if (index != SIZE_MAX) { hb_array_remove(array, index); }
 }
 
-// Alias for array_append
-void array_push(array_T* array, void* item) {
-  array_append(array, item);
+// Alias for hb_array_append
+void hb_array_push(hb_array_T* array, void* item) {
+  hb_array_append(array, item);
 }
 
-void* array_pop(array_T* array) {
+void* hb_array_pop(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
 
-  void* last_item = array_last(array);
+  void* last_item = hb_array_last(array);
   array->size--;
 
   return last_item;
 }
 
-size_t array_size(const array_T* array) {
+size_t hb_array_size(const hb_array_T* array) {
   if (array == NULL) { return 0; }
 
   return array->size;
 }
 
-size_t array_capacity(const array_T* array) {
+size_t hb_array_capacity(const hb_array_T* array) {
   return array->capacity;
 }
 
-void array_free(array_T** array) {
+void hb_array_free(hb_array_T** array) {
   if (!array || !*array) { return; }
 
   free((*array)->items);