allocator.h File Reference

#include "types.h"

Go to the source code of this file.

Macros
#define	_MEM_POOL_ALIGN4(__name, __sz)   __attribute__((aligned(4))) u8 __name[__sz] = {0}

Typedefs
typedef struct __Allocator	MEM_Allocator

Functions
MEM_Allocator *	MEM_Init (void *pool, u32 pool_size)
	Creates a new allocator from the given memory pool.
void *	MEM_Alloc (MEM_Allocator *ma, u32 size)
	Allocate a block of memory from the pool with at least 'size' bytes.
void	MEM_Free (MEM_Allocator *ma, void *ptr)
	Free a previously allocated block.
void *	MEM_Realloc (MEM_Allocator *ma, void *ptr, u32 new_size)
	Reallocate a previously allocated block to a new size.

Macro Definition Documentation

_MEM_POOL_ALIGN4

#define _MEM_POOL_ALIGN4	(		__name,
			__sz
	)		__attribute__((aligned(4))) u8 __name[__sz] = {0}

Definition at line 12 of file allocator.h.

Typedef Documentation

MEM_Allocator

typedef struct __Allocator MEM_Allocator

Definition at line 9 of file allocator.h.

Function Documentation

MEM_Alloc()

void * MEM_Alloc	(	MEM_Allocator *	ma,
		u32	size
	)

Allocate a block of memory from the pool with at least 'size' bytes.

Parameters

ma	Pointer to the memory allocator.
size	Size of the block to allocate.

Returns

Pointer to the allocated memory or NULL if no block is available.

Definition at line 52 of file allocator.c.

{
    if (!ma || ma != &sAllocator || size == 0)
        return NULL;
 
    // Optional: Align requested size to 4 bytes.
    size = ALIGN4_VAL(size);
 
    __BlockHeader *current_blk = ma->head, *new_blk;
    const u32 min_split_size = sizeof(__BlockHeader) + 4; // minimal payload of 4 bytes
    while (current_blk)
    {
        if (current_blk->free && current_blk->size >= size)
        {
            // Found a suitable free block. If the remaining space after allocation
            // is large enough for a new block header and a minimal payload (4 bytes),
            // split the block.
            if (current_blk->size >= size + min_split_size)
            {
                // Create the new block header in the remaining space after the allocation.
                new_blk = (__BlockHeader *)((u8 *)current_blk + sizeof(__BlockHeader) + size);
                *new_blk = (__BlockHeader){
                    .size = current_blk->size - size - sizeof(__BlockHeader), // Remaining size.
                    .free = true,
                    .next = current_blk->next,
                };
 
                // Update current block.
                current_blk->size = size;
                current_blk->free = false;
                current_blk->next = new_blk;
            }
            else
                current_blk->free = false;
 
            ma->pool_used += current_blk->size + sizeof(__BlockHeader);
            return (void *)((u8 *)current_blk + sizeof(__BlockHeader));
        }
 
        current_blk = current_blk->next;
    }
 
    // No suitable block found.
    return NULL;
}

MEM_Free()

void MEM_Free	(	MEM_Allocator *	ma,
		void *	ptr
	)

Free a previously allocated block.

Parameters

ma	Pointer to the memory allocator.
ptr	Pointer to the block to free.

Definition at line 98 of file allocator.c.

{
    if (!ma || ma != &sAllocator || !ptr)
        return;
 
    // Get the block header stored just before the user pointer.
    __BlockHeader *const blk = (__BlockHeader *)((u8 *)ptr - sizeof(__BlockHeader));
    blk->free = true;
    ma->pool_used -= blk->size + sizeof(__BlockHeader);
 
    // Coalesce with the next block if it's free.
    if (blk->next && blk->next->free)
    {
        blk->size += sizeof(__BlockHeader) + blk->next->size; // Add the size of the next block.
        blk->next = blk->next->next;                          // Skip the next block, pointing to the one after it.
    }
 
    // Also try to coalesce with any previous block.
    // Moving to the block before the one to be freed.
    __BlockHeader *current_blk = ma->head, *prev;
    while (current_blk && current_blk != blk)
    {
        prev = current_blk;
        current_blk = current_blk->next;
    }
 
    if (prev && prev->free)
    {
        prev->size += sizeof(__BlockHeader) + blk->size; // Add the size of the block to be freed.
        prev->next = blk->next;                          // Skip the block to be freed, pointing to the one after it.
    }
}

MEM_Init()

MEM_Allocator * MEM_Init	(	void *	pool,
		u32	pool_size
	)

Creates a new allocator from the given memory pool.

Parameters

pool	Pointer to the memory pool.
pool_size	Size of the memory pool in bytes.

Returns

Pointer to the new allocator or NULL on error.

Definition at line 31 of file allocator.c.

{
    if (!pool || pool_size < sizeof(__BlockHeader))
        return NULL;
 
    sAllocator = (struct __Allocator){
        .pool = pool,
        .pool_size = pool_size,
        .pool_used = 0,
        .head = (__BlockHeader *)pool,
    };
 
    sAllocator.head->size = pool_size - sizeof(__BlockHeader);
    sAllocator.head->free = true;
    sAllocator.head->next = NULL;
 
    return &sAllocator;
}

MEM_Realloc()

void * MEM_Realloc	(	MEM_Allocator *	ma,
		void *	ptr,
		u32	new_size
	)

Reallocate a previously allocated block to a new size.

Parameters

ma	Pointer to the memory allocator.
ptr	Pointer to the block to reallocate. If NULL, acts like MEM_Alloc().
new_size	New size of the block. If 0, acts like MEM_Free(); if less than the current size, shrinks the block; if greater, allocates a new block, copies the data, and frees the old block.

Returns

Pointer to the reallocated block or NULL on error.

Definition at line 131 of file allocator.c.

{
    if (!ma || ma != &sAllocator)
        return NULL;
 
    if (!new_size)
    {
        // If size is 0, free the block and return NULL.
        MEM_Free(ma, ptr);
        return NULL;
    }
 
    if (!ptr) // If ptr is NULL, simply allocate a new block.
        return MEM_Alloc(ma, new_size);
 
    // Align the requested new size to 4 bytes.
    new_size = ALIGN4_VAL(new_size);
 
    // Get the header for the block.
    __BlockHeader *blk = (__BlockHeader *)((u8 *)ptr - sizeof(__BlockHeader));
    if (new_size <= blk->size)
    {
        // The block is already big enough. If the new size is much smaller,
        // we can split the block to free up unused memory.
        const u32 min_split_thresh = sizeof(__BlockHeader) + 8; // minimal payload of 8 bytes
        if (blk->size >= new_size + min_split_thresh)
        {
            // Splitting the block. Create a new block header in the remaining space.
            __BlockHeader *const new_blk = (__BlockHeader *)((u8 *)blk + sizeof(__BlockHeader) + new_size);
            *new_blk = (__BlockHeader){
                .size = blk->size - new_size - sizeof(__BlockHeader),
                .free = true,
                .next = blk->next, // Link to the next block
            };
 
            blk->size = new_size;
            blk->next = new_blk; // Link to the newly created block
        }
 
        return ptr; // Returing the same pointer.
    }
    else
    {
        // The new size is larger than the current block. Need to move the data to a bigger block.
        void *new_ptr = MEM_Alloc(ma, new_size);
        if (!new_ptr)
            return NULL;
 
        memcpy(new_ptr, ptr, blk->size);
        MEM_Free(ma, ptr);
        return new_ptr;
    }
}