template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/core/alloc/def.h>
#include <derive-c/core/self/def.h>
#include <derive-c/alloc/std.h>
#include <derive-c/container/map/swiss/template.h>
#include <derive-c/core/self/undef.h>
#include <derive-c/core/alloc/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	ALLOCATIONS_MAP   NS(NAME, allocations)
	For unit tests expected to throw, as C has no unwind, we cannot free allocated memory. This macro wraps the allocator in debug, to allow clearing leaks after an exception.
#define	ALLOC   stdalloc
#define	KEY   void*
#define	KEY_HASH(ptr)
#define	KEY_DEBUG   dc_void_ptr_debug
#define	VALUE   size_t
#define	INTERNAL_NAME   ALLOCATIONS_MAP

Functions
static DC_PUBLIC SELF	new (ref alloc_ref)
static DC_PUBLIC ALLOCATIONS_MAP const *	get_allocations (SELF const *self)
static DC_PUBLIC void	delete (SELF *self)
static DC_PUBLIC void	unleak (SELF *self)
static DC_PUBLIC void *	allocate_zeroed (SELF *self, size_t size)
static DC_PUBLIC void *	allocate_uninit (SELF *self, size_t size)
static DC_PUBLIC void *	reallocate (SELF *self, void *old_ptr, size_t old_size, size_t new_size)
static DC_PUBLIC void	deallocate (SELF *self, void *ptr, size_t size)
static DC_PUBLIC void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
	DC_TRAIT_REFERENCABLE_BY_PTR (SELF)
	DC_TRAIT_ALLOC (SELF)

Macro Definition Documentation

ALLOC

#define ALLOC   stdalloc

Definition at line 31 of file template.h.

ALLOCATIONS_MAP

#define ALLOCATIONS_MAP   NS(NAME, allocations)

For unit tests expected to throw, as C has no unwind, we cannot free allocated memory. This macro wraps the allocator in debug, to allow clearing leaks after an exception.

In release, it is a no-op / pass through.

• Not entirely zero cost, as the reference type is pointer size, even if the wrapped allocator's reference is not.

As this is entirely C, we do not get the niceties of a C++ RAII allocator guard shebang. However, this is usable inside unit tests written in C.

Definition at line 25 of file template.h.

INTERNAL_NAME

#define INTERNAL_NAME   ALLOCATIONS_MAP

Definition at line 36 of file template.h.

KEY

#define KEY   void*

Definition at line 32 of file template.h.

KEY_DEBUG

#define KEY_DEBUG   dc_void_ptr_debug

Definition at line 34 of file template.h.

KEY_HASH

#define KEY_HASH

(

ptr

)

Value:

((size_t)(*(ptr)))

Definition at line 33 of file template.h.

VALUE

#define VALUE   size_t

Definition at line 35 of file template.h.

Function Documentation

allocate_uninit()

DC_PUBLIC void * allocate_uninit ( SELF * self, size_t size )

static

Definition at line 78 of file template.h.

                                                                          {
    DC_ASSUME(self);
    void* ptr = NS(ALLOC, allocate_uninit)(self->alloc_ref, size);
    size_t* alloc = NS(ALLOCATIONS_MAP, try_insert)(&self->allocations, ptr, size);
    DC_ASSERT(alloc != NULL,
              "Got uninit allocation, that is already allocated at %p (attempted size: %zu)", ptr,
              *alloc);
    return ptr;
}

allocate_zeroed()

DC_PUBLIC void * allocate_zeroed ( SELF * self, size_t size )

static

Definition at line 68 of file template.h.

                                                                          {
    DC_ASSUME(self);
    void* ptr = NS(ALLOC, allocate_zeroed)(self->alloc_ref, size);
    size_t* alloc = NS(ALLOCATIONS_MAP, try_insert)(&self->allocations, ptr, size);
    DC_ASSERT(alloc != NULL,
              "Got zeroed allocation, that is already allocated at %p (attempted size: %zu)", ptr,
              size);
    return ptr;
}

DC_TRAIT_ALLOC()

DC_TRAIT_ALLOC

(

SELF

)

DC_TRAIT_REFERENCABLE_BY_PTR()

DC_TRAIT_REFERENCABLE_BY_PTR

(

SELF

)

deallocate()

DC_PUBLIC void deallocate ( SELF * self, void * ptr, size_t size )

static

Definition at line 110 of file template.h.

                                                                               {
    DC_ASSUME(ptr);
    DC_ASSUME(self);
 
    size_t const* tracked_size = NS(ALLOCATIONS_MAP, try_read)(&self->allocations, ptr);
    DC_ASSERT(tracked_size != NULL,
              "Attempted to deallocate %p (size: %zu), but was not already allocated", ptr, size);
    DC_ASSERT(*tracked_size == size,
              "Incorrect size passed on %p deallocation (was: %zu, expected: %zu)", ptr,
              *tracked_size, size);
 
    NS(ALLOCATIONS_MAP, delete_entry)(&self->allocations, ptr);
 
    NS(ALLOC, deallocate)(self->alloc_ref, ptr, size);
}

debug()

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

static

Definition at line 126 of file template.h.

                                                                                        {
    fprintf(stream, DC_EXPAND_STRING(SELF) " @%p {\n", (void*)self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "base: " DC_EXPAND_STRING(ALLOC) "@%p,\n",
                       (void*)NS(NS(ALLOC, ref), deref)(self->alloc_ref));
 
    dc_debug_fmt_print(fmt, stream, "allocations: ");
    NS(ALLOCATIONS_MAP, debug)(&self->allocations, fmt, stream);
    fprintf(stream, "\n");
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

delete()

DC_PUBLIC void delete ( SELF * self )

static

Definition at line 58 of file template.h.

                                                   {
    NS(ALLOCATIONS_MAP, delete)(&self->allocations);
}

get_allocations()

DC_PUBLIC ALLOCATIONS_MAP const * get_allocations ( SELF const * self )

static

Definition at line 53 of file template.h.

                                                                                    {
    DC_ASSUME(self);
    return &self->allocations;
}

new()

DC_PUBLIC SELF new ( ref alloc_ref )

static

Definition at line 46 of file template.h.

                                                              {
    return (SELF){
        .alloc_ref = alloc_ref,
        .allocations = NS(ALLOCATIONS_MAP, new)(stdalloc_get_ref()),
    };
}

reallocate()

DC_PUBLIC void * reallocate ( SELF * self, void * old_ptr, size_t old_size, size_t new_size )

static

Definition at line 88 of file template.h.

                                                             {
    DC_ASSUME(self);
    DC_ASSUME(old_ptr);
 
    size_t const* tracked_size = NS(ALLOCATIONS_MAP, try_read)(&self->allocations, old_ptr);
    DC_ASSERT(tracked_size != NULL, "Reallocating pointer that is not allocated");
    DC_ASSERT(*tracked_size == old_size,
              "Incorrect size provided for reallocation of %p (was %zu, but expected %zu)", old_ptr,
              old_size, *tracked_size);
    NS(ALLOCATIONS_MAP, delete_entry)(&self->allocations, old_ptr);
 
    void* new_ptr = NS(ALLOC, reallocate)(self->alloc_ref, old_ptr, old_size, new_size);
 
    size_t* alloc = NS(ALLOCATIONS_MAP, try_insert)(&self->allocations, new_ptr, new_size);
    DC_ASSERT(alloc != NULL,
              "Got new reallocation, that is already allocated at %p (attempted size: %zu)",
              new_ptr, new_size);
 
    return new_ptr;
}

unleak()

DC_PUBLIC void unleak ( SELF * self )

static

Definition at line 62 of file template.h.

                                                   {
    DC_FOR(ALLOCATIONS_MAP, &self->allocations, iter, entry) {
        NS(ALLOC, deallocate)(self->alloc_ref, *entry.key, *entry.value);
    }
}