tklb::memory::tracer Namespace Reference

Classes
struct	MagicBlock
	Struct inserted at the end of every allocation. More...

Functions
static void *	allocateTrace (size_t size, const char *file, int line) noexcept
static void *	reallocateTrace (void *ptr, size_t size, const char *file, int line) noexcept
static void *	clearallocateTrace (size_t num, size_t size, const char *file, int line) noexcept
static void	deallocateTrace (void *ptr, const char *file, int line) noexcept
static void	deallocateAlignedTrace (void *ptr, const char *file, int line) noexcept
static void *	allocateAlignedTrace (const char *file, int line, size_t size, size_t align=DEFAULT_ALIGN) noexcept
template<class T , typename ... Args>
static T *	createTrace (const char *file, int line, Args &&... args)
template<class T >
static void	disposeTrace (T *ptr, const char *file, int line)
static void	checkHeap ()
	Checks the MagicBlocks for all allocations. More...
static void	init ()
static void	stop ()

Variables
constexpr char	TKLB_MAGIC_STRING [] = "tklbend"
constexpr char	TKLB_MAGIC_BACKUP_STRING [] = "tklback"
HeapBuffer< MagicBlock * >	MagicBlocks
bool	EXCLUDE_TRACE = false

Function Documentation

allocateAlignedTrace()

static void * tklb::memory::tracer::allocateAlignedTrace ( const char *  file, int  line, size_t  size, size_t  align = DEFAULT_ALIGN  )

inlinestaticnoexcept

Definition at line 174 of file TMemoryTracing.hpp.

                                                                                                             {
        if (EXCLUDE_TRACE) {
            return allocateAligned(size, align);
        }
        void* mem = allocateAligned(size + sizeof(MagicBlock), align);
        MagicBlock::construct(mem, size, file, line);
        return mem;
    };

Here is the call graph for this function:

allocateTrace()

static void * tklb::memory::tracer::allocateTrace ( size_t  size, const char *  file, int  line  )

inlinestaticnoexcept

Definition at line 124 of file TMemoryTracing.hpp.

                                                                                        {
        if (EXCLUDE_TRACE) {
            return allocate(size);
        }
        void* mem = allocate(size + sizeof(MagicBlock));
        MagicBlock::construct(mem, size, file, line);
        return mem;
    };

Here is the call graph for this function:

checkHeap()

static void tklb::memory::tracer::checkHeap ( )

static

Checks the MagicBlocks for all allocations.

Definition at line 209 of file TMemoryTracing.hpp.

                            {
        if (MagicBlocks.data() == nullptr) { return; }
        size_t total = 0;
        for (size_t i = 0; i < MagicBlocks.size(); i++) {
            MagicBlock* block = MagicBlocks[i];
            MagicBlock::check(block);
            total += block->size;
        }
        size_t blocks = MagicBlocks.allocated();
        size_t left = Allocated;
        left -= blocks;
        TKLB_ASSERT(total == left)
    }

Here is the call graph for this function:

clearallocateTrace()

static void * tklb::memory::tracer::clearallocateTrace ( size_t  num, size_t  size, const char *  file, int  line  )

inlinestaticnoexcept

Definition at line 143 of file TMemoryTracing.hpp.

                                                                                                         {
        if (EXCLUDE_TRACE) {
            return clearallocate(num, size);
        }
        // how much space clearallocate will allocate
        size_t total = num * size;
        // the amount of elements needed
        size_t numNeeded = ((total + sizeof(MagicBlock)) / size) + 1;
        void* mem = clearallocate(numNeeded, size);
        MagicBlock::construct(mem, total, file, line);
        return mem;
    };

Here is the call graph for this function:

createTrace()

template<class T , typename ... Args>

static T * tklb::memory::tracer::createTrace ( const char *  file, int  line, Args &&...  args  )

inlinestatic

Definition at line 184 of file TMemoryTracing.hpp.

                                                                              {
        if (EXCLUDE_TRACE) {
            void* mem = allocate(sizeof(T));
            return new (mem) T(std::forward<Args>(args)...);
        }
        void* mem = allocate(sizeof(T) + sizeof(MagicBlock));
        if (mem == nullptr) { return nullptr; }
        MagicBlock::construct(mem, sizeof(T), file, line);
        T* obj = new (mem) T(std::forward<Args>(args)...);
        return obj;
    }

Here is the call graph for this function:

deallocateAlignedTrace()

static void tklb::memory::tracer::deallocateAlignedTrace ( void *  ptr, const char *  file, int  line  )

inlinestaticnoexcept

Definition at line 165 of file TMemoryTracing.hpp.

                                                                                              {
        if (EXCLUDE_TRACE) {
            return deallocateAligned(ptr);
        }
        if (ptr == nullptr) { return; }
        MagicBlock::destroy(ptr);
        deallocateAligned(ptr);
    };

Here is the call graph for this function:

deallocateTrace()

static void tklb::memory::tracer::deallocateTrace ( void *  ptr, const char *  file, int  line  )

inlinestaticnoexcept

Definition at line 156 of file TMemoryTracing.hpp.

                                                                                       {
        if (EXCLUDE_TRACE) {
            return deallocate(ptr);
        }
        if (ptr == nullptr) { return; }
        MagicBlock::destroy(ptr);
        deallocate(ptr);
    };

Here is the call graph for this function:

disposeTrace()

template<class T >

static void tklb::memory::tracer::disposeTrace ( T *  ptr, const char *  file, int  line  )

inlinestatic

Definition at line 197 of file TMemoryTracing.hpp.

                                                                        {
        if (ptr == nullptr) { return; }
        if (!EXCLUDE_TRACE) {
            MagicBlock::destroy(ptr);
        }
        ptr->~T();
        deallocate(ptr);
    }

Here is the call graph for this function:

init()

static void tklb::memory::tracer::init ( )

static

Definition at line 223 of file TMemoryTracing.hpp.

                       {
        EXCLUDE_TRACE = true;
        MagicBlocks.reserve(1024 * 1024);
        EXCLUDE_TRACE = false;
    }

reallocateTrace()

static void * tklb::memory::tracer::reallocateTrace ( void *  ptr, size_t  size, const char *  file, int  line  )

inlinestaticnoexcept

Definition at line 133 of file TMemoryTracing.hpp.

                                                                                                     {
        if (EXCLUDE_TRACE) {
            return reallocate(ptr, size);
        }
        MagicBlock::destroy(ptr);
        void* mem = reallocate(ptr, size + sizeof(MagicBlock));
        MagicBlock::construct(mem, size, file, line);
        return mem;
    };

Here is the call graph for this function:

stop()

static void tklb::memory::tracer::stop ( )

static

Definition at line 229 of file TMemoryTracing.hpp.

                       {
        EXCLUDE_TRACE = true;
        MagicBlocks.resize(0);
    }

Variable Documentation

EXCLUDE_TRACE

bool tklb::memory::tracer::EXCLUDE_TRACE = false

inline

Definition at line 42 of file TMemoryTracing.hpp.

MagicBlocks

HeapBuffer<MagicBlock*> tklb::memory::tracer::MagicBlocks

inline

Definition at line 41 of file TMemoryTracing.hpp.

TKLB_MAGIC_BACKUP_STRING

constexpr char tklb::memory::tracer::TKLB_MAGIC_BACKUP_STRING[] = "tklback"

constexpr

Definition at line 37 of file TMemoryTracing.hpp.

TKLB_MAGIC_STRING

constexpr char tklb::memory::tracer::TKLB_MAGIC_STRING[] = "tklbend"

constexpr

Definition at line 36 of file TMemoryTracing.hpp.