memory_arena
Loading...
Searching...
No Matches
arena_create.c
Go to the documentation of this file.
1
34#include "arena.h"
35#include <stdatomic.h>
36#include <stdlib.h>
37#include <string.h>
38
39#ifdef ARENA_ENABLE_THREAD_SAFE
40#include <pthread.h>
41#endif
42
43/*
44 * INTERNAL FUNCTION DECLARATIONS
45 */
46
47static inline void arena_set_default_label(t_arena* arena, const char* fallback);
48static inline t_arena* arena_alloc_struct(void);
49static inline void arena_log_and_teardown(t_arena** arena, const char* msg);
50static inline void* arena_alloc_buffer(size_t size);
51static inline void arena_reset_metadata(t_arena* arena);
52static inline bool arena_init_mutex(t_arena* arena);
53static inline bool arena_finish_init(t_arena* arena, void* buffer, size_t size, bool allow_grow);
54static inline bool arena_set_allocated_buffer(t_arena* arena, size_t size);
55static inline void arena_set_user_buffer(t_arena* arena, void* buffer, size_t size);
56static inline bool arena_set_or_alloc_buffer(t_arena* arena, void* buffer, size_t size);
57
58/*
59 * PUBLIC API
60 */
61
111t_arena* arena_create(size_t size, bool allow_grow)
112{
113 if (size == 0)
114 {
115 arena_report_error(NULL, "arena_create failed: zero size requested");
116 return NULL;
117 }
118
119 t_arena* arena = arena_alloc_struct();
120 if (!arena)
121 return NULL;
122
123 void* buffer = arena_alloc_buffer(size);
124 if (!buffer)
125 {
126 arena_log_and_teardown(&arena, "arena_create: buffer allocation failed");
127 return NULL;
128 }
129
130 if (!arena_finish_init(arena, buffer, size, allow_grow))
131 {
132 arena_log_and_teardown(&arena, "arena_create: init failure");
133 return NULL;
134 }
135
136 arena_set_default_label(arena, "arena_heap");
137 arena_generate_id(arena);
138 return arena;
139}
140
190bool arena_init(t_arena* arena, size_t size, bool allow_grow)
191{
192 if (!arena || size == 0)
193 {
194 arena_report_error(NULL, "arena_init failed: invalid arena or size");
195 return false;
196 }
197
198 void* buffer = arena_alloc_buffer(size);
199 if (!buffer)
200 {
201 arena_log_and_teardown(&arena, "arena_init: buffer allocation failed");
202 return NULL;
203 }
204
205 if (!arena_finish_init(arena, buffer, size, allow_grow))
206 {
207 arena_report_error(arena, "arena_init: arena_finish_init failed");
208 free(buffer);
209 return false;
210 }
211
212 arena_set_default_label(arena, "arena_stack");
213 arena_generate_id(arena);
214 return true;
215}
216
286void arena_init_with_buffer(t_arena* arena, void* buffer, size_t size, bool allow_grow)
287{
288 if (!arena)
289 {
290 arena_report_error(NULL, "arena_init_with_buffer: NULL arena");
291 return;
292 }
293
295 atomic_store_explicit(&arena->can_grow, allow_grow, memory_order_release);
296 arena_init_mutex(arena);
297
298 if (!arena_set_or_alloc_buffer(arena, buffer, size))
299 return;
300
301 arena_set_default_label(arena, "arena_from_buffer");
302 arena_generate_id(arena);
303}
304
361void arena_reinit_with_buffer(t_arena* arena, void* buffer, size_t size, bool allow_grow)
362{
363 arena_destroy(arena);
364 arena_init_with_buffer(arena, buffer, size, allow_grow);
365}
366
367/*
368 * INTERNAL HELPERS (static inline)
369 */
370
398static inline void arena_set_default_label(t_arena* arena, const char* fallback)
399{
400 if (!arena->debug.label)
401 arena->debug.label = fallback;
402}
403
426static inline t_arena* arena_alloc_struct(void)
427{
428 return (t_arena*) calloc(1, sizeof(t_arena));
429}
430
458static inline void arena_log_and_teardown(t_arena** arena, const char* msg)
459{
460 if (!arena || !*arena)
461 {
462 arena_report_error(NULL, "%s", msg);
463 return;
464 }
465 arena_report_error(*arena, "%s", msg);
466 arena_destroy(*arena);
467 arena_delete(arena);
468}
469
492static inline void* arena_alloc_buffer(size_t size)
493{
494 void* buffer = calloc(1, size);
495 if (!buffer)
496 arena_report_error(NULL, "arena_create failed: buffer allocation of %zu bytes failed", size);
497 return buffer;
498}
499
530static inline void arena_reset_metadata(t_arena* arena)
531{
532 arena->buffer = NULL;
533 arena->size = 0;
534 arena->offset = 0;
535 arena->marker_stack_top = 0;
536 memset(arena->marker_stack, 0, sizeof(arena->marker_stack));
537 arena->parent_ref = NULL;
538
539 arena->grow_cb = default_grow_cb;
540 arena->debug.error_cb = arena_default_error_callback;
541 arena->debug.error_context = NULL;
542 arena->debug.label = NULL;
543
544 arena->hooks.hook_cb = NULL;
545 arena->hooks.context = NULL;
546
547 arena_stats_reset(&arena->stats);
548
549 atomic_store_explicit(&arena->owns_buffer, false, memory_order_release);
550 atomic_store_explicit(&arena->can_grow, false, memory_order_release);
551 atomic_store_explicit(&arena->is_destroying, false, memory_order_release);
552
553#ifdef ARENA_ENABLE_THREAD_SAFE
554 arena->use_lock = false;
555#endif
556}
557
585static inline bool arena_init_mutex(t_arena* arena)
586{
587#ifdef ARENA_ENABLE_THREAD_SAFE
588 pthread_mutexattr_t attr;
589 if (pthread_mutexattr_init(&attr) != 0)
590 goto fail;
591 if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0)
592 goto fail_attr;
593 if (pthread_mutex_init(&arena->lock, &attr) != 0)
594 goto fail_attr;
595 pthread_mutexattr_destroy(&attr);
596 arena->use_lock = true;
597 return true;
598fail_attr:
599 pthread_mutexattr_destroy(&attr);
600fail:
601 arena_report_error(NULL, "arena_create failed: mutex setup failed");
602 return false;
603#else
604 (void) arena;
605 return true;
606#endif
607}
608
640static inline bool arena_finish_init(t_arena* arena, void* buffer, size_t size, bool allow_grow)
641{
643 arena->buffer = (uint8_t*) buffer;
644 arena->size = size;
645 atomic_store_explicit(&arena->owns_buffer, true, memory_order_release);
646 atomic_store_explicit(&arena->can_grow, allow_grow, memory_order_release);
647 atomic_store_explicit(&arena->is_destroying, false, memory_order_release);
648
649 if (!arena_init_mutex(arena))
650 {
651 free(buffer);
652 return false;
653 }
654 arena_generate_id(arena);
655 return true;
656}
657
682static inline bool arena_set_allocated_buffer(t_arena* arena, size_t size)
683{
684 void* buffer = calloc(1, size);
685 if (!buffer)
686 {
687 arena_report_error(NULL, "arena_init_with_buffer: malloc for %zu bytes failed", size);
688 return false;
689 }
690 arena->buffer = (uint8_t*) buffer;
691 arena->size = size;
692 atomic_store_explicit(&arena->owns_buffer, true, memory_order_release);
693 return true;
694}
695
719static inline void arena_set_user_buffer(t_arena* arena, void* buffer, size_t size)
720{
721 arena->buffer = (uint8_t*) buffer;
722 arena->size = size;
723 atomic_store_explicit(&arena->owns_buffer, false, memory_order_release);
724}
725
750static inline bool arena_set_or_alloc_buffer(t_arena* arena, void* buffer, size_t size)
751{
752 if (!buffer && size > 0)
753 return arena_set_allocated_buffer(arena, size);
754
755 arena_set_user_buffer(arena, buffer, size);
756 return true;
757}
Core public API for the Arena memory allocator.
void arena_destroy(t_arena *arena)
void arena_delete(t_arena **arena)
bool arena_init(t_arena *arena, size_t size, bool allow_grow)
void arena_init_with_buffer(t_arena *arena, void *buffer, size_t size, bool allow_grow)
void arena_reinit_with_buffer(t_arena *arena, void *buffer, size_t size, bool allow_grow)
t_arena * arena_create(size_t size, bool allow_grow)
void arena_generate_id(t_arena *arena)
Generate a unique debug ID for an arena.
void arena_default_error_callback(const char *msg, void *ctx)
Default fallback error callback (prints to stderr).
void arena_report_error(t_arena *arena, const char *fmt,...)
Report an error from an arena using its configured error callback.
static void arena_reset_metadata(t_arena *arena)
Reset all arena metadata fields to their default initial state.
static void arena_set_user_buffer(t_arena *arena, void *buffer, size_t size)
Assign a user-provided buffer to an arena without taking ownership.
static void arena_log_and_teardown(t_arena **arena, const char *msg)
Report an error, destroy the arena, and free its memory.
static bool arena_finish_init(t_arena *arena, void *buffer, size_t size, bool allow_grow)
Finalize the initialization of an arena with a provided buffer.
static bool arena_set_or_alloc_buffer(t_arena *arena, void *buffer, size_t size)
Configure an arena's buffer by either assigning a user-provided region or allocating one internally.
size_t default_grow_cb(size_t current_size, size_t requested_size)
Default growth policy callback for arena resizing.
static void * arena_alloc_buffer(size_t size)
Allocate a zero-initialized memory buffer for the arena.
static bool arena_set_allocated_buffer(t_arena *arena, size_t size)
Allocate and assign a zero-initialized buffer to an arena.
static void arena_set_default_label(t_arena *arena, const char *fallback)
Set a fallback debug label if none is set.
static bool arena_init_mutex(t_arena *arena)
Initialize the mutex used for thread-safe arena operations.
static t_arena * arena_alloc_struct(void)
Allocate and zero-initialize a new arena struct.
void arena_stats_reset(t_arena_stats *stats)
Reset the given statistics structure to zero.
The main memory arena structure used for fast allocation.