一个简化版本的内存池实现

最近写的一个程序中需要频繁的申请和释放零碎的内存块，这些内存块的大小却只有简单的几种。如果直接使用系统调用malloc/free、new/delete进行内存分配和释放，则效率很低。程序运行时间长了会产生大量的内存碎片。想起uC/OS-II 里面提供了个内存分配单元，正好满足我的需要。就把里面相关的代码扒了出来。写成了一个内存池的类。

这个内存池的功能非常的简单，初始化时分配一大块内存，然后将各个小内存块串成一个单项链表。每次分配内存块时从链表的头上去取一个内存块。回收内存块时也是将内存块插到链表的开头处。

这个类的结构如下：

#ifndef MEMPOOL_H
#define MEMPOOL_H

#define MEM_NO_ERR          0
#define MEM_INVALID_ADDR    1
#define MEM_INVALID_BLKS    2
#define MEM_INVALID_SIZE    3
#define MEM_INVALID_PART    4
#define MEM_INVALID_PBLK    5
#define MEM_FULL            6
class MemPool
{
public:
MemPool();
~MemPool();
int create (int nblocks, unsigned int blocksize);
void* get( void );
int release ( void *pblk );
int blocks( void ) const {return m_memNBlks;};
int frees( void ) const {return m_memNFree;};
private:
char *m_memAddr; /* Pointer to beginning of memory partition */
char *m_memFreeList; /* Pointer to list of free memory blocks */
int m_memBlkSize; /* Size (in bytes) of each block of memory */
int m_memNBlks; /* Total number of blocks in this partition */
int m_memNFree; /* Number of memory blocks remaining in this */
};

#endif

create 函数初始化内存池。主要的工作就是分配内存，然后将内存块串起来形成一个链表。因为要用指针形成链表，因此要求内存块的大小至少要能容纳一个指针。

get 函数获得一个内存块，如果没有剩余的内存块了，就返回 null。

release 函数回收内存块。

blocks 函数返回内存池总共有多少内存块。

frees 函数返回内存池还剩多少剩余的内存块。

代码实现如下：

#include <stddef.h>
#include "MemPool.h"

MemPool::MemPool()
{
m_memAddr = NULL;
m_memFreeList = NULL;
m_memBlkSize = 0;
m_memNBlks = 0;
m_memNFree = 0;
}
MemPool::~MemPool()
{
if(m_memAddr != NULL)
{
delete [] m_memAddr;
}
}
int MemPool::create ( int nblks, unsigned int blksize )
{
if( m_memAddr != NULL )
{
delete [] m_memAddr;
}
m_memAddr = new char[nblks * blksize];
if ( m_memAddr == NULL )
{
return MEM_INVALID_ADDR;
}
if ( nblks < 2 )
{
/* Must have at least 2 blocks per partition */
return MEM_INVALID_BLKS;
}

if ( blksize < sizeof(void *) )
{
/* Must contain space for at least a pointer */
return MEM_INVALID_SIZE;
}
void ** p = (void **)m_memAddr;
char *pblk = m_memAddr + blksize;
for (int i = 0; i < (nblks - 1); i++)
{
*p = (void *) pblk;
p = (void **) pblk;
pblk   = pblk + blksize;
}
*p = (void *)0;

m_memFreeList = m_memAddr;
m_memNBlks = nblks;
m_memNFree = nblks;
return MEM_NO_ERR;
}

void * MemPool::get( void )
{
void *pblk;
if (m_memNFree > 0)
{
/* See if there are any free memory blocks */
pblk = m_memFreeList;    /* Yes, point to next free memory block */
m_memFreeList = (char *) *(void **)pblk; /* Adjust pointer to new free list */
m_memNFree--;/* One less memory block in this partition  */
return (pblk); /* Return memory block to caller */
}
return ((void *)0);
}
int MemPool::release ( void *pblk )
{
if (pblk == (void *)0)
{
/* Must release a valid block */
return (MEM_INVALID_PBLK);
}
if (m_memNFree >= m_memNBlks)
{
/* Make sure all blocks not already returned */
return (MEM_FULL);
}
/* Insert released block into free block list */
*(void **)pblk = m_memFreeList;
m_memFreeList = (char *) pblk;

m_memNFree++; /* One more memory block in this partition */
return (MEM_NO_ERR); /* Notify caller that memory block was released */
}

下面是个简答的测试代码：

#include <iostream>
#include "MemPool.h"
using namespace std;
typedef struct
{
unsigned char *ImageData;
int SizeX;
int SizeY;
int ImageID;
double Timestamp;
double TransferTime;
unsigned int PacketCount;
}IMAGE_INFO;

int main()
{
IMAGE_INFO * p[15];
MemPool mem;
mem.create(15, sizeof(IMAGE_INFO));

for(int i = 0; i < 10; i++)
{
p[i] = (IMAGE_INFO *)mem.get();
cout << "p[" << i << "] addr = " << p[i] << endl;
p[i]->SizeX = i;
p[i]->SizeY = i;
}
for(int i = 1; i < 10; i++)
{
cout << "p[" << i << "]->SizeX = " << p[i]->SizeX << endl;
mem.release(p[i]);
}
cout << "mem.blocks()" << mem.blocks() << endl;
cout << "mem.frees()" << mem.frees() << endl;
return 0;
}

这个测试程序的运行结果如下：

p[0] addr = 0xac1358
p[1] addr = 0xac1380
p[2] addr = 0xac13a8
p[3] addr = 0xac13d0
p[4] addr = 0xac13f8
p[5] addr = 0xac1420
p[6] addr = 0xac1448
p[7] addr = 0xac1470
p[8] addr = 0xac1498
p[9] addr = 0xac14c0
p[1]->SizeX = 1
p[2]->SizeX = 2
p[3]->SizeX = 3
p[4]->SizeX = 4
p[5]->SizeX = 5
p[6]->SizeX = 6
p[7]->SizeX = 7
p[8]->SizeX = 8
p[9]->SizeX = 9
mem.blocks()15
mem.frees()14

最后多说一句，如果程序中多个线程要访问同一个内存池，那个需要给 get 和 release 函数加锁。

另外，这个代码其实可以用C++的类模版来实现。下面是用了类模版技术的一个实现：

#ifndef MEMPOOL2_H_INCLUDED
#define MEMPOOL2_H_INCLUDED

#define MEM_NO_ERR          0
#define MEM_INVALID_ADDR    1
#define MEM_INVALID_BLKS    2
#define MEM_INVALID_SIZE    3
#define MEM_INVALID_PART    4
#define MEM_INVALID_PBLK    5
#define MEM_FULL            6

template < typename T >
class MemPool2
{
public:
MemPool2();
~MemPool2();
int create (int nblocks);
T* get( void );
int release ( T *pblk );
int blocks( void ) const {return m_NBlocks;};
int frees( void ) const {return m_NFree;};
private:
T *m_addr; /* Pointer to beginning of memory partition */
void *m_freeList; /* Pointer to list of free memory blocks */
int m_blockSize; /* Size (in bytes) of each block of memory */
int m_NBlocks; /* Total number of blocks in this partition */
int m_NFree; /* Number of memory blocks remaining in this */
};
template < typename T >
MemPool2<T>::MemPool2()
{
m_addr = NULL;
m_freeList = NULL;
m_blockSize = sizeof(T);
m_NBlocks = 0;
m_NFree = 0;
}
template < typename T >
MemPool2<T>::~MemPool2()
{
if(m_addr != NULL)
{
delete [] m_addr;
}
}
template < typename T >
int MemPool2<T>::create ( int nblocks )
{
if( m_addr != NULL )
{
delete [] m_addr;
}
m_addr = new T[nblocks];
if ( m_addr == NULL )
{
return MEM_INVALID_ADDR;
}
if ( nblocks < 2 )
{
/* Must have at least 2 blocks per partition */
return MEM_INVALID_BLKS;
}

if ( sizeof(T) < sizeof(void *) )
{
/* Must contain space for at least a pointer */
return MEM_INVALID_SIZE;
}
void ** p = (void **)m_addr;
T *pblock = m_addr;
for (int i = 0; i < (nblocks - 1); i++)
{
pblock ++;
*p = (void *) pblock;
p = (void **) pblock;
}
*p = (void *)0;

m_freeList = m_addr;
m_NBlocks = nblocks;
m_NFree = nblocks;
return MEM_NO_ERR;
}
template < typename T >
T * MemPool2<T>::get( void )
{
T *pblk;
if (m_NFree > 0)
{
/* See if there are any free memory blocks */
pblk = (T *) m_freeList;    /* Yes, point to next free memory block */
m_freeList = (void *) *(void **)pblk; /* Adjust pointer to new free list */
m_NFree--;/* One less memory block in this partition  */
return (pblk); /* Return memory block to caller */
}
return ((T *)0);
}
template < typename T >
int MemPool2<T>::release ( T *pblock )
{
if (pblock == NULL)
{
/* Must release a valid block */
return (MEM_INVALID_PBLK);
}
if (m_NFree >= m_NBlocks)
{
/* Make sure all blocks not already returned */
return (MEM_FULL);
}
/* Insert released block into free block list */
*(void **)pblock = m_freeList;
m_freeList = (void *) pblock;

m_NFree++; /* One more memory block in this partition */
return (MEM_NO_ERR); /* Notify caller that memory block was released */
}

#endif // MEMPOOL2_H_INCLUDED

测试代码如下：

#include <iostream>
#include "MemPool2.h"
using namespace std;
typedef struct
{
unsigned char *ImageData;
int SizeX;
int SizeY;
int ImageID;
double Timestamp;
double TransferTime;
unsigned int PacketCount;
}IMAGE_INFO;

int main()
{
IMAGE_INFO * p[15] = {0};
MemPool2<IMAGE_INFO> mem;
mem.create(5);

for(int i = 0; i < 7; i++)
{
p[i] = mem.get();

if(p[i] != NULL)
{
cout << "p[" << i << "] addr = " << p[i] << endl;
p[i]->SizeX = i;
p[i]->SizeY = i;
}

}
for(int i = 0; i < 9; i++)
{
if(p[i] != NULL)
{
cout << "p[" << i << "]->SizeX = " << p[i]->SizeX << endl;
}
mem.release(p[i]);
}
cout << "mem.blocks()" << mem.blocks() << endl;
cout << "mem.frees()" << mem.frees() << endl;
return 0;
}