memory_arena
Loading...
Searching...
No Matches
Data Structures | Typedefs | Functions
arena.h File Reference

Core public API for the Arena memory allocator. More...

#include <stdlib.h>
#include <string.h>
#include "internal/arena_debug.h"
#include "arena_hooks.h"
#include "internal/arena_internal.h"
#include "internal/arena_math.h"
#include "arena_stats.h"
+ Include dependency graph for arena.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  s_arena
 

Typedefs

typedef size_t(* arena_grow_callback) (size_t current_size, size_t requested_size)
 
typedef struct s_arena t_arena
 
typedef size_t t_arena_marker
 

Functions

void * arena_alloc (t_arena *arena, size_t size)
 
void * arena_alloc_aligned (t_arena *arena, size_t size, size_t alignment)
 
void * arena_alloc_aligned_labeled (t_arena *arena, size_t size, size_t alignment, const char *label)
 
void * arena_alloc_internal (t_arena *arena, size_t size, size_t alignment, const char *label)
 Core internal allocator with alignment and labeling support.
 
void * arena_alloc_labeled (t_arena *arena, size_t size, const char *label)
 
bool arena_alloc_sub (t_arena *parent, t_arena *child, size_t size)
 
bool arena_alloc_sub_aligned (t_arena *parent, t_arena *child, size_t size, size_t alignment)
 
bool arena_alloc_sub_labeled (t_arena *parent, t_arena *child, size_t size, const char *label)
 
bool arena_alloc_sub_labeled_aligned (t_arena *parent, t_arena *child, size_t size, size_t alignment, const char *label)
 
void * arena_calloc (t_arena *arena, size_t count, size_t size)
 
void * arena_calloc_aligned (t_arena *arena, size_t count, size_t size, size_t alignment)
 
void * arena_calloc_aligned_labeled (t_arena *arena, size_t count, size_t size, size_t alignment, const char *label)
 
void * arena_calloc_labeled (t_arena *arena, size_t count, size_t size, const char *label)
 
t_arena * arena_create (size_t size, bool allow_grow)
 
void arena_delete (t_arena **arena)
 
void arena_destroy (t_arena *arena)
 
bool arena_grow (t_arena *arena, size_t required_size)
 
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)
 
t_arena_marker arena_mark (t_arena *arena)
 
bool arena_might_shrink (t_arena *arena)
 
size_t arena_peak (t_arena *arena)
 
void arena_pop (t_arena *arena, t_arena_marker marker)
 
void * arena_realloc_last (t_arena *arena, void *old_ptr, size_t old_size, size_t new_size)
 
void arena_reinit_with_buffer (t_arena *arena, void *buffer, size_t size, bool allow_grow)
 
size_t arena_remaining (t_arena *arena)
 
void arena_reset (t_arena *arena)
 
void arena_shrink (t_arena *arena, size_t new_size)
 
size_t arena_used (t_arena *arena)
 

Detailed Description

Core public API for the Arena memory allocator.

Author
Toonsa
Date
2025

This header defines the central data structure (t_arena) and exposes all major functions for arena-based memory allocation, deallocation, initialization, and state management.

Features:

This header is the entry point to the arena system and is included by all modules using arenas for custom allocation.

Optional modules included:

Definition in file arena.h.


Data Structure Documentation

◆ s_arena

struct s_arena

Definition at line 128 of file arena.h.

+ Collaboration diagram for s_arena:
Data Fields
uint8_t * buffer Pointer to the memory buffer.
_Atomic bool can_grow Whether the arena supports dynamic growth.
t_arena_debug debug Debugging and diagnostic metadata.
arena_grow_callback grow_cb Optional callback for dynamic resizing.
t_arena_hooks hooks Allocation hooks for monitoring/debugging.
_Atomic bool is_destroying Indicates the arena is being destroyed.
t_arena_marker marker_stack[ARENA_MAX_STACK_DEPTH] Stack of saved markers.
int marker_stack_top Top index of marker stack.
size_t offset Current used offset (bump pointer).
_Atomic bool owns_buffer Whether this arena owns the buffer memory.
struct s_arena * parent_ref Reference to parent arena if this is a sub-arena.
size_t size Total size of the buffer.
t_arena_stats stats Allocation and memory usage statistics.

Typedef Documentation

◆ arena_grow_callback

typedef size_t(* arena_grow_callback) (size_t current_size, size_t requested_size)

◆ t_arena

typedef struct s_arena t_arena

◆ t_arena_marker

typedef size_t t_arena_marker

Definition at line 91 of file arena.h.

Function Documentation

◆ arena_alloc()

void * arena_alloc ( t_arena *  arena,
size_t  size 
)

◆ arena_alloc_aligned()

void * arena_alloc_aligned ( t_arena *  arena,
size_t  size,
size_t  alignment 
)

◆ arena_alloc_aligned_labeled()

void * arena_alloc_aligned_labeled ( t_arena *  arena,
size_t  size,
size_t  alignment,
const char *  label 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc.c.

Definition at line 274 of file arena_alloc.c.

275{
276 if (!label)
277 label = "arena_alloc_aligned_labeled";
278 return arena_alloc_internal(arena, size, alignment, label);
279}

References arena_alloc_internal().

◆ arena_alloc_labeled()

void * arena_alloc_labeled ( t_arena *  arena,
size_t  size,
const char *  label 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_hooks.c.

Definition at line 217 of file arena_alloc.c.

218{
219 if (!label)
220 label = "arena_alloc_labeled";
221 return arena_alloc_internal(arena, size, ARENA_DEFAULT_ALIGNMENT, label);
222}

References arena_alloc_internal(), and ARENA_DEFAULT_ALIGNMENT.

◆ arena_alloc_sub()

bool arena_alloc_sub ( t_arena *  parent,
t_arena *  child,
size_t  size 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c.

Definition at line 187 of file arena_alloc_sub.c.

188{
189 return arena_alloc_sub_labeled(parent, child, size, "subarena");
190}
bool arena_alloc_sub_labeled(t_arena *parent, t_arena *child, size_t size, const char *label)

References arena_alloc_sub_labeled().

◆ arena_alloc_sub_aligned()

bool arena_alloc_sub_aligned ( t_arena *  parent,
t_arena *  child,
size_t  size,
size_t  alignment 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c.

Definition at line 257 of file arena_alloc_sub.c.

258{
259 return arena_alloc_sub_labeled_aligned(parent, child, size, alignment, "subarena");
260}
bool arena_alloc_sub_labeled_aligned(t_arena *parent, t_arena *child, size_t size, size_t alignment, const char *label)

References arena_alloc_sub_labeled_aligned().

◆ arena_alloc_sub_labeled()

bool arena_alloc_sub_labeled ( t_arena *  parent,
t_arena *  child,
size_t  size,
const char *  label 
)

◆ arena_alloc_sub_labeled_aligned()

bool arena_alloc_sub_labeled_aligned ( t_arena *  parent,
t_arena *  child,
size_t  size,
size_t  alignment,
const char *  label 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c.

Definition at line 399 of file arena_alloc_sub.c.

400{
401 if (!arena_alloc_sub_validate(parent, child))
402 return false;
403
404 void* mem = arena_alloc_aligned(parent, size, alignment);
405 if (!mem)
406 {
407 arena_report_error(parent, "arena_alloc_sub failed: allocation from parent arena failed");
408 return false;
409 }
410
411 arena_setup_subarena(parent, child, mem, size, label);
412
413 ALOG("[arena_alloc_sub] Created sub-arena (%s) of %zu bytes from %p → %p\n", child->debug.label, size,
414 (void*) parent, (void*) child);
415
416 return true;
417}
void * arena_alloc_aligned(t_arena *arena, size_t size, size_t alignment)
#define ALOG(...)
Debug logging macro (enabled only if ARENA_DEBUG_LOG is set).
void arena_report_error(t_arena *arena, const char *fmt,...)
Report an error from an arena using its configured error callback.
static void arena_setup_subarena(t_arena *parent, t_arena *child, void *buffer, size_t size, const char *label)
Initialize a child arena as a sub-arena of a parent using a provided memory block.
static bool arena_alloc_sub_validate(t_arena *parent, t_arena *child)
Validate the input parameters for creating a sub-arena.

References ALOG, arena_alloc_aligned(), arena_alloc_sub_validate(), arena_report_error(), and arena_setup_subarena().

◆ arena_calloc()

void * arena_calloc ( t_arena *  arena,
size_t  count,
size_t  size 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c, and /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_calloc.c.

Definition at line 96 of file arena_calloc.c.

97{
98 return arena_calloc_labeled(arena, count, size, "arena_calloc_zero");
99}
void * arena_calloc_labeled(t_arena *arena, size_t count, size_t size, const char *label)

References arena_calloc_labeled().

◆ arena_calloc_aligned()

void * arena_calloc_aligned ( t_arena *  arena,
size_t  count,
size_t  size,
size_t  alignment 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_calloc.c.

Definition at line 148 of file arena_calloc.c.

149{
150 return arena_calloc_aligned_labeled(arena, count, size, alignment, "arena_calloc_zero");
151}
void * arena_calloc_aligned_labeled(t_arena *arena, size_t count, size_t size, size_t alignment, const char *label)

References arena_calloc_aligned_labeled().

◆ arena_calloc_aligned_labeled()

void * arena_calloc_aligned_labeled ( t_arena *  arena,
size_t  count,
size_t  size,
size_t  alignment,
const char *  label 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_calloc.c.

Definition at line 267 of file arena_calloc.c.

268{
269 if (!label)
270 label = "arena_calloc_zero";
271
272 if (!validate_arena_calloc_input(arena, count, size))
273 {
274 if (arena)
276 return NULL;
277 }
278
279 size_t total;
280 if (would_overflow_mul(count, size, &total))
281 {
283 arena_report_error(arena,
284 "arena_calloc failed: multiplication overflow "
285 "(count = %zu, size = %zu)",
286 count, size);
287 return NULL;
288 }
289
290 return arena_alloc_internal(arena, total, alignment, label);
291}
static void arena_record_failed_alloc(t_arena *arena)
Increment the arena's failed allocation counter in a thread-safe manner.
static bool validate_arena_calloc_input(t_arena *arena, size_t count, size_t size)
Validate input parameters for a calloc-style arena allocation.
static bool would_overflow_mul(size_t a, size_t b, size_t *result)
Perform a checked multiplication of two size_t values.
Definition arena_math.h:79

References arena_alloc_internal(), arena_record_failed_alloc(), arena_report_error(), validate_arena_calloc_input(), and would_overflow_mul().

◆ arena_calloc_labeled()

void * arena_calloc_labeled ( t_arena *  arena,
size_t  count,
size_t  size,
const char *  label 
)

◆ arena_create()

t_arena * arena_create ( size_t  size,
bool  allow_grow 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_create.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_hooks.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_resize.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_stack.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c, /home/toonsa/myProjects/memoryArena/srcs/internal/arena_debug.c, arena_shrink_monitor.c, and arena_stack_parser.c.

Definition at line 111 of file arena_create.c.

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}
void arena_generate_id(t_arena *arena)
Generate a unique debug ID for an arena.
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 void * arena_alloc_buffer(size_t size)
Allocate a zero-initialized memory buffer for the arena.
static void arena_set_default_label(t_arena *arena, const char *fallback)
Set a fallback debug label if none is set.
static t_arena * arena_alloc_struct(void)
Allocate and zero-initialize a new arena struct.
The main memory arena structure used for fast allocation.

References arena_alloc_buffer(), arena_alloc_struct(), arena_finish_init(), arena_generate_id(), arena_log_and_teardown(), arena_report_error(), and arena_set_default_label().

◆ arena_delete()

void arena_delete ( t_arena **  arena)

◆ arena_destroy()

void arena_destroy ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc.c, /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c, /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_calloc.c, /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_realloc_last.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_cleanup.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_create.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_io.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_scratch.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_tlscratch.c.

Definition at line 82 of file arena_cleanup.c.

83{
84 if (!arena)
85 return;
86
87 bool expected = false;
88 if (!atomic_compare_exchange_strong(&arena->is_destroying, &expected, true))
89 return;
90
91#ifdef ARENA_ENABLE_THREAD_SAFE
92 if (arena->use_lock)
93 {
94 ARENA_CHECK(arena);
95 ARENA_LOCK(arena);
96
99
100 arena_zero_metadata(arena);
101
102 ARENA_UNLOCK(arena);
103 arena->use_lock = false;
104 pthread_mutex_destroy(&arena->lock);
105 return;
106 }
107#endif
108
111 arena_zero_metadata(arena);
112}
#define ARENA_CHECK(arena)
#define ARENA_UNLOCK(arena)
#define ARENA_LOCK(arena)
Acquire the mutex lock if thread safety is enabled.
static void arena_free_buffer_if_owned(t_arena *arena)
Free the arena's internal buffer if the arena owns it.
static void arena_free_growth_history(t_arena *arena)
Free the memory used to store the arena's growth history.
void arena_zero_metadata(t_arena *arena)
Zero out and reset all debug/stats metadata associated with the arena.

References ARENA_CHECK, arena_free_buffer_if_owned(), arena_free_growth_history(), ARENA_LOCK, ARENA_UNLOCK, and arena_zero_metadata().

◆ arena_grow()

bool arena_grow ( t_arena *  arena,
size_t  required_size 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc.c, /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_realloc_last.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_resize.c.

Definition at line 142 of file arena_resize.c.

143{
144 if (!arena)
145 return false;
146
147 if (required_size == 0)
148 return true;
149
150 ARENA_LOCK(arena);
151
152 if (!arena_grow_validate(arena, required_size))
153 {
154 ARENA_UNLOCK(arena);
155 return false;
156 }
157
158 size_t old_size = arena->size;
159 size_t new_size = arena_grow_compute_new_size(arena, required_size);
160 if (new_size == 0)
161 {
162 arena_report_error(arena, "arena_grow failed: computed size invalid");
163 ARENA_UNLOCK(arena);
164 return false;
165 }
166
167 if (new_size > (size_t)(1ULL << 32)) // 4GiB
168 {
169 arena_report_error(arena, "arena_grow rejected size: %zu", new_size);
170 return false;
171 }
172 bool success = arena_grow_realloc_buffer(arena, new_size, old_size);
173 ARENA_UNLOCK(arena);
174 return success;
175}
static bool arena_grow_realloc_buffer(t_arena *arena, size_t new_size, size_t old_size)
Reallocate the arena's buffer to a new size.
static bool arena_grow_validate(t_arena *arena, size_t required_size)
Validate whether the arena is allowed to grow for a given request.
static size_t arena_grow_compute_new_size(t_arena *arena, size_t required_size)
Compute the new size for the arena based on the growth policy.

References arena_grow_compute_new_size(), arena_grow_realloc_buffer(), arena_grow_validate(), ARENA_LOCK, arena_report_error(), and ARENA_UNLOCK.

◆ arena_init()

bool arena_init ( t_arena *  arena,
size_t  size,
bool  allow_grow 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc.c, /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_calloc.c, /home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_realloc_last.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_cleanup.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_create.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_io.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_scratch.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_tlscratch.c.

Definition at line 190 of file arena_create.c.

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}

References arena_alloc_buffer(), arena_finish_init(), arena_generate_id(), arena_log_and_teardown(), arena_report_error(), and arena_set_default_label().

◆ arena_init_with_buffer()

void arena_init_with_buffer ( t_arena *  arena,
void *  buffer,
size_t  size,
bool  allow_grow 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_alloc_sub.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_create.c.

Definition at line 286 of file arena_create.c.

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}
static void arena_reset_metadata(t_arena *arena)
Reset all arena metadata fields to their default initial state.
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.
static bool arena_init_mutex(t_arena *arena)
Initialize the mutex used for thread-safe arena operations.

References arena_generate_id(), arena_init_mutex(), arena_report_error(), arena_reset_metadata(), arena_set_default_label(), and arena_set_or_alloc_buffer().

◆ arena_mark()

t_arena_marker arena_mark ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_stack.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c.

Definition at line 227 of file arena_state.c.

228{
229 if (!arena)
230 return 0;
231
232 ARENA_LOCK(arena);
233 size_t offset = arena->offset;
234 ARENA_UNLOCK(arena);
235 return offset;
236}

References ARENA_LOCK, and ARENA_UNLOCK.

◆ arena_might_shrink()

bool arena_might_shrink ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_resize.c, and arena_shrink_monitor.c.

Definition at line 385 of file arena_resize.c.

386{
387 if (!should_attempt_shrink(arena))
388 return false;
389
390 ARENA_LOCK(arena);
391 ARENA_CHECK(arena);
392
393 const size_t used = arena->offset;
394 const size_t size = arena->size;
395
397 {
398 const size_t target = arena_shrink_target(used);
399
400 if (target < size)
401 {
402 arena_shrink(arena, target);
403 ARENA_UNLOCK(arena);
404 return true;
405 }
406 }
407
408 ARENA_UNLOCK(arena);
409 return false;
410}
size_t used
Number of bytes used in the arena buffer.
Definition arena_io.h:2
void arena_shrink(t_arena *arena, size_t new_size)
static size_t arena_shrink_target(size_t used)
Compute the target buffer size for a shrink operation.
static bool should_attempt_shrink(t_arena *arena)
Determine whether the arena is eligible for dynamic shrinking.
static bool arena_should_maybe_shrink(size_t used, size_t size)
Decide whether the arena buffer should be shrunk based on usage ratio.

References ARENA_CHECK, ARENA_LOCK, arena_should_maybe_shrink(), arena_shrink(), arena_shrink_target(), ARENA_UNLOCK, should_attempt_shrink(), and used.

◆ arena_peak()

size_t arena_peak ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c.

Definition at line 175 of file arena_state.c.

176{
177 if (!arena)
178 return 0;
179
180 ARENA_LOCK(arena);
181 size_t peak = arena->stats.peak_usage;
182 ARENA_UNLOCK(arena);
183 return peak;
184}

References ARENA_LOCK, and ARENA_UNLOCK.

◆ arena_pop()

void arena_pop ( t_arena *  arena,
t_arena_marker  marker 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_stack.c, and /home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c.

Definition at line 283 of file arena_state.c.

284{
285 if (!arena)
286 return;
287
288 ARENA_LOCK(arena);
289 if (marker > arena->offset)
290 {
291 arena_report_error(arena, "arena_pop failed: invalid marker %zu (offset: %zu)", marker, arena->offset);
292 ARENA_UNLOCK(arena);
293 return;
294 }
295
296 arena_poison_memory(arena->buffer + marker, arena->offset - marker);
297 arena->offset = marker;
298 ARENA_UNLOCK(arena);
299}
#define arena_poison_memory(ptr, size)
No-op poison macro when poisoning is disabled.

References ARENA_LOCK, arena_poison_memory, arena_report_error(), and ARENA_UNLOCK.

◆ arena_realloc_last()

void * arena_realloc_last ( t_arena *  arena,
void *  old_ptr,
size_t  old_size,
size_t  new_size 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/allocation/arena_realloc_last.c.

Definition at line 122 of file arena_realloc_last.c.

123{
124 if (!arena_realloc_validate(arena, old_ptr, new_size))
125 return NULL;
126
127 ARENA_LOCK(arena);
128 ARENA_CHECK(arena);
129
130 bool is_last = is_last_allocation(arena, old_ptr, old_size);
131 void* result = is_last ? realloc_in_place(arena, old_ptr, old_size, new_size) : NULL;
132
133 ARENA_UNLOCK(arena);
134
135 return is_last ? result : realloc_fallback(arena, old_ptr, old_size, new_size);
136}
static void * realloc_in_place(t_arena *arena, void *old_ptr, size_t old_size, size_t new_size)
Attempt to resize the last allocation in place.
static bool arena_realloc_validate(t_arena *arena, void *old_ptr, size_t new_size)
Validate input arguments for arena_realloc_last.
static void * realloc_fallback(t_arena *arena, void *old_ptr, size_t old_size, size_t new_size)
Perform a fallback reallocation by allocating new memory and copying data.
static bool is_last_allocation(t_arena *arena, void *old_ptr, size_t old_size)
Check if a given pointer corresponds to the most recent allocation.

References ARENA_CHECK, ARENA_LOCK, arena_realloc_validate(), ARENA_UNLOCK, is_last_allocation(), realloc_fallback(), and realloc_in_place().

◆ arena_reinit_with_buffer()

void arena_reinit_with_buffer ( t_arena *  arena,
void *  buffer,
size_t  size,
bool  allow_grow 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_create.c.

Definition at line 361 of file arena_create.c.

362{
363 arena_destroy(arena);
364 arena_init_with_buffer(arena, buffer, size, allow_grow);
365}
void arena_destroy(t_arena *arena)
void arena_init_with_buffer(t_arena *arena, void *buffer, size_t size, bool allow_grow)

References arena_destroy(), and arena_init_with_buffer().

◆ arena_remaining()

size_t arena_remaining ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c.

Definition at line 122 of file arena_state.c.

123{
124 if (!arena)
125 return 0;
126
127 ARENA_LOCK(arena);
128 size_t remaining = arena->size - arena->offset;
129 ARENA_UNLOCK(arena);
130 return remaining;
131}

References ARENA_LOCK, and ARENA_UNLOCK.

◆ arena_reset()

void arena_reset ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_scratch.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c, /home/toonsa/myProjects/memoryArena/srcs/core/arena_tlscratch.c, and arena_shrink_monitor.c.

Definition at line 345 of file arena_state.c.

346{
347 if (!arena)
348 return;
349
350 ARENA_LOCK(arena);
351 ARENA_ASSERT_VALID(arena);
352
353 arena_poison_memory(arena->buffer, arena->size);
354 arena->offset = 0;
355
356 ARENA_UNLOCK(arena);
357}
#define ARENA_ASSERT_VALID(arena)

References ARENA_ASSERT_VALID, ARENA_LOCK, arena_poison_memory, and ARENA_UNLOCK.

◆ arena_shrink()

void arena_shrink ( t_arena *  arena,
size_t  new_size 
)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_resize.c.

Definition at line 267 of file arena_resize.c.

268{
269 if (!arena)
270 return;
271
272 ARENA_LOCK(arena);
273 ARENA_CHECK(arena);
274
275 bool ok = arena_shrink_validate(arena, new_size) && arena_shrink_apply(arena, new_size);
276
277 (void) ok;
278 ARENA_UNLOCK(arena);
279}
static bool arena_shrink_validate(t_arena *arena, size_t new_size)
Validate whether an arena can be safely shrunk to a new size.
static bool arena_shrink_apply(t_arena *arena, size_t new_size)
Apply the memory shrink operation to an arena's buffer.

References ARENA_CHECK, ARENA_LOCK, arena_shrink_apply(), arena_shrink_validate(), and ARENA_UNLOCK.

◆ arena_used()

size_t arena_used ( t_arena *  arena)
Examples
/home/toonsa/myProjects/memoryArena/srcs/core/arena_state.c.

Definition at line 73 of file arena_state.c.

74{
75 if (!arena)
76 return 0;
77
78 ARENA_LOCK(arena);
79 size_t used = arena->offset;
80 ARENA_UNLOCK(arena);
81 return used;
82}

References ARENA_LOCK, ARENA_UNLOCK, and used.