template.h File Reference

#include <stdint.h>
#include <string.h>
#include <derive-c/alloc/trait.h>
#include <derive-c/core/debug/gdb_marker.h>
#include <derive-c/core/debug/memory_tracker.h>
#include <derive-c/core/prelude.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

Typedefs
typedef char	buffer[CAPACITY]

Functions
static SELF	new (buffer *buffer)
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 *self, void *ptr)
static void *	realloc (SELF *self, void *ptr, size_t new_size)
static void *	calloc (SELF *self, size_t count, size_t size)
	TRAIT_ALLOC (SELF)

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 19 of file template.h.

USED

#define USED   uint8_t

Definition at line 27 of file template.h.

Typedef Documentation

buffer

typedef char buffer[CAPACITY]

Definition at line 36 of file template.h.

Function Documentation

calloc()

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

static

Definition at line 189 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 65 of file template.h.

                                        {
    ASSUME(self);
 
#if !defined NDEBUG
    // JUSTIFY: Allocations & sizes zeroed on free in debug, we check all data has been freed.
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_READ_WRITE, (*self->buffer),
                       self->used);
    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
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_WRITE, (*self->buffer),
                       self->used);
    memset((*self->buffer), 0, self->used);
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, (*self->buffer),
                       CAPACITY);
    self->used = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

free()

void free ( SELF * self, void * ptr )

static

Definition at line 110 of file template.h.

                                                  {
    ASSUME(self);
    ASSUME(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));
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_READ_WRITE, used_ptr,
                       sizeof(USED));
    memset(ptr, 0, *used_ptr);
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, ptr, *used_ptr);
    *used_ptr = 0;
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, used_ptr, sizeof(USED));
#endif
}

Here is the call graph for this function:

get_used()

USED get_used ( SELF const * self )

static

Definition at line 86 of file template.h.

                                                 {
    ASSUME(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 91 of file template.h.

                                                       {
    ASSUME(self);
    if (self->used + (size + sizeof(USED)) > CAPACITY) {
        return NULL;
    }
    char* ptr = &(*self->buffer)[self->used];
    USED* used_ptr = (USED*)ptr;
 
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_WRITE, used_ptr, sizeof(USED));
    *used_ptr = size;
    char* allocation_ptr = ptr + sizeof(USED);
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, used_ptr, sizeof(USED));
 
    self->used += size + sizeof(USED);
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_WRITE, allocation_ptr, size);
 
    return allocation_ptr;
}

Here is the call graph for this function:

new()

SELF new ( buffer * buffer )

static

Definition at line 46 of file template.h.

                                                     {
    SELF self = {
        .used = 0,
        .buffer = buffer,
        .derive_c_staticbumpalloc = {},
    };
    // JUSTIFY: Zeroed buffer
    //           - For easier debugging & view in gdb.
    //           - Additionally allows for calloc to be malloc.
    memset(*self.buffer, 0, CAPACITY);
 
    // JUSTIFY: no capabilities on init
    //  - Protect access by users outside of malloc/calloc
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, self.buffer, CAPACITY);
 
    return self;
}

Here is the call graph for this function:

realloc()

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

static

Definition at line 128 of file template.h.

                                                                       {
    ASSUME(self);
 
    if (!ptr) {
        return NS(SELF, malloc)(self, new_size);
    }
 
    char* byte_ptr = (char*)ptr;
    USED* old_size = (USED*)(byte_ptr - sizeof(USED));
    memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_READ_WRITE, old_size,
                       sizeof(USED));
    const bool was_last_alloc = (byte_ptr + *old_size == &(*self->buffer)[self->used]);
 
    if (was_last_alloc) {
        if (new_size > *old_size) {
            size_t increase = new_size - *old_size;
            if (self->used + increase > CAPACITY) {
                return NULL;
            }
            self->used += increase;
            memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_WRITE,
                               (char*)ptr + *old_size, increase);
        } else if (new_size < *old_size) {
            size_t decrease = *old_size - new_size;
            self->used -= decrease;
 
            // JUSTIFY: Zeroing the end of the old allocation
            // - Future calls to calloc may reuse this memory
            memset((char*)ptr + new_size, 0, decrease);
 
            memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE,
                               (char*)ptr + new_size, decrease);
        }
 
        *old_size = new_size;
        memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, old_size,
                           sizeof(USED));
        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;
        memory_tracker_set(MEMORY_TRACKER_LVL_ALLOC, MEMORY_TRACKER_CAP_NONE, old_size,
                           sizeof(USED));
        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:

TRAIT_ALLOC()

TRAIT_ALLOC

(

SELF

)

Variable Documentation

metadata_size

size_t metadata_size = sizeof(USED)

static

Definition at line 44 of file template.h.