ARM/linux|malloc内存分配详解

这里的存储分配程序,讲的就是标准库中malloc函数的实现原理。首先要了解针对malloc的内存存储结构。malloc不像全局变量一样,不是在编译器编译的时候就会分配内存空间,而是在调用到malloc函数时才会分配空间。有时还会中途调用free函数释放空间出来。所以:
1、malloc在第一次被调用时,从系统中获取最小为一个单元的空闲空间(eg:最小单元为1024个最受限单元块。当x<=1024,获取1024个,否则获取x个),再进行分配;
2、malloc所剩下的空闲空间一般都不是连续的,而是分散的。这样也提高了空间的利用率。
为了管理malloc的空闲空间,每一个独立块的最前面都包含了一个“头部”信息:一个指向下一个空闲块的指针、一个本身独立块的长度(书上说还有一个指向自身存储空间的指针,但每个存储空间都有自身的指针,为什么还要这个呢。后看英语版原著,这么写的:Each block contains a size, a pointer to nextblock, and the space itself.)。下一个空闲块是按存储地址升序排列,离本空闲块最近的一个空闲块,若本空闲块在最后,则指向最前的空闲块。这样所有属于malloc的空闲空间都被串在了一起。如下图所示:

ARM/linux|malloc内存分配详解
文章图片



注:中文版的此图解释翻译搞错了,如下图:
ARM/linux|malloc内存分配详解
文章图片





因为后面的free函数已经把相邻的空闲链表给整合成一块了,所以我的图没有出现相邻的空闲链表。

每块由malloc控制的空间都包含一个“头部”信息,为了方便管理,每块的空间大小都是头部大小的整数倍。而头部长度=指向下一个空闲块的指针的长度+自身空间大小的unsigned长度。但为了确保由malloc函数返回的存储空间满足将要保存的对象的对齐要求。每个机器都有一个最受限的类型:如果最受限的类型可以存储在某一个特定的地址中,则其他所有的类型也可以存放在此地址中。有的是double型,有的是long型,甚至还有的是int型。因此,头部结构将与最受限的类型进行联合,来确保对齐。
因为有头部信息,头部信息里的本块空间size也是包括头部的大小,所以每次申请malloc空闲块的时候,都要加上一个单元,最后返回给用户的时候,再去掉头部。
每次调用malloc申请空间时,malloc有一个专门指向当前空闲块链表的静态指针freep。从当前开始扫描剩下的空闲块链表,直到扫到一个足够大的空闲块。此算法成为“首次适应”(first fit),与之相对的是“最佳适应”(best fit):它将扫描出满足条件最小的块。这里的代码是“首次适应”算法。结果将出现三种情况:
1)找到一块刚好合适的空闲块,则此块空间从链表中移走并将此块的地址返回给用户,并把静态指针freep指向前一空闲块地址;
2)找到一块比需求大的空闲块,则从此空闲块中的后部取一块与需求一样的空间给用户,前部改变空闲块大小便可;
ARM/linux|malloc内存分配详解
文章图片



注(直到写本博文才发现自己错了):
①一直都认为返回给用户地址前一单元的头部,应该把空间退还给前面的空闲块,不然就闲着了。其实,里面记录了一个重要信息:空间块大小(包括头部和返回给用户的单元大小),在free释放空间的时候,就必须用到此头部的信息;
②后面的free程序以为是专供系统申请空间后插入空闲块链表用的,其实它就是我们平常用malloc、realloc、或calloc申请空间后,再释放的程序。

3)如果扫描了一遍,都没有找到足够大的空闲块,则向系统再申请一块新的空间。
上面都是在malloc已经有了空闲块的前提下,但第一次申请的时候,malloc是没有空闲块空间的。因此,在预编译时,就建立了一个单元的空闲块链表base来当做空闲链表的入口。当第一次调用malloc时,空闲链表的静态指针freep为NULL,那将它指向base,大小设为0(这样这块base空间将一直存在,且不被申请,确保了之后freep一直指向有效的空闲块链表),且指向它自己,同时向系统申请空闲空间(每次向系统申请的空间都是一块连续的空闲块)。

[cpp]view plain copy

  1. typedef long Align; /*按照long类型的边界对齐,即以long作为最受限类型*/
  2. union header{/*头部信息*/
  3. struct {
  4. union header *ptr; /*指向下一个空闲块*/
  5. unsigned size; /*本空闲块大小*/
  6. }s;
  7. Align x; /*强制对齐*/
  8. };
  9. typedef union header Header;
  10. static Header base; /*第一次调用malloc的空闲块链表入口,大小为0的空链表(按照上面逻辑的来说,这里的size应该为1)*/
  11. static Header *freep = NULL; /*静态的空闲块链表指针,初始化为NULL。第一次申请后才会指向base*/
  12. /*malloc函数:通用存储分配函数*/
  13. void *malloc(unsigned nbytes)
  14. {
  15. Header *p,*prevp; /*定义一个当前空闲块指针变量,和前一个空闲块指针变量*/
  16. Header *morecore(unsigned); /*用于向系统申请空闲空间函数*/
  17. unsigned nunits; /*需要申请的实际单元大小,即上面图中的z*/
  18. nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1; /*与上图对应,把字节大小转换为单元大小,向上取整,并加上一个单元(头部)*/
  19. if((prevp = freep) == NULL){/*没有空闲链表,第一次申请*/
  20. base.s.ptr = prevp = freep = &base; /*freep指向base,base的下一个空闲块指针指向自己*/
  21. base.s.size =0; /*设置大小为0*/
  22. }
  23. for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
  24. if(p->s.size >= nunits){
  25. if(p->s.size == nunits)/*大小刚好合适*/
  26. prevp->s.ptr = p->s.ptr; /*移走此块空闲区域*/
  27. else{/*比实际需求大,从空闲块尾部分配*/
  28. p->s.size -= nunits; /*缩小空闲块大小*/
  29. p += p->s.size; /*指针指向被申请的空间的头部*/
  30. p->s.size = nunits; /*设置被申请的空闲块大小*/
  31. }
  32. freep =prevp; /*当前静态指针指向前一空闲块,如果当前块还有空闲区域,下次将继续从此处开始扫描,节省时间*/
  33. return (void *)(p+1); /*返回去头部单元的空闲空间*/
  34. }
  35. if(p == freep)/*闭环的空闲链表,第一次调用malloc申请,或扫描一遍,未发现足够大的空间*/
  36. if((p = morecore(nunits)) == NULL)/*向系统申请空间*/
  37. return NULL; /*未申请成功,*/
  38. }
  39. }

通过下面的morecore()和free()函数的程序分析可知,在向系统成功申请空间后,p将指向有足够空间的空闲块。但在此代码中,进入下一此空闲块扫描前,p将指向下一块不足的空闲块,导致多扫描了一遍。个人觉得,如果空间足够,可以多申请一个静态指针beforefreep,指向freep的前一个空闲块。这样上面代码可添加一句,提高效率:
[cpp]view plain copy
  1. if(p == freep){ /*这样要添加大括号*/
  2. if((p = morecore(nunits)) == NULL)
  3. return NULL;
  4. p = beforefreep;
  5. }
  6. if(p == freep) /*这里可以不用加大括号,else与最近的if匹配*/
  7. if((p = morecore(nunits)) == NULL)
  8. return NULL;
  9. else
  10. p = beforefreep;
向系统申请空间的时,不是按需分配,而是有一个最小申请单元数。让您足够用,这次用不完可以留着下次用,不用每次都向系统申请,又不会系统浪费空间。
真正向系统申请空间,还需调用系统调用sbrk(n)(UNIX下),若申请成功,该指针返回指向n个字节的存储空间;若申请失败,返回-1(不是NULL)。返回的指针类型是char *(应该是最小的存储空间单元)。

[cpp]view plain copy
  1. #define NALLOC 1024 /*最小申请单元数*/
  2. /*morecore函数:向系统申请更多的存储空间*/
  3. static Header *morecore(unsigned nu)/*返回的是静态空闲块链表指针*/
  4. {
  5. char *cp, *sbrk(int);
  6. Header *up;
  7. if(nu < NALLOC)
  8. nu =NALLOC;
  9. cp = sbrk(nu * sizeof(Header)); /*调用系统调用申请系统空间*/
  10. if(cp == (char *) -1)
  11. return NULL; /*申请失败,没有空间*/
  12. up = (Header *)cp; /*转换为Header*指针类型*/
  13. up->s.size = nu; /*设置此空间块的大小*/
  14. free((void *)(up +1)); /*释放空间*/
  15. return freep;
  16. }

这里的返回的freep,在free中更新了,才返回的。当初也想过既然freep都是静态全局变量了,那这里为什么还要返回一个静态变量呢,直接在函数里赋值就好了。其实这里有成功与失败,所以程序来需要判断申请结果,而且返回的freep是与申请最相关东西。
free(void *ap)函数就是释放指针ap所指的空间,具体要释放的大小在ap前一个指针,即头部信息里。释放主要就是为了把此空间插入到空闲块链表中。所以要找到此空间块两边的空闲块(也有可能只有一块空闲块,即入口base)。然后判断是否与前一块相连,与后一块相连,相连的话,合并成一块,否则直接在中间插入一个新的空闲块链表。

[cpp]view plain copy
  1. /*free函数:释放ap,将ap块放入空闲链表中*/
  2. void free(void *ap)
  3. {
  4. Header *p, *bp;
  5. bp =(Header *)ap -1; /*指向ap块的头部*/
  6. for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)/*找到bp所在空闲链表中的位置*/
  7. if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))/*判断是否在链表的开头或末尾*/
  8. break;
  9. if(bp + bp->s.size == p->s.ptr){/*先判断能否与高地址的空闲块合并,即与后一块合并*/
  10. bp->s.size += p->s.ptr->s.size;
  11. bp->s.ptr = p->s.ptr->s.ptr;
  12. }
  13. else
  14. bp->s.ptr = p->s.ptr; /*不能合并,bp指向后一块地址*/
  15. if(p + p->s.size == bp){ /*再判断能否与地地址的空闲块合并,即与前一块合并*/
  16. p->s.size += bp->s.size;
  17. p->s.ptr = bp->s.ptr;
  18. }
  19. else
  20. p->s.ptr =bp; /*不能合并,p指向bp地址*/
  21. freep =p;
  22. }

注:中文版翻译的又有歧义了,原著分别是“join to upper nbr”和“jointo lower nbr”。
ARM/linux|malloc内存分配详解
文章图片


这个free程序,处理的太妙了。一般思维,先与前一块合并,再与下一块合并,如下面的程序(显然比我的好多了):
[cpp]view plain copy
  1. if(p + p->s.size == bp){ /*与前一块相连?*/
  2. if(bp + bp->s.size == p->s.ptr){/*与后一块相连?*/
  3. p->s.size += bp->s.size + p->s.ptr->s.size;
  4. p->s.ptr = p->s.ptr->s.ptr;
  5. }else
  6. p->s.size += bp->s.size;
  7. }else{
  8. if(bp + bp->s.size == p->s.ptr){/*与后一块相连?*/
  9. bp->s.size += p->s.ptr->s.size;
  10. bp->s.ptr = p->s.ptr->s.ptr;
  11. p->s.ptr = bp;
  12. }else/*不与任何一块相连*/
  13. bp->s.ptr = p->s.ptr;
  14. p->s.ptr = bp;
  15. }
【ARM/linux|malloc内存分配详解】从这里可以看出,通过malloc申请后的空间,并没有初始化,所以在使用前记得初始化,不小心当做右值使用,出错的概率很大。

    推荐阅读