学而不思则罔,思而不学则殆

有其事必有其理, 有其理必有其事

  IT博客 :: 首页 :: 联系 :: 聚合  :: 管理
  85 Posts :: 12 Stories :: 47 Comments :: 0 Trackbacks
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的使用过程中如果不是恰好把链表中所有的小块都用上
    的话,在链表中最后的一些小块会始终用不上。把这些小块加入链
    表是多余的。虽然这个开销可能很小:)
posted on 2007-04-16 15:32 易道 阅读(3760) 评论(0)  编辑 收藏 引用
只有注册用户登录后才能发表评论。