DebugAlloc.cpp

Go to the documentation of this file.

#define _CRT_SECURE_NO_DEPRECATE
 
#include <dcl/Config.h>
#if __DCL_WINDOWS
#include <windows.h>        // for dcl/Thread.h
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
 
#include <stdlib.h>     // malloc, free
#include <string.h>     // strcpy, strlen
#include <wchar.h>      // wcslen, wcscpy
 
#include "LibState.h"
 
#include <dcl/Object.h>
#include <dcl/Thread.h>
#include <dcl/Writer.h>
 
#define __strlen(s) wcslen(s)
#define __strcpy(d, s)  wcscpy(d, s)
 
#undef new
#undef malloc
#undef realloc
#undef calloc
#undef free
 
//#ifdef __GNUC__
//#include <dcl/_trace.h>
//#endif
 
#define __DCL_ASSERT_N(expr)        // no assert
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/DebugAlloc.cpp");
 
__DCL_BEGIN_NAMESPACE
 
extern LibState* __pLibState;
 
// https://en.wikipedia.org/wiki/Thread-local_storage
#ifdef _MSC_VER
#define THREAD_LOCAL_STORAGE __declspec(thread)
#elif defined(__GNUC__)
#define THREAD_LOCAL_STORAGE __thread
#endif
 
static THREAD_LOCAL_STORAGE const char_t* __near_filename = NULL;
static THREAD_LOCAL_STORAGE unsigned int __near_line = 0;
 
__DCL_END_NAMESPACE
 
__DCL_USING_NAMESPACE
 
DCLCAPI void DCLDebugAllocEnterNear(
            const char_t* _filename,
            unsigned int    _line
            )
{
    __near_filename = _filename;
    __near_line = _line;
}
 
/* 
static const char_t* __LimiteFileName(const char_t* _filename)
{
    size_t n = __strlen(_filename);
    if (n > 128)
        return _filename + n - 128;
    return _filename;
}
 */
 
DCLCAPI void* DCLDebugMalloc(
            size_t          _size,
            bool            _check,
            DCLAllocFunction allocFunction,
            const char_t* _filename,
            unsigned int    _line
            )
{
    if (_filename == NULL) {
        _filename = __near_filename;
        _line = __near_line;
    }
 
    if (_size == 0)
    {
        DCLDebugTrace(
            _filename, _line,
            __T("MEMDBG Warning! malloc(size:%d)!\n"), _size
            );
 
        return NULL;
    }
 
    void* p = NULL;
 
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
    
    lockAlloc.lock();
 
    p = listAlloc.allocAddTail(
                        _size,
                        _check,
                        allocFunction,
                        _filename,
                        _line
                        );
 
    lockAlloc.unlock();
 
    return p;
}
 
static const char_t* __AllocTypeStr(DCLAllocFunction allocFunction)
{
    switch(allocFunction)
    {
    case DCL_ALLOC_DEFAULT :
        return __T("default");
    case DCL_ALLOC_NEW :
        return __T("new");
    case DCL_ALLOC_NEW_ARRAY :
        return __T("new[]");
    case DCL_ALLOC_NEW_OBJECT :
        return __T("new object");
    case DCL_ALLOC_NEW_OBJECT_ARRAY :
        return __T("new[] object");
    case DCL_ALLOC_DELETE :
        return __T("delete");
    case DCL_ALLOC_DELETE_ARRAY :
        return __T("delete[]");
    case DCL_ALLOC_DELETE_OBJECT :
        return __T("delete object");
    case DCL_ALLOC_DELETE_OBJECT_ARRAY :
        return __T("delete[] object");
    }
 
    return __T("unknown!");
}
 
static bool __IsValidAllocFunction(
                    DCLAllocFunction allocType,
                    DCLAllocFunction freeType
                )
{
    switch(allocType)
    {
    case DCL_ALLOC_DEFAULT :
        return DCL_ALLOC_DEFAULT == freeType;
    case DCL_ALLOC_NEW :
        return DCL_ALLOC_DELETE == freeType;
    case DCL_ALLOC_NEW_ARRAY :
        return DCL_ALLOC_DELETE_ARRAY == freeType;
    case DCL_ALLOC_NEW_OBJECT :
        return DCL_ALLOC_DELETE_OBJECT == freeType;
    case DCL_ALLOC_NEW_OBJECT_ARRAY :
        return DCL_ALLOC_DELETE_OBJECT_ARRAY == freeType;
    // not used for GCC warnings
    case DCL_ALLOC_DELETE :
        return DCL_ALLOC_NEW == freeType;
    case DCL_ALLOC_DELETE_ARRAY :
        return DCL_ALLOC_NEW_ARRAY == freeType;
    case DCL_ALLOC_DELETE_OBJECT :
        return DCL_ALLOC_NEW_OBJECT == freeType;
    case DCL_ALLOC_DELETE_OBJECT_ARRAY :
        return DCL_ALLOC_NEW_OBJECT_ARRAY == freeType;
    }
    return false;
}
 
DCLCAPI void DCLDebugFree(
            void*           __p,
            DCLAllocFunction allocFunction,
            const char_t* __filename,
            unsigned int    __line
            )
{
    if (!__p)
    {
        DCLDebugTrace(
            __filename, __line,
            __T("MEMDBG Error! free(p:NULL) p is NULL assigned!\n")
            );
 
        DCLDebugAssert(__filename, __line, __T("p != NULL"),  __T("free(p:NULL)"));
        // throw or abort
    }
 
    // DCLDebugAssert, DCLDebugTrace의 출력은 메모리를 할당하는 OutputStream을 사용하기 때문에
    // 다음의 lock() ... unlock() 내부에서 DCLDebugAssert와 DCLDebugTrace를 사용할 수 없다.
    // lock() ... unlock() 에서는 메지시를 만들고 마지막에서 출력한다.
 
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    AllocList::Node* pNode = NULL;
    bool bValidFunction;
    char_t szAllocFile[512];
    int nAllocLine;
    DCLAllocFunction af;
 
    lockAlloc.lock();
    pNode = listAlloc.rfind(__p);
    if (pNode)
    {
        bValidFunction = __IsValidAllocFunction(pNode->allocFunction, allocFunction);
        if (!bValidFunction)
        {
            __strcpy(szAllocFile, pNode->szFileName);
            nAllocLine = pNode->nLine;
            af = pNode->allocFunction;
        }
        listAlloc.erase(pNode);
    }
    lockAlloc.unlock();
 
    if (__filename == NULL)
        __filename = __T("delete location");
 
    if (pNode == NULL)
        DCLDebugTrace(__filename, __line, __T("MEMDBG Error! Cannot found prev alloc!!\n"));
    else if (!bValidFunction)
        DCLDebugTrace(__filename, __line,
            __T("MEMDBG Error! No Match allocFunction!! alloc:%ls:%d:%ls ==> free:%ls\n"),
            szAllocFile, nAllocLine, __AllocTypeStr(af),
            __AllocTypeStr(allocFunction)
            );
}
 
DCLCAPI void* DCLDebugCalloc(
            size_t          __count,
            size_t          _size,
            bool            __check,
            const char_t* __filename,
            unsigned int    __line
            )
{
    if ((__count == 0) || (_size == 0))
    {
        DCLDebugTrace(
            __filename, __line,
            __T("MEMDBG Warning! calloc(count:%d, size:%d)! %ls(%d)\n"),
            __count, _size
            );
        return NULL;
    }
 
    size_t nTotalSize = __count * _size;
 
    void* result = DCLDebugMalloc(
                nTotalSize,
                __check,
                DCL_ALLOC_DEFAULT,
                __filename,
                __line
                );
 
    memset(result, 0, nTotalSize);
    return result;
}
 
DCLCAPI void* DCLDebugRealloc(
            void*           __oldptr,
            size_t          __newsize,
            bool            __check,
            const char_t* __filename,
            unsigned int    __line
            )
{
    if ((__oldptr == NULL) || (__newsize == 0))
    {
        DCLDebugTrace(
            __filename, __line,
            __T("MEMDBG Warning! realloc(oldptr:%p, newsize:%d)\n"),
            __oldptr,
            __newsize
            );
//      return NULL;
    }
 
    void* newptr = NULL;
    AllocList::Node* pOldNode = NULL;
    char_t szOldFileName[512];
    int nOldLine;
    DCLAllocFunction oldAF = DCL_ALLOC_DEFAULT;
 
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    lockAlloc.lock();
 
    if (__oldptr)
    {
        pOldNode = listAlloc.rfind(__oldptr);
        if (pOldNode)
        {
            if (__newsize == 0)
            {
                // nNewSize가 0 이다. 노드를 삭제하고
                // return NULL
                listAlloc.erase(pOldNode);
            }
            else
            {
                if (pOldNode->allocFunction != DCL_ALLOC_DEFAULT)
                {
                    __strcpy(szOldFileName, pOldNode->szFileName);
                    nOldLine = pOldNode->nLine;
                    oldAF = pOldNode->allocFunction;
                }
                else
                {
                    // 노드를 realloc하고 update한다.
 
                    AllocList::Node* pNewNode =
                        listAlloc.reallocNode(
                                pOldNode,
                                __newsize,
                                __filename,
                                __line
                                );
                    if (pNewNode)
                        newptr = pNewNode->data();
                }
            }
        }
    }
    else // NULL == oldptr
    {
        if (__newsize)
            newptr = listAlloc.allocAddTail(
                        __newsize,
                        __check,
                        DCL_ALLOC_DEFAULT,  //allocFunction
                        __filename,
                        __line
                        );
    }
 
    lockAlloc.unlock();
 
    if (pOldNode == NULL)
        DCLDebugTrace(__filename, __line, __T("MEMDBG Error! Cannot found prev alloc!!\n"));
    else if (oldAF != DCL_ALLOC_DEFAULT)
        DCLDebugTrace(__filename, __line,
            __T("MEMDBG Error! Invalid realloc!! prev:%ls:%d:%ls ==> realloc\n"),
            szOldFileName, nOldLine, __AllocTypeStr(oldAF)
            );
 
    return newptr;
}
 
DCLCAPI bool DCLDebugAllocIsValid(const void* _ptr)
{
    bool bFound = false;
 
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    lockAlloc.lock();
    bFound = listAlloc.find(_ptr) != NULL;
    lockAlloc.unlock();
 
    return bFound;
}
 
DCLCAPI void DCLDebugAllocSetCheckFlag(
            const void*     _ptr,
            bool            _check
            )
{
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    lockAlloc.lock();
    AllocList::Node* pNode = listAlloc.rfind(_ptr);
    if (pNode)
        pNode->bCheck = _check;
    lockAlloc.unlock();
}
 
DCLCAPI bool DCLDebugAllocGetPosition(
            const void*     _ptr,
            char_t*           _pfilename,
            size_t          _count,
            unsigned int*   _pline
            )
{
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    lockAlloc.lock();
    AllocList::Node* pNode = listAlloc.rfind(_ptr);
    if (pNode) {
        wcsncpy(_pfilename, pNode->szFileName, _count);
        *_pline = pNode->nLine;
    }
    lockAlloc.unlock();
 
    return pNode != NULL;
}
 
/* 
return : uThreadId가 할당한 마지막 포지션 항목이 없으면 NULL
*/
DCLCAPI const void* DCLDebugGetLastAllocPosition(
            unsigned long uThreadId
            )
{
    const void* pv = NULL;
 
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
    
    lockAlloc.lock();
    AllocList::Node* pNode = listAlloc.end();
    while(pNode)
    {
        if (pNode->uThreadId == uThreadId)
        {
            pv = (const void*)pNode;
            break;
        }
 
        listAlloc.prev(pNode);
    }
    lockAlloc.unlock();
 
    return pv;
}
 
/* 
uThreadId가 pvBegin에서 pvEnd까지의 메모리 누출 보고
return : 메모리 누출 항목의 갯수 >= 0
*/
DCLCAPI size_t DCLDebugDumpThreadMemoryLeak(
                unsigned long uThreadId,
                const void* pvStartPosition,
                DCLAllocLeakDumpLevel level,
                __DCL_NAMESPACE Writer* pWriter
                )
{
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    lockAlloc.lock();
 
    AllocList::Node* pStartNode = listAlloc.begin();
    AllocList::Node* pNode = pStartNode;
    if (pvStartPosition)
    {
        while(pNode)
        {
            if (pvStartPosition == (const void*)pNode)
            {
                listAlloc.next(pNode);
                pStartNode = pNode;
                break;
            }
            listAlloc.next(pNode);
        }
    }
 
 
    // uThreadId인 노드 갯수
    size_t nCount = 0;
    pNode = pStartNode;
    while(pNode)
    {
        if (pNode->uThreadId == uThreadId)
        {
            nCount++;
        }
        listAlloc.next(pNode);
    }
 
    AllocList::Node* pLeaks = NULL;
    if (nCount)
    {
        // 메모리 누출이 있으면 이를 출력할 임시 버퍼를 할당한다.
        // pWriter에서 메모리할당을 할 경우 그대로 사용하면 deadlock이 발생한다.
        // __allocLock 이 lock 되어 있다.
        pLeaks = (AllocList::Node*) malloc(sizeof(AllocList::Node) * nCount);
        if (!pLeaks)
        {
            // 메모리를 할당할 수 없다.
            lockAlloc.unlock();
            return -1;
        }
 
        pNode = pStartNode;
        int i = 0;
        while(pNode)
        {
            if (pNode->uThreadId == uThreadId)
                memcpy(&pLeaks[i++], pNode, sizeof(AllocList::Node));
 
            listAlloc.next(pNode);
        }
        __DCL_ASSERT_N(i  == nCount);
    }
 
    lockAlloc.unlock();
 
    // __allocLock이 unlock 되었으므로 OutputStream은 출력 중에 메모리를 할당할 수 있다.
    if (nCount)
    {
        bool bHeaderPrint = false;
        bool bDoPrint = false;
 
        pNode = pLeaks;
        for(size_t i = 0; i < nCount; i++)
        {
            switch(level)
            {
            default :
            case DCL_ALLOC_DUMP_ALL :
                bDoPrint = true;
                break;
            case DCL_ALLOC_DUMP_INTERNAL :
                bDoPrint = !(pNode->bCheck);
                break;
            case DCL_ALLOC_DUMP_USER :
                bDoPrint = pNode->bCheck;
                break;
            }
 
            if (bDoPrint)
            {
                if (!bHeaderPrint)
                {
                    pWriter->printf(__T("Thread memory leak!\n  thread:%u\n"), uThreadId);
                    bHeaderPrint = true;
                }
 
                try
                {
                    pWriter->printf(L"  %2d:%lc:%ls:%d:%ls:%zdbytes:%p\n",
                                i + 1,
                                pNode->bCheck ? L'U' : L'I',
                                *(pNode->szFileName) ? pNode->szFileName : L"(unknown)",
                                pNode->nLine,
                                __AllocTypeStr(pNode->allocFunction),
                                pNode->nSize,
                                pNode->data()
                                );
                }
                catch(IOException* e)
                {
                    e->destroy();
                    // OutputStream 출력중에 에러가 발생했다.
                    nCount = -1;
                    break;
                }
            }
            pNode++;
        }   // end of for
        free(pLeaks);
    }
    
    return nCount;
}
 
DCLCAPI size_t DCLDebugDumpGlobalMemoryLeak(
                DCLAllocLeakDumpLevel level,
                __DCL_NAMESPACE Writer* pWriter
                )
{
    AllocList::Node* pNode = NULL;
    AllocList::Node* pLeaks = NULL;
 
    AllocList& listAlloc = __pLibState->listAlloc;
    InternalMutex& lockAlloc = __pLibState->lockAlloc;
 
    lockAlloc.lock();
    size_t nCount = listAlloc.count();
    if (nCount > 0)
    {
        // 메모리 누출이 있으면 이를 출력할 임시 버퍼를 할당한다.
        // pWriter에서 메모리할당을 할 경우 그대로 사용하면 deadlock이 발생한다.
        // __allocLock 이 lock 되어 있다.
        pLeaks = (AllocList::Node*)malloc(sizeof(AllocList::Node) * nCount);
        if (!pLeaks)
        {
            // 메모리를 할당할 수 없다.
            lockAlloc.unlock();
            return -1;
        }
 
        pNode = listAlloc.begin();
        size_t i = 0;
        while(pNode)
        {
            memcpy(&pLeaks[i++], pNode, sizeof(AllocList::Node));
 
            listAlloc.next(pNode);
        }
        __DCL_ASSERT_N(i == nCount);
    }
 
    lockAlloc.unlock();
 
    // __allocLock이 unlock 되었으므로 OutputStream은 출력 중에 메모리를 할당할 수 있다.
    if (nCount)
    {
        bool bHeaderPrint = false;
        bool bDoPrint = false;
 
        pNode = pLeaks;
        for(size_t i = 0; i < nCount; i++)
        {
            switch(level)
            {
            default :
            case DCL_ALLOC_DUMP_ALL :
                bDoPrint = true;
                break;
            case DCL_ALLOC_DUMP_INTERNAL :
                bDoPrint = !(pNode->bCheck);
                break;
            case DCL_ALLOC_DUMP_USER :
                bDoPrint = pNode->bCheck;
                break;
            }
 
            if (bDoPrint)
            {
                if (!bHeaderPrint)
                {
                    pWriter->printf(L"Global memory leak!\n");
                    bHeaderPrint = true;
                }
 
                try
                {
                    pWriter->printf(L"  %2d:%u:%lc:%ls:%d:%ls:%zdbytes:%p\n",
                                i + 1,
                                pNode->uThreadId,
                                pNode->bCheck ? L'U' : L'I',
                                *(pNode->szFileName) ? pNode->szFileName : L"(unknown)",
                                pNode->nLine,
                                __AllocTypeStr(pNode->allocFunction),
                                pNode->nSize,
                                pNode->data()
                                );
                }
                catch(IOException* e)
                {
                    e->destroy();
                    // OutputStream 출력중에 에러가 발생했다.
                    nCount = -1;
                    break;
                }
            }
            pNode++;
        }
        free(pLeaks);
    }
    
    return nCount;
}

// C++ new/delete
 
DCLCAPI void* operator new(
                size_t          _size,
                bool            _check,
                const char_t* _filename,
                unsigned int    _line
                )
{
    return DCLDebugMalloc(
                _size == 0 ? 1 : _size,
                _check,
                DCL_ALLOC_NEW, 
                _filename,
                _line
                );
}
 
DCLCAPI void* operator new[](
                size_t          _size,
                bool            _check,
                const char_t* _filename,
                unsigned int    _line
                )
{
    return DCLDebugMalloc(
                _size == 0 ? 1 : _size,
                _check,
                DCL_ALLOC_NEW_ARRAY,
                _filename,
                _line
                );
}
 
DCLCAPI void operator delete(
                void*           _ptr,
                bool            ,// _check
                const char_t* _filename,
                unsigned int    _line
                )
{
    DCLDebugFree(
        _ptr,
        DCL_ALLOC_DELETE,
        _filename,
        _line
        );
}
 
DCLCAPI void operator delete[](
                void*           _ptr,
                bool            ,// _check
                const char_t* _filename,
                unsigned int    _line
                )
{
    __DCL_TRACE0(L"delete[] _ptr bool..\n");
    DCLDebugFree(
        _ptr,
        DCL_ALLOC_DELETE_ARRAY,
        _filename,
        _line);
}
 
 
#if !__DCL_WINDOWS
// 원칙적으로 디버그 버전의 라이브러리에서는 다음의 연산자들이 사용될 수 없으나
// 디버그 버전과 릴리즈 버전이 같은 프로세스에서 함께 사용될 경우
// 릴리즈 버전의 new, new[], delete, delete[] 연산자가 디버그 버전에서 정의한
// 연산자의 구현이 호출된다.
// 다음의 new, new[]가 호출되면 이들의 호출기록을 저장하고 있다가
// delete, delete[]에서 검사한다. 
DCLCAPI void* operator new(size_t _size)
{
    void* r = DCLDebugMalloc(
            _size == 0 ? 1 : _size,
            true,
            DCL_ALLOC_NEW,
            NULL,
            0
        );
    // fprintf(stderr, "%ls:%d [%zd][%p]\n",
    //  __near_filename ? __near_filename : L"(unknown)",
    //  __near_line, _size, r);
    return r;
}
 
DCLCAPI void* operator new[](size_t _size)
{
    void* r = DCLDebugMalloc(
            _size == 0 ? 1 : _size,
            true,
            DCL_ALLOC_NEW_ARRAY,
            NULL,
            0
        );
    // fprintf(stderr, "%ls:%d [%zd][%p]\n",
    //  __near_filename ? __near_filename : L"(unknown)",
    //  __near_line, _size, r);
    return r;
}
 
DCLCAPI void operator delete(void* _ptr)
{
    // fprintf(stderr, "%ls:%d [%p]\n",
    //  __near_filename ? __near_filename : L"(unknown)",
    //  __near_line, _ptr);
    DCLDebugFree(_ptr, DCL_ALLOC_DELETE, NULL, 0);
}
 
DCLCAPI void operator delete[](void* _ptr)
{
    // fprintf(stderr, "%ls:%d [%p]\n",
    //  __near_filename ? __near_filename : L"(unknown)",
    //  __near_line, _ptr);
    DCLDebugFree(_ptr, DCL_ALLOC_DELETE_ARRAY, NULL, 0);
}
 
#endif      // !__DCL_WINDOWS
#endif      // __DCL_HAVE_ALLOC_DEBUG