heap.c

Go to the documentation of this file.

//alc.c - allocation and memory functions
//upgraded to support multiple arenas
 
#include "heap.h"
#include "../lib/types.h"
#include "../lib/err.h"
 
/**
 * @brief initializes a central heap rather then child arena
 *
 * hinit is a function used to initliaze a new central heap, like kheap
 * @param arena, in hinit this is the ptr to your heap
 * @param start, this should be a buffer like 'static uint8_t mem[HEAP_SIZE]' using the size of your heap
 * @param size, the size of the heap using 'sizeof(mem)'
 * 
 * using hinit is done with
 * @code{.c}
 * #include "../mem/heap.h" //or just heap.h
 * #define MYHEAP_SIZE (1024 * 1024) //the size of your heap, in this case 1mb, this is in bytes, so 1024 is 1kb, 1024 * 1024 is 1mb, and etc
 * arena_t myheap; //your heap
 * static uint8_t mymem[MYHEAP_SIZE] //that actual size
 * //now lets call hinit
 * hinit(&myheap, mymem, sizeof(mymem));
 * @endcode
 * 
 * it initializes the heap by making the start and size be your set size but the current heap addr the start
 *
 * @see kheap, alc(), res(), anew(), arena_t
*/
void __hinit(arena_t *arena, void *start, uint32_t size) { //pointer arena is pointing to struct (check heap.h)
    arena->start = (uint32_t*)start; //set start to start
    arena->current = (uint32_t*)start; //make current start so it initializes
    arena->size = size; //size to size
}
 
/**
 * @brief allocates memory to a heap
 * 
 * alc is a function that allocates memory from a central heap
 * @param arena, the ptr to the arena to allocate from
 * @param size, the amount to allocate
 *
 * using alc is done with
 * @code{.c}
 * #include "../mem/heap.h" //or just heap.h
 * void* myspace = alc(&myarena, 16); //allocate 16 bytes
 * @endcode
 *
 * @see res(), anew() 
*/
void *__alc(arena_t *arena, uint32_t size) { //alc returns a void ptr to allocated mem rets 0 aka nll if alloc fails
    assert(arena != NULL, "alc: arena is NULL"); //err handling
    assert(arena->start != NULL, "alc: arena not initialized");
 
    //align to four bytes
    if (size & 3) { //if size is multiple of 4 last 2 bits set to 00 aka size & 3 = 0 then if not mult4 last 2 bits have 1s aka res is non-0
        size = (size & (uint32_t)~3) + 4; //now round down, so we invert bits, so if res is non 0 we continue and invert them to be 1 aka align it
    }
 
    //get current position as byte address to avoid dumb pointer arithmetic
    uint32_t current_addr = (uint32_t)arena->current; //save current pos's for later
    uint32_t start_addr = (uint32_t)arena->start;
    uint32_t end_addr = start_addr + arena->size;
 
    //overflow check using bytes instead of pointers
    if (current_addr + size > end_addr) { //if current + whats needed is over end then we cant allocate because were out of space
        panic("alc: out of memory"); //alloc failed
    }
 
    void *ptr = (void*)current_addr; //save the address to return
 
    arena->current = (uint32_t*)(current_addr + size); //set current to the newly allocated size using byte math
 
    return ptr; //return the new ptr
}
 
/**
 * @brief resets a arena or heap by setting current to start and overriding data
 *
 * @param arena, the arena or heap to reset
*/
void __res(arena_t *arena) {
    arena->current = arena->start; //reset current pointer to the start of the arena
}
 
/**
 * @brief creates a child arena under a central heap
 * 
 * anew is a function that makes a child arena under a parent heap
 * @param parent, the ptr to the parent arena
 * @param size, the size of the arena
 *
 * using anew is done with
 * @code{.c}
 * #include "../mem/heap.h" //or just heap.h
 * #define MYARENA_SIZE (256 * 1024) //256kb child arena
 * arena_t *myarena
 * myarena = anew(&myheap, MYARENA_SIZE);
 * @endcode
 *
 * and you can reset this new arena or use it!
 * 
 * @see res()
*/
arena_t *__anew(arena_t *parent, uint32_t size) { //anew returns a new arena allocated from parent
    //allocate arena struct from parent
    arena_t *new_arena = (arena_t*)alc(parent, sizeof(arena_t)); //grab space for the arena struct itself
    assert(new_arena != NULL, "anew: failed to allocate arena struct"); //err han
    
    //allocate memory for the new arenas buffer
    void *buf = alc(parent, size); //grab the actual memory block for the new arena
    assert(buf != NULL, "anew: failed to allocate arena buffer"); //err han
    
    //initialize the new arena
    hinit(new_arena, buf, size); //set up the new arena like a fresh heap
    
    return new_arena; //return pointer to the new arena
}