sokol_memtrack.h

#ifndef SOKOL_MEMTRACK_INCLUDED
/*
    sokol_memtrack.h -- memory allocation wrapper to track memory usage
                        of sokol libraries

    Project URL: https://github.com/floooh/sokol

    Simply include this file before the sokol header implementation includes
    and after the SOKOL_IMPL macro:

    #define SOKOL_IMPL
    #include "sokol_memtrack.h"
    #include "sokol_app.h"
    #include "sokol_gfx.h"
    ...

    Optionally provide the following defines with your own implementations:

    SOKOL_API_DECL      - public function declaration prefix (default: extern)
    SOKOL_API_IMPL      - public function implementation prefix (default: -)

    If sokol_memtrack.h is compiled as a DLL, define the following before
    including the declaration or implementation:

    SOKOL_DLL

    The sokol_memtrack.h header will redirect the macros SOKOL_MALLOC,
    SOKOL_FREE and SOKOL_CALLOC to use its own function wrappers which
    keep track of number and size of allocations. The wrapper functions
    then call the CRT functions malloc(), calloc() or free().

    Naturally, only the memory management calls in sokol header code are tracked,
    not in underlying APIs such as D3D11 or OpenGL.

    To get the current number and overall size of allocations, call:

        smemtrack_info_t alloc_info = smemtrack_info();

        int num_allocations = info.num_alloc;
        int allocation_size = info.num_bytes;

    The allocation wrapper functions are *not* thread-safe (which shouldn't
    be a problem because the sokol headers don't allocate or deallocate
    in threads).

    LICENSE
    =======

    zlib/libpng license

    Copyright (c) 2018 Andre Weissflog

    This software is provided 'as-is', without any express or implied warranty.
    In no event will the authors be held liable for any damages arising from the
    use of this software.

    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:

        1. The origin of this software must not be misrepresented; you must not
        claim that you wrote the original software. If you use this software in a
        product, an acknowledgment in the product documentation would be
        appreciated but is not required.

        2. Altered source versions must be plainly marked as such, and must not
        be misrepresented as being the original software.

        3. This notice may not be removed or altered from any source
        distribution.
*/
#define SOKOL_MEMTRACK_INCLUDED (1)
#include <stddef.h>
#include <stdint.h>

#ifndef SOKOL_API_DECL
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_IMPL)
#define SOKOL_API_DECL __declspec(dllexport)
#elif defined(_WIN32) && defined(SOKOL_DLL)
#define SOKOL_API_DECL __declspec(dllimport)
#else
#define SOKOL_API_DECL extern
#endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

typedef struct smemtrack_info_t {
    int num_allocs;
    int num_bytes;
} smemtrack_info_t;

SOKOL_API_DECL smemtrack_info_t smemtrack_info(void);

#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* SOKOL_MEMTRACK_INCLUDED */

/*=== IMPLEMENTATION =========================================================*/
#ifdef SOKOL_IMPL
#define SOKOL_MEMTRACK_IMPL_INCLUDED (1)
#include <stdlib.h> /* malloc, free, calloc */
#include <string.h> /* memset */

#ifndef SOKOL_API_IMPL
    #define SOKOL_API_IMPL
#endif
#ifndef SOKOL_DEBUG
    #ifndef NDEBUG
        #define SOKOL_DEBUG (1)
    #endif
#endif
#ifndef _SOKOL_PRIVATE
    #if defined(__GNUC__) || defined(__clang__)
        #define _SOKOL_PRIVATE __attribute__((unused)) static
    #else
        #define _SOKOL_PRIVATE static
    #endif
#endif

#define SOKOL_MALLOC(s) _smemtrack_malloc(s)
#define SOKOL_FREE(p) _smemtrack_free(p)
#define SOKOL_CALLOC(n,s) _smemtrack_calloc(n,s)

#define _SMEMTRACK_HEADER_SIZE (16)

static struct {
    smemtrack_info_t state;
} _smemtrack;

_SOKOL_PRIVATE void* _smemtrack_malloc(size_t size) {
    _smemtrack.state.num_allocs++;
    _smemtrack.state.num_bytes += (int) size;
    uint8_t* ptr = malloc(size + _SMEMTRACK_HEADER_SIZE);
    *(size_t*)ptr = size;
    return ptr + _SMEMTRACK_HEADER_SIZE;
}

_SOKOL_PRIVATE void _smemtrack_free(void* ptr) {
    uint8_t* alloc_ptr = ((uint8_t*)ptr) - _SMEMTRACK_HEADER_SIZE;
    size_t size = *(size_t*)alloc_ptr;
    _smemtrack.state.num_allocs--;
    _smemtrack.state.num_bytes -= (int) size;
    free(alloc_ptr);
}

_SOKOL_PRIVATE void* _smemtrack_calloc(size_t num, size_t size) {
    size_t mem_size = num * size;
    _smemtrack.state.num_allocs++;
    _smemtrack.state.num_bytes += (int) mem_size;
    uint8_t* ptr = malloc(mem_size + _SMEMTRACK_HEADER_SIZE);
    memset(ptr + _SMEMTRACK_HEADER_SIZE, 0, mem_size);
    *(size_t*)ptr = size;
    return ptr + _SMEMTRACK_HEADER_SIZE;
}

SOKOL_API_IMPL smemtrack_info_t smemtrack_info(void) {
    return _smemtrack.state;
}

#endif /* SOKOL_IMPL */