Ruby 4.1.0dev (2026-11-18 revision bcf3b03b44ae598e3adb59d359cf32202091a318)
arena.c
1#include "prism/internal/arena.h"
2
3#include "prism/internal/allocator.h"
4#include "prism/internal/assert.h"
5#include "prism/internal/oom.h"
6
7#include <stdint.h>
8#include <stdlib.h>
9
14#define PM_ARENA_BLOCK_SIZE(data_size) (offsetof(pm_arena_block_t, data) + (data_size))
15
20#ifndef PM_ARENA_INITIAL_SIZE
21#define PM_ARENA_INITIAL_SIZE 8192
22#endif
23
25#define PM_ARENA_GROWTH_INTERVAL 8
26
28#define PM_ARENA_MAX_SIZE (1024 * 1024)
29
36#define PM_ARENA_LARGE_DIVISOR 2
37
41static size_t
42pm_arena_next_block_size(const pm_arena_t *arena) {
43 size_t size = PM_ARENA_INITIAL_SIZE;
44
45 for (size_t exp = PM_ARENA_GROWTH_INTERVAL; exp <= arena->block_count; exp += PM_ARENA_GROWTH_INTERVAL) {
46 if (size < PM_ARENA_MAX_SIZE) size *= 2;
47 }
48
49 return size;
50}
51
56static pm_arena_block_t *
57pm_arena_block_alloc(pm_arena_block_t *prev, size_t data_size, size_t initial_used) {
58 PRISM_ASSERT(initial_used <= data_size);
59 if (PRISM_UNLIKELY(data_size > SIZE_MAX - PM_ARENA_BLOCK_SIZE(0))) {
60 pm_arena_alloc_overflow();
61 }
62
63 pm_arena_block_t *block = (pm_arena_block_t *) xmalloc(PM_ARENA_BLOCK_SIZE(data_size));
64 if (block == NULL) PRISM_OOM();
65
66 block->capacity = data_size;
67 block->used = initial_used;
68 block->prev = prev;
69
70 return block;
71}
72
77static pm_arena_block_t *
78pm_arena_block_new(pm_arena_t *arena, size_t data_size, size_t initial_used) {
79 pm_arena_block_t *block = pm_arena_block_alloc(arena->current, data_size, initial_used);
80 arena->current = block;
81 arena->block_count++;
82 return block;
83}
84
88static void
89pm_arena_blocks_free(pm_arena_block_t *block) {
90 while (block != NULL) {
91 pm_arena_block_t *prev = block->prev;
92 xfree_sized(block, PM_ARENA_BLOCK_SIZE(block->capacity));
93 block = prev;
94 }
95}
96
102void
103pm_arena_reserve(pm_arena_t *arena, size_t capacity) {
104 if (capacity <= PM_ARENA_INITIAL_SIZE) return;
105 if (arena->current != NULL && (arena->current->capacity - arena->current->used) >= capacity) return;
106 pm_arena_block_new(arena, capacity, 0);
107}
108
115void *
116pm_arena_alloc_slow(pm_arena_t *arena, size_t size) {
117 size_t block_data_size = pm_arena_next_block_size(arena);
118
119 if (size > block_data_size / PM_ARENA_LARGE_DIVISOR) {
120 arena->large = pm_arena_block_alloc(arena->large, size, size);
121 return arena->large->data;
122 }
123
124 pm_arena_block_t *block = pm_arena_block_new(arena, block_data_size, size);
125 return block->data;
126}
127
134void *
135pm_arena_alloc_aligned(pm_arena_t *arena, size_t size, size_t alignment) {
136 pm_arena_block_t *block = arena->current;
137
138 if (block != NULL) {
139 uintptr_t next = (uintptr_t) (block->data + block->used);
140 size_t padding = (size_t) (-next & (alignment - 1));
141 size_t available = block->capacity - block->used;
142
143 if (padding <= available && size <= available - padding) {
144 block->used += padding + size;
145 return (void *) (next + padding);
146 }
147 }
148
149 size_t mask = alignment - 1;
150 if (PRISM_UNLIKELY(size > SIZE_MAX - mask)) pm_arena_alloc_overflow();
151 uintptr_t start = (uintptr_t) pm_arena_alloc_slow(arena, size + mask);
152 uintptr_t aligned = (start + mask) & ~(uintptr_t) mask;
153
154 block = arena->current;
155 if (block != NULL && (uintptr_t) block->data == start) {
156 block->used = (size_t) (aligned - start) + size;
157 }
158
159 return (void *) aligned;
160}
161
167void
168pm_arena_alloc_overflow(void) {
169 PRISM_OOM();
170 abort();
171}
172
178 pm_arena_t *arena = (pm_arena_t *) xcalloc(1, sizeof(pm_arena_t));
179 if (arena == NULL) PRISM_OOM();
180 return arena;
181}
182
186void
187pm_arena_cleanup(pm_arena_t *arena) {
188 pm_arena_blocks_free(arena->current);
189 pm_arena_blocks_free(arena->large);
190 *arena = (pm_arena_t) { 0 };
191}
192
196void
197pm_arena_free(pm_arena_t *arena) {
198 pm_arena_cleanup(arena);
199 xfree_sized(arena, sizeof(pm_arena_t));
200}
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_arena_t * pm_arena_new(void)
Returns a newly allocated and initialized arena.
Definition arena.c:177
#define PRISM_UNLIKELY(x)
The compiler should predicate that this branch will not be taken.
Definition branch.h:17
#define xmalloc
Old name of ruby_xmalloc.
Definition xmalloc.h:53
#define xcalloc
Old name of ruby_xcalloc.
Definition xmalloc.h:55