template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/core/self/def.h>
#include <derive-c/core/self/undef.h>
#include <derive-c/core/includes/undef.h>

Go to the source code of this file.

Data Structures
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)
static void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
	DC_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 17 of file template.h.

USED

#define USED   uint8_t

Definition at line 25 of file template.h.

Typedef Documentation

buffer

typedef char buffer[CAPACITY]

Definition at line 34 of file template.h.

Function Documentation

calloc()

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

static

Definition at line 192 of file template.h.

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

clear()

void clear ( SELF * self )

static

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

Definition at line 64 of file template.h.

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

DC_TRAIT_ALLOC()

DC_TRAIT_ALLOC

(

SELF

)

debug()

void debug ( SELF const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 198 of file template.h.

                                                                              {
    fprintf(stream, STRINGIFY(SELF) "@%p {\n", self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "capacity: %lu,\n", CAPACITY);
    dc_debug_fmt_print(fmt, stream, "used: %lu,\n", self->used);
    dc_debug_fmt_print(fmt, stream, "buffer: %p,\n", self->buffer);
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

free()

void free ( SELF * self, void * ptr )

static

Definition at line 112 of file template.h.

                                                  {
    DC_ASSUME(self);
    DC_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));
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE, used_ptr,
                          sizeof(USED));
    memset(ptr, 0, *used_ptr);
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE, ptr, *used_ptr);
    *used_ptr = 0;
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE, used_ptr,
                          sizeof(USED));
#endif
}

get_used()

USED get_used ( SELF const * self )

static

Definition at line 85 of file template.h.

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

malloc()

void * malloc ( SELF * self, size_t size )

static

Definition at line 90 of file template.h.

                                                       {
    DC_ASSUME(self);
    if (self->used + (size + sizeof(USED)) > CAPACITY) {
        return NULL;
    }
    char* ptr = &(*self->buffer)[self->used];
    USED* used_ptr = (USED*)ptr;
 
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE, used_ptr,
                          sizeof(USED));
    *used_ptr = size;
    char* allocation_ptr = ptr + sizeof(USED);
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE, used_ptr,
                          sizeof(USED));
 
    self->used += size + sizeof(USED);
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE, allocation_ptr,
                          size);
 
    return allocation_ptr;
}

new()

SELF new ( buffer * buffer )

static

Definition at line 44 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
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE, self.buffer,
                          CAPACITY);
 
    return self;
}

realloc()

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

static

Definition at line 131 of file template.h.

                                                                       {
    DC_ASSUME(self);
 
    if (!ptr) {
        return NS(SELF, malloc)(self, new_size);
    }
 
    char* byte_ptr = (char*)ptr;
    USED* old_size = (USED*)(byte_ptr - sizeof(USED));
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_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;
            dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_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);
 
            dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_NONE,
                                  (char*)ptr + new_size, decrease);
        }
 
        *old_size = new_size;
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_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;
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_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;
}

Variable Documentation

metadata_size

size_t metadata_size = sizeof(USED)

static

Definition at line 42 of file template.h.