template.h File Reference

#include <stdint.h>
#include <string.h>
#include <derive-c/core/helpers.h>
#include <derive-c/core/panic.h>
#include <derive-c/core/self/def.h>
#include <derive-c/core/self/undef.h>

Include dependency graph for template.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...

Macros
#define	CAPACITY   1024
	A very simple bump allocator making use of a provided fixed size buffer (e.g. statically allocated).
#define	USED   uint8_t

Functions
static SELF	new ()
static void	clear (SELF *self)
	Clear the allocator, note that all data should be freed before this occurs.
static USED	get_used (SELF const *self)
static void *	malloc (SELF *self, size_t size)
static void	free (SELF *DEBUG_UNUSED(self), void *DEBUG_UNUSED(ptr))
static void *	realloc (SELF *self, void *ptr, size_t new_size)
static void *	calloc (SELF *self, size_t count, size_t size)

Variables
static size_t	metadata_size = sizeof(USED)

Macro Definition Documentation

CAPACITY

#define CAPACITY   1024

A very simple bump allocator making use of a provided fixed size buffer (e.g. statically allocated).

• Useful when an upper bound for allocation size is known at compile time
• Can be used when no global allocator is available (e.g. embedded systems, kernel dev)

Definition at line 17 of file template.h.

USED

#define USED   uint8_t

Definition at line 25 of file template.h.

Function Documentation

calloc()

void * calloc ( SELF * self, size_t count, size_t size )

static

Definition at line 138 of file template.h.

                                                                     {
    // JUSTIFY:
    //  - We already zeroed the buffer in `new()`
    return NS(SELF, malloc)(self, count * size);
}

Here is the call graph for this function:

clear()

void clear ( SELF * self )

static

Clear the allocator, note that all data should be freed before this occurs.

Definition at line 52 of file template.h.

                                        {
    DEBUG_ASSERT(self);
 
#if !defined NDEBUG
    // JUSTIFY: Allocations & sizes zeroed on free in debug, we check all data has been freed.
    for (size_t i = 0; i < self->used; i++) {
        if (self->buffer[i] != 0) {
            PANIC("Data not freed before clearing the static bump allocator");
        }
    }
#endif
    memset(self->buffer, 0, self->used);
    self->used = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

free()

void free ( SELF * DEBUG_UNUSEDself, void * DEBUG_UNUSEDptr )

static

Definition at line 84 of file template.h.

                                                                              {
    DEBUG_ASSERT(self);
    DEBUG_ASSERT(ptr);
 
#if !defined NDEBUG
    // JUSTIFY: Zero memory in debug.
    //           - Expensive for release, but helpful when debugging
    // NOTE: This means that users should free, before they clear and reuse the buffer.
    USED* used_ptr = (USED*)((char*)ptr - sizeof(USED));
    memset(ptr, 0, *used_ptr);
    *used_ptr = 0;
#endif
}

Here is the call graph for this function:

get_used()

USED get_used ( SELF const * self )

static

Definition at line 67 of file template.h.

                                                 {
    DEBUG_ASSERT(self);
    return self->used;
}

Here is the call graph for this function:

Here is the caller graph for this function:

malloc()

void * malloc ( SELF * self, size_t size )

static

Definition at line 72 of file template.h.

                                                       {
    DEBUG_ASSERT(self);
    if (self->used + (size + sizeof(USED)) > CAPACITY) {
        return NULL;
    }
    char* ptr = &self->buffer[self->used];
    USED* used_ptr = (USED*)ptr;
    *used_ptr = size;
    self->used += size + sizeof(USED);
    return ptr + sizeof(USED);
}

Here is the call graph for this function:

new()

SELF new ( )

static

Definition at line 42 of file template.h.

                            {
    SELF self = {.used = 0, .derive_c_staticbumpalloc = {}};
    // JUSTIFY: Zeroed buffer
    //           - For easier debugging & view in gdb.
    //           - Additionally allows for calloc to be malloc.
    memset(self.buffer, 0, CAPACITY);
    return self;
}

realloc()

void * realloc ( SELF * self, void * ptr, size_t new_size )

static

Definition at line 98 of file template.h.

                                                                       {
    DEBUG_ASSERT(self);
 
    if (!ptr) {
        return NS(SELF, malloc)(self, new_size);
    }
 
    char* byte_ptr = (char*)ptr;
    USED* old_size = (USED*)(byte_ptr - sizeof(USED));
    const bool was_last_alloc = (byte_ptr + *old_size == self->buffer + self->used);
 
    if (was_last_alloc) {
        if (self->used + (new_size - *old_size) > CAPACITY) {
            return NULL;
        }
 
        self->used += (new_size - *old_size);
        *old_size = new_size;
        return ptr;
    }
 
    if (new_size < *old_size) {
        // JUSTIFY: Shrinking an allocation
        //           - Can become a noop - as we cannot re-extend the allocation
        //             afterwards - no metadata for unused capacity not at end of buffer.
        *old_size = new_size;
        return ptr;
    }
 
    void* new_buff = NS(SELF, malloc)(self, new_size);
    if (!new_buff) {
        return NULL;
    }
 
    memcpy(new_buff, ptr, *old_size);
 
    NS(SELF, free)(self, ptr);
    return new_buff;
}

Here is the call graph for this function:

Variable Documentation

metadata_size

size_t metadata_size = sizeof(USED)

static

Definition at line 40 of file template.h.