arena_template.h

Go to the documentation of this file.

// Copyright (c) 2026 abxh
// SPDX-License-Identifier: MIT
 
/*  arena_template.h
 *
 *  Copyright (C) 2023 abxh
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *  See the file LICENSE included with this distribution for more
 *  information. */



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

#ifndef FUNCTION_LINKAGE
#define FUNCTION_LINKAGE
#endif

#ifndef IS_POW2
#define IS_POW2(X) ((X) != 0 && ((X) & ((X) - 1)) == 0)
#endif
 
// }}}
 
// type definitions: {{{
 
struct arena;
struct arena_state;

#ifdef TYPE_DEFINITIONS

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

struct arena_state {
    struct arena *arena_ptr; 
    size_t prev_offset;      
    size_t curr_offset;      
};
 
#endif
 
// }}}
 
// function declarations: {{{

FUNCTION_LINKAGE struct arena_state arena_state_save(struct arena *arena_ptr);

FUNCTION_LINKAGE void arena_state_restore(struct arena_state prev_state);

FUNCTION_LINKAGE void arena_init(void *self_, const size_t len, unsigned char *backing_buf);

FUNCTION_LINKAGE void arena_deallocate_all(void *self_);

FUNCTION_LINKAGE void arena_deallocate(void *self_, void *mem);

FUNCTION_LINKAGE void *arena_allocate_aligned(void *self_, const size_t alignment, const size_t size);

FUNCTION_LINKAGE void *arena_allocate(void *self_, const size_t size);

FUNCTION_LINKAGE void *arena_reallocate_aligned(void *self_, void *old_ptr_, const size_t alignment,
                                                const size_t old_size, const size_t new_size);

FUNCTION_LINKAGE void *arena_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 struct arena_state arena_state_save(struct arena *arena_ptr)
{
    struct arena_state 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 arena_state_restore(struct arena_state 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 arena_init(void *self_, const size_t len, unsigned char *backing_buf)
{
    assert(self_);
    assert(backing_buf);
 
    struct arena *self = (struct arena *)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 arena_deallocate_all(void *self_)
{
    assert(self_);
 
    struct arena *self = (struct arena *)self_;
 
    self->curr_offset = 0;
    self->prev_offset = 0;
}
 
FUNCTION_LINKAGE void arena_deallocate(void *self_, void *mem)
{
    assert(self_);
 
    (void)self_;
    (void)mem;
}
 
FUNCTION_LINKAGE void *arena_allocate_aligned(void *self_, const size_t alignment, const size_t size)
{
    assert(self_);
 
    struct arena *self = (struct arena *)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 *arena_allocate(void *self_, const size_t size)
{
    assert(self_);
 
    return arena_allocate_aligned(self_, alignof(max_align_t), size);
}

static inline void *internal_arena_try_optimizing_w_prev_offset(struct arena *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 *arena_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));
 
    struct arena *self = (struct arena *)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 =
        internal_arena_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 = arena_allocate_aligned(self, alignment, new_size);
 
    memmove(new_mem, old_ptr, copy_size);
 
    return new_mem;
}
 
FUNCTION_LINKAGE void *arena_reallocate(void *self_, void *old_ptr, const size_t old_size, const size_t new_size)
{
    assert(self_);
 
    return arena_reallocate_aligned(self_, old_ptr, alignof(max_align_t), old_size, new_size);
}
 
#endif
 
// }}}
 
// macro undefs: {{{
 
#undef FUNCTION_LINKAGE
#undef FUNCTION_DEFINITIONS
#undef TYPE_DEFINITIONS
 
// }}}
 
#ifdef __cplusplus
}
#endif
 
// vim: ft=c fdm=marker