xalloc.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cx/platform/cpp.h>
#include <cx/utils/macros/optarg.h>
#include <cx/utils/macros/salieri.h>
#include <cx/utils/macros/unused.h>
#include <stdbool.h>
#include <stddef.h>
 
#ifdef XALLOC_REMAP_MALLOC
// these need to be pulled in first so our #defines don't cause chaos when they
// are included
#include <stdlib.h>
#include <string.h>
 
#ifdef _WIN32
// never use this; we have heap profilers these days
#undef _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif
#endif
 
// If this macro is defined, causes the xalloc system to use the
// system-provided allocator rather than mimalloc. There may be some
// loss of functionality and performance when this option is in use,
// but it may be needed on systems with very tightly constrained limits
// on virtual address space allocation.
// #define XALLOC_USE_SYSTEM_MALLOC 1
 
CX_C_BEGIN
 
 
 
#define XA_LG_ALIGN_MASK ((unsigned int)0x3f)
 
#define XA_Align(exp) ((unsigned int)(exp & XA_LG_ALIGN_MASK))
 
#define XA_Zero ((unsigned int)0x0040)
 
enum XA_OPTIONAL_FLAG_ENUM {
    XA_Optional_High = 0x0100,
    XA_Optional_Low  = 0x0200,
    XA_Optional_None = 0x0400
};
#define XA_Optional(typ) ((unsigned int)XA_Optional_##typ)
#define XA_Optional_Mask (XA_Optional_High | XA_Optional_Low | XA_Optional_None)
 
#define XA_Opt XA_Optional(High)
 
// end of xalloc_flags group
 
 
enum XA_OOM_PHASE_ENUM {
    XA_LowEffort = 1,
 
    XA_HighEffort,
 
    XA_Urgent,
 
    XA_Fatal = -1
};
 
#ifndef _MSC_VER
// &* is a safe way to ensure the operand is a pointer, even a pointer to void
#define _xa_ptr_ptr_verify(ptr) unused_noeval(&*(*(ptr)))
#else
// &* doesn't work for void* on MSVC, check for void* conversion instead, but this results
// in a false negative for intptr_t* or pointer-sized ints
#define _xa_ptr_ptr_verify(ptr) unused_noeval((void*)(*(ptr)))
#endif
 
typedef void (*xaOOMCallback)(int phase, size_t allocsz);
 
void xaAddOOMCallback(xaOOMCallback cb);
 
void xaRemoveOOMCallback(xaOOMCallback cb);
 
// end of xalloc_oom group
 
 
#define xaAlloc(size, ...) _xaAlloc(size, opt_flags(__VA_ARGS__))
 
#define xaAllocStruct(typn, ...) (typn*)_xaAlloc(sizeof(typn), opt_flags(__VA_ARGS__))
 
_Check_return_ _When_(flags & XA_Optional_Mask, _Must_inspect_result_ _Ret_maybenull_)
    _When_(!(flags & XA_Optional_Mask), _Ret_notnull_)
        _When_(!(flags & XA_Optional_Mask) && (flags & XA_Zero), _Ret_valid_)
            _Post_writable_byte_size_(size) void* _xaAlloc(size_t size, unsigned int flags);
 
#define xaResize(ptr, size, ...) \
    (_xa_ptr_ptr_verify(ptr), _xaResize((void**)(ptr), size, opt_flags(__VA_ARGS__)))
_At_(*ptr, _Pre_maybenull_) _When_(
    !(flags &
      XA_Optional_Mask), _At_(*ptr, _Post_writable_byte_size_(size)) ) bool _xaResize(_Inout_ void** ptr, size_t size, unsigned int flags);
 
void xaFree(_Pre_maybenull_ _Post_invalid_ void* ptr);
 
#define xaDestroy(ptr) (_xa_ptr_ptr_verify(ptr), _xaDestroy((void**)(ptr)))
_At_(*ptr, _Pre_maybenull_ _Post_null_) bool _xaDestroy(_Inout_ void** ptr);
 
// end of xalloc_core group
 
 
size_t xaSize(_In_ void* ptr);
 
size_t xaOptSize(size_t sz);
 
// end of xalloc_introspection group
 
void xaFlush();
 
CX_C_END
 
// String utilities because cstrDup is tied in with xalloc
// and there's no better place for them
#include <cx/xalloc/cstrutil.h>
 
#ifdef XALLOC_REMAP_MALLOC
#define malloc(sz)       xa_malloc(sz)
#define calloc(num, sz)  xa_calloc(num, sz)
#define free(ptr)        xa_free(ptr)
#define realloc(ptr, sz) xa_realloc(ptr, sz)
#define strdup(s)        cstrDup(s)
#define _strdup(s)       cstrDup(s)
#define wcsdup(s)        cstrDupw(s)
#define _wcsdup(s)       cstrDupw(s)
 
#ifdef _WIN32
#undef _malloc_dbg
#define _malloc_dbg(sz, t, f, ln) xa_malloc(sz)
#undef _calloc_dbg
#define _calloc_dbg(num, sz, t, f, ln) xa_calloc(num, sz)
#undef _free_dbg
#define _free_dbg(ptr, t) xa_free(ptr)
#undef _realloc_dbg
#define _realloc_dbg(ptr, sz, t, f, ln) xa_realloc(ptr, sz)
#undef _strdup_dbg
#define _strdup_dbg(s, t, f, ln) cstrDup(s)
#undef _wcsdup_dbg
#define _wcsdup_dbg(s, t, f, ln) cstrDupw(s)
#endif
#endif
 
 
#ifdef XALLOC_COMPAT_REQUIRE
#define XA_COMPAT_OPT_FLAG 0
#else
#define XA_COMPAT_OPT_FLAG XA_Opt
#endif
 
// for compatibility with 3rd party libraries only
inline void* xa_malloc(size_t size)
{
    return _xaAlloc(size, XA_COMPAT_OPT_FLAG);
}
 
inline void* xa_calloc(size_t number, size_t size)
{
    return _xaAlloc(number * size, XA_Zero | XA_COMPAT_OPT_FLAG);
}
 
inline void* xa_realloc(void* ptr, size_t size)
{
    return _xaResize(&ptr, size, XA_COMPAT_OPT_FLAG) ? ptr : (void*)0;
}
 
inline void xa_free(void* ptr)
{
    xaFree(ptr);
}
 
inline char* xa_strdup(const char* src)
{
    return cstrDup(src);
}
 
// end of xalloc_compat group
 
// end of xalloc group