dlmalloc 简析

******************************************************************
By Sky
http://blog.csdn.net/ykdsea/
******************************************************************

本文基于android 4.4所用的dlmalloc版本进行分析。

malloc/free work flow

---

malloc/free是libc库提供的函数，主要是用户层的操做，而不是内核的系统调用。
通常的heap管理是经过sbrk或者mmap函数来向系统获取大量的内存（只是虚拟的内存地址），而后由特定的heap管理算法来管理用户程序申请/释放内存（好比dlmalloc）。有一点注意，brk/sbrk获取的只是虚拟地址，当这些地址被访问的时候，才会产生page fault，真实的物理内存才会被分配出来。

Free的时候，内存也只是返还给内存管理程序了，而不是直接返还给系统。当内存管理程序发现保留了过多的内存的时候，能够经过umap或者brk/sbrk来把内存还给系统。

mmap的使用：
通常状况下，系统是使用brk/sbrk来扩展可用内存的。在某些特殊状况下，会考虑使用mmap来直接申请对应的内存，这个作法能够减小内存中空洞存在，他的缺点是速度比较慢。
在dlmalloc中，是在查找没有可用的free chunk的时候，而且分配的size大于必定的值的时候，会使用mmap直接分配。

dlmalloc

---

android中采用的dlmalloc为默认的heap管理算法。
dlmalloc的介绍说明：http://gee.cs.oswego.edu/dl/html/malloc.html

dlmalloc的配置：(基于android 4.4的code)
dlmalloc中有配置选项来适应不一样的使用环境。
USE_LOCKS：是否使用lock，在多线程使用环境下须要考虑enable，若是外部已经有所就不须要了。
HAVE_MMAP：系统是否支持mmap。
USE_DL_PREFIX：是否须要提供dl相关的接口。
MSPACES：是否须要提供mspace相关的接口。
ONLY_MSPACES：是否只提供mspace相关的接口。
DEFAULT_MMAP_THRESHOLD：使用mmap进行分配的阀值。

dlmalloc的管理策略：
Boundary Tags （边界标记）
在分配的chunk的头部和尾部都记录了当前chunk的size。
这样有两个好处：
1)从任意一个chunk均可以访问前一个/后一个chunk。
2)方便相邻的两个chunk合并为一个大的chunk。

Binning （分箱）
binning是按照byte size来分的，低于256 bytes的chunk，以8为增量，分为8,16,24...256bytes来分箱，每一个bin中全部的free chunk用链表来组织。
大于256 bytes的chunk，是用tree来维护free chunk的（同时配合使用了链表）。
分箱的好处是：
浪费少许内存，来达到快速分配的目的。在分配的时候，能够直接找到对应的bin来拿到free chunk。

 

关键的数据结构理解

---

malloc_chunk

struct malloc_chunk {
  size_t prev_foot; /* Size of previous chunk (if free). */ size_t head; /* Size and inuse bits. */ struct malloc_chunk* fd; /* double links -- used only if free. */ struct malloc_chunk* bk;
};

prev_foot
prev_foot是记录前一个chunk的size，可是这个成员的设置并非在当前的chunk创建的时候去作的。
在使用的时候，当某个chunk被申请了，他会使用
#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s))
在他的data后面设定他的size，他实际操做的是下一个chunk的prev_root的值。
这个和http://gee.cs.oswego.edu/dl/html/malloc.html里面的图示也是一致的，在头部和尾部保留了当前chunk的size。

这边有疑问：为何前一个chunk的尾部必定后一个chunk的头部？
1，申请内存的时候，是按照8bytes为界分配的(包括额外的信息)。
2，由于采用分箱的策略，分配的时候，老是从大的chunk分裂出小的chunk出来的，因此能够保证不会存在
不能使用的memory hole在内存中。
这两点保证全部的chunk是连续在一块儿的，并且能够直接合并，在合并以后他们的字节数仍是8 bytes为界的。

head
head中记录了当前chunk的状态，还有size。
状态占用低3个bit（由于chunk为8bytes倍数，因此低3位一直是0的）。

fd和bk
fd是forward pointer，bk是backward pointer，他们是构成Free list的时候指向前一个和后一个free chunk用的。
须要注意的时候，他们只在free chunk中使用，而在used chunk中不须要使用，因此没有为他们分配分配内存，是直接使用了
free chunk中user data部分的内存。

malloc_state

struct malloc_state {
  binmap_t smallmap;
  binmap_t treemap;
  size_t dvsize;
  size_t topsize; char* least_addr;
  mchunkptr dv;
  mchunkptr top;
  size_t trim_check;
  size_t release_checks;
  size_t magic;
  mchunkptr smallbins[(NSMALLBINS+1)*2];
  tbinptr treebins[NTREEBINS];
  size_t footprint;
  size_t max_footprint;
  size_t footprint_limit; /* zero means no limit */ flag_t mflags; #if USE_LOCKS
  MLOCK_T mutex; /* locate lock among fields that rarely change */ #endif /* USE_LOCKS */
  msegment seg; void* extp; /* Unused but available for extensions */ size_t exts;
};

malloc_state是整个malloc全局的信息的保存。下面看看几个关键的成员变量。

mchunkptr smallbins[(NSMALLBINS+1)*2]
smallbins是对于small chunk的分箱（即小于256 bytes的chunk的bins）。smallbins对每一个bin都构造了一个双向的链表，free的chunk link在当前的
bin中。

smallbins的长度(NSMALLBINS+1)*2是如何来的？
smallbins主要是构造一个双向链表，里面只须要保存两个pointer就能够实现了，因此他实际须要的是NSMALLBINS*2的大小便可。
同时dlmalloc中为了使用方便（而且统一）因此使用mallochunk结构中的fd和bk来指向chunk，因此在在数组头部pad了sizeof(prev_foot)+sizeof(head)=2个pointer的宽度。
这样就获得了NSMALLBINS*2+2 = (NSMALLBINS+1)*2的数组宽度了。

如何计算对应的bin index？
small bins是以8 bytes为间隔区分的，因此申请的size >> 3，就能够获得与之对应的bin index。
对应的宏是：#define smallbin_at(M, i) ((sbinptr)((void*)&((M)->smallbins[(i)<<1])))

tbinptr treebins[NTREEBINS]
treebins是对于大于256 bytes的chunk的bins。关于treebins能够参考文章：http://blog.sina.com.cn/s/blog_5674d18801019x0f.html
treebins中每一个bin是用tree来管理的，因此只须要一个pointer来指向tree的root便可。

smallbins很简单以8bytes为step去分箱，那对于treebins是如何作的？
从code里面能够看到从malloc size计算出bin的方法以下

#define compute_tree_index(S, I)\
{\
  unsigned int X = S >> TREEBIN_SHIFT;\ if (X == 0)\
    I = 0;\ else if (X > 0xFFFF)\
    I = NTREEBINS-1;\ else {\
    unsigned int K = (unsigned) sizeof(X)*__CHAR_BIT__ - 1 - (unsigned) __builtin_clz(X); \
    I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\
  }\
}

idx的划分主要是考虑0x100 ~ 0xFFFF00这段size如何被划分到0 ~ 30 index的bin中去的。
第一行K的运算中，__builtin_clz(X)先计算出了1以前有多少个0，而后用32 - 1去减，计算获得了最高位1以后的位数，注意这个是右移8位以后的计算结果，K + TREEBIN_SHIFT才是原始size的最高位1以后的位数。
第二行的运算中，K<<1,首先是按照最高位的offset（0 ~ 15）cast到（0~30），而((S >> (K + (TREEBIN_SHIFT-1)) & 1))，这一步实际检查最高位1的低1位是0仍是1。

这样看就很清楚了，实际是根据最高位1以后的位数先把数值分红了15份，而后再把每一份一份为2，获得了最终0~30的映射。
如0x1000，最高位1后面的位数是4，获得它的idx范围是8~9,又由于低1位为0，因此他对应的idx就是8.


每一个bin当中的tree是如何组织的？
分析宏

/* Insert chunk into tree */ #define insert_large_chunk(M, X, S) {\
  tbinptr* H;\
  bindex_t I;\
  compute_tree_index(S, I);\
  H = treebin_at(M, I);\
  X->index = I;\
  X->child[0] = X->child[1] = 0;\ if (!treemap_is_marked(M, I)) {\
    mark_treemap(M, I);\
    *H = X;\
    X->parent = (tchunkptr)H;\
    X->fd = X->bk = X;\
  }\ else {\
    tchunkptr T = *H;\
    size_t K = S << leftshift_for_tree_index(I);\ for (;;) {\ if (chunksize(T) != S) {\
        tchunkptr* C = &(T->child[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);\
        K <<= 1;\ if (*C != 0)\
          T = *C;\ else if (RTCHECK(ok_address(M, C))) {\
          *C = X;\
          X->parent = T;\
          X->fd = X->bk = X;\ break;\
        }\ else {\
          CORRUPTION_ERROR_ACTION(M);\ break;\
        }\
      }\ else {\
        tchunkptr F = T->fd;\ if (RTCHECK(ok_address(M, T) && ok_address(M, F))) {\
          T->fd = F->bk = X;\
          X->fd = F;\
          X->bk = T;\
          X->parent = 0;\ break;\
        }\ else {\
          CORRUPTION_ERROR_ACTION(M);\ break;\
        }\
      }\
    }\
  }\
}

从代码中能够看出插入节点的时候，
1，若是当前tree节点值和插入的一致，那么把这个节点插入到当前tree节点的链表中去。
2，若是不相等，除去最高两位的节点，检测以后每一个bit是0仍是1，来确认是选择节点的left child仍是right child。
这样的策略，保证了对于任意一个节点，他的左子树上的节点值老是小于右子树上的值的。可是对于某个节点来讲，他和他子树上节点的关系，只是保证不相等，不能保证必定大于或者小于他的子树的值。策略和trie tree相似了，可是又有一些差别。

find算法是怎么样的？
知道了insert的逻辑，那么find就比较好理解了。主要须要注意的是节点和子树的关系是不肯定的，在find的时候，须要作比较。


smallmap和treemap binmap_t是一个32bit的unsigned log，他的每一个bit对应分箱策略中某个箱子是否有有效的chunk包含在内，这样主要是为了方便在分配的时候，快速查找到有效的bin。 smallmap对应着smallbins的每一个bin的状态。 treemap对应着treebins的每一个bin的状态。