PoolMemoryAllocator.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/basic.h>
#include <ogdf/basic/internal/config_autogen.h>
 
#include <cstddef>
#include <cstdint>
#include <vector>
#ifndef OGDF_MEMORY_POOL_NTS
#   include <mutex>
#endif
 
namespace ogdf {
 
 
class PoolMemoryAllocator {
    struct MemElem {
        MemElem* m_next;
    };
 
    using MemElemPtr = MemElem*;
 
    struct BlockChain;
    struct PoolElement;
 
    static constexpr size_t MIN_BYTES = sizeof(MemElemPtr);
    static constexpr size_t TABLE_SIZE = 256;
    static constexpr size_t BLOCK_SIZE = 8192;
 
public:
    PoolMemoryAllocator() { }
 
    ~PoolMemoryAllocator() { }
 
    static OGDF_EXPORT void cleanup();
 
    static OGDF_EXPORT bool checkSize(size_t nBytes);
 
    static OGDF_EXPORT void* allocate(size_t nBytes);
 
    static OGDF_EXPORT void deallocate(size_t nBytes, void* p);
 
 
    static OGDF_EXPORT void deallocateList(size_t nBytes, void* pHead, void* pTail);
 
    static OGDF_EXPORT void flushPool();
 
    static OGDF_EXPORT size_t memoryAllocatedInBlocks();
 
    static OGDF_EXPORT size_t memoryInGlobalFreeList();
 
    static OGDF_EXPORT size_t memoryInThreadFreeList();
 
    static OGDF_EXPORT void defragGlobal();
 
    static OGDF_EXPORT void defragThread();
 
    static OGDF_EXPORT void getGlobalFreeListSizes(std::vector<size_t>& sizes);
 
    static OGDF_EXPORT void getThreadFreeListSizes(std::vector<size_t>& sizes);
 
private:
    static inline void enterCS() {
#ifndef OGDF_MEMORY_POOL_NTS
        s_mutex.lock();
#endif
    }
 
    static inline void leaveCS() {
#ifndef OGDF_MEMORY_POOL_NTS
        s_mutex.unlock();
#endif
    }
 
    static int slicesPerBlock(uint16_t nBytes) {
        int nWords;
        return slicesPerBlock(nBytes, nWords);
    }
 
    static int slicesPerBlock(uint16_t nBytes, int& nWords) {
        nWords = (nBytes + OGDF_SIZEOF_POINTER - 1) / OGDF_SIZEOF_POINTER;
        return (BLOCK_SIZE - OGDF_SIZEOF_POINTER) / (nWords * OGDF_SIZEOF_POINTER);
    }
 
    static void* fillPool(MemElemPtr& pFreeBytes, uint16_t nBytes);
 
    static MemElemPtr allocateBlock();
    static void makeSlices(MemElemPtr p, int nWords, int nSlices);
 
    static BlockChain* s_blocks;
 
#ifdef OGDF_DEBUG
    static long long s_globallyAllocatedBytes;
    static thread_local long long s_locallyAllocatedBytes;
#endif
 
#ifdef OGDF_MEMORY_POOL_NTS
    static MemElemPtr s_tp[TABLE_SIZE];
#else
    static PoolElement s_pool[TABLE_SIZE];
 
    static std::mutex s_mutex;
    static thread_local MemElemPtr s_tp[TABLE_SIZE];
#endif
};
 
}