/********************************************************************
created: 2008/08/01
filename: mempool.h
author: Lichuang
purpose: 模拟SGI STL内存池的实现, 可以配置是否支持多线程
*********************************************************************/#include"mempool.h"#includeCMemPool::CMemPool()
: m_pStartFree(NULL)
, m_pEndFree(NULL)
, m_nHeapSize(0)
{
::memset(m_szFreeList,0,sizeof(m_szFreeList));
}
CMemPool::~CMemPool()
{
}//从内存池中分配尺寸为n的内存void*CMemPool::Allocate(size_t nSize)
{if(nSize>MAX_BLOCK_SIZE)
{return::malloc(nSize);
}if(0>=nSize)
{returnNULL;
}
Obj**ppFreeList;
Obj*pResult;
THREAD_LOCK;//获得尺寸n的HASH表地址ppFreeList=m_szFreeList+GetFreeListIndex(nSize);
pResult=*ppFreeList;if(NULL==pResult)
{//如果之前没有分配, 或者已经分配完毕了, 就调用refill函数重新分配//需要注意的是, 传入refill的参数是经过对齐处理的pResult=(Obj*)Refill(RoundUp(nSize));
}else{//否则就更新该HASH表的LIST头节点指向下一个LIST的节点, 当分配完毕时, 头结点为NULL*ppFreeList=pResult->pFreeListLink;
}
THREAD_UNLOCK;returnpResult;
}void*CMemPool::Reallocate(void*p, size_t nOldSize, size_t nNewSize)
{void*pResult;
size_t nCopySize;//如果超过内存池所能承受的最大尺寸, 调用系统API重新分配内存if(nOldSize>(size_t)MAX_BLOCK_SIZE&&nNewSize>(size_t)MAX_BLOCK_SIZE)
{return::realloc(p, nNewSize);
}//如果新老内存尺寸在对齐之后相同, 那么直接返回if(RoundUp(nOldSize)==RoundUp(nNewSize))returnp;//首先按照新的尺寸分配内存pResult=Allocate(nNewSize);if(NULL==pResult)
{returnNULL;
}//copy旧内存的数据到新的内存区域nCopySize=nNewSize>nOldSize?nOldSize : nNewSize;
::memcpy(pResult, p, nCopySize);//释放旧内存区域Deallocate(p, nOldSize);returnpResult;
}//将尺寸为n的内存回收到内存池中voidCMemPool::Deallocate(void*p, size_t nSize)
{
Obj*pObj=(Obj*)p;
Obj**ppFreeList;if(0>=nSize)
{return;
}//如果要回收的内存大于MAX_BLOCK_SIZE, 直接调用free回收内存if(nSize>MAX_BLOCK_SIZE)
{
::free(p);return;
}//将回收的内存作为链表的头回收ppFreeList=m_szFreeList+GetFreeListIndex(nSize);
THREAD_LOCK;
pObj->pFreeListLink=*ppFreeList;*ppFreeList=pObj;
THREAD_UNLOCK;
}intCMemPool::GetMemSize()
{returnm_nHeapSize;
}
size_t CMemPool::RoundUp(size_t nBytes)
{return(nBytes+ALIGN-1)&~(ALIGN-1);
}intCMemPool::GetFreeListIndex(size_t nBytes)
{return(nBytes+ALIGN-1)/ALIGN-1;
}char*CMemPool::AllocChunk(size_t nSize,int&nObjs)
{char*pResult;//总共所需的内存size_t nTotalBytes=nSize*nObjs;//剩余的内存size_t nBytesLeft=m_pEndFree-m_pStartFree;//如果剩余的内存可以满足需求, 就直接返回之, 并且更新内存池的指针if(nBytesLeft>=nTotalBytes)
{
pResult=m_pStartFree;
m_pStartFree+=nTotalBytes;returnpResult;
}//如果剩余的内存大于单位内存数量, 也就是说至少还可以分配一个单位内存//计算出最多可以分配多少块单位内存, 保存至nobjs, 返回内存的指针if(nBytesLeft>=nSize)
{
nObjs=(int)(nBytesLeft/nSize);
nTotalBytes=nSize*nObjs;
pResult=m_pStartFree;
m_pStartFree+=nTotalBytes;returnpResult;
}//如果还有剩余的内存, 将它放到对应的HASH-LIST头部if(0
{
Obj**ppFreeList=m_szFreeList+GetFreeListIndex(nBytesLeft);
((Obj*)m_pStartFree)->pFreeListLink=*ppFreeList;*ppFreeList=(Obj*)m_pStartFree;
}//需要获取的内存, 注意第一次分配都要两倍于total_bytes的大小//同时要加上原有的heap_size / 4的对齐值size_t nBytesToGet=2*nTotalBytes+RoundUp(m_nHeapSize>>4);
m_pStartFree=(char*)::malloc(nBytesToGet);//获取成功 重新调用chunk_alloc函数分配内存if(NULL!=m_pStartFree)
{
m_nHeapSize+=nBytesToGet;
m_pEndFree=m_pStartFree+nBytesToGet;returnAllocChunk(nSize, nObjs);
}//下面是获取不成功的处理
.//从下一个HASH-LIST中寻找可用的内存inti=(int)GetFreeListIndex(nSize)+1;
Obj**ppFreeList,*p;for(; i
{
ppFreeList=m_szFreeList+i;
p=*ppFreeList;if(NULL!=p)
{*ppFreeList=p->pFreeListLink;
m_pStartFree=(char*)p;
m_pEndFree=m_pStartFree+(i+1)*ALIGN;returnAllocChunk(nSize, nObjs);
}
}
m_pEndFree=NULL;returnNULL;
}//重新分配尺寸为n的内存, 其中n是经过字节对齐处理的数void*CMemPool::Refill(size_t n)
{//每个链表每次初始化时最多LIST_NODE_NUM个元素intnObjs=LIST_NODE_NUM;char*pChunk=AllocChunk(n, nObjs);
Obj**ppFreeList;
Obj*pResult;
Obj*pCurrentObj,*pNextObj;inti;//如果只请求成功了一个元素, 直接返回之if(1==nObjs)
{returnpChunk;
}//获得尺寸n的HASH表地址ppFreeList=m_szFreeList+GetFreeListIndex(n);//获得请求的内存地址pResult=(Obj*)pChunk;//请求了一个单位内存, 减少一个计数--nObjs;//从下一个单位开始将剩余的obj连接起来*ppFreeList=pNextObj=(Obj*)(pChunk+n);//将剩余的obj连接起来for(i=1; ;++i)
{
pCurrentObj=pNextObj;
pNextObj=(Obj*)((char*)pNextObj+n);//分配完毕, 下一个节点为NULL, 退出循环if(nObjs==i)
{
pCurrentObj->pFreeListLink=NULL;break;
}
pCurrentObj->pFreeListLink=pNextObj;
}returnpResult;
}