Memory.h

Go to the documentation of this file.

//Luke Lenhart, 2001-2008
//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

#include <list>
#include <string>
#include <string.h> //for memset
#include "Types.h"
#include "Locks.h"

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

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

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

    //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, void *memory, void *object, uint objectSize, int count, const char *file, int line);
    EMemAllocType TraceFree(EMemAllocType type, volatile void *object, char *&outAllocMem, int *outObjectSize, int *outCount, const char *file, int line);

    //used by the allocation scheme, do not call directly
    void InternalInitialize();
    void InternalShutdown();

#ifndef MEMMAN_TRACING // -- if NOT using management --
    //Returns if a specific pointer is an allocated object (always returns true if management is disabled)
    inline bool IsPointerAnObject(void *p)
        { return true; }

    //checks for memory corruption around all allocated memory
    inline void CheckForPaddingCorruption() {}
#endif

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

    //Returns if a specific pointer is an allocated object (always returns true if management is disabled)
    bool IsPointerAnObject(void *p);

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

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

        SAlloc *next;

        std::string Describe();
    };

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

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

    //used internally
    bool VerifyAllocPadding(uint8 *mem, uint objSize);

    //used as part of mapping the difference between the memory we provide for an object and the memory new return to the caller
    struct SMapAllocDifference
    {
        void *actual;
        void *returned;
    };
    std::list<SMapAllocDifference> allocDifferences;
    MPMA::MutexLock *allocDiffLock;

#endif // -- end if using management --

    //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 use, do not call directly
#ifdef MEMMAN_TRACING // -- if using management --
    //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;
        }
    }

    //used as part of tracking a allocation differences
    template <typename T> static T dbgN3_ReturnNew(T obj)
    {
        AllocDifferenceMapEnd(obj);
        return obj;
    }

    static void AllocDifferenceMapStart(void *mem);
    static void AllocDifferenceMapEnd(void *mem);

    static void* DeallocDifferenceMap(void *mem, bool pop);
#endif // -- end if using management --
};

extern MPMAMemoryManager mpmaMemoryManager;

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

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

//allocators that store tracing information
void* operator new(size_t objLen, MPMAMemoryManager *theMan, const char *file, int line);

#define new3(obj)       MPMAMemoryManager::dbgN3_ReturnNew(new (&mpmaMemoryManager, __FILE__, __LINE__) obj)
#define new2(obj, junk) new3(obj)

void* operator new[](size_t objLen, MPMAMemoryManager *theMan, size_t count, const char *file, int line);

#define new3_array(obj, count)       MPMAMemoryManager::dbgN3_ReturnNew(new (&mpmaMemoryManager, count, __FILE__, __LINE__) obj[count])
#define new2_array(obj, count, junk) new3_array(obj, count)

//freers that match the above allocators

void operator delete(void *obj, MPMAMemoryManager *theMan, const char *file, int line);

void operator delete[](void *obj, MPMAMemoryManager *theMan, size_t count, const char *file, int line);

#define delete3(obj) \
do { \
    void *pObj=(void*)(obj); \
    int count=0; \
    int objSize=0; \
    char *realMem=0; \
    EMemAllocType type=mpmaMemoryManager.TraceFree(EMAT_One, pObj, realMem, &objSize, &count, __FILE__, __LINE__); \
    if (type==EMAT_One) MPMAMemoryManager::dbgN2_Destruct(obj); \
    else if (type==EMAT_Array) MPMAMemoryManager::dbgN2_Destruct_array(obj, count); \
    memset(pObj, 0x7e, objSize); \
    delete[] realMem; \
    *((uint**)&obj)=(uint*)-1; \
} while(false)

#define delete2(obj) delete3(obj) 

#define delete3_array(obj) \
do { \
    void *pObj=(void*)(obj); \
    int count=0; \
    int objSize=0; \
    char *realMem=0; \
    EMemAllocType type=mpmaMemoryManager.TraceFree(EMAT_Array, pObj, realMem, &objSize, &count, __FILE__, __LINE__); \
    if (type==EMAT_One) MPMAMemoryManager::dbgN2_Destruct(obj); \
    else if (type==EMAT_Array) MPMAMemoryManager::dbgN2_Destruct_array(obj, count); \
    memset(pObj, 0x7e, objSize); \
    delete[] realMem; \
    *((uint**)&obj)=(uint*)-1; \
} while(false)

#define delete2_array(obj) delete3_array(obj)

#else // -- if NOT using management --

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

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

#endif // -- end if using management --


// -- 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;
};