通用高效的c++内存池(特定类型)

通用高效内存池的设计要点:

1）快速分配；

2）快速回收；

3）空间利用率高。

4）类型独立(最好)。

不打算对比各种内存分配器的优劣，主要是介绍一最近实现的特定类型的通用高效C++内存池。

特点：

1）基于共享内存； -- 不会因为进程挂掉而丢失数据。

2）快速分配； -- 在内存池接近满时，效率不高。

3）快速回收；-- 常数。

4）空间利用率高 -- 利用bit标识内存块使用与否 （《C++设计新思维》的小对象分配器不占用额外空间！！）

已知缺点：

1）在内存池接近满时，分配效率不高。

2）非类型独立。每一种类型需要一特定内存池。

3）非线程安全，需要使用者自行保证。

#ifndef  __Memory_POOL__H__
#define  __Memory_POOL__H__

#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/shm.h>

#include <bitstring.h>
#include "utilfunc.h"


template<class T>
struct MemPoolHead
{
    size_t iTotalSize;       //
    size_t iCurSize;         // 剩余空间数
    size_t iNextPos;        // 下一个可用位置，用于快速分配（循环分配）
    size_t iRecordLen;

    T      arrDatas[0];      // 作为占位符，初始化后有效

    MemPoolHead()
    {
        memset(this, 0, sizeof(MemPoolHead));
    }
};

template<class T>
void PrintMemPoolHead(const MemPoolHead<T>& stHead) 
{ 
    printf("iTotalSize=%zu, iCurSize=%zu, iNextPos=%zu, iRecordLen=%zu\n",
            stHead.iTotalSize, stHead.iCurSize, stHead.iNextPos, stHead.iRecordLen);
}

template<class T>
class MemoryPool
{
    public:
        MemoryPool();

        ~MemoryPool();

        int Init(int ishmKey);   // for read exist data
        
        int Init(int ishmKey, const MemPoolHead<T>& stHeadInfo);  // for creating
        
        T*  GetPos();

        void DelPos(T* pdata);
 
        void PrintHead() const;
 
        int DeleteShm();
 
        int Reset();
        
        T* NextElem(size_t* pIndex) const;


        size_t Total() const;
        
        size_t Size() const;

        bool   Empty() const;

        bool   IsFull() const;

    private:
        MemoryPool(const MemoryPool&);
        MemoryPool& operator=(const MemoryPool&);

        int   m_ishmKey;
        MemPoolHead<T>*   m_datas;

        char*   m_usedbits;   // 标识特定内存块是否已使用
};


template<class T>
MemoryPool<T>::MemoryPool()
{
    m_ishmKey = -1;
    m_datas = NULL;
    m_usedbits = NULL;
}

template<class T>
MemoryPool<T>::~MemoryPool()
{

}

template<class T>
int MemoryPool<T>::Init(int ishmKey, const MemPoolHead<T>& stHeadInfo)
{
    if( stHeadInfo.iCurSize > stHeadInfo.iTotalSize || stHeadInfo.iRecordLen != sizeof(T)){
        printf("Invalid parameters\n");
        return -1;
    }

    size_t size = sizeof(MemPoolHead<T>) + (stHeadInfo.iTotalSize) * sizeof(T) + (stHeadInfo.iTotalSize / 8 + 1);
    
    PrintMemPoolHead(stHeadInfo);
    printf("Head len=%lu, Recode Len=%lu, shm Size=%lu\n", sizeof(MemPoolHead<T>), sizeof(T), size);

    int iCreate = false;
    char* sShm = NULL;    
    if (!(sShm = UTIL::GetShm(ishmKey,size,0666&(~IPC_CREAT)))) 
    {
        if (!(sShm = UTIL::GetShm(ishmKey,size,0666|IPC_CREAT))) 
        {
            printf("get shm error!\n");
            return -2;
        }
        else 
        {
            iCreate = true;  

            memset(sShm, 0, size);
        }
    }

    m_datas = (MemPoolHead<T>*)sShm;   
    m_ishmKey = ishmKey;

    m_usedbits = sShm + sizeof(MemPoolHead<T>) + (stHeadInfo.iTotalSize) * sizeof(T);


    if( iCreate ){
        memcpy(m_datas, &stHeadInfo, sizeof(stHeadInfo));

        m_datas->iCurSize = 0;
        m_datas->iNextPos = 0;
    }
    else {
        if( stHeadInfo.iTotalSize != m_datas->iTotalSize || stHeadInfo.iRecordLen != m_datas->iRecordLen )
        {
            printf("Memory head info is not matched!\n");
            PrintHead();

            m_datas = NULL;
            m_ishmKey = -1;
            return -1;
        }
    }

    return 0;
}
        
template<class T>
int MemoryPool<T>::Init(int ishmKey)
{
    MemPoolHead<T> stHead;
    char* sShm = NULL;
    if (!(sShm = UTIL::GetShm(ishmKey, sizeof(MemPoolHead<T>), 0666&(~IPC_CREAT)))) {
        return -1;
    }

    memcpy(&stHead, sShm, sizeof(MemPoolHead<T>));

    return Init(ishmKey, stHead);
}

template<class T>
T* MemoryPool<T>::GetPos()
{
    if( NULL == m_datas || m_datas->iNextPos > m_datas->iTotalSize ){
        printf("Something wrong in memory pool!\n");
        return NULL;
    }

    if( m_datas->iCurSize >= m_datas->iTotalSize ){
        printf("Memory pool is full\n");
        return NULL;
    }

    T *pdata = NULL;

    while(1){

        if( m_datas->iNextPos >= m_datas->iTotalSize ){
            m_datas->iNextPos = 0;
        }
        
        if( bit_test(m_usedbits, m_datas->iNextPos) ){  // pos is used
            m_datas->iNextPos++;
            continue;
        }
        else{
            bit_set(m_usedbits, m_datas->iNextPos);
            
            pdata = &m_datas->arrDatas[m_datas->iNextPos++];
            m_datas->iCurSize ++;
            break;
        }
    }
    return pdata;
}

template<class T>
void MemoryPool<T>::DelPos(T* pdata)
{
    if( (char*)pdata >= (char*)m_datas + sizeof(MemPoolHead<T>) && (char*)pdata < m_usedbits) 
    {
        if( ((char*)pdata - ((char*)m_datas + sizeof(MemPoolHead<T>))) % sizeof(T) == 0){
            size_t index = ((char*)pdata - ((char*)m_datas + sizeof(MemPoolHead<T>))) / sizeof(T);
            
            if( bit_test(m_usedbits, index) ){
                printf("delete pos: %p(%zu)\n", pdata, index); 

                memset(pdata, 0, sizeof(T));
            
                m_datas->iCurSize --;

                bit_clear(m_usedbits, index);
            }
        }
    }
}

template<class T>
void MemoryPool<T>::PrintHead() const
{   
    if( NULL == m_datas ) return;

    PrintMemPoolHead(*m_datas);
}

template<class T>
int MemoryPool<T>::DeleteShm()
{
    if( NULL == m_datas ) return 0;

    shmdt(m_datas);

    return UTIL::DeleteShm(m_ishmKey);
}
        
template<class T>
int MemoryPool<T>::Reset()
{
    if( NULL == m_datas ) return 0;
    
    size_t size = (m_datas->iTotalSize) * sizeof(T) + (m_datas->iTotalSize / 8 + 1);

    memset((char*)m_datas + sizeof(MemPoolHead<T>), 0, size);
    m_datas->iCurSize = 0;
    m_datas->iNextPos = 0;

    return 0;
}
        
template<class T>
T* MemoryPool<T>::NextElem(size_t* pIndex) const
{
    if( NULL == m_datas || NULL == pIndex ) return NULL;
    
    while( *pIndex < m_datas->iTotalSize ) 
    {
        size_t index = *pIndex;
        if( bit_test(m_usedbits, index) )
        {
            *pIndex = index + 1;

            return &m_datas->arrDatas[index];
        }
        *pIndex = index + 1;
    }

    return NULL;
}

template<class T>
size_t MemoryPool<T>::Total() const
{
    if( NULL == m_datas ) return 0;

    return m_datas->iTotalSize;
}

template<class T>
size_t MemoryPool<T>::Size() const
{
    if( NULL == m_datas ) return 0;

    return m_datas->iCurSize;
}

template<class T>
bool   MemoryPool<T>::Empty() const
{
    if( NULL == m_datas ) return false;

    return ( 0 == m_datas->iCurSize);
}

template<class T>
bool   MemoryPool<T>::IsFull() const
{
    if( NULL == m_datas ) return true;

    return (m_datas->iTotalSize == m_datas->iCurSize);
}

#endif