noselasd/nob
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rework Arena into chain of MemoryBlock

Browse Source
This commit is contained in:
Nils O. Selåsdal
2026-06-07 21:05:51 +02:00
parent 4971459cbf
commit d2482d91a7
5 changed files with 151 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/arena.c
+55 -56
View File
@@ -2,79 +2,77 @@
#include "base_core.h" #include "base_core.h"
#include "platform.h" #include "platform.h"
static INLINE U32 arena_absolute_pos(const Arena *arena)
MemoryBlock *memoryblock_allocate(size_t size)
{ {
const Arena *current = arena->current; void *base = memory_allocate(size);
return current->base_pos + current->pos; Assert(base != NULL);
MemoryBlock *block = (MemoryBlock *)base;
block->base = (U8 *)base;
block->size = size;
block->pos = MemoryBlock_Header_Size;
block->base_pos = 0;
block->prev = NULL;
return block;
} }
Arena *arena_alloc(const ArenaParams *params) void arena_init(Arena *arena, const ArenaParams *params)
{ {
Assert(params->size > ARENA_HEADER_SZ); Assert(params->size > MemoryBlock_Header_Size);
Assert(params->size < (U32_Max - ARENA_HEADER_SZ - 1)); Assert(params->size < (U32_Max - MemoryBlock_Header_Size - 1));
void *base; MemoryBlock *block = memoryblock_allocate(params->size);
base = memory_allocate(params->size); ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
Assert(base != NULL);
ASAN_UNPOISON_MEMORY_REGION(base, ARENA_HEADER_SZ);
Arena *arena = (Arena *)base;
arena->base = (U8 *)base;
arena->current = arena;
arena->size = params->size;
arena->pos = ARENA_HEADER_SZ;
arena->base_pos = 0;
arena->flags = params->flags; arena->flags = params->flags;
arena->prev = NULL;
arena->checkpoint_level = 0; arena->checkpoint_level = 0;
arena->current = block;
arena->requested_size = params->size;
ASAN_POISON_MEMORY_REGION(&arena->base[arena->pos], arena_available(arena)); ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
return arena;
} }
void arena_free(Arena *arena) void arena_free(Arena *arena)
{ {
Arena *it = arena->current; MemoryBlock *block = arena->current;
while (it != NULL) { while (block != NULL) {
Arena *prev = it->prev; MemoryBlock *prev = block->prev;
memory_free(it->base, it->size); memory_free(block->base, block->size);
it = prev; block = prev;
} }
} }
void *arena_push(Arena *arena, U32 size, U32 align) void *arena_push(Arena *arena, U32 size, U32 align)
{ {
Assert(size < (U32_Max - align - ARENA_HEADER_SZ - 1)); Assert(size < (U32_Max - align - MemoryBlock_Header_Size - 1));
Assert(IsPow2(align)); Assert(IsPow2(align));
Arena *current = arena->current; MemoryBlock *block = arena->current;
U32 start_pos = AlignUpPow2(current->pos, align); U32 start_pos = AlignUpPow2(block->pos, align);
U32 available = arena_available(current); U32 available = memoryblock_available(block);
if (available < size) { if (available < size) {
U32 new_size = arena->size; // original user requeted size U32 new_size = arena->requested_size; // original user requeted size
if (new_size < size) { if (new_size < size) {
new_size = AlignUpPow2(size + ARENA_HEADER_SZ,align); new_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
} }
ArenaParams new_params = {}; MemoryBlock *new_block = memoryblock_allocate(new_size);
new_params.flags = current->flags; new_block->base_pos = block->base_pos + block->size;
new_params.size = new_size; new_block->prev = block;
arena->current = new_block;
Arena *new_arena = arena_alloc(&new_params); block = new_block;
new_arena->base_pos = current->base_pos + current->size; start_pos = AlignUpPow2(block->pos, align);
new_arena->prev = current;
arena->current = new_arena;
current = new_arena;
start_pos = AlignUpPow2(current->pos, align);
} }
U32 end_pos = start_pos + size; U32 end_pos = start_pos + size;
Assert(end_pos <= current->size); Assert(end_pos <= block->size);
U8 *mem = &current->base[start_pos]; U8 *mem = &block->base[start_pos];
current->pos = end_pos; block->pos = end_pos;
ASAN_UNPOISON_MEMORY_REGION(mem, size); ASAN_UNPOISON_MEMORY_REGION(mem, size);
return mem; return mem;
@@ -82,26 +80,27 @@ void *arena_push(Arena *arena, U32 size, U32 align)
void arena_pop_to(Arena *arena, U32 abs_pos) void arena_pop_to(Arena *arena, U32 abs_pos)
{ {
Arena *current = arena->current; MemoryBlock *block = arena->current;
abs_pos = Max(ARENA_HEADER_SZ, abs_pos); abs_pos = Max(MemoryBlock_Header_Size, abs_pos);
while (current) { while (block) {
Arena *prev = current->prev; MemoryBlock *prev = block->prev;
if (current->base_pos >= abs_pos) { if (block->base_pos >= abs_pos) {
ASAN_UNPOISON_MEMORY_REGION(current->base, current->size); // needed as we use malloc ASAN_UNPOISON_MEMORY_REGION(block->base, block->size);
memory_free(current->base, current->size); memory_free(block->base, block->size);
arena->current = prev; arena->current = prev;
} else { } else {
U32 new_pos = abs_pos - current->base_pos; U32 new_pos = abs_pos - block->base_pos;
new_pos = Max(MemoryBlock_Header_Size, new_pos);
// Note, when doing commit/release, new_pos <= current->pos // Note, when doing commit/release, new_pos <= current->pos
// is the right thing . shouldn't be able to pop to larger than what's already commited // is the right thing . shouldn't be able to pop to larger than what's already commited
Assert(new_pos <= current->size); Assert(new_pos <= block->size);
current->pos = new_pos; block->pos = new_pos;
ASAN_POISON_MEMORY_REGION(&current->base[current->pos], arena_available(arena)); ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
break; break;
} }
current = prev; block = prev;
} }
} }
@@ -109,7 +108,7 @@ ArenaCheckPoint arena_temp_begin(Arena *arena)
{ {
ArenaCheckPoint checkpoint = {}; ArenaCheckPoint checkpoint = {};
checkpoint.arena = arena; checkpoint.arena = arena;
checkpoint.absolute_pos = arena_absolute_pos(arena); checkpoint.absolute_pos = arena_used(arena);
arena->checkpoint_level++; arena->checkpoint_level++;
return checkpoint; return checkpoint;
src/arena.h
+26 -12
View File
@@ -10,15 +10,20 @@ struct ArenaParams {
ArenaFlags flags; // No flags defined yet ArenaFlags flags; // No flags defined yet
}; };
typedef struct Arena Arena; typedef struct MemoryBlock MemoryBlock;
struct Arena { struct MemoryBlock {
Arena *current;
U8 *base; U8 *base;
U32 size; U32 size;
U32 pos; // start of next allocation
U32 base_pos; // absolute position of base relative to the first linked arena U32 base_pos; // absolute position of base relative to the first linked arena
U32 pos; // start of next allocation
MemoryBlock *prev;
};
typedef struct Arena Arena;
struct Arena {
MemoryBlock *current;
U32 requested_size;
ArenaFlags flags; ArenaFlags flags;
Arena *prev;
S32 checkpoint_level; S32 checkpoint_level;
}; };
@@ -28,16 +33,13 @@ struct ArenaCheckPoint {
U32 absolute_pos; U32 absolute_pos;
}; };
StaticAssert(sizeof(Arena) <= 64); StaticAssert(sizeof(MemoryBlock) <= 64);
#define ARENA_HEADER_SZ 64u #define MemoryBlock_Header_Size 64u
static INLINE U32 arena_available(const Arena *arena)
{
return arena->size - arena->pos;
}
Arena *arena_alloc(const ArenaParams *params); void arena_init(Arena *arena, const ArenaParams *params);
void arena_free(Arena *arena); void arena_free(Arena *arena);
void *arena_push(Arena *arena, U32 size, U32 align); void *arena_push(Arena *arena, U32 size, U32 align);
@@ -48,3 +50,15 @@ ArenaCheckPoint arena_temp_begin(Arena *arena);
void arena_temp_end(ArenaCheckPoint *checkpoint); void arena_temp_end(ArenaCheckPoint *checkpoint);
void arena_pop_to(Arena *arena, U32 abs_pos); void arena_pop_to(Arena *arena, U32 abs_pos);
void arena_reset(Arena *arena); void arena_reset(Arena *arena);
MemoryBlock *memoryblock_allocate(size_t size);
static INLINE U32 memoryblock_available(const MemoryBlock *block)
{
return block->size - block->pos;
}
static INLINE U32 arena_used(const Arena *arena)
{
const MemoryBlock *block = arena->current;
return block->base_pos + block->pos;
}
src/main.c
+37 -34
View File
@@ -5,76 +5,79 @@
void arena_dump(const Arena *arena) void arena_dump(const Arena *arena)
{ {
arena = arena->current; MemoryBlock *block = arena->current;
puts("@@@@@@@@@@"); puts("@@@@@@@@@@");
while (arena) { while (block) {
puts("-----Arena-----"); puts("-----Arena-----");
printf("base: %p\n", arena->base); printf("base: %p\n", block->base);
printf("size: %u\n", arena->size); printf("size: %u\n", block->size);
printf("pos: %u\n", arena->pos); printf("pos: %u\n", block->pos);
printf("base_pos: %u\n", arena->base_pos); printf("base_pos: %u\n", block->base_pos);
printf("prev: %p\n", arena->prev); printf("prev: %p\n", block->prev);
puts("-----Arena end-"); puts("-----Arena end-");
arena = arena->prev; block = block->prev;
} }
} }
static void arena_test_1(void) static void arena_test_1(void)
{ {
ArenaParams arena_params = {}; ArenaParams arena_params = {};
arena_params.size = 1024+ARENA_HEADER_SZ; arena_params.size = 1024+MemoryBlock_Header_Size;
Arena *arena = arena_alloc(&arena_params); Arena arena;
arena_dump(arena); arena_init(&arena, &arena_params);
void *ptr = arena_push(arena, 512, 1); arena_dump(&arena);
void *ptr = arena_push(&arena, 512, 1);
MemoryZero(ptr, 512); MemoryZero(ptr, 512);
printf("Allocated ptr %p\n", ptr); printf("Allocated ptr %p\n", ptr);
arena_dump(arena); arena_dump(&arena);
ptr = arena_push(arena, 512, 1); ptr = arena_push(&arena, 512, 1);
MemoryZero(ptr, 512); MemoryZero(ptr, 512);
printf("Allocated ptr %p\n", ptr); printf("Allocated ptr %p\n", ptr);
arena_dump(arena); arena_dump(&arena);
ptr = arena_push(arena, 1, 1); ptr = arena_push(&arena, 1, 1);
MemoryZero(ptr, 1); MemoryZero(ptr, 1);
printf("Allocated ptr %p\n", ptr); printf("Allocated ptr %p\n", ptr);
arena_dump(arena); arena_dump(&arena);
arena_free(arena); arena_free(&arena);
} }
static void arena_test_2(void) static void arena_test_2(void)
{ {
ArenaParams arena_params = {}; ArenaParams arena_params = {};
arena_params.size = 1024+ARENA_HEADER_SZ; arena_params.size = 1024+MemoryBlock_Header_Size;
Arena *arena = arena_alloc(&arena_params); Arena arena;
arena_init(&arena, &arena_params);
void *ptr; void *ptr;
ptr = arena_push(arena, 1024, 8); ptr = arena_push(&arena, 1024, 8);
MemoryZero(ptr, 1024); MemoryZero(ptr, 1024);
printf("Allocated ptr %p\n", ptr); printf("Allocated ptr %p\n", ptr);
arena_dump(arena); arena_dump(&arena);
ArenaCheckPoint checkpoint = arena_temp_begin(arena); ArenaCheckPoint checkpoint = arena_temp_begin(&arena);
ptr = arena_push(arena, 4096, 8); ptr = arena_push(&arena, 4096, 8);
MemoryZero(ptr, 4096); MemoryZero(ptr, 4096);
ptr = arena_push(arena, 4096, 8); ptr = arena_push(&arena, 4096, 8);
MemoryZero(ptr, 4096); MemoryZero(ptr, 4096);
ArenaCheckPoint checkpoint2 = arena_temp_begin(arena); ArenaCheckPoint checkpoint2 = arena_temp_begin(&arena);
ptr = arena_push(arena, 64, 8); ptr = arena_push(&arena, 64, 8);
MemoryZero(ptr, 64); MemoryZero(ptr, 64);
arena_temp_end(&checkpoint2); arena_temp_end(&checkpoint2);
arena_temp_end(&checkpoint); arena_temp_end(&checkpoint);
arena_pop_to(arena, 1088); arena_pop_to(&arena, 1088);
arena_dump(arena); arena_dump(&arena);
ptr = arena_push(arena, 1, 1); ptr = arena_push(&arena, 1, 1);
((U8*)ptr)[0] = 0x37; ((U8*)ptr)[0] = 0x37;
ptr = arena_push(arena, 1, 1); ptr = arena_push(&arena, 1, 1);
((U8*)ptr)[0] = 0x73; ((U8*)ptr)[0] = 0x73;
arena_pop_to(arena, 1089); arena_pop_to(&arena, 1089);
arena_dump(arena); arena_dump(&arena);
arena_pop_to(&arena, 0);
arena_free(arena); arena_free(&arena);
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
src/platform.c
+28 -28
View File
@@ -10,25 +10,25 @@ U32 platform_page_size(void)
return getpagesize(); return getpagesize();
} }
static INLINE size_t AlignToPageSize(size_t sz) static INLINE size_t AlignToPageSize(size_t size)
{ {
U32 page_size = platform_page_size(); U32 page_size = platform_page_size();
size_t aligned_sz = AlignUpPow2(sz, page_size); size_t aligned_size = AlignUpPow2(size, page_size);
return aligned_sz; return aligned_size;
} }
static INLINE size_t AlignToPageStart(size_t sz) static INLINE size_t AlignToPageStart(size_t size)
{ {
U32 page_size = platform_page_size(); U32 page_size = platform_page_size();
size_t aligned_sz = AlignDownPow2(sz, page_size); size_t aligned_size = AlignDownPow2(size, page_size);
return aligned_sz; return aligned_size;
} }
void *platform_malloc(size_t sz) void *platform_malloc(size_t size)
{ {
return malloc(sz); return malloc(size);
} }
void platform_free(void *mem) void platform_free(void *mem)
@@ -37,53 +37,53 @@ void platform_free(void *mem)
} }
void *memory_allocate(size_t sz) void *memory_allocate(size_t size)
{ {
if (sz == 0) { if (size == 0) {
sz = 1; size = 1;
} }
size_t aligned_sz = AlignToPageSize(sz); size_t aligned_size = AlignToPageSize(size);
void *mem = mmap(0, aligned_sz, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); void *mem = mmap(0, aligned_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
TRACEF("memory_allocate size=%zu aligned_size=%zu mem=%p\n", sz, aligned_sz, mem); TRACEF("memory_allocate size=%zu aligned_size=%zu mem=%p\n", size, aligned_size, mem);
if (mem == MAP_FAILED) { if (mem == MAP_FAILED) {
mem = NULL; mem = NULL;
} }
return mem; return mem;
} }
void memory_free(void *mem, size_t sz) void memory_free(void *mem, size_t size)
{ {
size_t aligned_sz = AlignToPageSize(sz); size_t aligned_size = AlignToPageSize(size);
TRACEF(" memory_free size=%zu aligned_size=%zu mem=%p\n", sz, aligned_sz, mem); TRACEF(" memory_free size=%zu aligned_size=%zu mem=%p\n", size, aligned_size, mem);
int rc = munmap(mem, aligned_sz); int rc = munmap(mem, aligned_size);
Assert(rc == 0); Assert(rc == 0);
} }
void memory_commit(void *mem, size_t sz) void memory_commit(void *mem, size_t size)
{ {
size_t aligned_sz = AlignToPageSize(sz); size_t aligned_size = AlignToPageSize(size);
void *aligned_mem = (void *)AlignToPageStart((uintptr_t)mem); void *aligned_mem = (void *)AlignToPageStart((uintptr_t)mem);
TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", sz, aligned_sz, mem, aligned_mem); TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", size, aligned_size, mem, aligned_mem);
int rc; int rc;
rc = mprotect(aligned_mem, aligned_sz, PROT_READ | PROT_WRITE); rc = mprotect(aligned_mem, aligned_size, PROT_READ | PROT_WRITE);
Assert(rc == 0); Assert(rc == 0);
rc = madvise(aligned_mem, aligned_sz, MADV_WILLNEED); rc = madvise(aligned_mem, aligned_size, MADV_WILLNEED);
Assert(rc == 0); Assert(rc == 0);
} }
void memory_decommit(void *mem, size_t sz) void memory_decommit(void *mem, size_t size)
{ {
size_t aligned_sz = AlignToPageSize(sz); size_t aligned_size = AlignToPageSize(size);
void *aligned_mem = (void *)AlignToPageStart((uintptr_t)mem); void *aligned_mem = (void *)AlignToPageStart((uintptr_t)mem);
TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", sz, aligned_sz, mem, aligned_mem); TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", size, aligned_size, mem, aligned_mem);
int rc; int rc;
rc = mprotect(aligned_mem, aligned_sz, PROT_NONE); rc = mprotect(aligned_mem, aligned_size, PROT_NONE);
Assert(rc == 0); Assert(rc == 0);
rc = madvise(aligned_mem, aligned_sz, MADV_DONTNEED); rc = madvise(aligned_mem, aligned_size, MADV_DONTNEED);
Assert(rc == 0); Assert(rc == 0);
} }
src/platform.h
+3 -3
View File
@@ -1,10 +1,10 @@
#pragma once #pragma once
#include <stdlib.h> #include <stdlib.h>
void *platform_malloc(size_t sz); void *platform_malloc(size_t size);
void platform_free(void *mem); void platform_free(void *mem);
U32 platform_page_size(void); U32 platform_page_size(void);
void *memory_allocate(size_t sz); void *memory_allocate(size_t size);
void *memory_free(void *mem, size_t sz); void *memory_free(void *mem, size_t size);