john/cell
1
0
Fork 0
Code Issues 31 Pull Requests Actions Packages Projects Releases 2 Wiki Activity

growable buddy memory runtime

Browse Source
This commit is contained in:
John Alanbrook
2026-02-13 07:59:52 -06:00
parent 36fd0a35f9
commit 1ba060668e
3 changed files with 278 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
source/quickjs-internal.h
View File

@@ -95,6 +95,9 @@
/* test the GC by forcing it before each object allocation */
// #define FORCE_GC_AT_MALLOC
#include <sys/mman.h>
#include <unistd.h>
#define POISON_HEAP
/* POISON_HEAP: Use ASan's memory poisoning to detect stale pointer access */
#ifdef POISON_HEAP
@@ -116,9 +119,6 @@
#define gc_unpoison_region(addr, size) ((void)0)
#endif
#include <sys/mman.h>
#include <unistd.h>
static inline size_t poison_page_align(size_t size) {
size_t ps = (size_t)sysconf(_SC_PAGESIZE);
return (size + ps - 1) & ~(ps - 1);
@@ -333,9 +333,8 @@ static inline objhdr_t objhdr_set_cap56 (objhdr_t h, uint64_t cap) {
#else
#define BUDDY_MIN_ORDER 9 /* 512B minimum on 32-bit */
#endif
#define BUDDY_MAX_ORDER 28 /* 256MB maximum */
#define BUDDY_LEVELS (BUDDY_MAX_ORDER - BUDDY_MIN_ORDER + 1)
#define BUDDY_POOL_SIZE (1ULL << BUDDY_MAX_ORDER)
#define BUDDY_MAX_LEVELS 40 /* supports pools up to 2^(BUDDY_MIN_ORDER+39) */
#define BUDDY_DEFAULT_POOL (1ULL << 24) /* 16MB initial pool */
typedef struct BuddyBlock {
struct BuddyBlock *next;
@@ -344,15 +343,26 @@ typedef struct BuddyBlock {
uint8_t is_free;
} BuddyBlock;
typedef struct BuddyPool {
struct BuddyPool *next;
uint8_t *base;
size_t total_size;
uint8_t max_order; /* log2(total_size) */
uint32_t alloc_count; /* outstanding allocations */
BuddyBlock *free_lists[BUDDY_MAX_LEVELS];
} BuddyPool;
typedef struct BuddyAllocator {
uint8_t *base; /* 256MB base address */
size_t total_size; /* 256MB */
BuddyBlock *free_lists[BUDDY_LEVELS];
uint8_t initialized;
BuddyPool *pools; /* linked list, newest first */
size_t next_pool_size; /* next pool doubles from this */
size_t initial_size; /* starting pool size */
size_t cap; /* 0 = no cap */
size_t total_mapped; /* sum of all pool sizes */
} BuddyAllocator;
/* Forward declarations for buddy allocator functions */
static void buddy_destroy (BuddyAllocator *b);
static size_t buddy_max_block (BuddyAllocator *b);
/* controls a host of contexts, handing out memory and scheduling */
struct JSRuntime {

1
source/quickjs.h
View File

@@ -305,6 +305,7 @@ typedef JSValue JSCFunctionData (JSContext *ctx, JSValue this_val,
JSRuntime *JS_NewRuntime (void);
void JS_FreeRuntime (JSRuntime *rt);
void JS_SetMemoryLimit (JSRuntime *rt, size_t limit);
void JS_SetPoolSize (JSRuntime *rt, size_t initial, size_t cap);
JSContext *JS_NewContext (JSRuntime *rt);
JSContext *JS_NewContextWithHeapSize (JSRuntime *rt, size_t heap_size);

269
source/runtime.c
View File

@@ -28,6 +28,11 @@
#define WOTA_IMPLEMENTATION
#include "quickjs-internal.h"
// #define DUMP_BUDDY
#ifdef DUMP_BUDDY
#include "buddy_debug.c"
#endif
static inline JS_BOOL JS_IsInteger (JSValue v) {
if (JS_VALUE_GET_TAG(v) == JS_TAG_INT) return true;
if (JS_VALUE_GET_TAG(v) != JS_TAG_SHORT_FLOAT) return false;
@@ -731,7 +736,7 @@ void *js_malloc (JSContext *ctx, size_t size) {
size_t live = (size_t)((uint8_t *)ctx->heap_free - (uint8_t *)ctx->heap_base);
size_t need = live + size;
size_t ns = ctx->current_block_size;
while (ns < need && ns < (1ULL << BUDDY_MAX_ORDER))
while (ns < need && ns < buddy_max_block(&ctx->rt->buddy))
ns *= 2;
#ifdef DUMP_GC
printf (" growing %zu -> %zu for %zu byte alloc (live %zu)\n",
@@ -926,16 +931,247 @@ static int init_class_range (JSContext *ctx, JSClass const *tab, int start, int
}
/* Destroy buddy allocator and free pool */
void buddy_destroy (BuddyAllocator *b) {
if (!b->initialized) return;
/* Create a new buddy pool of the given size */
static BuddyPool *buddy_pool_new(size_t pool_size) {
BuddyPool *pool = js_mallocz_rt(sizeof(BuddyPool));
if (!pool) return NULL;
free (b->base);
b->base = NULL;
b->initialized = 0;
for (int i = 0; i < BUDDY_LEVELS; i++) {
b->free_lists[i] = NULL;
pool->base = mmap(NULL, pool_size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
if (pool->base == MAP_FAILED) {
js_free_rt(pool);
return NULL;
}
pool->total_size = pool_size;
/* Compute max_order = log2(pool_size) */
uint8_t order = BUDDY_MIN_ORDER;
while ((1ULL << order) < pool_size)
order++;
pool->max_order = order;
pool->alloc_count = 0;
for (int i = 0; i < BUDDY_MAX_LEVELS; i++)
pool->free_lists[i] = NULL;
/* One free block spanning the entire pool */
BuddyBlock *blk = (BuddyBlock *)pool->base;
blk->order = pool->max_order;
blk->is_free = 1;
blk->next = NULL;
blk->prev = NULL;
int level = pool->max_order - BUDDY_MIN_ORDER;
pool->free_lists[level] = blk;
return pool;
}
/* Try to allocate from a specific pool */
static void *buddy_pool_alloc(BuddyPool *pool, uint8_t order) {
int level = order - BUDDY_MIN_ORDER;
int levels = pool->max_order - BUDDY_MIN_ORDER + 1;
/* Search for a free block at this level or higher */
int found = -1;
for (int i = level; i < levels; i++) {
if (pool->free_lists[i]) {
found = i;
break;
}
}
if (found < 0)
return NULL;
/* Remove the block from its free list */
BuddyBlock *blk = pool->free_lists[found];
pool->free_lists[found] = blk->next;
if (blk->next)
blk->next->prev = NULL;
/* Split down to the target level */
uint8_t cur_order = BUDDY_MIN_ORDER + found;
while (cur_order > order) {
cur_order--;
int split_level = cur_order - BUDDY_MIN_ORDER;
/* Right half becomes a free buddy */
uint8_t *right = (uint8_t *)blk + (1ULL << cur_order);
BuddyBlock *rblk = (BuddyBlock *)right;
rblk->order = cur_order;
rblk->is_free = 1;
rblk->prev = NULL;
rblk->next = pool->free_lists[split_level];
if (rblk->next)
rblk->next->prev = rblk;
pool->free_lists[split_level] = rblk;
}
pool->alloc_count++;
return (void *)blk;
}
/* Allocate a block of the given size */
static void *buddy_alloc(BuddyAllocator *b, size_t size) {
/* Lazy-init: create first pool on demand */
if (!b->pools) {
BuddyPool *pool = buddy_pool_new(b->initial_size);
if (!pool) {
fprintf(stderr, "buddy_alloc: initial pool mmap failed\n");
abort();
}
pool->next = NULL;
b->pools = pool;
b->total_mapped = pool->total_size;
b->next_pool_size = b->initial_size * 2;
}
/* Compute order from size */
uint8_t order = BUDDY_MIN_ORDER;
while ((1ULL << order) < size)
order++;
/* Walk pools, try to allocate from each */
for (BuddyPool *pool = b->pools; pool; pool = pool->next) {
if (order <= pool->max_order) {
void *ptr = buddy_pool_alloc(pool, order);
if (ptr) {
#ifdef DUMP_BUDDY
buddy_dump(pool, "alloc", (uint8_t *)ptr, order);
#endif
return ptr;
}
}
}
/* No pool could satisfy — create a new one */
size_t new_pool_size = b->next_pool_size;
size_t needed = 1ULL << order;
if (new_pool_size < needed)
new_pool_size = needed;
/* Check cap */
if (b->cap && b->total_mapped + new_pool_size > b->cap)
return NULL;
BuddyPool *pool = buddy_pool_new(new_pool_size);
if (!pool)
return NULL;
/* Prepend to list */
pool->next = b->pools;
b->pools = pool;
b->total_mapped += pool->total_size;
b->next_pool_size = new_pool_size * 2;
void *ptr = buddy_pool_alloc(pool, order);
#ifdef DUMP_BUDDY
if (ptr)
buddy_dump(pool, "alloc", (uint8_t *)ptr, order);
#endif
return ptr;
}
/* Free a block and coalesce with its buddy if possible */
static void buddy_free(BuddyAllocator *b, void *ptr, size_t size) {
uint8_t order = BUDDY_MIN_ORDER;
while ((1ULL << order) < size)
order++;
/* Find the pool containing ptr */
BuddyPool *pool = NULL;
BuddyPool **prev_link = &b->pools;
for (BuddyPool *p = b->pools; p; prev_link = &p->next, p = p->next) {
if ((uint8_t *)ptr >= p->base &&
(uint8_t *)ptr < p->base + p->total_size) {
pool = p;
break;
}
}
if (!pool) {
fprintf(stderr, "buddy_free: ptr %p not in any pool\n", ptr);
abort();
}
uint8_t *block = (uint8_t *)ptr;
#ifdef DUMP_BUDDY
buddy_dump(pool, "free", block, order);
#endif
/* Coalesce with buddy */
while (order < pool->max_order) {
size_t offset = block - pool->base;
size_t buddy_offset = offset ^ (1ULL << order);
uint8_t *buddy_addr = pool->base + buddy_offset;
/* Check if buddy is on the free list at this level */
int level = order - BUDDY_MIN_ORDER;
BuddyBlock *buddy = NULL;
for (BuddyBlock *p = pool->free_lists[level]; p; p = p->next) {
if ((uint8_t *)p == buddy_addr) {
buddy = p;
break;
}
}
if (!buddy)
break;
/* Remove buddy from free list */
if (buddy->prev)
buddy->prev->next = buddy->next;
else
pool->free_lists[level] = buddy->next;
if (buddy->next)
buddy->next->prev = buddy->prev;
/* Merge: take the lower address */
if (buddy_addr < block)
block = buddy_addr;
order++;
}
/* Add merged block to free list */
int level = order - BUDDY_MIN_ORDER;
BuddyBlock *blk = (BuddyBlock *)block;
blk->order = order;
blk->is_free = 1;
blk->prev = NULL;
blk->next = pool->free_lists[level];
if (blk->next)
blk->next->prev = blk;
pool->free_lists[level] = blk;
pool->alloc_count--;
/* Release empty pools (but keep at least one) */
if (pool->alloc_count == 0 && b->pools != pool) {
*prev_link = pool->next;
b->total_mapped -= pool->total_size;
munmap(pool->base, pool->total_size);
js_free_rt(pool);
} else if (pool->alloc_count == 0 && pool->next) {
/* pool is the head but not the only one — unlink it */
b->pools = pool->next;
b->total_mapped -= pool->total_size;
munmap(pool->base, pool->total_size);
js_free_rt(pool);
}
}
/* Destroy buddy allocator and free all pools */
void buddy_destroy (BuddyAllocator *b) {
BuddyPool *pool = b->pools;
while (pool) {
BuddyPool *next = pool->next;
munmap(pool->base, pool->total_size);
js_free_rt(pool);
pool = next;
}
b->pools = NULL;
b->total_mapped = 0;
}
/* Maximum block size the buddy allocator can hand out */
static size_t buddy_max_block(BuddyAllocator *b) {
return b->cap ? b->cap : SIZE_MAX;
}
/* ============================================================
@@ -1189,7 +1425,7 @@ int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size) {
if (allow_grow) {
if (ctx->next_block_size > new_size)
new_size = ctx->next_block_size;
while (new_size < alloc_size && new_size < (1ULL << BUDDY_MAX_ORDER))
while (new_size < alloc_size && new_size < buddy_max_block(&ctx->rt->buddy))
new_size *= 2;
}
#ifdef POISON_HEAP
@@ -1329,7 +1565,7 @@ int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size) {
#endif
if (allow_grow && recovered > 0 && old_used > 0 && recovered < old_used / 5) {
size_t doubled = new_size * 2;
if (doubled <= (1ULL << BUDDY_MAX_ORDER)) {
if (doubled <= buddy_max_block(&ctx->rt->buddy)) {
ctx->next_block_size = doubled;
#ifdef DUMP_GC
will_grow = 1;
@@ -1386,6 +1622,9 @@ JSRuntime *JS_NewRuntime (void) {
if (!rt) return NULL;
memset (rt, 0, sizeof (*rt));
rt->buddy.initial_size = BUDDY_DEFAULT_POOL;
rt->buddy.next_pool_size = BUDDY_DEFAULT_POOL;
return rt;
}
@@ -1393,6 +1632,12 @@ void JS_SetMemoryLimit (JSRuntime *rt, size_t limit) {
rt->malloc_limit = limit;
}
void JS_SetPoolSize (JSRuntime *rt, size_t initial, size_t cap) {
rt->buddy.initial_size = initial;
rt->buddy.next_pool_size = initial;
rt->buddy.cap = cap;
}
/* Helpers to call system memory functions (for memory allocated by external libs) */
#define malloc(s) malloc_is_forbidden (s)
@@ -1443,7 +1688,7 @@ JSContext *JS_NewContextRawWithHeapSize (JSRuntime *rt, size_t heap_size) {
/* Round up to power of 2 for buddy allocator */
size_t actual = min_size;
while (actual < heap_size && actual < (1ULL << BUDDY_MAX_ORDER)) {
while (actual < heap_size && actual < buddy_max_block(&rt->buddy)) {
actual <<= 1;
}
heap_size = actual;