@herb-tools/node 0.8.9 → 0.9.0

package/extension/libherb/util/hb_allocator.c

@@ -0,0 +1,341 @@
+#include "../include/util/hb_allocator.h"
+#include "../include/util/hb_arena.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// --- Malloc backend ---
+
+static void* malloc_alloc(hb_allocator_T* _self, size_t size) {
+  return calloc(1, size);
+}
+
+static void malloc_dealloc(hb_allocator_T* _self, void* pointer) {
+  free(pointer);
+}
+
+static char* malloc_strdup(hb_allocator_T* _self, const char* string) {
+  if (!string) { return NULL; }
+
+  size_t length = strlen(string);
+  char* copy = malloc(length + 1);
+  if (!copy) { return NULL; }
+
+  memcpy(copy, string, length + 1);
+
+  return copy;
+}
+
+static char* malloc_strndup(hb_allocator_T* _self, const char* string, size_t length) {
+  if (!string) { return NULL; }
+
+  char* copy = malloc(length + 1);
+  if (!copy) { return NULL; }
+
+  memcpy(copy, string, length);
+  copy[length] = '\0';
+
+  return copy;
+}
+
+static void* malloc_realloc(hb_allocator_T* _self, void* pointer, size_t _old_size, size_t new_size) {
+  return realloc(pointer, new_size);
+}
+
+static void malloc_destroy(hb_allocator_T* _self) {
+}
+
+hb_allocator_T hb_allocator_with_malloc(void) {
+  return (hb_allocator_T) {
+    .alloc = malloc_alloc,
+    .realloc = malloc_realloc,
+    .dealloc = malloc_dealloc,
+    .strdup = malloc_strdup,
+    .strndup = malloc_strndup,
+    .destroy = malloc_destroy,
+    .context = NULL,
+  };
+}
+
+// --- Arena backend ---
+
+static void* arena_alloc(hb_allocator_T* self, size_t size) {
+  return hb_arena_alloc((hb_arena_T*) self->context, size);
+}
+
+static void* arena_realloc(hb_allocator_T* self, void* pointer, size_t old_size, size_t new_size) {
+  if (!pointer) { return arena_alloc(self, new_size); }
+
+  void* new_pointer = hb_arena_alloc((hb_arena_T*) self->context, new_size);
+  if (!new_pointer) { return NULL; }
+
+  size_t copy_size = old_size < new_size ? old_size : new_size;
+  memcpy(new_pointer, pointer, copy_size);
+
+  return new_pointer;
+}
+
+static void arena_dealloc(hb_allocator_T* _self, void* _pointer) {
+}
+
+static char* arena_strdup(hb_allocator_T* self, const char* string) {
+  if (!string) { return NULL; }
+
+  size_t length = strlen(string);
+  char* copy = hb_arena_alloc((hb_arena_T*) self->context, length + 1);
+  if (!copy) { return NULL; }
+
+  memcpy(copy, string, length + 1);
+
+  return copy;
+}
+
+static char* arena_strndup(hb_allocator_T* self, const char* string, size_t length) {
+  if (!string) { return NULL; }
+
+  char* copy = hb_arena_alloc((hb_arena_T*) self->context, length + 1);
+  if (!copy) { return NULL; }
+
+  memcpy(copy, string, length);
+  copy[length] = '\0';
+
+  return copy;
+}
+
+static void arena_destroy(hb_allocator_T* self) {
+  hb_arena_T* arena = (hb_arena_T*) self->context;
+  hb_arena_free(arena);
+  free(arena);
+  self->context = NULL;
+}
+
+hb_allocator_T hb_allocator_with_arena(hb_arena_T* arena) {
+  return (hb_allocator_T) {
+    .alloc = arena_alloc,
+    .realloc = arena_realloc,
+    .dealloc = arena_dealloc,
+    .strdup = arena_strdup,
+    .strndup = arena_strndup,
+    .destroy = arena_destroy,
+    .context = arena,
+  };
+}
+
+// --- Tracking backend ---
+
+#define TRACKING_INITIAL_CAPACITY 128
+#define TRACKING_TOMBSTONE ((void*) 1)
+
+static size_t tracking_probe(hb_allocator_tracking_stats_T* stats, void* pointer) {
+  size_t mask = stats->buckets_capacity - 1;
+  size_t index = ((size_t) pointer >> 4) & mask;
+
+  while (true) {
+    void* key = stats->buckets[index].pointer;
+    if (key == NULL || key == TRACKING_TOMBSTONE || key == pointer) { return index; }
+    index = (index + 1) & mask;
+  }
+}
+
+static void tracking_grow(hb_allocator_tracking_stats_T* stats) {
+  size_t old_capacity = stats->buckets_capacity;
+  hb_allocator_tracking_entry_T* old_buckets = stats->buckets;
+
+  size_t new_capacity = old_capacity ? old_capacity * 2 : TRACKING_INITIAL_CAPACITY;
+  stats->buckets = calloc(new_capacity, sizeof(hb_allocator_tracking_entry_T));
+  stats->buckets_capacity = new_capacity;
+  stats->buckets_used = 0;
+
+  for (size_t i = 0; i < old_capacity; i++) {
+    if (old_buckets[i].pointer != NULL && old_buckets[i].pointer != TRACKING_TOMBSTONE) {
+      size_t index = tracking_probe(stats, old_buckets[i].pointer);
+      stats->buckets[index] = old_buckets[i];
+      stats->buckets_used++;
+    }
+  }
+
+  free(old_buckets);
+}
+
+static void tracking_record(hb_allocator_tracking_stats_T* stats, void* pointer, size_t size) {
+  if (stats->buckets_used * 2 >= stats->buckets_capacity) { tracking_grow(stats); }
+
+  size_t index = tracking_probe(stats, pointer);
+  stats->buckets[index] = (hb_allocator_tracking_entry_T) { .pointer = pointer, .size = size };
+  stats->buckets_used++;
+  stats->allocation_count++;
+  stats->bytes_allocated += size;
+}
+
+static void tracking_record_untracked(hb_allocator_tracking_stats_T* stats, void* pointer) {
+  stats->untracked_deallocation_count++;
+
+  if (stats->untracked_pointers_size >= stats->untracked_pointers_capacity) {
+    size_t new_capacity = stats->untracked_pointers_capacity ? stats->untracked_pointers_capacity * 2 : 16;
+    void** new_pointers = realloc(stats->untracked_pointers, new_capacity * sizeof(void*));
+
+    if (!new_pointers) { return; }
+
+    stats->untracked_pointers = new_pointers;
+    stats->untracked_pointers_capacity = new_capacity;
+  }
+
+  stats->untracked_pointers[stats->untracked_pointers_size++] = pointer;
+}
+
+static void tracking_unrecord(hb_allocator_tracking_stats_T* stats, void* pointer) {
+  if (!stats->buckets_capacity) {
+    tracking_record_untracked(stats, pointer);
+
+    return;
+  }
+
+  size_t mask = stats->buckets_capacity - 1;
+  size_t index = ((size_t) pointer >> 4) & mask;
+
+  while (true) {
+    void* key = stats->buckets[index].pointer;
+
+    if (key == NULL) {
+      tracking_record_untracked(stats, pointer);
+
+      return;
+    }
+
+    if (key == pointer) {
+      stats->deallocation_count++;
+      stats->bytes_deallocated += stats->buckets[index].size;
+      stats->buckets[index].pointer = TRACKING_TOMBSTONE;
+      stats->buckets[index].size = 0;
+
+      return;
+    }
+
+    index = (index + 1) & mask;
+  }
+}
+
+static void* tracking_alloc(hb_allocator_T* self, size_t size) {
+  hb_allocator_tracking_stats_T* stats = (hb_allocator_tracking_stats_T*) self->context;
+  void* pointer = calloc(1, size);
+
+  if (pointer) { tracking_record(stats, pointer, size); }
+
+  return pointer;
+}
+
+static void* tracking_realloc(hb_allocator_T* self, void* pointer, size_t _old_size, size_t new_size) {
+  hb_allocator_tracking_stats_T* stats = (hb_allocator_tracking_stats_T*) self->context;
+
+  if (pointer) { tracking_unrecord(stats, pointer); }
+
+  void* new_pointer = realloc(pointer, new_size);
+
+  if (new_pointer) { tracking_record(stats, new_pointer, new_size); }
+
+  return new_pointer;
+}
+
+static void tracking_dealloc(hb_allocator_T* self, void* pointer) {
+  hb_allocator_tracking_stats_T* stats = (hb_allocator_tracking_stats_T*) self->context;
+  tracking_unrecord(stats, pointer);
+  free(pointer);
+}
+
+static char* tracking_strdup(hb_allocator_T* self, const char* string) {
+  if (!string) { return NULL; }
+
+  hb_allocator_tracking_stats_T* stats = (hb_allocator_tracking_stats_T*) self->context;
+  size_t length = strlen(string);
+  char* copy = malloc(length + 1);
+  if (!copy) { return NULL; }
+
+  memcpy(copy, string, length + 1);
+  tracking_record(stats, copy, length + 1);
+
+  return copy;
+}
+
+static char* tracking_strndup(hb_allocator_T* self, const char* string, size_t length) {
+  if (!string) { return NULL; }
+
+  hb_allocator_tracking_stats_T* stats = (hb_allocator_tracking_stats_T*) self->context;
+  char* copy = malloc(length + 1);
+  if (!copy) { return NULL; }
+
+  memcpy(copy, string, length);
+  copy[length] = '\0';
+  tracking_record(stats, copy, length + 1);
+
+  return copy;
+}
+
+static void tracking_destroy(hb_allocator_T* self) {
+  hb_allocator_tracking_stats_T* stats = (hb_allocator_tracking_stats_T*) self->context;
+
+  free(stats->buckets);
+  free(stats->untracked_pointers);
+  free(stats);
+
+  self->context = NULL;
+}
+
+hb_allocator_T hb_allocator_with_tracking(void) {
+  hb_allocator_tracking_stats_T* stats = calloc(1, sizeof(hb_allocator_tracking_stats_T));
+
+  return (hb_allocator_T) {
+    .alloc = tracking_alloc,
+    .realloc = tracking_realloc,
+    .dealloc = tracking_dealloc,
+    .strdup = tracking_strdup,
+    .strndup = tracking_strndup,
+    .destroy = tracking_destroy,
+    .context = stats,
+  };
+}
+
+hb_allocator_tracking_stats_T* hb_allocator_tracking_stats(hb_allocator_T* allocator) {
+  return (hb_allocator_tracking_stats_T*) allocator->context;
+}
+
+// --- High-level API ---
+
+bool hb_allocator_init(hb_allocator_T* allocator, hb_allocator_type_T type) {
+  return hb_allocator_init_with_size(allocator, type, 0);
+}
+
+bool hb_allocator_init_with_size(hb_allocator_T* allocator, hb_allocator_type_T type, size_t initial_size) {
+  switch (type) {
+    case HB_ALLOCATOR_MALLOC: {
+      *allocator = hb_allocator_with_malloc();
+      return true;
+    }
+
+    case HB_ALLOCATOR_ARENA: {
+      if (initial_size == 0) { initial_size = HB_ALLOCATOR_DEFAULT_ARENA_SIZE; }
+
+      hb_arena_T* arena = malloc(sizeof(hb_arena_T));
+      if (!arena) { return false; }
+
+      if (!hb_arena_init(arena, initial_size)) {
+        free(arena);
+        return false;
+      }
+
+      *allocator = hb_allocator_with_arena(arena);
+      return true;
+    }
+
+    case HB_ALLOCATOR_TRACKING: {
+      *allocator = hb_allocator_with_tracking();
+      return true;
+    }
+
+    default: return false;
+  }
+}
+
+void hb_allocator_destroy(hb_allocator_T* allocator) {
+  allocator->destroy(allocator);
+}

package/extension/libherb/util/hb_allocator.h

@@ -0,0 +1,78 @@
+#ifndef HERB_ALLOCATOR_H
+#define HERB_ALLOCATOR_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "hb_arena.h"
+
+#ifndef HB_ALLOCATOR_DEFAULT_ARENA_SIZE
+#  define HB_ALLOCATOR_DEFAULT_ARENA_SIZE (1024 * 16)
+#endif
+
+typedef enum {
+  HB_ALLOCATOR_MALLOC,
+  HB_ALLOCATOR_ARENA,
+  HB_ALLOCATOR_TRACKING,
+} hb_allocator_type_T;
+
+typedef struct {
+  void* pointer;
+  size_t size;
+} hb_allocator_tracking_entry_T;
+
+typedef struct {
+  size_t allocation_count;
+  size_t deallocation_count;
+  size_t untracked_deallocation_count;
+  size_t bytes_allocated;
+  size_t bytes_deallocated;
+  hb_allocator_tracking_entry_T* buckets;
+  size_t buckets_capacity;
+  size_t buckets_used;
+  void** untracked_pointers;
+  size_t untracked_pointers_size;
+  size_t untracked_pointers_capacity;
+} hb_allocator_tracking_stats_T;
+
+typedef struct hb_allocator {
+  void* (*alloc)(struct hb_allocator* self, size_t size);
+  void* (*realloc)(struct hb_allocator* self, void* pointer, size_t old_size, size_t new_size);
+  void (*dealloc)(struct hb_allocator* self, void* pointer);
+  char* (*strdup)(struct hb_allocator* self, const char* string);
+  char* (*strndup)(struct hb_allocator* self, const char* string, size_t length);
+  void (*destroy)(struct hb_allocator* self);
+  void* context;
+} hb_allocator_T;
+
+bool hb_allocator_init(hb_allocator_T* allocator, hb_allocator_type_T type);
+bool hb_allocator_init_with_size(hb_allocator_T* allocator, hb_allocator_type_T type, size_t initial_size);
+void hb_allocator_destroy(hb_allocator_T* allocator);
+
+hb_allocator_T hb_allocator_with_malloc(void);
+hb_allocator_T hb_allocator_with_arena(hb_arena_T* arena);
+hb_allocator_T hb_allocator_with_tracking(void);
+
+hb_allocator_tracking_stats_T* hb_allocator_tracking_stats(hb_allocator_T* allocator);
+
+static inline void* hb_allocator_alloc(hb_allocator_T* allocator, size_t size) {
+  return allocator->alloc(allocator, size);
+}
+
+static inline void* hb_allocator_realloc(hb_allocator_T* allocator, void* pointer, size_t old_size, size_t new_size) {
+  return allocator->realloc(allocator, pointer, old_size, new_size);
+}
+
+static inline void hb_allocator_dealloc(hb_allocator_T* allocator, void* pointer) {
+  allocator->dealloc(allocator, pointer);
+}
+
+static inline char* hb_allocator_strdup(hb_allocator_T* allocator, const char* string) {
+  return allocator->strdup(allocator, string);
+}
+
+static inline char* hb_allocator_strndup(hb_allocator_T* allocator, const char* string, size_t length) {
+  return allocator->strndup(allocator, string, length);
+}
+
+#endif

package/extension/libherb/util/hb_arena.c

@@ -1,14 +1,38 @@
 #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)
+#ifdef HERB_USE_MALLOC
+#  include <stdlib.h>
+#else
+#  ifdef __linux__
+#    define _GNU_SOURCE
+#  endif
+#  include <sys/mman.h>
+#endif
+
+static void* hb_arena_allocate_page(size_t size) {
+#ifdef HERB_USE_MALLOC
+  return malloc(size);
+#else
+  void* memory = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (memory == MAP_FAILED) { return NULL; }
+
+  return memory;
+#endif
+}
+
+static void hb_arena_free_page(void* pointer, size_t size) {
+#ifdef HERB_USE_MALLOC
+  free(pointer);
+#else
+  munmap(pointer, size);
+#endif
+}
 
 static inline size_t hb_arena_align_size(size_t size, size_t alignment) {
   assert(size <= SIZE_MAX - (alignment - 1));
@@ -22,7 +46,7 @@ static inline bool hb_arena_page_has_capacity(hb_arena_page_T* page, size_t requ
   return page->position + required_size <= page->capacity;
 }
 
-static inline void* hb_arena_page_alloc_from(hb_arena_page_T* page, size_t size) {
+static inline void* hb_arena_page_alloc(hb_arena_page_T* page, size_t size) {
   assert(size > 0);
   assert(page->position + size <= page->capacity);
 
@@ -32,28 +56,18 @@ static inline void* hb_arena_page_alloc_from(hb_arena_page_T* page, size_t 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);
+static size_t hb_arena_page_free(hb_arena_page_T* starting_page);
 
+static bool hb_arena_append_page(hb_arena_T* allocator, size_t page_size) {
   assert(page_size <= SIZE_MAX - sizeof(hb_arena_page_T));
-  size_t total_size = page_size + sizeof(hb_arena_page_T);
+  size_t page_size_with_meta_data = page_size + sizeof(hb_arena_page_T);
 
-  hb_arena_page_T* page = hb_system_allocate_memory(total_size);
+  hb_arena_page_T* page = hb_arena_allocate_page(page_size_with_meta_data);
   if (page == NULL) { return false; }
 
-  *page = (hb_arena_page_T) { .next = NULL, .capacity = page_size, .position = 0 };
+  page->next = NULL;
+  page->capacity = page_size;
+  page->position = 0;
 
   if (allocator->head == NULL) {
     allocator->head = page;
@@ -72,15 +86,15 @@ static bool hb_arena_append_page(hb_arena_T* allocator, size_t minimum_size) {
   return true;
 }
 
-bool hb_arena_init(hb_arena_T* allocator, size_t initial_size) {
-  assert(initial_size > 0);
+bool hb_arena_init(hb_arena_T* allocator, size_t default_page_size) {
+  assert(default_page_size > 0);
 
   allocator->head = NULL;
   allocator->tail = NULL;
-  allocator->default_page_size = initial_size;
+  allocator->default_page_size = default_page_size;
   allocator->allocation_count = 0;
 
-  return hb_arena_append_page(allocator, initial_size);
+  return hb_arena_append_page(allocator, default_page_size);
 }
 
 void* hb_arena_alloc(hb_arena_T* allocator, size_t size) {
@@ -92,27 +106,28 @@ void* hb_arena_alloc(hb_arena_T* allocator, size_t size) {
   allocator->allocation_count++;
 
   if (hb_arena_page_has_capacity(allocator->tail, required_size)) {
-    return hb_arena_page_alloc_from(allocator->tail, required_size);
+    return hb_arena_page_alloc(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);
+      return hb_arena_page_alloc(allocator->tail, required_size);
     }
   }
 
-  bool allocated = hb_arena_append_page(allocator, required_size);
+  size_t page_size = MAX(allocator->default_page_size, required_size);
+  bool allocated = hb_arena_append_page(allocator, page_size);
 
   if (!allocated) { return NULL; }
 
-  return hb_arena_page_alloc_from(allocator->tail, required_size);
+  return hb_arena_page_alloc(allocator->tail, required_size);
 }
 
 size_t hb_arena_position(hb_arena_T* allocator) {
   size_t total = 0;
 
-  hb_arena_for_each_page(allocator, page) {
+  hb_arena_for_each_page(allocator) {
     total += page->position;
   }
 
@@ -122,7 +137,7 @@ size_t hb_arena_position(hb_arena_T* allocator) {
 size_t hb_arena_capacity(hb_arena_T* allocator) {
   size_t total = 0;
 
-  hb_arena_for_each_page(allocator, page) {
+  hb_arena_for_each_page(allocator) {
     total += page->capacity;
   }
 
@@ -130,48 +145,58 @@ size_t hb_arena_capacity(hb_arena_T* allocator) {
 }
 
 void hb_arena_reset(hb_arena_T* allocator) {
-  hb_arena_for_each_page(allocator, page) {
-    hb_arena_page_reset(page);
-  }
-
-  allocator->tail = allocator->head;
+  hb_arena_reset_to(allocator, 0);
   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);
+  hb_arena_page_T* current_page = allocator->head;
+  size_t current_position = 0;
+
+  while (current_page != NULL) {
+    current_position += current_page->position;
 
-    return;
+    if (current_position >= target_position) {
+      current_page->position -= current_position - target_position;
+      break;
+    }
+
+    current_page = current_page->next;
   }
 
-  size_t accumulated = 0;
+  if (current_page == NULL) { return; }
 
-  hb_arena_for_each_page(allocator, page) {
-    if (accumulated + page->capacity >= target_position) {
-      page->position = target_position - accumulated;
-      allocator->tail = page;
+  allocator->tail = current_page;
 
-      hb_arena_reset_pages_after(page->next);
+  if (current_page->next != NULL) {
+    size_t freed_size = hb_arena_page_free(current_page->next);
+    current_page->next = NULL;
 
-      return;
-    }
+    hb_arena_append_page(allocator, freed_size);
+  }
+}
+
+static size_t hb_arena_page_free(hb_arena_page_T* starting_page) {
+  size_t freed_capacity = 0;
 
-    accumulated += page->capacity;
-    page->position = page->capacity;
+  for (hb_arena_page_T* current_page = starting_page; current_page != NULL;) {
+    hb_arena_page_T* next_page = current_page->next;
+
+    freed_capacity += current_page->capacity;
+
+    size_t total_size = sizeof(hb_arena_page_T) + current_page->capacity;
+    hb_arena_free_page(current_page, total_size);
+
+    current_page = next_page;
   }
+
+  return freed_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;
-  }
+  hb_arena_page_free(allocator->head);
 
   allocator->head = NULL;
   allocator->tail = NULL;

package/extension/libherb/util/hb_arena.h

@@ -20,12 +20,17 @@ typedef struct HB_ARENA_STRUCT {
   size_t allocation_count;
 } hb_arena_T;
 
+#define hb_arena_for_each_page(arena) for (hb_arena_page_T* page = (arena)->head; page != NULL; page = page->next)
+
+#define hb_arena_for_each_page_const(arena)                                                                            \
+  for (const hb_arena_page_T* page = (arena)->head; page != NULL; page = page->next)
+
 bool hb_arena_init(hb_arena_T* allocator, size_t initial_size);
 void* hb_arena_alloc(hb_arena_T* allocator, size_t size);
 size_t hb_arena_position(hb_arena_T* allocator);
 size_t hb_arena_capacity(hb_arena_T* allocator);
 void hb_arena_reset(hb_arena_T* allocator);
-void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position);
+void hb_arena_reset_to(hb_arena_T* allocator, size_t target_position);
 void hb_arena_free(hb_arena_T* allocator);
 
 #endif