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 "platform.h"
static INLINE U32 arena_absolute_pos(const Arena *arena)
MemoryBlock *memoryblock_allocate(size_t size)
{
const Arena *current = arena->current;
return current->base_pos + current->pos;
void *base = memory_allocate(size);
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 < (U32_Max - ARENA_HEADER_SZ - 1));
Assert(params->size > MemoryBlock_Header_Size);
Assert(params->size < (U32_Max - MemoryBlock_Header_Size - 1));
void *base;
base = memory_allocate(params->size);
Assert(base != NULL);
ASAN_UNPOISON_MEMORY_REGION(base, ARENA_HEADER_SZ);
MemoryBlock *block = memoryblock_allocate(params->size);
ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
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->prev = NULL;
arena->checkpoint_level = 0;
arena->current = block;
arena->requested_size = params->size;
ASAN_POISON_MEMORY_REGION(&arena->base[arena->pos], arena_available(arena));
return arena;
ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
}
void arena_free(Arena *arena)
{
Arena *it = arena->current;
MemoryBlock *block = arena->current;
while (it != NULL) {
Arena *prev = it->prev;
memory_free(it->base, it->size);
it = prev;
while (block != NULL) {
MemoryBlock *prev = block->prev;
memory_free(block->base, block->size);
block = prev;
}
}
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));
Arena *current = arena->current;
U32 start_pos = AlignUpPow2(current->pos, align);
U32 available = arena_available(current);
MemoryBlock *block = arena->current;
U32 start_pos = AlignUpPow2(block->pos, align);
U32 available = memoryblock_available(block);
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) {
new_size = AlignUpPow2(size + ARENA_HEADER_SZ,align);
new_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
}
ArenaParams new_params = {};
new_params.flags = current->flags;
new_params.size = new_size;
Arena *new_arena = arena_alloc(&new_params);
new_arena->base_pos = current->base_pos + current->size;
new_arena->prev = current;
arena->current = new_arena;
current = new_arena;
start_pos = AlignUpPow2(current->pos, align);
MemoryBlock *new_block = memoryblock_allocate(new_size);
new_block->base_pos = block->base_pos + block->size;
new_block->prev = block;
arena->current = new_block;
block = new_block;
start_pos = AlignUpPow2(block->pos, align);
}
U32 end_pos = start_pos + size;
Assert(end_pos <= current->size);
Assert(end_pos <= block->size);
U8 *mem = &current->base[start_pos];
current->pos = end_pos;
U8 *mem = &block->base[start_pos];
block->pos = end_pos;
ASAN_UNPOISON_MEMORY_REGION(mem, size);
return mem;
@@ -82,26 +80,27 @@ void *arena_push(Arena *arena, U32 size, U32 align)
void arena_pop_to(Arena *arena, U32 abs_pos)
{
Arena *current = arena->current;
abs_pos = Max(ARENA_HEADER_SZ, abs_pos);
while (current) {
Arena *prev = current->prev;
MemoryBlock *block = arena->current;
abs_pos = Max(MemoryBlock_Header_Size, abs_pos);
while (block) {
MemoryBlock *prev = block->prev;
if (current->base_pos >= abs_pos) {
ASAN_UNPOISON_MEMORY_REGION(current->base, current->size); // needed as we use malloc
memory_free(current->base, current->size);
if (block->base_pos >= abs_pos) {
ASAN_UNPOISON_MEMORY_REGION(block->base, block->size);
memory_free(block->base, block->size);
arena->current = prev;
} 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
// is the right thing . shouldn't be able to pop to larger than what's already commited
Assert(new_pos <= current->size);
current->pos = new_pos;
ASAN_POISON_MEMORY_REGION(&current->base[current->pos], arena_available(arena));
Assert(new_pos <= block->size);
block->pos = new_pos;
ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
break;
}
current = prev;
block = prev;
}
}
@@ -109,7 +108,7 @@ ArenaCheckPoint arena_temp_begin(Arena *arena)
{
ArenaCheckPoint checkpoint = {};
checkpoint.arena = arena;
checkpoint.absolute_pos = arena_absolute_pos(arena);
checkpoint.absolute_pos = arena_used(arena);
arena->checkpoint_level++;
return checkpoint;
src/arena.h
+26 -12
View File
@@ -10,15 +10,20 @@ struct ArenaParams {
ArenaFlags flags; // No flags defined yet
};
typedef struct Arena Arena;
struct Arena {
Arena *current;
typedef struct MemoryBlock MemoryBlock;
struct MemoryBlock {
U8 *base;
U32 size;
U32 pos; // start of next allocation
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;
Arena *prev;
S32 checkpoint_level;
};
@@ -28,16 +33,13 @@ struct ArenaCheckPoint {
U32 absolute_pos;
};
StaticAssert(sizeof(Arena) <= 64);
#define ARENA_HEADER_SZ 64u
StaticAssert(sizeof(MemoryBlock) <= 64);
#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_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_pop_to(Arena *arena, U32 abs_pos);
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)
{
arena = arena->current;
MemoryBlock *block = arena->current;
puts("@@@@@@@@@@");
while (arena) {
while (block) {
puts("-----Arena-----");
printf("base: %p\n", arena->base);
printf("size: %u\n", arena->size);
printf("pos: %u\n", arena->pos);
printf("base_pos: %u\n", arena->base_pos);
printf("prev: %p\n", arena->prev);
printf("base: %p\n", block->base);
printf("size: %u\n", block->size);
printf("pos: %u\n", block->pos);
printf("base_pos: %u\n", block->base_pos);
printf("prev: %p\n", block->prev);
puts("-----Arena end-");
arena = arena->prev;
block = block->prev;
}
}
static void arena_test_1(void)
{
ArenaParams arena_params = {};
arena_params.size = 1024+ARENA_HEADER_SZ;
Arena *arena = arena_alloc(&arena_params);
arena_dump(arena);
void *ptr = arena_push(arena, 512, 1);
arena_params.size = 1024+MemoryBlock_Header_Size;
Arena arena;
arena_init(&arena, &arena_params);
arena_dump(&arena);
void *ptr = arena_push(&arena, 512, 1);
MemoryZero(ptr, 512);
printf("Allocated ptr %p\n", ptr);
arena_dump(arena);
ptr = arena_push(arena, 512, 1);
arena_dump(&arena);
ptr = arena_push(&arena, 512, 1);
MemoryZero(ptr, 512);
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);
printf("Allocated ptr %p\n", ptr);
arena_dump(arena);
arena_free(arena);
arena_dump(&arena);
arena_free(&arena);
}
static void arena_test_2(void)
{
ArenaParams arena_params = {};
arena_params.size = 1024+ARENA_HEADER_SZ;
Arena *arena = arena_alloc(&arena_params);
arena_params.size = 1024+MemoryBlock_Header_Size;
Arena arena;
arena_init(&arena, &arena_params);
void *ptr;
ptr = arena_push(arena, 1024, 8);
ptr = arena_push(&arena, 1024, 8);
MemoryZero(ptr, 1024);
printf("Allocated ptr %p\n", ptr);
arena_dump(arena);
ArenaCheckPoint checkpoint = arena_temp_begin(arena);
ptr = arena_push(arena, 4096, 8);
arena_dump(&arena);
ArenaCheckPoint checkpoint = arena_temp_begin(&arena);
ptr = arena_push(&arena, 4096, 8);
MemoryZero(ptr, 4096);
ptr = arena_push(arena, 4096, 8);
ptr = arena_push(&arena, 4096, 8);
MemoryZero(ptr, 4096);
ArenaCheckPoint checkpoint2 = arena_temp_begin(arena);
ptr = arena_push(arena, 64, 8);
ArenaCheckPoint checkpoint2 = arena_temp_begin(&arena);
ptr = arena_push(&arena, 64, 8);
MemoryZero(ptr, 64);
arena_temp_end(&checkpoint2);
arena_temp_end(&checkpoint);
arena_pop_to(arena, 1088);
arena_dump(arena);
ptr = arena_push(arena, 1, 1);
arena_pop_to(&arena, 1088);
arena_dump(&arena);
ptr = arena_push(&arena, 1, 1);
((U8*)ptr)[0] = 0x37;
ptr = arena_push(arena, 1, 1);
ptr = arena_push(&arena, 1, 1);
((U8*)ptr)[0] = 0x73;
arena_pop_to(arena, 1089);
arena_dump(arena);
arena_pop_to(&arena, 1089);
arena_dump(&arena);
arena_pop_to(&arena, 0);
arena_free(arena);
arena_free(&arena);
}
int main(int argc, char *argv[])
src/platform.c
+28 -28
View File
@@ -10,25 +10,25 @@ U32 platform_page_size(void)
return getpagesize();
}
static INLINE size_t AlignToPageSize(size_t sz)
static INLINE size_t AlignToPageSize(size_t 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();
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)
@@ -37,53 +37,53 @@ void platform_free(void *mem)
}
void *memory_allocate(size_t sz)
void *memory_allocate(size_t size)
{
if (sz == 0) {
sz = 1;
if (size == 0) {
size = 1;
}
size_t aligned_sz = AlignToPageSize(sz);
void *mem = mmap(0, aligned_sz, 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);
size_t aligned_size = AlignToPageSize(size);
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", size, aligned_size, mem);
if (mem == MAP_FAILED) {
mem = NULL;
}
return mem;
}
void memory_free(void *mem, size_t sz)
void memory_free(void *mem, size_t size)
{
size_t aligned_sz = AlignToPageSize(sz);
TRACEF(" memory_free size=%zu aligned_size=%zu mem=%p\n", sz, aligned_sz, mem);
size_t aligned_size = AlignToPageSize(size);
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);
}
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);
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;
rc = mprotect(aligned_mem, aligned_sz, PROT_READ | PROT_WRITE);
rc = mprotect(aligned_mem, aligned_size, PROT_READ | PROT_WRITE);
Assert(rc == 0);
rc = madvise(aligned_mem, aligned_sz, MADV_WILLNEED);
rc = madvise(aligned_mem, aligned_size, MADV_WILLNEED);
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);
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;
rc = mprotect(aligned_mem, aligned_sz, PROT_NONE);
rc = mprotect(aligned_mem, aligned_size, PROT_NONE);
Assert(rc == 0);
rc = madvise(aligned_mem, aligned_sz, MADV_DONTNEED);
rc = madvise(aligned_mem, aligned_size, MADV_DONTNEED);
Assert(rc == 0);
}
src/platform.h
+3 -3
View File
@@ -1,10 +1,10 @@
#pragma once
#include <stdlib.h>
void *platform_malloc(size_t sz);
void *platform_malloc(size_t size);
void platform_free(void *mem);
U32 platform_page_size(void);
void *memory_allocate(size_t sz);
void *memory_free(void *mem, size_t sz);
void *memory_allocate(size_t size);
void *memory_free(void *mem, size_t size);