MemMan.h

Go to the documentation of this file.

//Luke Lenhart, 2001-2007
//See /docs/License.txt for details on how this code may be used.

#pragma once

#include "Setup.h"

// --

#if defined(_DEBUG) || defined(ENABLE_MEMMAN_TRACE_IN_RELEASE)
    #define MEMMAN_TRACING
#endif

//decide whether this platform already has a thread-safe new and delete operator
//#ifdef WIN32
    //#define NEEDS_THREADSAFE_ALLOC
//#endif

#include <list>
#include <string>
#include "Types.h"
#include "Locks.h"

//internal use
enum EMemAllocType
{
    EMAT_None,
    EMAT_One,
    EMAT_Array
};

class MemMan
{
public:
    MemMan();
    ~MemMan();

    void AddLeakReportCallback(void (*leakCallback)(const std::string &leakMessage));

    //checks for memory corruption around all allocated memory
    void CheckForPaddingCorruption();

    //tells the memory manager that some memory has been allocated externally (used for tracking max usage only)
    //returns an ID of the hinted allocation
    int HintMemAlloc(int bytes);
    //tells the memory manager that some memory has been freed externally that was previously hinted at
    void HintMemFree(int ID);

    //returns whether the memory manager is ready to handle requests
    inline bool IsReady() const
        { return m_ready; }

    //used by the allocation scheme, do not call directly - traces an alloc or free
    void TraceAlloc(EMemAllocType type, volatile void *addr, void *allocMem, uint size, const char *name, const char *file, int line, int count);
    EMemAllocType TraceFree(EMemAllocType type, volatile void *addr, const char *file, int line, char *&outAllocMem, int *outCount=0);

    //used by the allocation scheme, do not call directly - does a threadsafe alloc or free
    char* InternalAllocBlock(uint bytes);
    void InternalFreeBlock(volatile char *mem);
    void InternalInitialize();
    void InternalShutdown();

#ifdef MEMMAN_TRACING // -- if using management  --

    struct SAlloc
    {
        EMemAllocType type;
        void *addr; //object address
        void *allocMem; //container memory
        uint size;
        std::string objName;
        std::string srcFile;
        int srcLine;
        int count; //number in array
        std::string allocStack;
        std::string deleteStack;

        SAlloc *next;
    };

private:
    bool m_critErrors; //did any critical memory errors occur?

    SAlloc *m_head; //first item in linked list of allocations

    // -- max usage tracking

    int maxMem; //maximum amount of memory ever used
    void RecalcMaxMem(); //recalcs the max memory used

    int curHintAllocID; //ID of next hint to be requested

    struct Hint
    {
        int ID;
        int bytes;
        std::string stack;
    };
    std::list<Hint> hints; //list of all (hint ID,size) hints

#endif //tracing

    //calls back to the leak report callbacks
    void ReportLeak(const std::string &leak);
    std::list<void (*)(const std::string &)> leakCallbacks;

    bool m_ready; //class ready to handle requests
    MPMA::MutexLock *syncLock;

public: //internal
    //calls an objects destructor
    template <typename T> static void dbgN2_Destruct(T *obj)
    {
        obj->~T();
    }
    template <typename T> static void dbgN2_Destruct_array(T *obj, int count)
    {
        for (int i=0; i<count; ++i)
        {
            obj->~T();
            ++obj;
        }
    }
};

extern MemMan mMan;

#ifdef MEMMAN_TRACING // -- if using management  --

//bytes on each side of an allocation that are used to check for damage
#define dbgN2_padding 8

//functions for allocating and setting trace information

template <typename AllocType> AllocType* new2_call(AllocType *obj, const char *name, const char *file, int line)
{
    mMan.TraceAlloc(EMAT_One, obj, (char*)obj-dbgN2_padding, sizeof(AllocType), name, file, line, 1);
    return obj;
}

template <typename AllocType> AllocType* new2_array_call(size_t count, const char *name, const char *file, int line)
{
    //alloc
    char *realMem=mMan.InternalAllocBlock(sizeof(AllocType)*count + dbgN2_padding*2);
    char *allocSpot=realMem+dbgN2_padding;
    AllocType *obj=new (allocSpot) AllocType[count];

    mMan.TraceAlloc(EMAT_Array, obj, realMem, sizeof(AllocType)*count, name, file, line, (int)count);
    return obj;
}

#endif

#ifdef MEMMAN_TRACING // -- if using management  --

//verifies that a type and object declaration are the same type
void dbgN2_PrecheckType(const char *objName, const char *typName);

//macros for freeing and setting trace information

#define delete2_call(obj,pMem,file,line) \
do { \
    int count=0; \
    char *realMem=0; \
    EMemAllocType type=mMan.TraceFree(EMAT_One, obj, file, line, realMem,&count); /*see how it was allocated*/ \
    if (type==EMAT_One) MemMan::dbgN2_Destruct(obj); \
    else if (type==EMAT_Array) MemMan::dbgN2_Destruct_array(obj,count); \
    mMan.InternalFreeBlock(realMem); \
    *((uint**)(pMem))=(uint*)-1; /*invalidate their pointer*/ \
} while(false)

#define delete2_array_call(obj,pMem,file,line) \
do { \
    int count=0; \
    char *realMem=0; \
    EMemAllocType type=mMan.TraceFree(EMAT_Array, obj, file, line, realMem, &count); /*see how it was allocated*/ \
    if (type==EMAT_One) MemMan::dbgN2_Destruct(obj); \
    else if (type==EMAT_Array) MemMan::dbgN2_Destruct_array(obj,count); \
    mMan.InternalFreeBlock(realMem); \
    *((uint**)(pMem))=(uint*)-1; /*invalidate their pointer*/ \
} while(false)


//macros replace normal calls with extra debug information

#define new2(obj,type) (dbgN2_PrecheckType(""#obj,""#type), new2_call(new (mMan.InternalAllocBlock(dbgN2_padding*2+sizeof(type))+dbgN2_padding) obj, ""#obj, __FILE__, __LINE__))
#define new2_array(obj,count,type) (dbgN2_PrecheckType(""#obj,""#type), new2_array_call<type>(count, ""#obj, __FILE__, __LINE__))

#define delete2(obj) delete2_call(obj,(void**)&obj,__FILE__,__LINE__)
#define delete2_array(obj) delete2_array_call(obj,(void**)&obj,__FILE__,__LINE__)

#define hint_mem_alloc(bytes) mMan.HintMemAlloc(bytes)
#define hint_mem_free(ID) mMan.HintMemFree(ID)

#else // -- if NOT using management

#ifdef NEEDS_THREADSAFE_ALLOC //if our platform doesn't have threadsafe new and delete

    #define new2(obj,type) new (mMan.InternalAllocBlock(sizeof(type))) obj

    inline char* MemMan_InjectIntBeforeArray(char *mem, uint count)
    {
        *(uint*)mem=count;
        return mem + sizeof(uint);
    }

    #define new2_array(obj,count,type) new (MemMan_InjectIntBeforeArray(mMan.InternalAllocBlock(sizeof(type)*count + sizeof(uint)), count)) obj

    #define delete2(obj) do {\
        MemMan::dbgN2_Destruct(obj); \
        mMan.InternalFreeBlock((volatile char*)obj); } while(false)

    #define delete2_array(obj) do {\
        MemMan::dbgN2_Destruct_array(obj,*((uint*)obj-1)); \
        mMan.InternalFreeBlock((volatile char*)obj - sizeof(uint)); } while(false)


#else //platform has threadsafe new and delete already

    #define new2(obj,junk) new obj
    #define new2_array(obj,count,junk) new obj[count]

    #define delete2(obj) delete obj
    #define delete2_array(obj) delete[] obj

#endif

#define hint_mem_alloc(bytes) 0
#define hint_mem_free(ID) 

#endif //(build check)


// -- auto scope pointer freer --
//will free a pointer when this goes out of scope (and it's not a null pointer)
//pass in the ADDRESS of your pointer

template <typename T>
class AutoDelete
{
public:
    inline AutoDelete(T *inPtr): ptr(inPtr) {}
    inline ~AutoDelete() {if (ptr) delete2(ptr);}
private:
    T *ptr;
};

template <typename T>
class AutoDeleteArray
{
public:
    inline AutoDeleteArray(T *inPtr): ptr(inPtr) {}
    inline ~AutoDeleteArray() {if (ptr) delete2_array(ptr);}
private:
    T *ptr;
};

---