arena.h

 
#ifndef ARENA_H
#define ARENA_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#ifdef _MSC_VER
#include <intrin.h>
#define ARENA_INLINE         __forceinline
#define ARENA_PREFETCH(addr) _mm_prefetch((const char*)(addr), _MM_HINT_T0)
#define ARENA_LIKELY(x)      (x)
#define ARENA_UNLIKELY(x)    (x)
#define ARENA_ALIGNED(n)     __declspec(align(n))
#else
#define ARENA_INLINE         inline __attribute__((always_inline))
#define ARENA_PREFETCH(addr) __builtin_prefetch((addr), 1, 3)
#define ARENA_LIKELY(x)      __builtin_expect(!!(x), 1)
#define ARENA_UNLIKELY(x)    __builtin_expect(!!(x), 0)
#define ARENA_ALIGNED(n)     __attribute__((aligned(n)))
#endif
 
#define ARENA_DEFAULT_ALIGN 16
 
#define ARENA_MIN_BLOCK_SIZE (64 * 1024)
 
typedef struct ArenaBlock {
    struct ArenaBlock* next;
    char* base; 
    char* end;  
    bool is_static;
} ArenaBlock;
 
typedef struct ARENA_ALIGNED(64) Arena {
    char* curr;                
    char* end;                 
    ArenaBlock* current_block; 
    ArenaBlock* head;          
    size_t page_size;          
    size_t total_committed;
    bool heap_allocated;    
    ArenaBlock first_block; 
} Arena;
 
void arena_init(Arena* restrict a, void* restrict buf, size_t size);
 
Arena* arena_create(size_t reserve_size);
 
static ARENA_INLINE void arena_reset(Arena* restrict a) {
    if (!a || !a->head) return;
    a->current_block = a->head;
    a->curr = a->head->base;
    a->end = a->head->end;
}
 
void arena_destroy(Arena* restrict arena);
 
static ARENA_INLINE size_t arena_committed_size(const Arena* restrict a) { return a->total_committed; }
 
static ARENA_INLINE size_t arena_used_size(const Arena* restrict a) {
    if (!a || !a->current_block) return 0;
    size_t block_capacity = (size_t)(a->current_block->end - a->current_block->base);
    size_t block_used = (size_t)(a->curr - a->current_block->base);
    return (a->total_committed - block_capacity) + block_used;
}
 
void* _arena_alloc_slow(Arena* restrict arena, size_t size, size_t alignment);
 
static ARENA_INLINE void* arena_alloc_align(Arena* restrict arena, size_t size, size_t alignment) {
    if (size == 0) return NULL;
 
    uintptr_t aligned = ((uintptr_t)arena->curr + alignment - 1) & ~(alignment - 1);
    uintptr_t next = aligned + size;
 
    if (ARENA_LIKELY(next <= (uintptr_t)arena->end)) {
        arena->curr = (char*)next;
        return (void*)aligned;
    }
 
    return _arena_alloc_slow(arena, size, alignment);
}
 
static ARENA_INLINE void* arena_alloc(Arena* restrict arena, size_t size) {
    return arena_alloc_align(arena, size, ARENA_DEFAULT_ALIGN);
}
 
static ARENA_INLINE void* arena_alloc_unaligned(Arena* restrict arena, size_t size) {
    if (size == 0) return NULL;
 
    char* ptr = arena->curr;
    char* next = ptr + size;
 
    if (ARENA_LIKELY(next <= arena->end)) {
        arena->curr = next;
        return ptr;
    }
 
    return _arena_alloc_slow(arena, size, 1);
}
 
#define ARENA_ALLOC(arena, type) ((type*)arena_alloc_align((arena), sizeof(type), _Alignof(type)))
 
#define ARENA_ALLOC_ARRAY(arena, type, count) \
    ((type*)arena_alloc_align((arena), sizeof(type) * (count), _Alignof(type)))
 
#define ARENA_ALLOC_ZERO(arena, type)                         \
    ({                                                        \
        type* _ptr = ARENA_ALLOC((arena), type);              \
        (_ptr) ? (type*)memset(_ptr, 0, sizeof(type)) : NULL; \
    })
 
#define ARENA_ALLOC_ARRAY_ZERO(arena, type, count)                      \
    ({                                                                  \
        type* _ptr = ARENA_ALLOC_ARRAY((arena), type, (count));         \
        (_ptr) ? (type*)memset(_ptr, 0, sizeof(type) * (count)) : NULL; \
    })
 
static ARENA_INLINE bool arena_alloc_batch(Arena* restrict arena, const size_t* restrict sizes, size_t count,
                                           void** restrict out_ptrs) {
    if (!arena || !sizes || !out_ptrs || count == 0) return false;
 
    const size_t mask = ARENA_DEFAULT_ALIGN - 1;
    size_t total = 0;
    for (size_t i = 0; i < count; ++i) {
        total = (total + mask) & ~mask;
        total += sizes[i];
    }
 
    char* base = (char*)arena_alloc(arena, total);
    if (!base) return false;
 
    char* cur = base;
    for (size_t i = 0; i < count; ++i) {
        cur = (char*)(((uintptr_t)cur + mask) & ~mask);
        out_ptrs[i] = cur;
        cur += sizes[i];
    }
 
    return true;
}
 
static ARENA_INLINE char* arena_strdup(Arena* restrict arena, const char* restrict str) {
    if (!arena || !str) return NULL;
    size_t len = strlen(str);
    char* dup = (char*)arena_alloc_unaligned(arena, len + 1);
    if (!dup) return NULL;
    memcpy(dup, str, len + 1);
    return dup;
}
 
static ARENA_INLINE char* arena_strdupn(Arena* restrict arena, const char* restrict str, size_t length) {
    if (!arena || !str) return NULL;
    char* dup = (char*)arena_alloc_unaligned(arena, length + 1);
    if (!dup) return NULL;
    memcpy(dup, str, length);
    dup[length] = '\0';
    return dup;
}
 
#if defined(__cplusplus)
}
#endif
 
#endif  // ARENA_H