PoolMemoryAllocator.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_POOL_MEMORY_ALLOCATOR_H
#define OGDF_POOL_MEMORY_ALLOCATOR_H

#ifndef OGDF_MEMORY_POOL_NTS
#include <ogdf/basic/CriticalSection.h>
#else
#include <ogdf/basic/System.h>
#endif


namespace ogdf {



class PoolMemoryAllocator
{
    struct MemElem {
        MemElem *m_next;
    };
    struct MemElemEx {
        MemElemEx *m_next;
        MemElemEx *m_down;
    };

    typedef MemElem   *MemElemPtr;
    typedef MemElemEx *MemElemExPtr;

    struct PoolVector;
    struct PoolElement;
    struct BlockChain;
    typedef BlockChain *BlockChainPtr;

public:
    enum {
        eMinBytes = sizeof(MemElemPtr),
        eTableSize = 256,
        eBlockSize = 8192,
        ePoolVectorLength = 15
    };

    PoolMemoryAllocator() { }
    ~PoolMemoryAllocator() { }

    static OGDF_EXPORT void init();

    static OGDF_EXPORT void initThread() {
#if !defined(OGDF_MEMORY_POOL_NTS) && defined(OGDF_NO_COMPILER_TLS)
        pthread_setspecific(s_tpKey,calloc(eTableSize,sizeof(MemElemPtr)));
#endif
    }

    static OGDF_EXPORT void cleanup();

    static OGDF_EXPORT bool checkSize(size_t nBytes) {
        return nBytes < eTableSize;
    }

    static OGDF_EXPORT void *allocate(size_t nBytes) {
#if !defined(OGDF_MEMORY_POOL_NTS) && defined(OGDF_NO_COMPILER_TLS)
        MemElemPtr *pFreeBytes = ((MemElemPtr*)pthread_getspecific(s_tpKey))+nBytes;
#else
        MemElemPtr *pFreeBytes = s_tp+nBytes;
#endif
        if (OGDF_LIKELY(*pFreeBytes != 0)) {
            MemElemPtr p = *pFreeBytes;
            *pFreeBytes = p->m_next;
            return p;
        } else {
            return fillPool(*pFreeBytes,__uint16(nBytes));
        }
    }

    static OGDF_EXPORT void deallocate(size_t nBytes, void *p) {
#if !defined(OGDF_MEMORY_POOL_NTS) && defined(OGDF_NO_COMPILER_TLS)
        MemElemPtr *pFreeBytes = ((MemElemPtr*)pthread_getspecific(s_tpKey))+nBytes;
#else
        MemElemPtr *pFreeBytes = s_tp+nBytes;
#endif
        MemElemPtr(p)->m_next = *pFreeBytes;
        *pFreeBytes = MemElemPtr(p);
    }


    static OGDF_EXPORT void deallocateList(size_t nBytes, void *pHead, void *pTail) {
#if !defined(OGDF_MEMORY_POOL_NTS) && defined(OGDF_NO_COMPILER_TLS)
        MemElemPtr *pFreeBytes = ((MemElemPtr*)pthread_getspecific(s_tpKey))+nBytes;
#else
        MemElemPtr *pFreeBytes = s_tp+nBytes;
#endif
        MemElemPtr(pTail)->m_next = *pFreeBytes;
        *pFreeBytes = MemElemPtr(pHead);
    }

    static OGDF_EXPORT void flushPool();
    static OGDF_EXPORT void flushPool(__uint16 nBytes);

    static OGDF_EXPORT size_t memoryAllocatedInBlocks();

    static OGDF_EXPORT size_t memoryInGlobalFreeList();

    static OGDF_EXPORT size_t memoryInThreadFreeList();

private:
    static int slicesPerBlock(__uint16 nBytes) {
        int nWords;
        return slicesPerBlock(nBytes,nWords);
    }

    static int slicesPerBlock(__uint16 nBytes, int &nWords) {
        nWords = (nBytes+sizeof(MemElemPtr)-1)/sizeof(MemElemPtr);
        return (eBlockSize-sizeof(MemElemPtr))/(nWords*sizeof(MemElemPtr));
    }

    static void incVectorSlot(PoolElement &pe);

    static void flushPoolSmall(__uint16 nBytes);
    static MemElemExPtr collectGroups(
        __uint16 nBytes,
        MemElemPtr &pRestHead,
        MemElemPtr &pRestTail,
        int &nRest);

    static void *fillPool(MemElemPtr &pFreeBytes, __uint16 nBytes);

    static MemElemPtr allocateBlock(__uint16 nBytes);

    static PoolElement s_pool[eTableSize];
    static MemElemPtr s_freeVectors;
    static BlockChainPtr s_blocks;

#ifdef OGDF_MEMORY_POOL_NTS
    static MemElemPtr s_tp[eTableSize];
#elif defined(OGDF_NO_COMPILER_TLS)
    static CriticalSection *s_criticalSection;
    static pthread_key_t s_tpKey;
#else
    static CriticalSection *s_criticalSection;
    static OGDF_DECL_THREAD MemElemPtr s_tp[eTableSize];
#endif
};


}

#endif