关闭

[内存管理]内存池pool库

标签: objectclassstringdelete算法测试
2397人阅读 评论(0) 收藏 举报
分类:


 pool库概述

如果之前学过操作系统的内存管理机制和内存分配算法等知识,那么就了解“内存池”的概念。

简单地说,内存池预先分配了一块大的内存空间,然后就可以在其中使用某种算法实现高效快速的自定制内存分配。

boost.pool库基于简单分配存储思想实现了一个快速、紧凑的内存池库,不仅能够管理大量的对象,而且还可以被用作STL的内存分配器。它近似于一个小型的垃圾回收机制,在需要大量地分配/释放小对象时很有效,并且完全不需要考虑delete。

pool库包含四个部分,最简单地pool、分配类实例的object_pool、单件内存池singleton_pool和可用于标准库的pool_alloc。

 

1:pool

pool是最简单也最容易使用的内存池类,可以返回一个简单数据类型(POD,Plain Old Data)的内存指针,它位于命名空间boost,为了使用pool组件,需要包含头文件<boost/pool/pool.hpp>。

类摘要:

template<typename UserAllocator >
class pool{
     public:
	 explicit pool(size_type requested_size);
	 ~pool();
	 size_type get_requested_size() const;
	 
	 void *malloc();
	 void *ordered_malloc();
	 void *ordered_malloc(size_type n);
	 bool is_from(void *chunk) const;
	 
	 void free(void *chunk);
	 void ordered_free(void *chunk);
	 void free(void *chunks,size_type n);
	 void ordered_free(void *chunks,size_type n);
	 
	 bool release_memory();
	 bool purge_memory();
};


操作函数

pool的模板类型参数UserAllocator 是一个用户定义的内存分配器,它实现了特定的内存分配算法,通常可以直接用默认的default_user_allocator_new_delete。

pool的构造函数接受一个size_type类型的整数requested_size,指示每次pool分配内存块的大小(而不是pool内存池的大小),这个值可以用get_requested_size()获得。pool会根据需要自动地向系统申请或归还使用的内存,在析构时,pool将自动释放它所持有的所有内存块。

成员函数malloc()和ordered_malloc()的行为很类似C中的全局函数malloc(),用void*指针返回从内存池中分配的内存块,大小为构造函数中指定的requested_size。如果内存分配失败,函数将返回0,不会抛出异常。malloc()从内存池中任意分配一个内存块,而ordered_malloc()则在分配的同时合并空闲块链表。ordered_malloc()带参数的形式还可以连续分配n块的内存。分配后的内存块可以用is_from()函数测试是否是从这个内存池分配过去的。

与malloc()对应的一组函数是free(),用来手工释放之前分配的内存块,这些内存块必须是从这个内存池分配出去的(is_from(chunk) == true)。一般情况内存池会自动管理内存分配,不应该调用free()函数,除非你认为内存池的空间已经不足,必须释放已经分配的内存。

最后还有两个成员函数:release_memory()让内存池释放所有未被分配的内存,但已分配的内存块不受影响;purge_memory()则强制释放pool所持有的所有内存,不管内存块是否被使用。实际上,pool的析构函数就是调用的purge_memory()。这两个函数一般情况下也不应该手工调用。

 

使用示例:

#include <iostream>
#include <boost/pool/pool.hpp>
using namespace boost;
using namespace std;
int main(){
 //一个可分配int的内存池 
  pool<> pl(sizeof(int));
  //必须把void*转换成需要的类型 
  int *p = (int *)pl.malloc();
  assert(pl.is_from(p));
  cout << "pl is allocated from pool." << endl;
  //释放内存池分配的内存块 
  pl.free(p);
  cout << "Free memory pool of the allocated memory block" << endl;
  //连续分配大量的内存 
  for(int i = 0; i < 100; ++i)
  pl.ordered_malloc(10);
  cout << "allocated a large of memory" << endl
       << "now free all memory..." << endl;
     
}


运行结果:

pl is allocated from pool.
Free memory pool of the allocated memory block
allocated a large of memory
now free all memory...

 

pool很容易使用,可以像C中的malloc()一样分配内存,然后随意使用。除非有特殊要求,否则不必对分配的内存调用free()释放,pool会很好地管理内存。

因为pool在分配内存失败的时候不会抛出异常,所以实际编写代码时应该检查malloc()函数返回的指针,以防止空指针错误。不过这种情况极少出现。

int *p = (int *)pl,malloc();

if(p != NULL);

关于pool<>需要注意的是:它只能作为普通数据类型如int、double、float等的内存池,不能应用于复杂的类和对象,因为它只负责分配内存,不调用构造函数。

 

object_pool

object_pool是用于类对象的内存池,它的功能与pool类似,但会在析构时对所有已经分配的内存块调用析构函数,从而正确地释放资源。

类摘要:

 

template<typename ElementType>
class object_pool:protected pool{
   public:
   object_pool();
   ~object_pool();
   
   element_type *malloc();
   void free(element_type *p);
   bool is_from(element_type *p) const;
   
   element_type * construct();
   void destory(element_type *p);	
};

  操作函数

object_pool是pool的子类,但它使用的是保护继承,因此不能使用pool的接口。

object_pool的模板参数类型参数ElementType指定了object_pool 要分配的元素类型,要求其析构函数不能抛出异常。一旦在模板中指定了类型,object_pool对象就不能再用于分配其他类型的对象。

malloc()和free()函数分别分配和释放一块类型为ElementType*的内存块,同样,可以用is_from()来测试内存块的归属,只有是本内存池分配的内存才能被free()函数释放掉。但它们被调用时并不调用类的构造函数和析构函数,也就是说操作的是一块原始内存块,里面的值是未定义的。因此应该尽量少用malloc()和free()。

object_pool的特殊之处是construct()和destory()函数,这两个函数是object_pool的真正价值之所在。construct()实际上是一组函数,有多个参数的重载形式(目前最多支持三个参数,但可以扩展),它先调用malloc()分配内存,然后再在内存块上使用传入的参数调用类的构造函数,返回的是一个已经初始化的对象指针。destory()则先调用对象的析构函数,然后再用free()释放内存块。

 

使用示例:

#include <iostream>
#include <boost/pool/object_pool.hpp>
using namespace std;
using namespace boost;
//一个示范类 
struct demo_class{
   public:
   int a,b,c;
   demo_class(int x = 1,int y = 2,int z = 3):a(x),b(y),c(z){}	
};
int main(){
	//对象内存池 
	object_pool<demo_class> pl;
	//分配一个原始的内存块 
	demo_class *p = pl.malloc();
	assert(pl.is_from(p));
	cout << "ok,allocated from pl..." << endl;
	//p指向的内存未经过初始化 
	assert(p->a != 1 || p->b != 2 || p->c != 3);
	//构造一个对象,可以传递参数 
	p = pl.construct(7,8,9);
	assert(p->a == 7);
	cout << p->a << " " << p->b << " " << p->c << endl;
	//定义一个分配string对象的内存池 
	object_pool<string> pls;
	//连续分配大量string对象 
	for(int i = 0; i < 10; ++i){
	  string *ps = pls.construct("hello object_pool");
	  cout << *ps << endl;
	}
	//所有创建的对象在这里都被正确地析构、释放内存 
}


singleton_pool

singleton_pool与pool的接口完全一致,可以分配简单数据类型的内存指针,但它是一个单件,并提供线程安全。

由于目前Boost还未提供标准的单件库,singleton_pool在其内部实现了一个较简单、泛型的单件类,保证在main()函数运行之前就创建单件。

 

类摘要:

template< typename Tag,unsigned RequestedSize >
class singleton_pool{
    public:
	static bool is_from(void *ptr);
	static void *malloc();
	static void *ordered_malloc();
	static void *ordered_malloc(size_type n);
	
	static void free(void *ptr);
	static void ordered_free(void *ptr);
	static void free(void *ptr,std::size_type n);
	
	static bool release_memory();
	static bool purge_memory();	
};


 singleton_pool主要有两个模板类型参数(其余的可以使用缺省值)。第一个Tag仅仅是用于标记不同的单件,可以是空类,甚至是声明(这个用法还被用于boost.exception)。

第二个参数RequestedSize等同于pool构造函数中的整数requested_size,指示pool分配内存块的大小。

   singleton_pool的接口与pool完全一致,但成员均是静态的,因此不需要声明singleton_pool的对象,直接用域操作符::来调用静态成员函数。因此singleton_pool是单件,所以它的生命周期与整个程序一样长,除非搬运调用release_memory()或者purge_memory(),否则singleton_pool不会自动释放所占用的内存。除了这两点其他用法与pool完全相同。

 

pool_alloc

pool_alloc提供了两个可以用于标准容器模板参数的内存分配器,分别是pool_alloc和fast_pool_allocator,它们的行为与之前的内存池类有一点不同-----当内存分配失败时会抛出异常std::bad_alloc,除非特别的需求,我们应该总使用STL实现自带的内存分配器,使用pool_alloc需要经过仔细测试,以保证它与容器可以共同工作。

使用示例:

#include <iostream>
#include <vector>
#include <boost/pool/pool_alloc.hpp>
using namespace std;
using namespace boost;
int main(){
 //使用pool_allocator代替标准容器默认的内存分配器 
    vector<int,pool_allocator<int> > v;
    //vector将使用新的分配器良好工作 
 v.push_back(10);
 cout << v.size() << endl; 
}
1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:484212次
    • 积分:5399
    • 等级:
    • 排名:第5145名
    • 原创:113篇
    • 转载:46篇
    • 译文:2篇
    • 评论:117条
    最新评论