buddy_krealloc, needed for arrays

Author: braindigitalis

include/buddy_allocator.h

@@ -94,7 +94,7 @@ typedef struct buddy_allocator {
  * automatically on the first call to @ref buddy_malloc, or may be added
  * eagerly by growing manually.
  */
-void buddy_init(buddy_allocator_t *alloc, int min_order, int max_order, int grow_order);
+void buddy_init(buddy_allocator_t* alloc, int min_order, int max_order, int grow_order);
 
 /**
  * @brief Allocate a block of memory from the buddy allocator.
@@ -107,7 +107,7 @@ void buddy_init(buddy_allocator_t *alloc, int min_order, int max_order, int grow
  * automatically allocated of size (1 << grow_order). Returned blocks
  * are aligned to their block size (power of two).
  */
-void *buddy_malloc(buddy_allocator_t *alloc, size_t size);
+void* buddy_malloc(buddy_allocator_t* alloc, size_t size);
 
 /**
  * @brief Free a previously allocated block.
@@ -119,7 +119,7 @@ void *buddy_malloc(buddy_allocator_t *alloc, size_t size);
  * is also free, the two are merged into a larger block. The owning region
  * is identified via a back-pointer stored in the block header.
  */
-void buddy_free(buddy_allocator_t *alloc, const void *ptr);
+void buddy_free(buddy_allocator_t* alloc, const void *ptr);
 
 /**
  * @brief Destroy a buddy allocator and free all regions.
@@ -141,4 +141,17 @@ void buddy_destroy(buddy_allocator_t *alloc);
  * The returned string is allocated from the buddy allocator's
  * private heap and must be freed with @ref buddy_free.
  */
-char* buddy_strdup(buddy_allocator_t *alloc, const char *s);
+char* buddy_strdup(buddy_allocator_t* alloc, const char *s);
+
+/**
+ * @brief Reallocate a block within a buddy allocator.
+ *
+ * Works like krealloc(): if ptr is NULL, behaves like buddy_malloc().
+ * If size == 0, frees the block and returns NULL.
+ *
+ * @param alloc  Buddy allocator to allocate from.
+ * @param ptr    Pointer previously returned by buddy_malloc().
+ * @param size   New desired size in bytes.
+ * @return       Pointer to resized block, or NULL on OOM.
+ */
+void* buddy_realloc(buddy_allocator_t* alloc, void *ptr, size_t size);

src/basic/array.c

@@ -222,7 +222,7 @@ bool basic_redim_int_array(const char* var, int64_t size, struct basic_ctx* ctx)
 			if ((uint64_t)size == cur->itemcount) {
 				return true;
 			}
-			cur->values = krealloc(cur->values, sizeof(int64_t) * size);
+			cur->values = buddy_realloc(ctx->allocator, cur->values, sizeof(int64_t) * size);
 			if ((uint64_t)size > cur->itemcount) {
 				/* If array is being expanded, zero the new entries */
 				for (int64_t i = cur->itemcount; i < size; ++i) {
@@ -255,7 +255,7 @@ bool basic_redim_string_array(const char* var, int64_t size, struct basic_ctx* c
 					buddy_free(ctx->allocator, cur->values[x]);
 				}
 			}
-			cur->values = krealloc(cur->values, sizeof(char*) * size);
+			cur->values = buddy_realloc(ctx->allocator, cur->values, sizeof(char*) * size);
 			if ((uint64_t)size > cur->itemcount) {
 				/* If array is being expanded, zero the new entries */
 				for (int64_t i = cur->itemcount; i < size; ++i) {
@@ -282,7 +282,7 @@ bool basic_redim_double_array(const char* var, int64_t size, struct basic_ctx* c
 			if ((uint64_t)size == cur->itemcount) {
 				return true;
 			}
-			cur->values = krealloc(cur->values, sizeof(double) * size);
+			cur->values = buddy_realloc(ctx->allocator, cur->values, sizeof(double) * size);
 			if ((uint64_t)size > cur->itemcount) {
 				/* If array is being expanded, zero the new entries */
 				for (int64_t i = cur->itemcount; i < size; ++i) {

src/buddy_allocator.c

@@ -212,3 +212,52 @@ char *buddy_strdup(buddy_allocator_t *alloc, const char *s) {
 	memcpy(copy, s, len);
 	return copy;
 }
+
+void *buddy_realloc(buddy_allocator_t *alloc, void *ptr, size_t size) {
+	if (!ptr) {
+		// realloc(NULL, size): malloc
+		return buddy_malloc(alloc, size);
+	}
+	if (size == 0) {
+		// realloc(ptr, 0): free
+		buddy_free(alloc, ptr);
+		return NULL;
+	}
+
+	// Find old size from header
+	buddy_header_t *header = (buddy_header_t *)ptr - 1;
+	int old_order = header->order;
+	size_t old_total = order_size(old_order);
+	size_t old_payload = old_total - sizeof(buddy_header_t);
+
+	// Required order for new size
+	int new_order = size_to_order(header->region, size + sizeof(buddy_header_t));
+
+	if (new_order == old_order) {
+		// Same block size: no change
+		return ptr;
+	} else if (new_order < old_order) {
+		// Shrinking: split block and free remainder
+		header->order = new_order;
+		// Carve off the extra as a buddy block
+		int cur = old_order;
+		// repeatedly split until the leftover is the right order
+		while (cur > new_order) {
+			cur--;
+			buddy_block_t *buddy = (buddy_block_t *)((uint8_t *)header + order_size(cur));
+			buddy->next = header->region->free_lists[cur];
+			header->region->free_lists[cur] = buddy;
+		}
+
+		return ptr;
+	} else {
+		// Growing: allocate + copy + free
+		void *new_ptr = buddy_malloc(alloc, size);
+		if (!new_ptr) {
+			return NULL; // OOM
+		}
+		memcpy(new_ptr, ptr, old_payload);
+		buddy_free(alloc, ptr);
+		return new_ptr;
+	}
+}