allocator.c

Go to the documentation of this file.

 
#include <kiba/allocators/allocator.h>
 
#include <kiba/allocators/free_list.h>
#include <kiba/allocators/linear.h>
#include <kiba/allocators/system.h>
#include <kiba/core/log.h>
#include <kiba/core/memory.h>
 
usize allocator_managed_block_required_size(usize size, usize alignment);
void *allocator_managed_block_create(void *allocated, usize size, usize alignment);
void *allocator_managed_block_extract(const void *block, usize *size, usize *alignment, usize *offset);
 
b8 allocator_create(allocator *alloc, allocator_type type, usize size) {
    switch (type) {
        case ALLOCATOR_LINEAR:
            return allocator_create_custom(alloc, linear_allocator_create, size);
        case ALLOCATOR_FREE_LIST:
            return allocator_create_custom(alloc, free_list_allocator_create, size);
        case ALLOCATOR_SYSTEM:
            return allocator_create_custom(alloc, system_allocator_create, size);
    }
    KB_ERROR("no valid core allocator type selected: {i32}", type);
    return false;
}
 
b8 allocator_create_custom(allocator *alloc, allocator_impl_create_fn create_fn, usize size) {
    KB_ASSERT(alloc != KB_NULL, "allocator pointer must be valid");
    return create_fn(alloc, size);
}
 
void allocator_destroy(allocator *alloc) {
    KB_ASSERT(alloc != KB_NULL && alloc->state != KB_NULL && alloc->impl.destroy != KB_NULL,
              "allocator must have initialized state");
    alloc->impl.destroy(alloc);
    allocator_implementation(alloc, KB_NULL, KB_NULL, KB_NULL, KB_NULL);
    memory_zero(alloc, sizeof(allocator));
}
 
void *allocator_allocate(allocator *alloc, usize size) { return allocator_allocate_aligned(alloc, size, 1); }
 
void *allocator_allocate_aligned(allocator *alloc, usize size, usize alignment) {
    KB_ASSERT(alloc != KB_NULL && alloc->state != KB_NULL && alloc->impl.allocate != KB_NULL,
              "allocator must have initialized state");
    KB_ASSERT(size != 0, "size to allocate must not be 0");
    KB_ASSERT(alignment != 0, "alignment for allocation must not be 0");  // TODO maybe also verify power of 2
    usize actual_size = allocator_managed_block_required_size(size, alignment);
    void *block       = alloc->impl.allocate(alloc, actual_size);
    if (block != KB_NULL) {
        block = allocator_managed_block_create(block, size, alignment);
    }
    return block;
}
 
void *allocator_reallocate(allocator *alloc, void *original, usize new_size) {
    return allocator_reallocate_aligned(alloc, original, new_size, 0);
}
 
void *allocator_reallocate_aligned(allocator *alloc, void *original, usize new_size, usize alignment) {
    KB_ASSERT(
        alloc != KB_NULL && alloc->state != KB_NULL && alloc->impl.allocate != KB_NULL && alloc->impl.free != KB_NULL,
        "allocator must have initialized state");
    KB_ASSERT(original != KB_NULL, "original pointer for reallocate must not be nullptr");
    KB_ASSERT(new_size != 0, "new size for reallocation must not be 0");
    usize original_size, original_alignment, original_offset;
    void *actual_original =
        allocator_managed_block_extract(original, &original_size, &original_alignment, &original_offset);
    if (!alignment) {
        alignment = original_alignment;  // ensure new block retains original alignment
    }
 
    usize actual_new_size = allocator_managed_block_required_size(new_size, alignment);
    void *new_block       = alloc->impl.allocate(alloc, actual_new_size);
    if (new_block != KB_NULL) {
        new_block = allocator_managed_block_create(new_block, new_size, alignment);
        memory_copy(new_block, original, KB_MIN(new_size, original_size - original_offset));
        alloc->impl.free(alloc, actual_original, original_size);
    }
    return new_block;
}
 
void allocator_free(allocator *alloc, void *mem) {
    KB_ASSERT(alloc != KB_NULL && alloc->state != KB_NULL && alloc->impl.free != KB_NULL,
              "allocator must have initialized state");
    KB_ASSERT(mem != KB_NULL, "memory to free must not be nullptr");
    usize size, alignment, offset;
    void *actual_mem = allocator_managed_block_extract(mem, &size, &alignment, &offset);
    alloc->impl.free(alloc, actual_mem, size);
}
 
void allocator_free_all(allocator *alloc) {
    KB_ASSERT(alloc != KB_NULL && alloc->state != KB_NULL && alloc->impl.free_all != KB_NULL,
              "allocator must have initialized state");
    alloc->impl.free_all(alloc);
}
 
void allocator_implementation(allocator                 *alloc,
                              allocator_impl_destroy_fn  destroy,
                              allocator_impl_allocate_fn allocate,
                              allocator_impl_free_fn     free,
                              allocator_impl_free_all_fn free_all) {
    KB_ASSERT(alloc != KB_NULL, "allocator pointer must be valid");
    alloc->impl.destroy  = destroy;
    alloc->impl.allocate = allocate;
    alloc->impl.free     = free;
    alloc->impl.free_all = free_all;
}
 
#define KB_ALLOCATOR_MANAGED_BLOCK_SIZE (3 * sizeof(usize))
 
usize allocator_managed_block_required_size(usize size, usize alignment) {
    KB_ASSERT_DEBUG(size != 0, "size of managed block must not be 0");
    KB_ASSERT_DEBUG(alignment != 0, "alignment of managed block must not be 0");
    return size + KB_ALLOCATOR_MANAGED_BLOCK_SIZE + alignment - 1;
}
 
void *allocator_managed_block_create(void *allocated, usize size, usize alignment) {
    KB_ASSERT_DEBUG(allocated != KB_NULL, "pointer to block to manage must be valid");
    void  *new_addr = memory_aligned_address((u8 *) allocated + KB_ALLOCATOR_MANAGED_BLOCK_SIZE, alignment);
    usize *header   = new_addr;
    header[-1]      = allocator_managed_block_required_size(size, alignment);
    header[-2]      = alignment;
    header[-3]      = (uptr) new_addr - (uptr) allocated;
    return new_addr;
}
 
void *allocator_managed_block_extract(const void *block, usize *size, usize *alignment, usize *offset) {
    KB_ASSERT_DEBUG(block != KB_NULL, "pointer to user part of managed block must be valid");
    const usize *data = block;
    *size             = data[-1];
    *alignment        = data[-2];
    *offset           = data[-3];
    return (u8 *) block - *offset;
}
 
#undef KB_ALLOCATOR_MANAGED_BLOCK_SIZE