linear.c

Go to the documentation of this file.

 
#include <kiba/allocators/linear.h>
 
#include <kiba/core/log.h>
#include <kiba/core/memory.h>
 
typedef struct linear_allocator_block {
    usize                          size;
    usize                          cur_offset;
    struct linear_allocator_block *next;
    void                          *data;
} linear_allocator_block;
 
linear_allocator_block *linear_allocator_block_create(usize size, linear_allocator_block *next);
 
linear_allocator_block *linear_allocator_block_create(usize size, linear_allocator_block *next) {
    linear_allocator_block *block = memory_page_allocate(sizeof(linear_allocator_block) + size, &size);
    if (block == KB_NULL) {
        KB_ERROR("could not allocate {usize} bytes for the linear_allocator_block", size);
        return KB_NULL;
    }
    block->size       = size;
    block->cur_offset = 0;
    block->next       = next;
    block->data       = block + 1;
    KB_TRACE("created linear_allocator_block with size {usize}", size);
    return block;
}
 
/* Linear allocator */
 
b8 linear_allocator_create(allocator *alloc, usize size) {
    linear_allocator_block *block = linear_allocator_block_create(size, KB_NULL);
    if (block == KB_NULL) {
        KB_ERROR("could not allocate memory for initial linear_allocator_block");
        return false;
    }
    allocator_implementation(alloc,
                             linear_allocator_destroy,
                             linear_allocator_allocate,
                             linear_allocator_free,
                             linear_allocator_free_all);
    alloc->state = block;
    KB_TRACE("created linear_allocator with initial size {usize}", size);
    return true;
}
 
void linear_allocator_destroy(allocator *alloc) {
    linear_allocator_block *block      = alloc->state;
    linear_allocator_block *prev_block = KB_NULL;
    while (block != KB_NULL) {
        prev_block = block;
        block      = block->next;
        KB_TRACE("destroying linear_allocator_block with size {usize}", prev_block->size);
        memory_page_free(prev_block);
    }
    KB_TRACE("destroyed linear_allocator");
}
 
void *linear_allocator_allocate(allocator *alloc, usize size) {
    linear_allocator_block *block         = alloc->state;
    linear_allocator_block *fitting_block = KB_NULL;
    linear_allocator_block *prev_block    = KB_NULL;
    while (block != KB_NULL) {
        if (size <= block->size - block->cur_offset) {
            fitting_block = block;
            break;
        } else {
            prev_block = block;
            block      = block->next;
        }
    }
    if (fitting_block == KB_NULL) {
        KB_TRACE("did not find fitting block, creating new one");
        usize new_size = prev_block->size;
        if (size > new_size) {
            KB_DEBUG(
                "new block size {usize} is not enough for requested allocation of {usize} bytes, using the requested "
                "size as new block size",
                new_size,
                size);
            new_size = size;
        }
        fitting_block = linear_allocator_block_create(new_size, alloc->state);
        if (fitting_block == KB_NULL) {
            KB_ERROR("could not allocate memory for linear_allocator_block");
            return KB_NULL;
        }
        alloc->state = fitting_block;  // fresh block is the first in the list
    }
    void *ret = (u8 *) fitting_block->data + fitting_block->cur_offset;
    fitting_block->cur_offset += size;
    return ret;
}
 
void linear_allocator_free(allocator *alloc, void *mem, usize size) {
    UNUSED(size);
    UNUSED(alloc);
    UNUSED(mem);
    KB_INFO("linear_allocator is not able to free individual allocations");
}
 
void linear_allocator_free_all(allocator *alloc) {
    linear_allocator_block *block = alloc->state;
    while (block) {
        block->cur_offset = 0;
        block             = block->next;
    }
    KB_TRACE("reset linear_allocator");
}