内存使用技巧及内存池实现(二)

转载地址：http://blog.csdn.net/gugemichael/article/details/7547143

  上一章节，提到了内存池的使用。其实内存池的作用看名字也能猜到，"池"意味着资源是同一管理和创建释放的，就像数据库的连接池、系统的线程池。主要就是为了避免创建、销毁资源的代价。c标准的malloc/free会造成大量的内存碎片以至于影响效率，所以“内存池”的技术某种程度上避免了这种消耗和影响。

        本人觉得实现的内存池可以分为3级：

           1、初级的简单内存池实现：解决malloc小空间的碎片化，托管回收。适用于函数或类，不跨线程 

           2、高级的内存池：通过块链式的方式长期托管内存，可以半自动的释放内存，并可以动态规划内存的块存储(类似linux内核BuddySystem)。

           3、可以托管内存和相关资源(文件句柄、数据库连接)的池 : 将和该块内存相关联的内存、资源整合，统一托管！全局托管资源。

        本文会实现并讲解1、2中的内存池实现方式。第3种时间和技术有限，大家可以自行写一写，或者用C++的RAII技术和STL中的实现来用。

        简单的内存池实现，核心思想就是想申请一块大内存(mb级别，并且为512KB的整数倍，好处是和linux内存管理配套，数字根据应用不同可以改)，这样做可能有一定的浪费，不过试想一下，如果只是申请几十个Byte，根本用不到内存池。用到了内存池肯定空间不会太小。然后从这块大内存上用游标控制分配，alloc一块内存指针就移动固定位数，最后统一释放。这样，在操作系统看来，就总是去申请很大一块内存，并且造成碎片的几率很低，速度也快。

        这种实现方式不会让用户去free，因为free了也没用，池子并不会服用。但是这块大内存的生命周期不会很长，所以一般场景下不影响。下一小节会介绍"高级"一点的实现的方式，通过动态的拆分和合并来管理不同大小的内存。

        废话不多说，直接上代码：

[cpp] view plain copy print ?

1. typedef struct _mempool simple_mempool;  
2.   
3. struct _mempool {  
4.     uint32_t size;      // memory pool total size (512KB * n)  
5.     void *raw_area;  
6.     void *cursor;       // indicate the current position of pool  
7. };  

        内存池结构体句柄，保存大小、游标，和原始malloc指针。

[cpp] view plain copy print ?

1. /** 
2.  * Don't allocate more than 512M space, because this mempool 
3.  * just implement simple way of pool, it don't free anything 
4.  * util call simple_mempool_destroy(), this feature is based  
5.  * on JUST USE it in an funtion or in one class 
6.  */  
7. void* simple_mempool_create(uint32_t size)  
8. {  
9.     if (size==0 || size>=1024*512)  
10.         return NULL;  
11.   
12.     // align of 4 byte  
13.     // size += size % 4;  
14.   
15.     simple_mempool *pool = (simple_mempool*)calloc(1,sizeof(simple_mempool));  
16.     pool->size = CHUNK_SIZE*size;  
17.     pool->raw_area = calloc(1,1024*size);  
18.     pool->cursor = pool->raw_area;  
19.   
20.     return pool;  
21. }  

         创建内存池，如果大于512M就忽略，建议使用高级内存池。

[cpp] view plain copy print ?

1. uint8_t simple_mempool_could_allocate(simple_mempool* pool, uint32_t n)  
2. {  
3.     // cursor will out of the end  
4.     if ((pool->cursor-pool->raw_area)+n > pool->size)  
5.         return 0;  
6.     else      
7.         return 1;  
8. }  
9.   
10. void* simple_mempool_allocate(simple_mempool* pool, uint32_t n)  
11. {  
12.     // no space here  
13.     if (NULL==pool || NULL==pool->raw_area || !simple_mempool_could_allocate(pool,n))  
14.         return NULL;  
15.   
16.     void* ret = pool->cursor;  
17.     // move the cursor  
18.     pool->cursor = (void*)((char*)pool->cursor + n);  
19.   
20.     return ret;  
21. }  

         实际分配函数，只是挪动了一下cursor指针而已。

[cpp] view plain copy print ?

1. uint32_t simple_mempool_left(simple_mempool *pool)  
2. {  
3.     if (NULL == pool)  
4.         return -1;  
5.     else return pool->size - (pool->cursor - pool->raw_area);  
6. }  

         查看剩余量，此处pool->size / pool->cursor - pool->raw_area等是无符号整型，虽然没做边界校验，但是allocate函数保证了cursor不会超过size。

[cpp] view plain copy print ?

1. void simple_mempool_destroy(simple_mempool* pool)  
2. {  
3.     free(pool->raw_area);  
4.     pool->cursor = pool->raw_area = NULL;     
5.     pool->size = 0;  
6. }  

         释放内存池，pool句柄可复用。

        下面是ut单侧的代码，分配完了就destroy并退出 :

[cpp] view plain copy print ?

1. #define ut_main main  
2. int ut_main()  
3. {  
4.   
5.     simple_mempool *pool = simple_mempool_create(1);  
6.   
7.     while(1) {  
8.         long long *tmp = simple_mempool_allocate(pool,sizeof(long long));   
9.         if (NULL == tmp) {  
10.             printf("no space in mempool , destroy it !!!");  
11.             simple_mempool_destroy(pool);  
12.             break;    
13.         }         
14.     }  
15.   
16.     return 0;  
17. }  

         周末我会把第2种实现的比较良好的内存池的实现方式贴上来，大家一起讨论。