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 defined(__WINNT__)
    #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)
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __UNUSED__ __THIS_FILE__[] = __T("dcl/LibState.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
InternalMutex::InternalMutex(const char* _name)
{
#if __DCL_PTHREAD
    pthread_mutex_init(&__mutex, NULL);
#elif defined(__WINNT__)
    InitializeCriticalSection(&__cs);
#endif
    __name = _name;
}
 
InternalMutex::~InternalMutex()
{
#if __DCL_PTHREAD
    pthread_mutex_destroy(&__mutex);
#elif defined(__WINNT__)
    DeleteCriticalSection(&__cs);
#endif
}
 
void InternalMutex::lock()
{
#if __DCL_PTHREAD
    pthread_mutex_lock(&__mutex);
#elif defined(__WINNT__)
    EnterCriticalSection(&__cs);
#endif
}
 
void InternalMutex::unlock()
{
#if __DCL_PTHREAD
    pthread_mutex_unlock(&__mutex);
#elif defined(__WINNT__)
    LeaveCriticalSection(&__cs);
#endif
}
 
#if __DCL_HAVE_ALLOC_DEBUG
size_t AllocList::Node::SIZE()
{
#if 0
    size_t r = sizeof(Node) % sizeof(void*);
    if (r)
        return sizeof(Node) + sizeof(void*) - r;
#endif
    return sizeof(Node);
}
 
void* AllocList::Node::DATA() const
{ 
    return (char*)this + Node::SIZE(); 
}
 
void AllocList::Node::setFilename(const char_t* _filename)
{
    __DCL_ASSERT_N(_filename != NULL);
 
    size_t len = __strlen(_filename);
    if (len > __DCL_DEBUG_PATH_MAX) {
         __strncpy(filename, _filename, 8);
         __strncpy(filename + 8, __T("..."), 3);
        _filename += len - __DCL_DEBUG_PATH_MAX + 8;
         __strcpy(filename + 11, _filename);
    }
    else {
        __strcpy(filename, _filename);
    }
}
 
AllocList::Node* AllocList::allocNode(
    size_t _size,
    bool _check,
    DCLAllocFunc _func, 
    const char_t* _filename,
    unsigned int _line
)
{
    __DCL_ASSERT_N(_size > 0);
 
    Node* newNode = (Node*)malloc(Node::SIZE() + _size);
    if (newNode) {
        newNode->thread = Thread::self();
        newNode->check = _check;
        newNode->func = _func;
 
        if (_filename)
            newNode->setFilename(_filename);
        else
            newNode->filename[0] = '\0';
 
        newNode->line = _line;
        newNode->size = _size;
        newNode->data = newNode->DATA();
    }
    return newNode;
}
 
void* AllocList::addTail(Node* _newNode)
{
    __DCL_ASSERT_N(_newNode != NULL);
 
    NodeBase* masterNode = &__masterNode;
 
    _newNode->next = masterNode;
    _newNode->prev = masterNode->prev;
 
    _newNode->prev->next = _newNode;
    masterNode->prev = _newNode;
    __nodeCount++;
 
    return _newNode->data;
}
 
AllocList::Node* AllocList::reallocNode(
    Node* _node,
    size_t _size,
    const char_t* _filename,
    unsigned int _line
)
{
    __DCL_ASSERT_N(_node != NULL);
    __DCL_ASSERT_N(_size > 0);
 
    // realloc은 realloc전과 후의 주소가 서로 다를 수 있다.
    // 이전의 노드 정보를 저장한다.
    NodeBase* prev_ = _node->prev;
    NodeBase* next_ = _node->next;
 
    bool check_ = _node->check;
    DCLAllocFunc func_ = _node->func;
 
    Node* reNode = (Node*)realloc(_node, Node::SIZE() + _size);
    if (reNode) {
        if (reNode != _node) {
            prev_->next = reNode;
            next_->prev = reNode;
 
        //  reNode->prev = prev_;
        //  reNode->next = next_;
 
            reNode->thread = Thread::self();
            reNode->check = check_;
            reNode->func = func_;
        }
 
        if (_filename)
            reNode->setFilename(_filename);
        else
            reNode->filename[0] = L'\0';
 
        reNode->line = _line;
        reNode->size = _size;
        reNode->data = reNode->DATA();
    }
    return reNode;
}
 
AllocList::AllocList()
{
    __nodeCount = 0;
    NodeBase* masterNode = &__masterNode;
    masterNode->prev = masterNode;
    masterNode->next = masterNode;
}
 
AllocList::~AllocList()
{
//  if (__nodeCount)
//      clear();
}
 
AllocList::Node* AllocList::begin() const
{
    const NodeBase* masterNode = &__masterNode;
    if (masterNode->next == masterNode)
        return NULL;
 
    return (Node*)masterNode->next;
}
 
AllocList::Node* AllocList::end() const
{
    const NodeBase* masterNode = &__masterNode;
    if (masterNode->prev == masterNode)
        return NULL;
 
    return (Node*)masterNode->prev;
}
 
AllocList::Node* AllocList::next(Node*& _node) const
{
    __DCL_ASSERT_N(_node != NULL);
    const NodeBase* masterNode = &__masterNode;
    if (_node->next == masterNode)
        _node = NULL;
    else
        _node = (Node*)_node->next;
 
    return _node;
}
 
AllocList::Node* AllocList::prev(Node*& _node) const
{
    __DCL_ASSERT_N(_node != NULL);
    const NodeBase* masterNode = &__masterNode;
    if (_node->prev == masterNode)
        _node = NULL;
    else
        _node = (Node*)_node->prev;
 
    return _node;
}
 
AllocList::Node* AllocList::find(const void* _ptr) const
{
    const NodeBase* masterNode = &__masterNode;
    const NodeBase* node = masterNode->next;
    while(node != masterNode) {
        if (((Node*)node)->data == _ptr)
            return (Node*)node;
 
        node = node->next;
    }
    return NULL;
}
 
AllocList::Node* AllocList::rfind(const void* _ptr) const
{
    const NodeBase* masterNode = &__masterNode;
    const NodeBase* node = masterNode->prev;
    while(node != masterNode) {
        if (((Node*)node)->data == _ptr)
            return (Node*)node;
 
        node = node->prev;
    }
    return NULL;
}
 
void* AllocList::allocAddTail(
    size_t _size,
    bool _check,
    DCLAllocFunc _func,
    const char_t* _filename,
    unsigned int _line
)
{
    Node* newNode = allocNode(
        _size,
        _check,
        _func,
        _filename,
        _line
    );
    if (newNode)
        return addTail(newNode);
 
    return NULL;
}
 
void AllocList::erase(Node* _node)
{
    __DCL_ASSERT_N(_node != NULL);
    _node->prev->next = _node->next;
    _node->next->prev = _node->prev;
 
    free(_node);
    __nodeCount--;
}
 
void AllocList::clear()
{
    NodeBase* masterNode = &__masterNode;
    NodeBase* temp = NULL;
    NodeBase* node = masterNode->next;
    while(node != masterNode) {
        temp = node;
        node = node->next;
        free(temp);
    }
 
    masterNode->next = masterNode;
    masterNode->prev = masterNode;
    __nodeCount = 0;
}
 
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
extern DCLCAPI size_t DCLGetNextPrimNumber(size_t _n);
 
PtrHashMap::PtrHashMap(size_t _nbucket)
{
    __nodeCount = 0;
    __bucketCount = DCLGetNextPrimNumber(_nbucket);
    __buckets = (NodeBase*)malloc(sizeof(NodeBase) * __bucketCount);
    for(size_t i = 0; i < __bucketCount; i++) {
        NodeBase* node = &(__buckets[i]);
        node->prev = node->next = node;
    }
}
 
PtrHashMap::~PtrHashMap()
{
    for(size_t i = 0; i < __bucketCount; i++) {
        NodeBase* temp = NULL;
        NodeBase* masterNode = &(__buckets[i]);
        NodeBase* node = masterNode->next;
        while(node != masterNode) {
            temp = node;
            node = node->next;
            free(temp);
        }
    }
    free(__buckets);
}
 
const void*& PtrHashMap::operator [] (const void* _key)
{
    NodeBase* masterNode = __buckets + bucketIndex(_key);
    NodeBase* node = masterNode->next;
    while(node != masterNode) {
        if (((Node*)node)->key == _key)
            return ((Node*)node)->value;
        node = node->next;
    }
 
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->prev = masterNode;
    newNode->next = masterNode->next;
    newNode->next->prev = newNode;
    masterNode->next = newNode;
    __nodeCount++;
    newNode->key = _key;
    return newNode->value;
}
 
PtrHashMap::Node* PtrHashMap::find(const void* _key) const
{
    NodeBase* masterNode = __buckets + bucketIndex(_key);
    NodeBase* node = masterNode->next;
//  int i = 1;
    while(node != masterNode) {
        if (((Node*)node)->key == _key)
            return (Node*)node;
        node = node->next;
//      printf("collision: %d\n", i++);
    }
    return NULL;
}
 
void PtrHashMap::erase(Node* _node)
{
    __DCL_ASSERT_N(_node != NULL);
 
    _node->prev->next = _node->next;
    _node->next->prev = _node->prev;
 
    free(_node);
    __nodeCount--;
}
 
LibState::LibState()
    : lockSQLDriverPool("LibState::lockSQLDriverPool")
#ifdef __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