高性能服务器内存池,服务器公共库开发-内存池管理模块

最新推荐文章于 2025-01-21 09:36:24 发布

穿杨之光

最新推荐文章于 2025-01-21 09:36:24 发布

阅读量134

点赞数

文章标签：高性能服务器内存池

/********************************************************************

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;

}