arena.c

Go to the documentation of this file.

 
#include "common/infix_internals.h"
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
INFIX_API c23_nodiscard infix_arena_t * infix_arena_create(size_t initial_size) {
    // Use calloc to ensure the initial struct state is zeroed.
    infix_arena_t * arena = infix_calloc(1, sizeof(infix_arena_t));
    if (arena == nullptr) {
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return nullptr;
    }
    arena->buffer = infix_calloc(1, initial_size);
    if (arena->buffer == nullptr && initial_size > 0) {
        infix_free(arena);
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return nullptr;
    }
    arena->capacity = initial_size;
    arena->current_offset = 0;
    arena->error = false;
    arena->next_block = nullptr;
    arena->block_size = initial_size;
    return arena;
}
INFIX_API void infix_arena_destroy(infix_arena_t * arena) {
    if (arena == nullptr)
        return;
    // Traverse the chain of blocks and free each one.
    infix_arena_t * current = arena;
    while (current != nullptr) {
        infix_arena_t * next = current->next_block;
        if (current->buffer)
            infix_free(current->buffer);
        infix_free(current);
        current = next;
    }
}
INFIX_API c23_nodiscard void * infix_arena_alloc(infix_arena_t * arena, size_t size, size_t alignment) {
    if (arena == nullptr)
        return nullptr;
 
    // Ensure alignment is power of 2
    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
        arena->error = true;
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_INVALID_ALIGNMENT, 0);
        return nullptr;
    }
 
    infix_arena_t * block = arena;
    while (true) {
        if (block->error)
            return nullptr;
 
        // Calculate current absolute address
        uintptr_t current_ptr = (uintptr_t)(block->buffer + block->current_offset);
 
        // Calculate aligned address
        // (x + align - 1) & ~(align - 1)
        uintptr_t aligned_ptr = (current_ptr + (alignment - 1)) & ~(alignment - 1);
 
        // Calculate padding needed
        size_t padding = (size_t)(aligned_ptr - current_ptr);
 
        // Calculate total space required in this block
        size_t total_needed = size + padding;
 
        // Check if fits in current block
        if (block->current_offset + total_needed <= block->capacity) {
            void * ret = (void *)aligned_ptr;
            block->current_offset += total_needed;
            return ret;
        }
 
        // Allocation failed in current block. Check next or create new.
        if (block->next_block) {
            block = block->next_block;
            continue;
        }
 
        // Create new block. Ensure it's large enough for alignment + size.
        size_t next_cap = block->block_size * 2;
        if (next_cap < size + alignment)
            next_cap = size + alignment;
 
        block->next_block = infix_arena_create(next_cap);
        if (!block->next_block) {
            block->error = true;
            return nullptr;
        }
 
        block = block->next_block;
    }
}
INFIX_API c23_nodiscard void * infix_arena_calloc(infix_arena_t * arena, size_t num, size_t size, size_t alignment) {
    // Security: Check for multiplication overflow.
    if (size > 0 && num > SIZE_MAX / size) {
        if (arena)
            arena->error = true;
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_INTEGER_OVERFLOW, 0);
        return nullptr;
    }
    size_t total_size = num * size;
    void * ptr = infix_arena_alloc(arena, total_size, alignment);
    if (ptr != nullptr)
        memset(ptr, 0, total_size);
    return ptr;
}
 
INFIX_API c23_nodiscard infix_arena_mark_t infix_arena_get_mark(infix_arena_t * arena) {
    infix_arena_mark_t mark = {nullptr, 0};
    if (arena == nullptr)
        return mark;
 
    infix_arena_t * current = arena;
    while (current->next_block != nullptr && current->next_block->current_offset > 0)
        current = current->next_block;
    mark.block = current;
    mark.offset = current->current_offset;
    return mark;
}
 
INFIX_API void infix_arena_rewind(infix_arena_t * arena, infix_arena_mark_t mark) {
    if (arena == nullptr || mark.block == nullptr)
        return;
 
    // Reset offset in the marked block
    mark.block->current_offset = mark.offset;
    mark.block->error = false;
 
    // Reset offsets in all subsequent blocks so they can be reused
    infix_arena_t * current = mark.block->next_block;
    while (current != nullptr) {
        current->current_offset = 0;
        current->error = false;
        current = current->next_block;
    }
}