一个简单内存池实现

    最近面试被问了一个内存池的实现，关键是内存块的组织，说来惭愧，由于之前没有详细去了解过实现，只记得操作系统上有说过空闲链表的实现，即按分配的块用链表链接，有小块优先，大块优先等~~~~
    后来回来认真地找了几个内存池实现的技术介绍，多数是以一个固定块，每个块又有固定长度的单元组成。参考了网上的一些实现方法，实现了这个简单的内存池，测试了一下，效果还可以呵呵~~~

 

(注意如果要加大测试量，要加入栈空间以防栈溢出)

 

#include<iostream> using namespace std; #include <time.h> #include <windows.h> #include "mempool.h" const int DEFAULT_UNIT_SIZE = 32; const int DEFAULT_BLOCK_SIZE = 2048; struct CMemBlock { int m_nFirst; //第一个索引单元编号 int m_nFree; //本内存块还有可用内存单元数 CMemBlock * pre; //内存块链表 char data[1]; //内存块起始位置 CMemBlock( int nBlockSize, int nUnitSize ):m_nFree(nBlockSize/nUnitSize),m_nFirst(0),pre(NULL) { //组织内存块内的切分索引 for( int i=0; i<m_nFree; i++) { //加入切块编号 *(unsigned short*)(data + i*nUnitSize ) = i + 1; //静态链表: 0->1, 1->2... } *(unsigned short*)(data + (i - 1)*nUnitSize ) = 0; //最后一块要指回0单元 } ~CMemBlock(){}; //重载new/delete, 要以一个size_t作第一个参数 static void * operator new( size_t, unsigned int nBlockSize ) { int len = sizeof(CMemBlock) + nBlockSize; //主要是分配出一个大内存块 void *p = ::operator new ( len ); memset(p,0, len); return p; } static void operator delete( void * p, size_t ) { ::operator delete(p); } }; const int MEM_ALIGNMENT = 8; class CMemPool { public: CMemPool( int nUnitSize = DEFAULT_UNIT_SIZE, int nMemBlockSize = DEFAULT_BLOCK_SIZE ); ~CMemPool(); void * Alloc(); void Free( void * pFree ); private: int m_nMemBlockSize; int m_nUnitSize; CMemBlock * m_pBlockHeader; }; CMemPool::CMemPool( int nUnitSize, int nMemBlockSize /* = 2048 */ ):m_nUnitSize(nUnitSize),m_nMemBlockSize(nMemBlockSize) { m_pBlockHeader = NULL; m_nUnitSize = nUnitSize; m_nMemBlockSize = nMemBlockSize; if( m_nUnitSize > 4 ) m_nUnitSize = ( m_nUnitSize + MEM_ALIGNMENT -1) & ~( MEM_ALIGNMENT - 1); else if( m_nUnitSize <= 2 ) m_nUnitSize = 2; else m_nUnitSize = 4; } CMemPool::~CMemPool() { CMemBlock * pBlock = m_pBlockHeader; while( pBlock ) { m_pBlockHeader = m_pBlockHeader->pre; delete pBlock; pBlock = m_pBlockHeader; } } void * CMemPool::Alloc() { if( !m_pBlockHeader ) { //申请一个新的由存块 m_pBlockHeader = new(m_nMemBlockSize) CMemBlock(m_nMemBlockSize,m_nUnitSize); m_pBlockHeader->pre = NULL; } CMemBlock * pBlock = m_pBlockHeader; //如果有空间的块未用完，进接在里面分配 if( pBlock->m_nFree ) { char * Free = pBlock->data + ( pBlock->m_nFirst*m_nUnitSize); pBlock->m_nFirst = *(unsigned short*)Free; pBlock->m_nFree--; //本来前两个字节是用来记录内存单元编号的，不过可以回收时计算，所以也可以用 return Free; } else //否则申请一个新的块，之后链接到之前申请的块后面 { pBlock = new(m_nMemBlockSize) CMemBlock(m_nMemBlockSize,m_nUnitSize); if( !pBlock) return NULL; pBlock->m_nFirst = 1; pBlock->m_nFree--; pBlock->pre = m_pBlockHeader; m_pBlockHeader = pBlock; //同上原因 return (void*)(pBlock->data); } } void CMemPool::Free( void * pFree ) { CMemBlock * p = m_pBlockHeader; //找出要释放内存单元所在的内存块 while( (unsigned long)p->data > (unsigned long)pFree ) p = p->pre; if( !p ) return; //增加该块可用量 p->m_nFree++; //更新指向 *((unsigned short*)( (unsigned long)pFree )) = p->m_nFirst; //计算回收块的编号 p->m_nFirst = ((unsigned long)pFree - (unsigned long)p->data ) / m_nUnitSize; //检测内存块是否都为空闲,如果只得一块就不回收 if( p->m_nFree == m_nMemBlockSize/m_nUnitSize ) { //回收这块内存空间给进程 CMemBlock * pFreeBlockPre = m_pBlockHeader; while( pFreeBlockPre != p && pFreeBlockPre->pre != p ) pFreeBlockPre = pFreeBlockPre->pre; //回收内存块后更新链表达 if( p == m_pBlockHeader ) m_pBlockHeader = m_pBlockHeader->pre; else pFreeBlockPre->pre = p->pre; delete p; p = NULL; } } void main() { srand(time(NULL)); const int ts = 10000000; void * p[ts]; int i; unsigned long start_time; CMemPool memPool; //test system new start_time = GetTickCount(); for( i=0; i<ts; i++ ) p[i] = new char[32]; cout<<"System new( "<<ts<<" ) time:"<<GetTickCount() - start_time <<endl; start_time = GetTickCount(); for( i=0; i<ts; i++ ) delete [] p[i]; cout<<"System delete( "<<ts<<" ) time:"<<GetTickCount() - start_time <<endl; //test memPool start_time = GetTickCount(); for( i=0; i<ts; i++ ) p[i] = memPool.Alloc(); cout<<"memPool alloc( "<<ts<<" ) time:"<<GetTickCount() - start_time <<endl; start_time = GetTickCount(); for( i=ts-1; i>=0; i-- ) memPool.Free( p[i] ); cout<<"memPool free( "<<ts<<" ) time:"<<GetTickCount() - start_time <<endl; }

 

 

      虽然是实现了，但还是对内存池的一些疑问~~小于块长度的内存分配请求会浪费空间（因为第次alloc会分配一个固定长度内存单元，方便回收），大于块长度的请求，又要用多块拼接而成。然而拼接的方法是个很大问题，如果设计为连续内存块，会有很严重的空洞问题；如果设计成链表结构，所有和这段信息相关的处理函数就都需要支持这种链表，否则就会引入额外的内存拷贝。

 

内存池补充资料：

1. 可以有固定分区分配（分配方法如字面意思，不再累述）
可变分区分配：为进程分配的空间是可变的（依照需要变化），其中又有几种不同的具体分配方法如：
最佳适应算法：进程退出后返还占用的内存，但是会产生不连续的内存，就像磁盘碎片一样。最佳适应算法就是从剩下的内存中找到一块大小最合适（不一定和需要的一样大，但必须>=需要的大小）的分配给进程，当然只分配进程需要的大小而那一块中剩下的部分（如果还有剩下）依然空闲。
首次适应算法：从头开始进行匹配，当第一次找到>=需要大小的内存块就进行分配。
循环首次适应算法：和首次适应差不多，只不过他不从头开始匹配，他是从当前的下一块内存开始匹配。
每种分配方法都有自己的优点和缺点，应当视具体情况选择。

 

2.http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html

 

3.论坛上的一些回答

（1）大块内存要怎么分配好呢？还是直接用系统分配实现？
个人认为大块内存直接用系统分配实现更好，用内存池的话多了很多 步骤

（2）大家能否介绍一下工作中用到内存池地方，以及带来的性能效应怎么样呢？
个人觉得内存池多用在那些内存块比较小，而且经常分配释放频率比较高的时候。因为如果是大块内存的使用用内存池效率不好！！还有就是如果是小块的内存如果经常需要分配和释放的话，用内存池效率比较快

 

4.测试数据

DEBUG:

System new( 10000000 ) time:2281
System delete( 10000000 ) time:4141
memPool alloc( 10000000 ) time:812
memPool free( 10000000 ) time:594

RELEASE:

System new( 10000000 ) time:1032
System delete( 10000000 ) time:1218
memPool alloc( 10000000 ) time:407
memPool free( 10000000 ) time:250