boost::pool与内存池技术

梦里梦外; 2022-07-24 12:10 205阅读 0赞

转自：http://www.cnblogs.com/hujian/archive/2009/07/10/1520233.html

Boost库的pool提供了一个内存池分配器，用于管理在一个独立的、大的分配空间里的动态内存分配。Boost库的pool主要适用于快速分配同样大小的内存块，尤其是反复分配和释放同样大小的内存块的情况。使用pool内存池主要有以下两个优点：  
　　1. 能够有效地管理许多小型对象的分配和释放工作，避免了自己去管理内存而产生的内存碎片和效率低下问题。  
　　2. 告别程序内存泄漏的烦恼，pool库会在内部对内存自动进行管理，避免了程序员一不小心而造成的内存泄漏问题。  
pool库主要提供了四种内存池接口，分别是pool、object\_pool、singleton\_pool和pool\_allocator（fast\_pool\_allocator）。

pool接口：头文件为<boost/pool/pool.hpp>，主要用于快速分配小块内存，使用时需要指定每次要分配的内存块的大 小。其malloc函数用于从内存池中分配内存；free函数用于释放内存，并交还给内存池，而不是系统；release\_memory函数用于释放所有 未被分配的内存；purge\_memory函数用于释放所有内存。当然，也可以不调用free或release\_memory等函数，pool接口对象在 析构时会调用purge\_memory自动释放所有内存。示例代码如下：

1 ![None.gif][]  pool <>  myPool( sizeof ( int ));  
 2 ![None.gif][] for  ( int  i  =  0 ; i  <  10 ; i \++ )  
 3 ![ExpandedBlockStart.gif][] ![ContractedBlock.gif][] ![dot.gif][] \{  
 4 ![InBlock.gif][] int  \* pnNum  =  ( int  \* )myPool.malloc();  
 5 ![InBlock.gif][] \* pnNum  =  i \+ 1 ;  
 6 ![InBlock.gif][] cout  <<  \* pnNum  <<  endl;  
 7 ![ExpandedBlockEnd.gif][] \}

object\_pool接口：头文件为<boost/pool/object\_pool.hpp>，顾名思义，主要用于对象的内存分配并自 动调用类的构造函数。其construct函数用于从内存池中分配内存并自动调用构造函数，其destroy函数用于释放内存交还给内存池并自动调用析构 函数。与pool接口一样，也可以不调用destroy函数，object\_pool接口对象在析构时会自动释放所有内存并自动调用析构函数。另 外，object\_pool接口也有malloc和free函数，但其malloc只分配内存而不负责构造，free只释放内存而不负责析构。因此，最好 将construct和destroy配对使用，将malloc和free配对使用，而不要两者混用。示例代码如下：

1  object\_pool < CTest >  myObjectPool;  
 2  for  ( int  j  =  0 ; j  <  10 ; j \++ )  
 3  \{  
 4  CTest  \* pTest  =  (CTest  \* )myObjectPool.construct(j \* j);  
 5  if  (j  ==  5 )  
 6  \{  
 7  myObjectPool.destroy(pTest);  
 8  \}  
 9  \}

singleton\_pool接口：头文件为<boost/pool /singleton\_pool.hpp>，singleton\_pool接口的构造函数是私有的，因此不能够创建一个 singleton\_pool接口的对象。singleton\_pool接口提供了一些静态方法如malloc、free用于内存的分配和释放，其他方面 与pool接口相同。示例代码如下：

1 struct  intpool \{ \};  
  2 struct  intpool2 \{ \};  
  3 typedef singleton\_pool < intpool,  sizeof ( int ) >  ipool1;  
  4 typedef singleton\_pool < intpool2,  sizeof ( int ) >  ipool2;  
  5  for  ( int  i  =  0 ; i  <  10 ;  \++ i)  
  6  \{  
  7  int  \* q1  =  ( int  \* )ipool1::malloc();  
  8  int  \* q2  =  ( int  \* )ipool2::malloc();  
  9  \* q1  =  i;  
 10  \* q2  =  i \* i;  
 11  cout  <<  \* q1  <<  "  and  "  <<  \* q2  <<  endl;  
 12  \}  
 13  ipool1::purge\_memory();  
 14  ipool2::purge\_memory();

pool\_allocator接口：头文件为<boost/pool/pool\_allocator.hpp>，主要与STL的容器一起使用，可用于代替STL中的allocator。示例代码如下：

1 ![None.gif][]  vector < int , pool\_allocator < int >  >  vctTemp;  
 2 ![None.gif][] list < char , fast\_pool\_allocator < char >  >  lstTemp;

其中，pool\_allocator的内部实现调用了ordered\_malloc和ordered\_free，可以满足对大量的连续内存块的分配请求。 fast\_pool\_allocator 的内部实现调用了malloc和free，比较适合于一次请求单个大内存块的情况，但也适用于通用分配，不过具有一些性能上的缺点。

--------------------

**转自：http://blog.csdn.net/xushiweizh/archive/2006/11/21/1400426.aspx**

Pool分配是一种分配内存方法，用于快速分配同样大小的内存块，  
尤其是反复分配/释放同样大小的内存块的情况。

# 1. pool #

快速分配小块内存，如果pool无法提供小块内存给用户，返回0。  
  
Example:

void  func()  
\{  
boost::pool <>  p( sizeof ( int ));  
 ^^^^^^^^^^^   
指定每次分配的块的大小  
 for  ( int  i  =  0 ; i  <  10000 ;  \++ i)  
\{  
 int  \*  const  t  =  p.malloc();  
pool分配指定大小的内存块；需要的时候，pool会向系统  
申请大块内存。  
...  //  Do something with t; don't take the time to free() it   
  p.free( t );  
 //  释放内存块，交还给pool，不是返回给系统。   
  \}

pool的析构函数会释放所有从系统申请到的内存。

# 2. object\_pool #

与pool的区别在于：pool需要指定每次分配的块的大小，object\_pool需要指定  
每次分配的对象的类型。

Example:

struct  X \{ ... \};  //  has destructor with side-effects   
   
 void  func()  
\{  
boost::object\_pool < X >  p;  
 ^   
 for  ( int  i  =  0 ; i  <  10000 ;  \++ i)  
\{  
X  \*  const  t  =  p.malloc();  
注意；X的构造函数不会被调用，仅仅是分配大小为sizeof(X)  
的内存块。如果需要调用构造函数（像new一样），应该调用  
construct。比如：  
X  \*  const  t  =  p.construct();  
...  
\}  
\}

# 3. singleton\_pool #

与pool用法一样。不同的是：可以定义多个pool类型的object，都是分配同样  
大小的内存块；singleton\_pool提供静态成员方法分配内存，不用定义object。  
  
Example:

struct  MyPoolTag \{ \};  
  
typedef boost::singleton\_pool < MyPoolTag,  sizeof ( int ) >  my\_pool;  
 void  func()  
\{  
 for  ( int  i  =  0 ; i  <  10000 ;  \++ i)  
\{  
 int  \*  const  t  =  my\_pool::malloc();  
 //  ^^^^^^^^^  
 //  和pool不一样。   
  ...  
\}  
  
my\_pool::purge\_memory();  
 //  释放my\_pool申请的内存。   
  \}

# 4. pool\_alloc #

基于singleton\_pool实现，提供allocator（用于STL等）。  
  
Example:

void  func()  
\{  
std::vector < int , boost::pool\_allocator < int >  >  v;  
 for  ( int  i  =  0 ; i  <  10000 ;  \++ i)  
v.push\_back( 13 );  
\}

需要的话，必须自己显式地调用  
boost::singleton\_pool<boost::pool\_allocator\_tag, sizeof(int)>::release\_memory()  
把allocator分配的内存返回系统。

#    实现原理 #

pool每次向系统申请一大块内存，然后分成同样大小的多个小块，  
形成链表连接起来。每次分配的时候，从链表中取出头上一块，提  
供给用户。链表为空的时候，pool继续向系统申请大块内存。  
一个小问题：在pool的实现中，在申请到大块内存后，马上把它分  
成小块形成链表。这个过程开销比较大。即你需要分配一小块内存  
时，却需要生成一个大的链表。用如下代码测试:

boost::pool <>  mem\_pool( 16 );  
  
 for (i  =  0 ; i  <  NPASS; i \++ ) \{  
period  =  clock();  
 for (n  =  0 ; n  <  NITEM; n \++ ) \{  
array\_ptr\[n\]  =  ( int  \* )mem\_pool.malloc();  
\}  
 for (n  =  0 ; n  <  NITEM; n \++ ) \{  
mem\_pool.free(array\_ptr\[n\]);  
\}  
period  =  clock()  \-  period;  
printf( " pool<> : period = %5d ms  " , period);  
\}

可以发现，第一遍花的时间明显多于后面的。  
  
而且在pool的使用过程中如果不是恰好把链表中所有的小块都用上  
的话，在链表中最后的一些小块会始终用不上。把这些小块加入链  
表是多余的。虽然这个开销可能很小:)

[None.gif]: /images/20220722/ff09802a30044c11b7c14ff8a85d253d.png
[ExpandedBlockStart.gif]: http://www.cnblogs.com/Images/OutliningIndicators/ExpandedBlockStart.gif
[ContractedBlock.gif]: http://www.cnblogs.com/Images/OutliningIndicators/ContractedBlock.gif
[dot.gif]: /images/20220722/d7f628d8c9fa4b8b8ee7df1ddd168d17.png
[InBlock.gif]: /images/20220722/b87d0d1f820c4ac4a85cf8f233ea56d7.png
[ExpandedBlockEnd.gif]: /images/20220722/9b8e2f66392c43208df6764ddea2b970.png