1#include "prism/internal/arena.h"
3#include "prism/internal/allocator.h"
4#include "prism/internal/assert.h"
5#include "prism/internal/oom.h"
14#define PM_ARENA_BLOCK_SIZE(data_size) (offsetof(pm_arena_block_t, data) + (data_size))
20#ifndef PM_ARENA_INITIAL_SIZE
21#define PM_ARENA_INITIAL_SIZE 8192
25#define PM_ARENA_GROWTH_INTERVAL 8
28#define PM_ARENA_MAX_SIZE (1024 * 1024)
36#define PM_ARENA_LARGE_DIVISOR 2
42pm_arena_next_block_size(
const pm_arena_t *arena) {
43 size_t size = PM_ARENA_INITIAL_SIZE;
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;
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();
63 pm_arena_block_t *block = (pm_arena_block_t *)
xmalloc(PM_ARENA_BLOCK_SIZE(data_size));
64 if (block == NULL) PRISM_OOM();
66 block->capacity = data_size;
67 block->used = initial_used;
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;
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));
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);
116pm_arena_alloc_slow(
pm_arena_t *arena,
size_t size) {
117 size_t block_data_size = pm_arena_next_block_size(arena);
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;
124 pm_arena_block_t *block = pm_arena_block_new(arena, block_data_size, size);
135pm_arena_alloc_aligned(
pm_arena_t *arena,
size_t size,
size_t alignment) {
136 pm_arena_block_t *block = arena->current;
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;
143 if (padding <= available && size <= available - padding) {
144 block->used += padding + size;
145 return (
void *) (next + padding);
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;
154 block = arena->current;
155 if (block != NULL && (uintptr_t) block->data == start) {
156 block->used = (size_t) (aligned - start) + size;
159 return (
void *) aligned;
168pm_arena_alloc_overflow(
void) {
179 if (arena == NULL) PRISM_OOM();
188 pm_arena_blocks_free(arena->current);
189 pm_arena_blocks_free(arena->large);
198 pm_arena_cleanup(arena);
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_arena_t * pm_arena_new(void)
Returns a newly allocated and initialized arena.
#define PRISM_UNLIKELY(x)
The compiler should predicate that this branch will not be taken.
#define xmalloc
Old name of ruby_xmalloc.
#define xcalloc
Old name of ruby_xcalloc.