xallocator.h

Go to the documentation of this file.

#ifndef _XALLOCATOR_H
#define _XALLOCATOR_H
 
#include <cstdint>
#include <stddef.h>
 
// @see https://github.com/endurodave/xallocator
// David Lafreniere
 
#ifdef __cplusplus
// Define AUTOMATIC_XALLOCATOR_INIT_DESTROY to automatically call xalloc_init() and
// xalloc_destroy() when using xallocator in C++ projects. On embedded systems that
// never exit, you can save 1-byte of RAM storage per translation unit by undefining
// AUTOMATIC_XALLOCATOR_INIT_DESTROY and calling xalloc_init() manually before the OS
// starts. 
#define AUTOMATIC_XALLOCATOR_INIT_DESTROY 
#ifdef AUTOMATIC_XALLOCATOR_INIT_DESTROY
class XallocInitDestroy
{
public:
    XallocInitDestroy();
    ~XallocInitDestroy();
private:
    static int32_t refCount;
};
static XallocInitDestroy xallocInitDestroy;
#endif  // AUTOMATIC_XALLOCATOR_INIT_DESTROY
#endif  // __cplusplus
 
#ifdef __cplusplus
extern "C" {
#endif
 
void xalloc_init();
 
void xalloc_destroy();
 
void *xmalloc(size_t size);
 
void xfree(void* ptr);
 
void *xrealloc(void *ptr, size_t size); 
 
void xalloc_stats();
 
#ifdef DMQ_ALLOCATOR
    // Macro to overload new/delete with xalloc/xfree. Add macro to any class to enable
    // fixed-block memory allocation. Add to a base class provides fixed-block memory
    // for the base and all derived classes.
    // 
    // While std::make_shared is usually recommended for standard C++, in a fixed-block 
    // memory architecture, explicit 'new' is required to trigger the overloaded operator.
    //
    // Example:
    //   class MyMsg { 
    //       XALLOCATOR 
    //   };
    //
    //   // BAD: Allocates global memory (Bypasses XALLOCATOR)
    //   auto msg = std::make_shared<MyMsg>(); 
    //
    //   // GOOD: Allocates fixed-block memory (Uses XALLOCATOR)
    //   std::shared_ptr<MyMsg> msg(new MyMsg());
    #define XALLOCATOR \
        public: \
            void* operator new(size_t size) { \
                return xmalloc(size); \
            } \
            void* operator new(size_t size, void* mem) { \
                return mem; \
            } \
            void* operator new(size_t size, const std::nothrow_t& nt) { \
                return xmalloc(size); \
            } \
            void* operator new[](size_t size) { \
                return xmalloc(size); \
            } \
            void operator delete(void* pObject) { \
                xfree(pObject); \
            } \
            void operator delete(void* pObject, const std::nothrow_t& nt) { \
                xfree(pObject); \
            } \
            void operator delete[](void* pData) { \
                xfree(pData); \
            }
#endif
 
#ifdef __cplusplus 
}
#endif
 
#endif