arena_template.h

Go to the documentation of this file.

// Copyright (c) 2026 abxh
// SPDX-License-Identifier: MIT



 
#ifdef __cplusplus
#ifdef __GNUC__
#define restrict __restrict__
#else
#define restrict
#endif
extern "C" {
#endif
 
#include <stddef.h>
 
// macro definitions: {{{

#ifndef PASTE
#define PASTE(a, b) a##b
#endif

#ifndef XPASTE
#define XPASTE(a, b) PASTE(a, b)
#endif

#ifndef JOIN
#define JOIN(a, b) XPASTE(a, XPASTE(_, b))
#endif

#ifndef IS_POW2
#define IS_POW2(X) ((X) != 0 && ((X) & ((X) - 1)) == 0)
#endif

#ifndef NAME
#error "Must define NAME."
#define FUNCTION_DEFINITIONS
#define TYPE_DEFINITIONS
#else
#define ARENA_NAME NAME
#endif

#ifndef FUNCTION_LINKAGE
#define FUNCTION_LINKAGE
#endif

#define ARENA_TYPE       struct ARENA_NAME
#define ARENA_STATE_TYPE struct JOIN(ARENA_NAME, state)
 
// }}}
 
// type definitions: {{{
 
struct ARENA_NAME;
struct JOIN(ARENA_NAME, state);

#ifdef TYPE_DEFINITIONS

struct ARENA_NAME {
    size_t buf_len;         
    size_t prev_offset;     
    size_t curr_offset;     
    unsigned char *buf_ptr; 
};

struct JOIN(ARENA_NAME, state) {
    ARENA_TYPE *arena_ptr; 
    size_t prev_offset;    
    size_t curr_offset;    
};
 
#endif
 
// }}}
 
// function declarations: {{{

FUNCTION_LINKAGE ARENA_STATE_TYPE JOIN(ARENA_NAME, state_save)(ARENA_TYPE *arena_ptr);

FUNCTION_LINKAGE void JOIN(ARENA_NAME, state_restore)(ARENA_STATE_TYPE prev_state);

FUNCTION_LINKAGE void JOIN(ARENA_NAME, init)(void *self_, const size_t len, unsigned char *backing_buf);

FUNCTION_LINKAGE void JOIN(ARENA_NAME, deallocate_all)(void *self_);

FUNCTION_LINKAGE void JOIN(ARENA_NAME, deallocate)(void *self_, void *mem);

FUNCTION_LINKAGE void *JOIN(ARENA_NAME, allocate_aligned)(void *self_, const size_t alignment, const size_t size);

FUNCTION_LINKAGE void *JOIN(ARENA_NAME, allocate)(void *self_, const size_t size);

FUNCTION_LINKAGE void *JOIN(ARENA_NAME, reallocate_aligned)(void *self_, void *old_ptr_, const size_t alignment,
                                                            const size_t old_size, const size_t new_size);

FUNCTION_LINKAGE void *JOIN(ARENA_NAME, reallocate)(void *self_, void *old_ptr, const size_t old_size,
                                                    const size_t new_size);
 
// }}}
 
// function definitions: {{{

#ifdef FUNCTION_DEFINITIONS
 
#include "align.h" // align, calc_alignment_padding
 
#include <assert.h>
#include <stdalign.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
FUNCTION_LINKAGE ARENA_STATE_TYPE JOIN(ARENA_NAME, state_save)(ARENA_TYPE *arena_ptr)
{
    ARENA_STATE_TYPE curr_state;
    curr_state.arena_ptr = arena_ptr;
    curr_state.prev_offset = arena_ptr->prev_offset;
    curr_state.curr_offset = arena_ptr->curr_offset;
    return curr_state;
}
 
FUNCTION_LINKAGE void JOIN(ARENA_NAME, state_restore)(ARENA_STATE_TYPE prev_state)
{
    prev_state.arena_ptr->prev_offset = prev_state.prev_offset;
    prev_state.arena_ptr->curr_offset = prev_state.curr_offset;
}
 
FUNCTION_LINKAGE void JOIN(ARENA_NAME, init)(void *self_, const size_t len, unsigned char *backing_buf)
{
    assert(self_);
    assert(backing_buf);
 
    ARENA_TYPE *self = (ARENA_TYPE *)self_;
 
    const uintptr_t padding = calc_alignment_padding(alignof(max_align_t), (uintptr_t)backing_buf);
 
    assert(len >= padding);
 
    self->buf_ptr = &backing_buf[padding];
    self->buf_len = len - padding;
    self->curr_offset = 0;
    self->prev_offset = 0;
}
 
FUNCTION_LINKAGE void JOIN(ARENA_NAME, deallocate_all)(void *self_)
{
    assert(self_);
 
    ARENA_TYPE *self = (ARENA_TYPE *)self_;
 
    self->curr_offset = 0;
    self->prev_offset = 0;
}
 
FUNCTION_LINKAGE void JOIN(ARENA_NAME, deallocate)(void *self_, void *mem)
{
    assert(self_);
 
    (void)self_;
    (void)mem;
}
 
FUNCTION_LINKAGE void *JOIN(ARENA_NAME, allocate_aligned)(void *self_, const size_t alignment, const size_t size)
{
    assert(self_);
 
    ARENA_TYPE *self = (ARENA_TYPE *)self_;
 
    void *ptr = (void *)&self->buf_ptr[self->curr_offset];
 
    size_t space_left = self->buf_len - (size_t)self->curr_offset;
 
    const bool has_space_left = align(alignment, size, &ptr, &space_left);
    if (!has_space_left) {
        return NULL;
    }
 
    const uintptr_t relative_offset = (uintptr_t)((unsigned char *)ptr - &self->buf_ptr[0]);
 
    self->prev_offset = relative_offset;
    self->curr_offset = relative_offset + size;
 
    memset(ptr, 0, size);
 
    return ptr;
}
 
FUNCTION_LINKAGE void *JOIN(ARENA_NAME, allocate)(void *self_, const size_t size)
{
    assert(self_);
 
    return JOIN(ARENA_NAME, allocate_aligned)(self_, alignof(max_align_t), size);
}

static inline void *JOIN(JOIN(internal, ARENA_NAME),
                         try_optimizing_w_prev_offset)(ARENA_TYPE *self, unsigned char *old_ptr, const size_t old_size,
                                                       const size_t new_size)
{
    if (&self->buf_ptr[self->prev_offset] != old_ptr) {
        return NULL;
    }
 
    self->curr_offset = self->prev_offset + new_size;
 
    if (new_size > old_size) {
        const size_t diff = new_size - old_size;
 
        memset(&self->buf_ptr[self->curr_offset], 0, diff);
    }
 
    return old_ptr;
}
 
FUNCTION_LINKAGE void *JOIN(ARENA_NAME, reallocate_aligned)(void *self_, void *old_ptr_, const size_t alignment,
                                                            const size_t old_size, const size_t new_size)
{
    assert(self_);
    assert(IS_POW2(alignment));
 
    ARENA_TYPE *self = (ARENA_TYPE *)self_;
    unsigned char *old_ptr = (unsigned char *)old_ptr_;
 
    const bool misc_input = old_ptr == NULL || old_size == 0 || new_size == 0;
    const bool inside_arena_buf = &self->buf_ptr[0] <= old_ptr && old_ptr <= &self->buf_ptr[self->buf_len - 1];
    if (misc_input || !inside_arena_buf) {
        return NULL;
    }
 
    const bool has_optimized_w_prev_buf =
        JOIN(JOIN(internal, ARENA_NAME), try_optimizing_w_prev_offset)(self, old_ptr, old_size, new_size);
    if (has_optimized_w_prev_buf) {
        return old_ptr;
    }
 
    const size_t copy_size = old_size < new_size ? old_size : new_size;
 
    void *new_mem = JOIN(ARENA_NAME, allocate_aligned)(self, alignment, new_size);
 
    memmove(new_mem, old_ptr, copy_size);
 
    return new_mem;
}
 
FUNCTION_LINKAGE void *JOIN(ARENA_NAME, reallocate)(void *self_, void *old_ptr, const size_t old_size,
                                                    const size_t new_size)
{
    assert(self_);
 
    return JOIN(ARENA_NAME, reallocate_aligned)(self_, old_ptr, alignof(max_align_t), old_size, new_size);
}
 
#endif
 
// }}}
 
// macro undefs: {{{
 
#undef NAME
#undef FUNCTION_LINKAGE
#undef FUNCTION_DEFINITIONS
#undef TYPE_DEFINITIONS
 
#undef ARENA_NAME
#undef ARENA_TYPE
#undef ARENA_STATE_TYPE
 
// }}}
 
#ifdef __cplusplus
}
#endif
 
// vim: ft=c fdm=marker