abdelrahman/wizapp-stdlib
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplify Arena

Browse Source
This commit is contained in:
Abdelrahman Said 2024-04-28 22:59:37 +01:00
parent e67e1df9a5
commit 7164156c35
2 changed files with 1 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
mem/include/arena/mem_arena.h
View File

@ -13,9 +13,6 @@ typedef struct growing_arena Arena;
bool wapp_mem_arena_init(Arena **arena, u64 base_capacity);
void *wapp_mem_arena_alloc(Arena *arena, u64 size);
void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment);
void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 size);
void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 size,
u64 alignment);
void wapp_mem_arena_clear(Arena *arena);
void wapp_mem_arena_destroy(Arena **arena);

129
mem/src/arena/mem_arena.c
View File

@ -11,21 +11,8 @@
#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
#endif /* ifndef DEFAULT_ALIGNMENT */
#define HDR_MAGIC_BYTE_COUNT 8
#define HDR_MAGIC \
{ 0x57, 0x41, 0x41, 0x52, 0x4e, 0x48, 0x44, 0x52 }
#define MAX_HDR_SEARCH_LENGTH 256
#define ARENA_MINIMUM_CAPACITY 1024
typedef struct arena_alloc_hdr ArenaAllocHDR;
struct arena_alloc_hdr {
u8 magic[HDR_MAGIC_BYTE_COUNT];
u64 alloc_size;
u64 alignment;
u8 *alloc_start;
};
typedef struct base_arena BaseArena;
struct base_arena {
u8 *buf;
@ -41,14 +28,11 @@ struct growing_arena {
u64 initial_capacity;
};
internal BaseArena *find_arena_from_pointer(const Arena *arena, void *ptr);
internal bool base_arena_init(BaseArena *arena, u64 capacity);
internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
u64 alignment);
internal void base_arena_clear(BaseArena *arena);
internal void base_arena_destroy(BaseArena *arena);
internal ArenaAllocHDR *find_alloc_header(BaseArena *arena, void *alloc_ptr);
// PUBLIC API
@ -122,54 +106,6 @@ void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
return output;
}
void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 size) {
return wapp_mem_arena_realloc_aligned(arena, ptr, size, DEFAULT_ALIGNMENT);
}
void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 size,
u64 alignment) {
if (!arena) {
return NULL;
}
BaseArena *base_arena = find_arena_from_pointer(arena, ptr);
if (!base_arena) {
return NULL;
}
ArenaAllocHDR *header = find_alloc_header(base_arena, ptr);
if (!header) {
return NULL;
}
if (header->alloc_start + header->alloc_size == base_arena->offset) {
// Avoid allocating new pointer and copying memory if pointer is at the end
// of the arena
i64 diff = size - header->alloc_size;
u8 *new_offset = base_arena->offset + diff;
u8 *clear_start = diff < 0 ? new_offset : base_arena->offset;
memset(clear_start, 0, llabs(diff));
header->alloc_size = size;
base_arena->offset = new_offset;
return header->alloc_start;
}
void *new_alloc = wapp_mem_arena_alloc_aligned(arena, size, alignment);
if (!new_alloc) {
return NULL;
}
u64 to_copy = size < header->alloc_size ? size : header->alloc_size;
memcpy(new_alloc, ptr, to_copy);
return new_alloc;
}
void wapp_mem_arena_clear(Arena *arena) {
if (!arena) {
return;
@ -235,30 +171,6 @@ void wapp_mem_arena_destroy(Arena **arena) {
// INTERNAL FUNCTIONS
internal BaseArena *find_arena_from_pointer(const Arena *arena, void *ptr) {
if (!arena || !ptr) {
return NULL;
}
// Ensure pointer is not out of bounds
u8 *alloc = (u8 *)ptr;
BaseArena *active = arena->active_arena;
if (alloc > active->buf + arena->initial_capacity) {
return NULL;
}
for (u64 i = 0; i < arena->count; ++i) {
if (alloc >= active->buf && alloc < active->buf + arena->initial_capacity) {
return (BaseArena *)active;
}
active = active->prev;
}
return NULL;
}
internal bool base_arena_init(BaseArena *arena, u64 capacity) {
if (!arena || arena->buf || capacity == 0) {
return false;
@ -285,22 +197,13 @@ internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
return NULL;
}
u8 *start_offset = arena->offset;
u8 *alloc_start = arena->offset + sizeof(ArenaAllocHDR);
u8 *alloc_start = arena->offset;
u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
if (output + size >= arena->buf + arena->capacity) {
return NULL;
}
ArenaAllocHDR *header = (ArenaAllocHDR *)start_offset;
*header = (ArenaAllocHDR){
.magic = HDR_MAGIC,
.alloc_size = size,
.alignment = alignment,
.alloc_start = output,
};
arena->offset = output + size;
return (void *)output;
@ -328,33 +231,3 @@ internal void base_arena_destroy(BaseArena *arena) {
arena->capacity = 0;
arena->prev = arena->next = NULL;
}
internal ArenaAllocHDR *find_alloc_header(BaseArena *arena, void *alloc_ptr) {
persistent const u8 magic[HDR_MAGIC_BYTE_COUNT] = HDR_MAGIC;
u8 *current = (u8 *)alloc_ptr;
u8 *max_search_end = current - MAX_HDR_SEARCH_LENGTH;
u8 *arena_buf_start = arena->buf;
u8 *search_end =
max_search_end > arena_buf_start ? max_search_end : arena_buf_start;
bool match;
for (; current >= search_end; --current) {
match = true;
for (u64 i = 0; i < HDR_MAGIC_BYTE_COUNT; ++i) {
if (current[i] != magic[i]) {
match = false;
break;
}
}
if (match) {
return (ArenaAllocHDR *)current;
}
}
return NULL;
}