《Glibc内存管理》笔记DAY4

分箱式内存管理
- Small bins
- Large bins
内容来源

分箱式内存管理

对于空闲的 chunk，ptmalloc 采用分箱式内存管理方式，根据空闲 chunk 的大小和处于的状态将其放在四个不同的 bin 中，这四个空闲 chunk 的容器包括 fast bins，unsorted bin，small bins 和 large bins。Fast bins 是小内存块的高速缓存，当一些大小小于 64 字节的 chunk 被回收时，首先会放入 fast bins 中，在分配小内存时，首先会查看 fast bins 中是否有合适的内存块，如果存在，则直接返回 fast bins 中的内存块，以加快分配速度。Usorted bin 只有一个，回收的 chunk 块必须先放到 unsorted bin 中，分配内存时会查看 unsorted bin 中是否有合适的 chunk，如果找到满足条件的 chunk，则直接返回给用户，否则将 unsorted bin 的所有 chunk 放入 small bins 或是 large bins 中。Small bins 用于存放固定大小的 chunk，共 64 个 bin，最小的 chunk 大小为 16 字节或 32 字节，每个 bin 的大小相差 8 字节或是 16 字节，当分配小内存块时，采用精确匹配的方式从 small bins 中查找合适的 chunk。Large bins 用于存储大于等于 512B 或 1024B 的空闲 chunk，这些 chunk 使用双向链表的形式按大小顺序排序，分配内存时按最近匹配方式从 large bins 中分配 chunk。

Small bins

ptmalloc使用 small bins 管理空闲小 chunk，每个 small bin 中的 chunk 的大小与 bin 的 index 有如下关系：

Chunk_size=2 * SIZE_SZ * index

ptmalloc 维护了 62 个双向环形链表（即 small bins 有 62 个 bin）

Large bins

比 small bins 大的bin用large bins管理。

large bins 63 个双向链表（即 large bins 有 63 个 bin）
每个 bin 中的 chunk 大小不是一个固定公差的等差数列，而是分成 6 组 bin，每组 bin 是一个固定公差的等差数列，每组的 bin 数量依次为 32、16、8、4、2、1，公差依次为 64B、512B、4096B、32768B、262144B 等。
可以将 small bins 和 large bins 存放在同一个包含 128 个 chunk 的数组上，我们可以根据数组下标计算出该 bin 的 chunk 大小（small bins）或是 chunk 大小范围（large bins），也可以根据需要分配内存块大小计算出所需 chunk所属 bin 的 index，ptmalloc 使用了一组宏巧妙的实现了这种计算。

#define NBINS 128
#define NSMALLBINS 64
#define SMALLBIN_WIDTH MALLOC_ALIGNMENT
#define MIN_LARGE_SIZE (NSMALLBINS * SMALLBIN_WIDTH)
#define in_smallbin_range(sz) \
 ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
#define smallbin_index(sz) \
 (SMALLBIN_WIDTH == 16 ? (((unsigned)(sz)) >> 4) : (((unsigned)(sz)) >> 3))
#define largebin_index_32(sz) \
(((((unsigned long)(sz)) >> 6) <= 38)? 56 + (((unsigned long)(sz)) >> 6): \
((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
 126)
// XXX It remains to be seen whether it is good to keep the widths of
// XXX the buckets the same or whether it should be scaled by a factor
// XXX of two as well.
#define largebin_index_64(sz) \
(((((unsigned long)(sz)) >> 6) <= 48)? 48 + (((unsigned long)(sz)) >> 6): \
36
((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
 126)
#define largebin_index(sz) \
 (SIZE_SZ == 8 ? largebin_index_64 (sz) : largebin_index_32 (sz))
#define bin_index(sz) \
((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))

in_smallbin_range(sz)：sz 大小属于 small bins 置 1，否则置 0。
smallbin_index(sz)：将 sz 大小的 chunk 转换成对应的数组下标。（对 samll bin）
largebin_index_32(sz) ：将 sz 大小的 chunk 转换成对应的数组下标。（对 32 位 large bin）
largebin_index_64(sz)：将 sz 大小的 chunk 转换成对应的数组下标。（对 64 位 large bin）
define largebin_index(sz)：将 sz 大小的 chunk 转换成对应的数组下标。（根据 SIZE_SZ 判断 large bin 转换宏）
bin_index(sz) ：将 sz 大小的 chunk 转换成对应的数组下标。（判断属于 large bin 还是 small bin）
对于 SIZE_SZ 为 4B 的平台，bin[0]和 bin[1]是不存在的，因为最小的 chunk 为 16B，small bins 一共 62 个，large bins 一共 63 个，加起来一共 125 个 bin。而 NBINS 定义为 128，其实 bin[0] 和 bin[127] 都不存在，bin[1] 为 unsorted bin 的 chunk 链表头。

typedef struct malloc_chunk* mbinptr;
/* addressing -- note that bin_at(0) does not exist */
#define bin_at(m, i) \
 (mbinptr) (((char *) &((m)->bins[((i) - 1) * 2])) \
 - offsetof (struct malloc_chunk, fd))
/* analog of ++bin */
#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
/* Reminders about list directionality within bins */
#define first(b) ((b)->fd)
#define last(b) ((b)->bk)
/* Take a chunk off a bin list */
#define unlink(P, BK, FD) { \
 FD = P->fd; \
 BK = P->bk; \
 if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
 malloc_printerr (check_action, "corrupted double-linked list", P); \
 else { \
 FD->bk = BK; \
40
 BK->fd = FD; \
 if (!in_smallbin_range (P->size) \
 && __builtin_expect (P->fd_nextsize != NULL, 0)) { \
 assert (P->fd_nextsize->bk_nextsize == P); \
 assert (P->bk_nextsize->fd_nextsize == P); \
 if (FD->fd_nextsize == NULL) { \
 if (P->fd_nextsize == P) \
 FD->fd_nextsize = FD->bk_nextsize = FD; \
 else { \
 FD->fd_nextsize = P->fd_nextsize; \
 FD->bk_nextsize = P->bk_nextsize; \
 P->fd_nextsize->bk_nextsize = FD; \
 P->bk_nextsize->fd_nextsize = FD; \
 } \
 } else { \
 P->fd_nextsize->bk_nextsize = P->bk_nextsize; \
 P->bk_nextsize->fd_nextsize = P->fd_nextsize; \
 } \
 } \
 } \
}

bin_at(m, i)：通过 bin index 获得 bin 的链表头。
next_bin(b)：获得下一个 bin 的地址，根据前面的分析，我们知道只需要将当前 bin 的地址向后移动两个指针的长度就得到下一个 bin 的链表头地址。
first(b)：获得 bin 的第一个可用 chunk
last(b)：获得 bin 的最后一个可用的 chunk
unlink(P, BK, FD)：将 chunk 从所在的空闲链表中取出来，注意 large bins 中的空闲 chunk 可能处于两个双向循环链表中，unlink 时需要从两个链表中都删除。
- __builtin_expect：这个指令是gcc引入的，作用是允许程序员将最有可能执行的分支告诉编译器。

内容来源

《Glibc内存管理》