memory.c

Go to the documentation of this file.

 
#include <kiba/core/memory.h>
 
#include <kiba/platform/memory.h>
 
#include <kiba/core/log.h>
 
typedef struct memory_page {
    usize               size_class;
    struct memory_page *next;
} memory_page;
 
#define KB_PAGE_SIZE             KB_MEGABYTE(8)
#define KB_MEMORY_MAX_SIZE_CLASS 4
 
memory_page *page_free_list[KB_MEMORY_MAX_SIZE_CLASS + 1] = {0};  // could be threadlocal in the future
 
static inline usize memory_page_size_class(usize num_bytes) {
    usize target = num_bytes + sizeof(memory_page);
    return target / KB_PAGE_SIZE + 1;
}
 
b8 memory_initialize(void) { return true; }
 
void *memory_page_allocate(usize target_num_bytes, usize *res_num_bytes) {
    memory_page *res        = KB_NULL;
    usize        size_class = memory_page_size_class(target_num_bytes);
    if (size_class <= KB_MEMORY_MAX_SIZE_CLASS && page_free_list[size_class]) {
        res                        = page_free_list[size_class];
        page_free_list[size_class] = res->next;
        res->next                  = KB_NULL;
    } else {
        res             = platform_memory_allocate(size_class * KB_PAGE_SIZE);
        if (res == KB_NULL) {
            return res;
        }
        res->next       = KB_NULL;
        res->size_class = size_class;
    }
    if (res_num_bytes) {
        *res_num_bytes = size_class * KB_PAGE_SIZE - sizeof(memory_page);
    }
    return ++res;  // skip header info
}
 
void memory_page_free(void *page_data) {
    memory_page *page = page_data;
    --page;  // recover header info
    if (page->size_class <= KB_MEMORY_MAX_SIZE_CLASS) {
        page->next                       = page_free_list[page->size_class];
        page_free_list[page->size_class] = page;
    } else {
        platform_memory_free(page, page->size_class * KB_PAGE_SIZE);
    }
}
 
void memory_shutdown(void) {
    for (usize i = 0; i < KB_MEMORY_MAX_SIZE_CLASS; ++i) {
        while (page_free_list[i]) {
            memory_page *page = page_free_list[i];
            page_free_list[i] = page->next;
            platform_memory_free(page, page->size_class * KB_PAGE_SIZE);
        }
    }
}
 
void *memory_allocate(usize size) {
    void *mem = platform_memory_allocate(size);
    return memory_zero(mem, size);
}
 
void memory_free(void *mem, usize size) { platform_memory_free(mem, size); }
 
void *memory_zero(void *mem, usize size) { return platform_memory_set(mem, 0, size); }
 
void *memory_set(void *mem, u8 byte, usize size) { return platform_memory_set(mem, byte, size); }
 
void *memory_copy(void *dst, const void *src, usize size) { return platform_memory_copy(dst, src, size); }
 
void *memory_aligned_address(void *addr, usize alignment) {
    return (void *) (((uptr) addr + alignment - 1) & (uptr) ~(alignment - 1));  // TODO clean that up
}