mem_allocator.h

Go to the documentation of this file.

 
#ifndef MEM_ALLOCATOR_H
#define MEM_ALLOCATOR_H
 
#include "base/base_macros.h"
#include "base/base_types.h"
#include "memory/mem_arena.h"
 
C_LINKAGE_BEGIN


typedef void *(*AllocFn)(void *ctx, usize size);

typedef void (*FreeFn)(void *ctx, void *ptr, usize size);

typedef void *(*ReallocFn)(void *ctx, void *ptr, usize old_size, usize new_size);

typedef struct Allocator {
    void     *ctx;     
    AllocFn   alloc;   
    FreeFn    free;    
    ReallocFn realloc; 
} Allocator;
 
// Dispatch helpers

function inline void *
allocator_alloc(Allocator *a, usize size)
{
    ASSERT(a != NULL && a->alloc != NULL && "allocator_alloc: invalid allocator");
    return a->alloc(a->ctx, size);
}

function inline void
allocator_free(Allocator *a, void *ptr, usize size)
{
    ASSERT(a != NULL && "allocator_free: invalid allocator");
    if (a->free != NULL) {
        a->free(a->ctx, ptr, size);
    }
}

function inline void *
allocator_realloc(Allocator *a, void *ptr, usize old_size, usize new_size)
{
    ASSERT(a != NULL && a->alloc != NULL && "allocator_realloc: invalid allocator");
    if (a->realloc != NULL) {
        return a->realloc(a->ctx, ptr, old_size, new_size);
    }
    // Fallback: fresh alloc + copy.
    void *new_ptr = a->alloc(a->ctx, new_size);
    if (new_ptr != NULL && ptr != NULL) {
        MEM_COPY(new_ptr, ptr, MIN(old_size, new_size));
    }
    allocator_free(a, ptr, old_size);
    return new_ptr;
}
 
// Arena Allocator Factory

function inline void *
_arena_alloc_fn(void *ctx, usize size)
{
    return arena_push_zero((Arena *)ctx, size);
}
 
function inline void
_arena_free_fn(void *ctx, void *ptr, usize size)
{
    (void)ctx;
    (void)ptr;
    (void)size;
}
 
function inline void *
_arena_realloc_fn(void *ctx, void *ptr, usize old_size, usize new_size)
{
    void *new_ptr = arena_push_zero((Arena *)ctx, new_size);
    if (new_ptr != NULL && ptr != NULL) {
        MEM_COPY(new_ptr, ptr, MIN(old_size, new_size));
    }
    return new_ptr;
}

function inline Allocator
arena_allocator(Arena *arena)
{
    Allocator a;
    a.ctx     = (void *)arena;
    a.alloc   = _arena_alloc_fn;
    a.free    = _arena_free_fn;
    a.realloc = _arena_realloc_fn;
    return a;
}
 // end allocator_interface
 
C_LINKAGE_END
 
#endif // MEM_ALLOCATOR_H