【转】boost 内存池

 

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 = ] ms ", period); } 可以发现，第一遍花的时间明显多于后面的。 而且在pool的使用过程中如果不是恰好把链表中所有的小块都用上的话，在链表中最后的一些小块会始终用不上。把这些小块加入链表是多余的。虽然这个开销可能很小:) (iwgh) 原文地址：http://www.rosoo.net/a/200708/6781.html

 

 

Boost pool 库引入了可用于实现快速内存分配的工具。正确的内存块对齐可以得到保证。

根据 Boost 文档所述，当您分配和释放许多小型对象时，建议使用池。使用池的另一个不太明显的优点在于，作为程序员，您不必担心内存泄露：内存由 Boost 库在内部自动进行管理。要使用 pool库，您不必在链接时提供特定的库——单凭头文件就足以完成链接了。

有多个接口对 pool 库可用：

• • 池接口——替代 malloc 进行工作的普通接口。要使用此接口，需要包括 boost/pool 文件夹中的 pool.hpp 头文件。
  • 对象池接口——有对象意识的接口，在对象创建和删除过程中分别相应地调用构造函数和析构函数。还可以使用此接口创建普通对象，而不调用它们的构造函数。接口定义是在位于 boost/pool 目录中的 object_pool.hpp 头文件中提供的。清单 13 引入了 pool 和 object_pool 接口。请注意以下几点：
    • pool 接口需要知道每个单独的元素而不是类型的大小，因为它是一个 malloc 风格的分配程序，不会调用构造函数。
    • pool 接口中的 malloc 例程返回 void*。
    • object-pool 接口需要类型信息，因为要调用构造函数。
    • object-pool 接口中的 malloc/construct 例程返回指向类型的指针。malloc 例程不调用构造函数，但是 construct 要调用构造函数。
    • 使用 pool 接口或 object-pool 接口来创建的元素的范围与从中创建它们的池的范围相同。
    • 要从池接口中释放内存，可以调用 purge_memory 方法。该方法释放您先前创建的内存块，并使得从分配程序例程返回的所有指针失效。
    • 要释放各个元素，可以调用 pool 接口中的 free 例程。例如，如果 t 是使用 pool 接口来创建的池，并且 m 是从 t 分配的指针，则 t.free(m) 将把内存返回给 t（将其添加到 t 的空闲内存列表）。 
      
      清单 13. pool 和 object_pool 接口
      

      #include <iostream> #include <boost/pool/pool.hpp> #include <boost/pool/object_pool.hpp> using namespace std; using namespace boost; class A { public: A( ) { cout << "Declaring A\n"; } ~A( ) { cout << "Deleting A\n"; } }; int main ( ) { cout << "Init pool...\n"; pool<> p(10 * sizeof(A)); for (int i=0; i<10; ++i) A* a = (A*) p.malloc(); // Always returns sizeof(A) p.purge_memory(); cout << "Init object pool...\n"; object_pool<A> q; for (int i=0; i<10; ++i) A* a = q.construct(); // Calls A's constructor 10 times return 0; }

  • singleton_pool 接口——与 pool 接口几乎相同，但是用作独立池。独立池的底层结构具有为 malloc、free 等声明的静态成员函数，并且构造函数是私有的。独立池声明中的第一个参数称为标记——它允许存在不同的独立池集（例如，用于 int 的多个池，其中每个池服务于不同的目的）。必须包括 singleton_pool.hpp 头文件才能使用此接口。请参见清单 14。 
    
    清单 14. singleton_pool 接口
    

    #include <iostream> #include <boost/pool/singleton_pool.hpp> using namespace std; using namespace boost; struct intpool { }; struct intpool2 { }; typedef boost::singleton_pool<intpool, sizeof(int)> ipool1; typedef boost::singleton_pool<intpool2, sizeof(int)> ipool2; int main ( ) { cout << "Init singleton pool...\n"; for (int i=0; i<10; ++i) { int* q1 = (int*) ipool1::malloc(); int* q2 = (int*) ipool2::malloc(); } ipool1::purge_memory(); ipool2::purge_memory(); return 0; }

  • pool_alloc 接口——通常与 STL 容器结合在一起使用。请考虑以下代码片段：

    #include <boost/pool/pool_alloc.hpp> std::vector<int, boost::pool_allocator<int> > v; std::list<double, boost::fast_pool_allocator<double> > L;

    
    存在两个分配程序：pool_allocator 和 fast_pool_allocator。第一个分配程序是通用分配，可以满足针对任何数量的连续内存块的请求。fast_pool_allocator 最适合于一次请求单个（通常较大）块，但是也适用于通用分配，不过具有一些性能缺点。
    • 原文地址：http://blog.chinaunix.net/uid-1827018-id-3384669.html

转载于:https://www.cnblogs.com/zhiqli/archive/2013/03/27/2984017.html