内存使用技巧及内存池实现

本文只是展示了一些基本的内存管理技巧，处于篇幅没有更深入的讲解，有兴趣可回复一起探讨^_^

        在当前的软件开发环境下，主要分为两大类：客户端和服务端。软件部署在客户端的情况逐渐被Web应用和服务端的网络应用所替代(游戏客户端例外)，并且随 着硬件的不断升级和成本的降低，各种计算资源和存储资源被程序随意使用，基本不用考虑一个进程多占了几个Byte，多消耗了CPU几个毫秒。不过，某些场 合下，比如嵌入式环境和大型服务器(尤其是分布式和云计算平台下的大规模数据和海量计算)，对资源的使用仍旧需要在时间和空间上进行优化。所以，作者认 为，通过技巧和算法来优化程序还是很有必要的。 

         本文主要介绍一些内存的使用技巧，系统场景为Linux，Windows/Mac也可作为参考。

         1、内存的基本操作 : 

          C语言中如果要申请堆内存，可以通过malloc/calloc/realloc来获得，参数就是内存大小和重新分配的大小。但需要注意的是malloc 出来分配的内存是未经过初始化的，不能直接使用，所以要bzero或memset(0)，可以用calloc(1,SIZE)一行来代替代替。这里用到的 sizeof要注意，获取一个struct或者class的大小一定要sizeof，否则会发生莫名的错误(后面会讲到字节对齐)。

[cpp] view plain copy print ?

1. void foo()  
2. {  
3.     // use malloc  
4.     int *p = (int*)malloc(sizeof(int));  
5.     memset(p,0,sizeof(*p));  
6.   
7.     // use calloc  
8.     int *c = (int*)calloc(1,sizeof(int));  
9. }  

          在C++里通过new来分配堆内存，new除了像malloc一样分配一块内存，还有一个功能就是会调用该类的构造函数，对此对象进行初始化操作，所以如 果是C++里，不是申请固定大小的内存自己规划用的只是为对象分配空间的话，就尽量用new。新的C++标准规定，当内存不够，new不成功的时候，不是 像以前一样返回NULL，而是抛出一个异常 -- std::bad_alloc，很多项目里，包括Google的开源项目，都不建议使用异常(因为没有finally，并且速度很慢)，所以new的时候 应该加上std::nothrow。

[cpp] view plain copy print ?

1. void foo()  
2. {  
3.     MySample *p = new (std::nothrow) MySamle();  
4.     if (NULL == p)  
5.         DealError();      // handle the error  
6. }  

       如果不使用了则用free/delete来释放，并且一定要把原来的指针指NULL。(不指NULL不一定有问题，但是为保险起见)。

       2、Linux进程内存区域分布:

      各个区段的意义和存储的数据网上资料很多，就不在此一一说明了。补充一句，栈是由高地址向低地址延伸，堆反过来(记不住的话可以记住栈分配int空间时候 是eps指针-4)。还有堆栈中间不是完全空闲的，最中间一段是mmap(内存映射)使用的。如果想查看大小，可以用size命令，比如: size ./myprogram

      3、malloc的具体平台实现 :

        我们都知道，malloc是libc的标准函数，是c语言的标准。所以windows、mac、linux才都会有这个函数。因为是标准，所以就不能特 化，不能特化就意味着某种程度上的速度慢(不是绝对，但是个规则)。malloc是用户态函数，要想从Linux系统中得到实际内存，是要调用linux 的brk系统调用的，这个brk就是移动堆顶指针的函数，是将进程的mm_stat机构中的brk值扩大以获得空间。

        malloc在分配内存的时候，参数size不是传入多大就分配多大，试想一个，malloc(1)如果直接分配一个字节，那么malloc的管理字节就 会比数据空间大很多(关于管理字节，可以认为存储的是已分配的空间的大小，比如free的时候，并不用传入指针指向空间的大小，因为有管理字节)。还 有，cpu通过内存控制器访问内存的时候，是按cpu"喜欢"的对齐方式访问，一般是按4的整数字节读取，如果分配的空间是4的整数倍，就会加快访问。而 且malloc会对传入的大小数字进行“归一化”，按照内核的递增序列分配内存（一般最低层次是8byte，按2的幂增长，最大1M，也就是说如果申请大 于1M，则要多少给多少）。

      malloc在分配了大量的内存之后，会变得越来越慢，因为malloc的分配过程是现在内存管理模块的"空闲链表"里找到一个合适大小的内存返回，如果空闲链表太长，势必影响速度。

      4、锁住物理内存，不被swap :

      有的应用，如memcached等缓存系统，或者实时性很高的系统，要求分配的内存要全部Hold在内存中，不被swap到磁盘上(Linux系统内存满 了才会swap，但需要考虑PageCache)。所以，可以使用mlockall/mlock函数把已分配的内存，甚至以后malloc的内存都一直留 在磁盘里。（不好之处是内存满了malloc直接返回NULL，还会触发SIGSEGV信号）。

[cpp] view plain copy print ?

1. void lock_mem(void* area, size_t len)  
2. {  
3.     // lock an area of pointer  
4.     mlock(area,len);  
5.   
6.     // lock all memory has allocated , but no effect with future  
7.     mlockall(MCL_CURRENT);  
8.   
9.     // lock all memory has allocated and future  
10.     mlockall(MCL_CURRENT | MCL_FUTURE);  
11. }  

      5、巧用struct/class字节对齐，压缩空间 :

      如果有一个struct/class在内存中可能有10万、或者100万个instanse(大规模服务器经常的情况)，可以考虑对它通过字节对齐进行压缩:

[cpp] view plain copy print ?

1. #include <stdio.h>  
2.   
3. struct NoAlign {  
4.     int a;    
5.     char b;   
6.     int c;    
7.     short d;  
8.     int e;    
9.     char f;   
10. };  
11.   
12. struct Align {   
13.     char b;   
14.     char f;   
15.     short d;  
16.     int a;    
17.     int c;    
18.     int e;    
19. };  
20.   
21. int main()  
22. {  
23.     printf("%d|%d",sizeof(struct NoAlign),sizeof(struct Align));  
24.     return 0;  
25. }  

       程序会输出"24|16"，我的是x64的系统，可以看出通过适当的调整字段的顺序，可进行字节对齐的压缩，最简单廉价的方法，何乐而不为呢！如果是数组，建议放在最后，这样offset会快些(意义不是很大)。

      6、内存读取访问最好按4的整倍数步进:

      可以看看memset的代码实现，并不是一个for循环然后set每一个字节，这样cpu效率低。memset的实现是按4个字节set一次进行步进，这 样效率高些，相对循环次数也多，然后针对剩下的1～3次可用1～3行冗余代码搞定(类似上篇文章介绍的冗余代码的一些好处)。

     7、offsetof()函数可以获得某个字段在struct中的偏移量 :

     offsetof()在32位系统下的实现类似:

[cpp] view plain copy print ?

1. #define OFF_SET_OF(s,m) (size_t)&(((s *)0)->m)  

      就是将0x00000000转换为struct*指针，然后对齐求其m元素的偏移再转换成地址再转换成数字。

      8、malloc的替代品 : tcmalloc/jemalloc

      介绍了这么多内存管理细节和技巧，总结一下，其实malloc并不是用于大量内存分配操作(容易产生碎片、速度有问题)，并且在多线程环境下也不太适合(malloc是不可重入但是线程安全的函数)，说他不适合是因为多线程情况下malloc容易泄漏资源。

      这里提出两个解决方式，第一个就是写一个内存池，自己托管内存的使用和分配释放，内存使用技巧及内存池实现(二)将进行详细介绍。还有一种就是使用改良的 类malloc分配器，使用google的tcmalloc和jemalloc，tcmalloc在效率上比malloc快了很多(malloc()一次 大概300ns，而tcmalloc()大约50ns)。主要是因为TCMalloc减少了多线程程序中的锁争用情况。对于小对象，几乎已经达到了零争用。对于大对象，TCMalloc尝试使用粒度较好和有效的自旋锁。Redis也该用jemalloc来解决内存碎片问题，并且jemalloc在realloc函数上也下了很多功夫，使得realloc原地更新分配，而不是另外开辟一段新空间。

       在编译mysql时候就可以指定tcmalloc，有些资料显示使用tcmalloc的程序有了很大的性能提升(本人未测试)。

       使用tcmalloc很简单，只需要加入脚本 ：LD_PRELOAD="/usr/local/lib/libtcmalloc.so"即可。

本文所有内容包括源码均是作者原创，出于尊重，如果转载请表明出处 ^_^        

        上一章节，提到了内存池的使用。其实内存池的作用看名字也能猜到，"池"意味着资源是同一管理和创建释放的，就像数据库的连接池、系统的线程池。主要就是 为了避免创建、销毁资源的代价。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. } 
    

http://blog.csdn.net/gugemichael/article/details/7547143