memory_arena
Loading...
Searching...
No Matches
arena_alloc.c
Go to the documentation of this file.
1
36#include "arena.h"
37#include <stdio.h>
38#include <string.h>
39#include <unistd.h>
40
41/*
42 * INTERNAL FUNCTION DECLARATIONS
43 */
44static inline bool arena_alloc_validate_input(t_arena* arena, size_t size, size_t alignment, const char* label);
45static inline bool arena_is_being_destroyed(t_arena* arena, const char* label);
46static inline bool arena_check_overflow(t_arena* arena, size_t size, const char* label);
47static inline size_t arena_calc_aligned_offset(t_arena* arena, size_t alignment);
48static inline bool arena_try_grow(t_arena* arena, size_t size, const char* label);
49static inline bool arena_ensure_capacity(t_arena* arena, size_t size, size_t alignment, const char* label,
50 size_t* aligned_offset, size_t* wasted);
51static inline void arena_update_stats(t_arena* arena, size_t size, size_t wasted);
52static inline void arena_commit_allocation(t_arena* arena, size_t size, size_t wasted, size_t aligned_offset);
53static inline void arena_zero_if_needed(void* ptr, size_t size, const char* label);
54static inline void arena_invoke_allocation_hook(t_arena* arena, void* ptr, size_t size, size_t offset, size_t wasted,
55 const char* label);
56void* arena_alloc_internal(t_arena* arena, size_t size, size_t alignment, const char* label);
57
58/*
59 * Public API
60 */
61
112void* arena_alloc(t_arena* arena, size_t size)
113{
114 return arena_alloc_internal(arena, size, ARENA_DEFAULT_ALIGNMENT, "arena_alloc");
115}
116
167void* arena_alloc_aligned(t_arena* arena, size_t size, size_t alignment)
168{
169 return arena_alloc_internal(arena, size, alignment, "arena_alloc_aligned");
170}
171
217void* arena_alloc_labeled(t_arena* arena, size_t size, const char* label)
218{
219 if (!label)
220 label = "arena_alloc_labeled";
221 return arena_alloc_internal(arena, size, ARENA_DEFAULT_ALIGNMENT, label);
222}
223
274void* arena_alloc_aligned_labeled(t_arena* arena, size_t size, size_t alignment, const char* label)
275{
276 if (!label)
277 label = "arena_alloc_aligned_labeled";
278 return arena_alloc_internal(arena, size, alignment, label);
279}
280
281/*
282 * Internal helpers
283 */
284
311static inline bool arena_alloc_validate_input(t_arena* arena, size_t size, size_t alignment, const char* label)
312{
313 if (!arena)
314 {
315 arena_report_error(NULL, "%s failed: NULL arena", label);
316 return false;
317 }
318 if (size == 0)
319 {
320 arena_report_error(arena, "%s failed: zero-size allocation", label);
321 return false;
322 }
323 if (alignment == 0 || (alignment & (alignment - 1)) != 0)
324 {
325 arena_report_error(arena, "%s failed: alignment (%zu) is not a power-of-two", label, alignment);
326 return false;
327 }
328 return true;
329}
330
356static inline bool arena_is_being_destroyed(t_arena* arena, const char* label)
357{
358 (void)label;
359 if (atomic_load_explicit(&arena->is_destroying, memory_order_acquire))
360 return true;
361 return false;
362}
363
388static inline bool arena_check_overflow(t_arena* arena, size_t size, const char* label)
389{
390 if (size > SIZE_MAX - arena->offset)
391 {
392 arena->stats.failed_allocations++;
393 arena_report_error(arena, "%s failed: size overflow (requested: %zu)", label, size);
394 return true;
395 }
396 return false;
397}
398
422static inline size_t arena_calc_aligned_offset(t_arena* arena, size_t alignment)
423{
424 size_t curr = (size_t) (arena->buffer + arena->offset);
425 size_t aligned = align_up(curr, alignment);
426 return aligned - (size_t) arena->buffer;
427}
428
454static inline bool arena_try_grow(t_arena* arena, size_t size, const char* label)
455{
456 if (!arena->can_grow)
457 {
458 arena_report_error(arena, "%s failed: cannot grow", label);
459 return false;
460 }
461 if (!arena_grow(arena, size))
462 {
463 arena_report_error(arena, "%s failed: growth failed", label);
464 return false;
465 }
466 return true;
467}
468
503static inline bool arena_ensure_capacity(t_arena* arena, size_t size, size_t alignment, const char* label,
504 size_t* aligned_offset, size_t* wasted)
505{
506 *aligned_offset = arena_calc_aligned_offset(arena, alignment);
507 *wasted = *aligned_offset - arena->offset;
508
509 if (*aligned_offset + size <= arena->size)
510 return true;
511
512 if (!arena_try_grow(arena, size, label))
513 return false;
514
515 *aligned_offset = arena_calc_aligned_offset(arena, alignment);
516 *wasted = *aligned_offset - arena->offset;
517
518 return *aligned_offset + size <= arena->size;
519}
520
551static inline void arena_update_stats(t_arena* arena, size_t size, size_t wasted)
552{
553 if (!arena)
554 return;
555
556 ARENA_LOCK(arena);
557 arena->stats.allocations++;
558 arena->stats.live_allocations++;
559 arena->stats.bytes_allocated += size;
560 arena->stats.wasted_alignment_bytes += wasted;
561 arena->stats.alloc_id_counter++;
562 arena->stats.last_alloc_size = size;
563 arena->stats.last_alloc_offset = arena->offset - size;
564 ARENA_UNLOCK(arena);
565}
566
593static inline void arena_commit_allocation(t_arena* arena, size_t size, size_t wasted, size_t aligned_offset)
594{
595 arena->offset = aligned_offset + size;
596 arena_update_peak(arena);
597 arena_update_stats(arena, size, wasted);
598}
599
628static inline void arena_zero_if_needed(void* ptr, size_t size, const char* label)
629{
630 if (label && strcmp(label, "arena_calloc_zero") == 0)
631 memset(ptr, 0, size);
632 else
633 arena_poison_memory(ptr, size);
634}
635
672static inline void arena_invoke_allocation_hook(t_arena* arena, void* ptr, size_t size, size_t offset, size_t wasted,
673 const char* label)
674{
675 arena_allocation_hook hook = atomic_load_explicit(&arena->hooks.hook_cb, memory_order_acquire);
676 if (hook)
677 hook(arena, (int) arena->stats.alloc_id_counter, ptr, size, offset, wasted, label);
678}
679
721void* arena_alloc_internal(t_arena* arena, size_t size, size_t alignment, const char* label)
722{
723 if (!arena_alloc_validate_input(arena, size, alignment, label))
724 return NULL;
725
726 ARENA_LOCK(arena);
727 ARENA_CHECK(arena);
728
729 if (arena_is_being_destroyed(arena, label))
730 {
731 ARENA_UNLOCK(arena);
732 return NULL;
733 }
734
735 if (arena_check_overflow(arena, size, label))
736 {
737 ARENA_UNLOCK(arena);
738 return NULL;
739 }
740
741 size_t aligned_offset = 0;
742 size_t wasted = 0;
743 if (!arena_ensure_capacity(arena, size, alignment, label, &aligned_offset, &wasted))
744 {
745 arena->stats.failed_allocations++;
746 arena_report_error(arena, "%s failed: out of memory (requested: %zu)", label, size);
747 ARENA_UNLOCK(arena);
748 return NULL;
749 }
750
751 arena_commit_allocation(arena, size, wasted, aligned_offset);
752 void* result = arena->buffer + aligned_offset;
753 arena_zero_if_needed(result, size, label);
754 arena_invoke_allocation_hook(arena, result, size, aligned_offset, wasted, label);
755
756 ALOG("[arena] %s: Allocated %zu bytes @ offset %zu (arena %p)\n", label, size, aligned_offset, (void*) arena);
757
758 ARENA_CHECK(arena);
759 ARENA_UNLOCK(arena);
760 return result;
761}
Core public API for the Arena memory allocator.
bool arena_grow(t_arena *arena, size_t required_size)
void * arena_alloc(t_arena *arena, size_t size)
void * arena_alloc_aligned_labeled(t_arena *arena, size_t size, size_t alignment, const char *label)
void * arena_alloc_aligned(t_arena *arena, size_t size, size_t alignment)
void * arena_alloc_labeled(t_arena *arena, size_t size, const char *label)
#define ARENA_DEFAULT_ALIGNMENT
Default alignment value supported.
#define arena_poison_memory(ptr, size)
No-op poison macro when poisoning is disabled.
#define ALOG(...)
Debug logging macro (enabled only if ARENA_DEBUG_LOG is set).
#define ARENA_CHECK(arena)
void(* arena_allocation_hook)(t_arena *arena, int alloc_id, void *ptr, size_t size, size_t offset, size_t wasted, const char *label)
Allocation hook callback type.
Definition arena_hooks.h:58
#define ARENA_UNLOCK(arena)
#define ARENA_LOCK(arena)
Acquire the mutex lock if thread safety is enabled.
void * arena_alloc_internal(t_arena *arena, size_t size, size_t alignment, const char *label)
Core internal allocator with alignment and labeling support.
static size_t arena_calc_aligned_offset(t_arena *arena, size_t alignment)
Compute the next aligned offset within the arena.
static bool arena_alloc_validate_input(t_arena *arena, size_t size, size_t alignment, const char *label)
Validate input parameters for arena allocation.
static bool arena_is_being_destroyed(t_arena *arena, const char *label)
Check whether the arena is currently being destroyed.
static bool arena_check_overflow(t_arena *arena, size_t size, const char *label)
Check whether an allocation would cause a size_t overflow.
static void arena_invoke_allocation_hook(t_arena *arena, void *ptr, size_t size, size_t offset, size_t wasted, const char *label)
Invoke the user-defined allocation hook, if registered.
static bool arena_try_grow(t_arena *arena, size_t size, const char *label)
Attempt to grow the arena's buffer to satisfy an upcoming allocation.
static void arena_commit_allocation(t_arena *arena, size_t size, size_t wasted, size_t aligned_offset)
Update offset, peak usage, and statistics.
static void arena_update_stats(t_arena *arena, size_t size, size_t wasted)
Update allocation statistics after a successful arena allocation.
static void arena_zero_if_needed(void *ptr, size_t size, const char *label)
Zero or poison a memory region depending on allocation label.
static bool arena_ensure_capacity(t_arena *arena, size_t size, size_t alignment, const char *label, size_t *aligned_offset, size_t *wasted)
Ensure that the arena has enough space for a new allocation with alignment.
void arena_report_error(t_arena *arena, const char *fmt,...)
Report an error from an arena using its configured error callback.
static size_t align_up(size_t value, size_t alignment)
Align a value upwards to the nearest multiple of alignment.
Definition arena_math.h:52
void arena_update_peak(t_arena *arena)
Update the arena’s peak memory usage if the current usage exceeds it.
The main memory arena structure used for fast allocation.