LibState.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>
#include <string.h>
#include <wchar.h>          // wcslen, wcscpy, wcsncpy
 
#if __DCL_PTHREAD
    #include <pthread.h>    // pthread_mutex_lock, pthread_mutex_unlock
#elif __DCL_WINDOWS
    #include <windows.h>    // InterlockedIncrement, InterlockedDecrement
#endif
 
#include <dcl/Thread.h>
#include "LibState.h"
 
#undef new
#undef malloc
#undef realloc
#undef calloc
#undef free
 
#define __strlen(s)     wcslen(s)
#define __strcpy(d, s)  wcscpy(d, s)
#define __strncpy(d, s, n)  wcsncpy(d, s, n)
 
#define __TRACE_THIS    0
#define __DCL_ASSERT_N(expr)
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/LibState.cpp");
 
__DCL_BEGIN_NAMESPACE
 
InternalMutex::InternalMutex(const char* pszName)
{
#if __DCL_PTHREAD
    pthread_mutex_init(&m_mutex, NULL);
#elif __DCL_WINDOWS
    InitializeCriticalSection(&m_cs);
#endif
    m_pszName = pszName;
}
 
InternalMutex::~InternalMutex()
{
#if __DCL_PTHREAD
    pthread_mutex_destroy(&m_mutex);
#elif __DCL_WINDOWS
    DeleteCriticalSection(&m_cs);
#endif
}
 
void InternalMutex::lock()
{
#if __DCL_PTHREAD
    pthread_mutex_lock(&m_mutex);
#elif __DCL_WINDOWS
    EnterCriticalSection(&m_cs);
#endif
}
 
void InternalMutex::unlock()
{
#if __DCL_PTHREAD
    pthread_mutex_unlock(&m_mutex);
#elif __DCL_WINDOWS
    LeaveCriticalSection(&m_cs);
#endif
}
 
#if __DCL_HAVE_ALLOC_DEBUG
size_t AllocList::Node::size()
{
    size_t r = sizeof(Node) % 8;
    if (r)
        return sizeof(Node) + 8 - r;
    return sizeof(Node);
}
 
void* AllocList::Node::data() const
{ 
    return (char*)this + Node::size(); 
}
 
void AllocList::Node::assignFileName(const char_t* _filename)
{
    __DCL_ASSERT_N(_filename != NULL);
 
    size_t nLen = __strlen(_filename);
    if (nLen > __DCL_DEBUG_PATH_MAX) {
         __strncpy(szFileName, _filename, 8);
         __strncpy(szFileName + 8, __T("..."), 3);
        _filename += nLen - __DCL_DEBUG_PATH_MAX + 8;
         __strcpy(szFileName + 11, _filename);
    }
    else
        __strcpy(szFileName, _filename);
}
 
AllocList::Node* AllocList::allocNode(
        size_t nSize,
        bool bCheck,
        DCLAllocFunction allocFunction, 
        const char_t* _filename,
        unsigned int _line
        )
{
    __DCL_ASSERT_N(nSize > 0);
 
    Node* pNewNode = (Node*)malloc(Node::size() + nSize);
    if (pNewNode) {
        pNewNode->uThreadId = Thread::getCurrentThreadId();
        pNewNode->bCheck = bCheck;
        pNewNode->allocFunction = allocFunction;
 
        if (_filename)
            pNewNode->assignFileName(_filename);
        else
            pNewNode->szFileName[0] = '\0';
 
        pNewNode->nLine = _line;
        pNewNode->nSize = nSize;
    }
    return pNewNode;
}
 
void* AllocList::addTail(Node* pNewNode)
{
    __DCL_ASSERT_N(pNewNode != NULL);
 
    NodeBase* pMasterNode = &m_masterNode;
 
    pNewNode->pNext = pMasterNode;
    pNewNode->pPrev = pMasterNode->pPrev;
 
    pNewNode->pPrev->pNext = pNewNode;
    pMasterNode->pPrev = pNewNode;
    m_nCount++;
        
    return pNewNode->data();
}
 
AllocList::Node* AllocList::reallocNode(
        Node* pNode,
        size_t nSize,
        const char_t* _filename,
        unsigned int _line
        )
{
    __DCL_ASSERT_N(pNode != NULL);
    __DCL_ASSERT_N(nSize > 0);
 
    // realloc은 realloc전과 후의 주소가 서로 다를 수 있다.
    // 이전의 노드 정보를 저장한다.
    NodeBase* pPrevSave = pNode->pPrev;
    NodeBase* pNextSave = pNode->pNext;
 
    bool bCheckSave = pNode->bCheck;
    DCLAllocFunction allocTypeSave = pNode->allocFunction;
 
    Node* pNewNode = (Node*)realloc(pNode, Node::size() + nSize);
    if (pNewNode) {
        if (pNewNode != pNode) {
            pPrevSave->pNext = pNewNode;
            pNextSave->pPrev = pNewNode;
 
        //  pNewNode->pPrev = pPrevSave;
        //  pNewNode->pNext = pNextSave;
 
            pNewNode->uThreadId = Thread::getCurrentThreadId();
            pNewNode->bCheck = bCheckSave;
            pNewNode->allocFunction = allocTypeSave;
        }
 
        if (_filename)
            pNewNode->assignFileName(_filename);
        else
            pNewNode->szFileName[0] = L'\0';
 
        pNewNode->nLine = _line;
        pNewNode->nSize = nSize;
    }
    return pNewNode;
}
 
AllocList::AllocList()
{
    NodeBase* pMasterNode = &m_masterNode;
    pMasterNode->pPrev = pMasterNode;
    pMasterNode->pNext = pMasterNode;
 
    m_nCount = 0;
}
 
AllocList::~AllocList()
{
//  if (m_nCount)
//      clear();
}
 
AllocList::Node* AllocList::begin() const
{
    const NodeBase* pMasterNode = &m_masterNode;
 
    if (pMasterNode->pNext == pMasterNode)
        return NULL;
 
    return (Node*)pMasterNode->pNext;
}
 
AllocList::Node* AllocList::end() const
{
    const NodeBase* pMasterNode = &m_masterNode;
 
    if (pMasterNode->pPrev == pMasterNode)
        return NULL;
 
    return (Node*)pMasterNode->pPrev;
}
 
AllocList::Node* AllocList::next(Node*& pNode) const
{
    __DCL_ASSERT_N(pNode != NULL);
 
    const NodeBase* pMasterNode = &m_masterNode;
 
    if (pNode->pNext == pMasterNode)
        pNode = NULL;
    else
        pNode = (Node*)pNode->pNext;
 
    return pNode;
}
 
AllocList::Node* AllocList::prev(Node*& pNode) const
{
    __DCL_ASSERT_N(pNode != NULL);
 
    const NodeBase* pMasterNode = &m_masterNode;
 
    if (pNode->pPrev == pMasterNode)
        pNode = NULL;
    else
        pNode = (Node*)pNode->pPrev;
        
    return pNode;
}
 
AllocList::Node* AllocList::find(const void* p) const
{
    const NodeBase* pMasterNode = &m_masterNode;
    const NodeBase* pNode = pMasterNode->pNext;
 
    while(pNode != pMasterNode) {
        if (((Node*)pNode)->data() == p)
            return (Node*)pNode;
 
        pNode = pNode->pNext;
    }
    return NULL;
}
 
AllocList::Node* AllocList::rfind(const void* p) const
{
    const NodeBase* pMasterNode = &m_masterNode;
    const NodeBase* pNode = pMasterNode->pPrev;
 
    while(pNode != pMasterNode) {
        if (((Node*)pNode)->data() == p)
            return (Node*)pNode;
 
        pNode = pNode->pPrev;
    }
    return NULL;
}
 
void* AllocList::allocAddTail(
        size_t nSize,
        bool bCheck,
        DCLAllocFunction allocFunction,
        const char_t* _filename,
        unsigned int _line
        )
{
    Node* pNewNode = allocNode(
            nSize,
            bCheck,
            allocFunction,
            _filename,
            _line
            );
    if (pNewNode)
        return addTail(pNewNode);
 
    return NULL;
}
 
void AllocList::erase(Node* pNode)
{
    __DCL_ASSERT_N(pNode != NULL);
    pNode->pPrev->pNext = pNode->pNext;
    pNode->pNext->pPrev = pNode->pPrev;
 
    free(pNode);
    m_nCount--;
}
 
void AllocList::clear()
{
    NodeBase* pMasterNode = &m_masterNode;
    NodeBase* pTempNode = NULL;
    NodeBase* pNode = pMasterNode->pNext;
    while(pNode != pMasterNode) {
        pTempNode = pNode;
        pNode = pNode->pNext;
        free(pTempNode);
    }
 
    pMasterNode->pNext = pMasterNode;
    pMasterNode->pPrev = pMasterNode;
    m_nCount = 0;
}
 
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
extern DCLCAPI size_t DCLGetNextPrimNumber(size_t _n);
 
PtrHashMap::PtrHashMap(size_t nBuckets)
{
    nBuckets = DCLGetNextPrimNumber(nBuckets);
 
    size_t nBytes = sizeof(NodeBase) * nBuckets;
    m_buckets = (NodeBase*)malloc(nBytes);
    for(size_t i = 0; i < nBuckets; i++) {
        NodeBase* pNode = &(m_buckets[i]);
        pNode->pPrev = pNode->pNext = pNode;
    }
    m_nBuckets = nBuckets;
    m_nCount = 0;
}
 
PtrHashMap::~PtrHashMap()
{
    for(size_t i = 0; i < m_nBuckets; i++) {
        NodeBase* pTempNode = NULL;
        NodeBase* pMasterNode = &(m_buckets[i]);
        NodeBase* pNode = pMasterNode->pNext;
        while(pNode != pMasterNode) {
            pTempNode = pNode;
            pNode = pNode->pNext;
            free(pTempNode);
        }
    }
    free(m_buckets);
}
 
const void*& PtrHashMap::operator [] (const void* key)
{
    size_t nBucket = bucketNumber(key);
    NodeBase* pMasterNode = &(m_buckets[nBucket]);
    NodeBase* pNode = pMasterNode->pNext;
    while(pNode != pMasterNode) {
        if (((Node*)pNode)->key == key)
            return ((Node*)pNode)->value;
        pNode = pNode->pNext;
    }
 
    Node* pNewNode = (Node*)malloc(sizeof(Node));
    pNewNode->pPrev = pMasterNode;
    pNewNode->pNext = pMasterNode->pNext;
    pNewNode->pNext->pPrev = pNewNode;
    pMasterNode->pNext = pNewNode;
    m_nCount++;
    pNewNode->key = key;
    return pNewNode->value;
}
 
PtrHashMap::Node* PtrHashMap::find(const void* key) const
{
    size_t nBucket = bucketNumber(key);
    NodeBase* pMasterNode = &(m_buckets[nBucket]);
    NodeBase* pNode = pMasterNode->pNext;
//  int i = 1;
    while(pNode != pMasterNode) {
        if (((Node*)pNode)->key == key)
            return (Node*)pNode;
        pNode = pNode->pNext;
//      printf("collision: %d\n", i++);
 
    }
    return NULL;
}
 
void PtrHashMap::erase(Node* pNode)
{
    __DCL_ASSERT_N(pNode != NULL);
 
    pNode->pPrev->pNext = pNode->pNext;
    pNode->pNext->pPrev = pNode->pPrev;
    
    free(pNode);
    m_nCount--;
}
 
LibState::LibState()
    : lockSQLDriverPool("LibState::lockSQLDriverPool")
#if __DCL_DEBUG
    , lockGlobalOutput("LibState::lockGlobalOutput")
    , mapThreadOutput(MAP_THREAD_OUTPUT_BUCKET_COUNT)
    , lockThreadOutput("LibState::lockThreadOutput")
#if __DCL_HAVE_ALLOC_DEBUG
    , lockAlloc("LibState::lockAlloc")
#endif      // __DCL_HAVE_ALLOC_DEBUG
#endif      // __DCL_DEBUG
{
    pfnSQLCleanup = NULL;
}
LibState::~LibState()
{
}
 
__DCL_END_NAMESPACE