本文介绍了glibc中malloc的实现细节，特别是malloc_chunk结构体及其相关宏，包括堆内存的组织形式、chunk的标志位、bins的分类与管理、arena的线程内存池等概念。通过对这些基础知识的解析，读者能够对glibc的内存管理有初步了解。
GITHUB PAGES ADDRESS
【学习札记NO.00003】基于libc-2.23版本的malloc源码简易分析 - Part-I - 堆内存的基本组织形式 by arttnba3
- [GITHUB PAGES ADDRESS](https://arttnba3.cn/2021/01/15/NOTE-0X00-MALLOC-2.23-PART-I/)
- 0x00.堆内存的组织形式
-
- 一、malloc_chunk
- 二、chunk相关宏
- 三、Bins：存放闲置chunk的数组
- 四、Fastbins：快速存取chunk的数组
- 五、malloc\_par：堆管理器参数
- 六、heap\_info：Heap Header(for heap allocated by mmap)
- 七、arena：线程内存池
-
- 1.malloc_state结构体
-
- ①mutex：互斥锁
- ②flags：标志位
- ③fastbinY：存放fastbin chunk的数组
- ④top：指向Top Chunk的指针
- ⑤last\_remainder：chunk切割中的剩余部分
- ⑥bins：存放闲置chunk的数组
- ⑦binmap：用以表示binmap的数组
- ⑧next：指向下一个arena的指针
- ⑨next\_free：指向下一个空闲的arena的指针
- ⑩attached\_threads：与该arena相关联的线程数
- ⑪system\_mem：记录当前arena在堆区中所分配到的内存的总大小
- ⑫ max\_system\_mem：记录当前arena在堆区中所分配到的内存的总大小的最大值
- 2.arena相关变量
- 3.arena相关函数与宏
-
- ①malloc\_init\_state()：初始化arena内成员
- ②\_int\_new\_arena()：创建一个新的arena
- ③get\_free\_list()：尝试从free\_list中获取一个空闲arena
- ④arena\_get()：获得一个arena
- ⑤arena\_lock()：将arena上锁
- ⑥arena\_get2()：遍历free\_list，若无合适则尝试获取一个新的arena或使用已有arena
- ⑦reused\_arena()：寻找可用arena上锁后返回
- ⑧detach\_arena()：将arena关联线程数减一
- ⑨arena\_for\_chunk()：获取一个堆块对应的arena
让我们先从chunk讲起…
推荐到我的博客去阅读这篇文章，csdn有的地方的markdown解析实在稀烂…
0x00.堆内存的组织形式
一、malloc_chunk
思来想去还是先从最简单的堆块的基本组织形式——malloc_chunk结构体开始讲起，同时也事先讲完一些通用宏定义，省得后面再不断的递归套娃回来看chunk相关的各种定义（←因为这个人真的遇到了这样的情况）
通常情况下，我们将向系统所申请得到的内存块称之为chunk，在ptmalloc的内部使用malloc_chunk结构体来表示，代码如下：
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
首先我们先看一些相关的宏定义：
#ifndef INTERNAL_SIZE_T
#define INTERNAL_SIZE_T size_t
#endif
/* The corresponding word size */
#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
/*
MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
It must be a power of two at least 2 * SIZE_SZ, even on machines
for which smaller alignments would suffice. It may be defined as
larger than this though. Note however that code and data structures
are optimized for the case of 8-byte alignment.
*/
#ifndef MALLOC_ALIGNMENT
# if !SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_16)
/* This is the correct definition when there is no past ABI to constrain it.
Among configurations with a past ABI constraint, it differs from
2*SIZE_SZ only on powerpc32. For the time being, changing this is
causing more compatibility problems due to malloc_get_state and
malloc_set_state than will returning blocks not adequately aligned for
long double objects under -mlong-double-128. */
# define MALLOC_ALIGNMENT (2 *SIZE_SZ < __alignof__ (long double) \
? __alignof__ (long double) : 2 *SIZE_SZ)
# else
# define MALLOC_ALIGNMENT (2 *SIZE_SZ)
# endif
#endif
/* The corresponding bit mask value */
#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
大致如下：
- INTERNAL_SIZE_T宏展开后其实就是size_t，32位下为4字节，64位下为8字节，SIZE_SZ为其别名
- MALLOC_ALIGNMENT则定义了chunk在内存中对齐的字节数，一般来说算出来都是对2*SIZE_SZ对齐，即32位下8字节对齐，64位下16字节对齐
- MALLOC_ALIGEN_MASK的值则是MALLOC_ALIGENMENT - 1，笔者猜测其表示的是标志位全满的标志位值（掩码），用以进行后续的标志位清除运算等操作
The __alignof__ operator
The __alignof__ operator is a language extension to C99 and Standard C++ that returns the number of bytes used in the alignment of its operand. The operand can be an expression or a parenthesized type identifier. If the operand is an expression representing an lvalue, the number returned by alignof represents the alignment that the lvalue is known to have. The type of the expression is determined at compile time, but the expression itself is not evaluated. If the operand is a type, the number represents the alignment usually required for the type on the target platform.
(from IBM Knowledge Center)
大意是说__alignof__运算符是对C99及标准C++的拓展，用以返回运算对象所占用空间的字节数
结构体中一共有六个变量，大致如下：
- prev_size:用以保存前一个内存物理地址相邻的chunk的size，仅在该chunk为free状态时会被使用到
- size：顾名思义，用以保存这个chunk的总的大小，即同时包含chunk头（prev_size + size）和chunk剩余部分的大小
- fd&&bk：仅在在chunk被free后使用，用以连接其他的chunk，也就是说当chunk处于被使用的状态时该字段无效，被用以存储用户的数据
- fd_nextsize&&bk_nextsize：仅在在chunk被free后使用，用以连接其他的chunk
后面我们还会再详细讲解这几个变量的相关内容，这里仅作一简览
由于最后的两个变量仅用于较大的free的chunk，故我们先暂且忽略
那么我们便可以知道：一个chunk在内存中大概是长这个样子的：
当然，我个人更喜欢用如下的结构来表示，问就是👴喜欢和MALLOC_ALIGNMENT对齐的感觉
二、chunk相关宏
malloc.c中还定义了一些和malloc_chunk相关的宏，如下：
1.chunk size相关宏
/*
---------- Size and alignment checks and conversions ----------
*/
/* conversion from malloc headers to user pointers, and back */
#define chunk2mem(p) ((void*)((char*)(p) + 2*SIZE_SZ))
#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
/* The smallest possible chunk */
#define MIN_CHUNK_SIZE (offsetof(struct malloc_chunk, fd_nextsize))
/* The smallest size we can malloc is an aligned minimal chunk */
#define MINSIZE \
(unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
/* Check if m has acceptable alignment */
#define aligned_OK(m) (((unsigned long)(m) & MALLOC_ALIGN_MASK) == 0)
#define misaligned_chunk(p) \
((uintptr_t)(MALLOC_ALIGNMENT == 2 * SIZE_SZ ? (p) : chunk2mem (p)) \
& MALLOC_ALIGN_MASK)
大致如下：
- chunk2mem：将指向chunk的指针转为指向memory的指针，即指针由指向chunk header（刚好是prev_size的位置）移动到指向fd
- mem2chunk：将指向memory的指针转换为指向chunk的指针，即指针由指向fd移动到指向chunk header，与chunk2mem互为逆操作
- MIN_CHUNK_SIZE：所可分配的最小的chunk的size，为由prev_size到fd_nextsize的偏移量，32位下是0x10，64位下是0x20，即一个最小的chunk应当包含有chunk header和fd、bk
- MINSIZE：所能分配的最小chunk的size；我们所能分配的最小的size的chunk应当为一个内存对其的最小的chunk，这里算出来其实就是MIN_CHUNK_SIZE，MIN_CHUNK_SIZE加上MALLOC_ALIGN_MASK以后再和做了取反操作的MALLOC_ALIGN_MASK做与运算猜测实际上是为了消除掉标志位
- aligned_OK：该宏用以检查是否与MALLOC_ALIGNMENT对齐，因为若是与MALLOC_ALIGNMENT不对其的话，其与MALLOC_ALIGN_MASK进行与运算的结果必然不为0（这里应该就不需要我再说明为什么了…）
- misaligned_chunk：该宏用以检测一个chunk是否为未对齐的chunk，若是则返回未对齐的字节数
简单的图示如下：
宏：offsetof
也是一个在很多文件中都有着定义的一个宏，如下：
/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */ #ifndef offsetof # define offsetof(type,ident) ((size_t)&(((type*)0)->ident)) #endif该宏的作用是求出某个类型中某个成员的偏移，大致过程如下：
- 将0转换为指向某个类型的指针
- 取地址符取出0->ident的地址
- 转换成size_t类型
由于是以0作为地址基底来取地址的，因此便可以很方便地计算出某个成员的偏移
2.memory request相关宏
接下来这些宏用以对请求的堆块大小进行检查，代码如下：
/*
Check if a request is so large that it would wrap around zero when
padded and aligned. To simplify some other code, the bound is made
low enough so that adding MINSIZE will also not wrap around zero.
*/
#define REQUEST_OUT_OF_RANGE(req) \
((unsigned long) (req) >= \
(unsigned long) (INTERNAL_SIZE_T) (-2 * MINSIZE))
/* pad request bytes into a usable size -- internal version */
#define request2size(req) \
(((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
MINSIZE : \
((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
/* Same, except also perform argument check */
#define checked_request2size(req, sz) \
if (REQUEST_OUT_OF_RANGE (req)) { \
__set_errno (ENOMEM); \
return 0; \
} \
(sz) = request2size (req);
大致如下：
- REQUEST_OUT_OF_RANGE：宏如其名，用以检查用户请求的内存大小是否大于规定的最大内存大小，这个值被定义为4字节整型能表示的最大值再减去两个最小chunk的size所求得的值，为的是避免当有人真的尝试去分配了这样的一个大chunk时malloc内部将这个值加上MINSIZE后会发生整型上溢而变成0附近的一个较小的值
- request2size：作用是将用户请求的内存大小转换为内存对齐的大小，这个转换后的大小便是实际分配给用户的chunk的size；若是请求的内存大小小于MINSIZE得到的size直接为MINSIZE，否则则会得到一个与MALLOC_ALIGNMENT对齐的chunk size
- checked_request2size：可以理解为request2size宏封装上了size检查的宏，需要注意的是若是REQUEST_OUT_OF_RANGE则该宏则会在设置errno标志位为ENOMEM后直接return 0，终止其调用函数的执行
关于chunk间的内存复用及request2size计算相关事项
众所周知·，ptmalloc在组织各chunk时允许一个chunk复用其物理相邻的下一个chunk的prev_size字段作为自己的储存空间，这也是为什么当一个chunk的物理相邻的前一个chunk处在被分配状态时该chunk的prev_size字段无效的原因，大致图示如下：
]
因此，基于这样的一种空间复用的思想，request2size宏计算出来的size便如图右侧所示了
3.chunk标志位相关宏
①标志位定义及相关宏
我们知道对于一个malloc_chunk而言其size字段应当与MALLOC_ALIGNMENT对齐，而在这样的情况下一个chunk的size字段的低3/4（32/64位系统）位将会永远为0，无法得到充分的利用，因此出于能压榨一点空间是一点空间的思想一个chunk的size字段的低三位用以保存相关的三个状态，代码如下：
/*
--------------- Physical chunk operations ---------------
*/
/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
#define PREV_INUSE 0x1
/* extract inuse bit of previous chunk */
#define prev_inuse(p) ((p)->size & PREV_INUSE)
/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
#define IS_MMAPPED 0x2
/* check for mmap()'ed chunk */
#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
/* size field is or'ed with NON_MAIN_ARENA if the chunk was obtained
from a non-main arena. This is only set immediately before handing
the chunk to the user, if necessary. */
#define NON_MAIN_ARENA 0x4
/* check for chunk from non-main arena */
#define chunk_non_main_arena(p) ((p)->size & NON_MAIN_ARENA)
从低位到高位依次如下：
- PREV_IN_USE：该chunk内存物理相邻的上一个chunk是否处于被分配状态
- IS_MAPPED：该chunk是否是由mmap()进行内存分配得到的
- NON_MAIN_ARENA：该chunk是否是一个不属于main_arena的chunk
因而有三个用以检测标志位的宏：prev_inuse()、chunk_is_mapped、chunk_non_main_arena()，这里便不再过多赘叙了
②标志位操作相关宏及其他宏
malloc.c中这些宏的代码如下：
/*
Bits to mask off when extracting size
Note: IS_MMAPPED is intentionally not masked off from size field in
macros for which mmapped chunks should never be seen. This should
cause helpful core dumps to occur if it is tried by accident by
people extending or adapting this malloc.
*/
#define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
/* Get size, ignoring use bits */
#define chunksize(p) ((p)->size & ~(SIZE_BITS))
/* Ptr to next physical malloc_chunk. */
#define next_chunk(p) ((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))
/* Ptr to previous physical malloc_chunk */
#define prev_chunk(p) ((mchunkptr) (((char *) (p)) - ((p)->prev_size)))
/* Treat space at ptr + offset as a chunk */
#define chunk_at_offset(p, s) ((mchunkptr) (((char *) (p)) + (s)))
/* extract p's inuse bit */
#define inuse(p) \
((((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))->size) & PREV_INUSE)
/* set/clear chunk as being inuse without otherwise disturbing */
#define set_inuse(p) \
((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))->size |= PREV_INUSE
#define clear_inuse(p) \
((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))->size &= ~(PREV_INUSE)
/* check/set/clear inuse bits in known places */
#define inuse_bit_at_offset(p, s) \
(((mchunkptr) (((char *) (p)) + (s)))->size & PREV_INUSE)
#define set_inuse_bit_at_offset(p, s) \
(((mchunkptr) (((char *) (p)) + (s)))->size |= PREV_INUSE)
#define clear_inuse_bit_at_offset(p, s) \
(((mchunkptr) (((char *) (p)) + (s)))->size &= ~(PREV_INUSE))
/* Set size at head, without disturbing its use bit */
#define set_head_size(p, s) ((p)->size = (((p)->size & SIZE_BITS) | (s)))
/* Set size/use field */
#define set_head(p, s) ((p)->size = (s))
/* Set size at footer (only when chunk is not in use) */
#define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->prev_size = (s))
大致如下：
- SIZE_BITS：该宏用以表示三个标志位全为1
- chunksize()：该宏用以清除size字段的标志位，得到原始的chunk size
- next_chunk()：该宏用以获得指向该chunk的物理相邻的下一个chunk的指针
- prev_chunk()：该宏用以获得指向该chunk的物理相邻的上一个chunk的指针，需要注意的是prev_size字段必须有效，即上一个chunk必须为free状态
- chunk_at_offset()：该宏用以将ptr + offset位置作为一个chunk来对待，获得一个指向ptr + offset位置的chunk指针（大意是假设ptr + offset上有一个chunk，然后我们用这个宏得到指向这个chunk的chunk指针，后面讲到top_chunk时会用到）
- inuse()、set_inuse()、clear_inuse()：检测、设置、清除chunk的PREV_INUSE标志位
- inuse_bit_at_offset()、set_inuse_bit_at_offset()、clear_inuse_bit_at_offset()：将ptr + offset位置视为一个chunk并检测、设置、清除该chunk的PREV_INUSE标志位
- set_head_size()：该宏用以在不改变标志位的情况下改变一个chunk的size字段
- set_size()：该宏用以改变一个chunk的size字段，是前者的简化版本
- set_foot()：该宏用以在将ptr + s视为一个chunk的地址的情况下将这个chunk的prev_size字段置为s
三、Bins：存放闲置chunk的数组
对于闲置的chunk，ptmalloc会根据size的不同将之存放到不同的bins中进行统一的调度，而不会马上返还给系统，这样一来在用户再次进行请求时，ptmalloc便可从bins中挑选出合适的chunk给予用户，这样一来便能大幅度地减少系统调用的次数及其带来的巨大开销
malloc.c中对于bins的说明如下：
/*
Bins
An array of bin headers for free chunks. Each bin is doubly
linked. The bins are approximately proportionally (log) spaced.
There are a lot of these bins (128). This may look excessive, but
works very well in practice. Most bins hold sizes that are
unusual as malloc request sizes, but are more usual for fragments
and consolidated sets of chunks, which is what these bins hold, so
they can be found quickly. All procedures maintain the invariant
that no consolidated chunk physically borders another one, so each
chunk in a list is known to be preceeded and followed by either
inuse chunks or the ends of memory.
Chunks in bins are kept in size order, with ties going to the
approximately least recently used chunk. Ordering isn't needed
for the small bins, which all contain the same-sized chunks, but
facilitates best-fit allocation for larger chunks. These lists
are just sequential. Keeping them in order almost never requires
enough traversal to warrant using fancier ordered data
structures.
Chunks of the same size are linked with the most
recently freed at the front, and allocations are taken from the
back. This results in LRU (FIFO) allocation order, which tends
to give each chunk an equal opportunity to be consolidated with
adjacent freed chunks, resulting in larger free chunks and less
fragmentation.
To simplify use in double-linked lists, each bin header acts
as a malloc_chunk. This avoids special-casing for headers.
But to conserve space and improve locality, we allocate
only the fd/bk pointers of bins, and then use repositioning tricks
to treat these as the fields of a malloc_chunk*.
*/
typedef struct malloc_chunk *mbinptr;
大意是说bins是一个用以存放闲置的chunk的数组，chunk按照size来存放在不同的下标的bin中，每个bin中的chunk都是使用双向链表进行链接的
一共有着128个bin，其中对于small size chunk而言其存放于存放着相同size的chunk中，因此其每个bin内也就不需要排序，但这也有助于更大的chunk达到最佳的分配机制
被free的chunk会放置于双向链表的头部，而在分配chunk时则是从链表的尾部取chunk，即bin中的chunk链表采取FIFO机制
为了简化双向链表的使用，每一个bin header都被如同malloc_chunk一般使用，同时为了节省空间，在chunk中仅会使用FD/BK字段
同时还typedef了一个mbinptr类型，为指向malloc_chunk结构体的指针
在ptmalloc中bins数组中的bin一共可以划分为三类：unsorted bin、small bin、large bin，将会在后面进行说明
1.bins通用宏
malloc.c中定义了一些和bins相关的宏，如下：
/* 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)
...
#define bin_index(sz) \
((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz))
- bin_at：取出位于下标 i 的bin chunk，需要注意的是在这里获得的指针为原始存在bin中的指针再减去了chunk header的大小所得到的值，这是由于在bins数组中存放的为fd/bk，需要减去chunk header的大小才能获得一个指向chunk的指针而不是指向mem的指针；从这里我们也可以看出一个bin占据bins数组两格的空间
- next_bin：获取下一个bin
- first && last：获得bin chunk的fd/bk
简单的简析一下关于bin_at宏的这样一个看起来迷惑的操作：Bins数组中的每一个bin都被视作free chunk构建的双向循环链表中的一个特殊的chunk，而每个bin会在数组中存放FD && BK，同时将物理相邻的上一个bin空间复用作为自己的chunk header
关于bin chunk的内存复用思想如下图所示：
同时有一个宏用以根据chunk的size获取相对应的bin下标，笔者在后面会展开讲这个宏里面的东西
2.bins相关定义宏
如下：
/*
Indexing
Bins for sizes < 512 bytes contain chunks of all the same size, spaced
8 bytes apart. Larger bins are approximately logarithmically spaced:
64 bins of size 8
32 bins of size 64
16 bins of size 512
8 bins of size 4096
4 bins of size 32768
2 bins of size 262144
1 bin of size what's left
There is actually a little bit of slop in the numbers in bin_index
for the sake of speed. This makes no difference elsewhere.
The bins top out around 1MB because we expect to service large
requests via mmap.
Bin 0 does not exist. Bin 1 is the unordered list; if that would be
a valid chunk size the small bins are bumped up one.
*/
#define NBINS 128
对于装载着size小于512（0x200）的chunk的bin而言，每个bin中都存放着相同大小的chunk，而存放更大size的chunk的bin（large bin）中每个bin中chunk的大小并不一致，而是处于一定范围内，被分为7组，（32位下）每组bin中chunk size间公差如上表所示（64位直接 * 2即可）
同时，bin 0不存在，bin 1则是一个无序的链表（unsorted bin）
宏定义了NBIINS为128，也就是说理应有着128个bin存放不同类型的chunk，但是bin 0 不存在，因此实际上只有127个bin，在后续arena的定义中我们也能看出这一点
①unsorted bin相关宏
如下：
/*
Unsorted chunks
All remainders from chunk splits, as well as all returned chunks,
are first placed in the "unsorted" bin. They are then placed
in regular bins after malloc gives them ONE chance to be used before
binning. So, basically, the unsorted_chunks list acts as a queue,
with chunks being placed on it in free (and malloc_consolidate),
and taken off (to be either used or placed in bins) in malloc.
The NON_MAIN_ARENA flag is never set for unsorted chunks, so it
does not have to be taken into account in size comparisons.
*/
/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
#define unsorted_chunks(M) (bin_at (M, 1))
对于在chunk分割过程中所剩余的chunk、以及所有回归闲置的chunk都会首先被存放在unsorted bin当中；当调用malloc时其中的chunk会有机会被放回到常规的bins中；因此通常情况下unsort bin就像一个队列一样，在free/malloc_consolidate中chunk会被放置其中，而在malloc时其中的chunk又会被重新拿走；unsorted bin中的chunk永远不会设置NON_MAIN_ARENA标志位
同时我们也可以得知对于存放在unsorted bin中的chunk的size并没有做限制
定义了宏unsorted_chunks()用以获得unsorted bin，我们可以看到unsorted bin在bins数组中占用了下标0与下标1，也就是说其为bins中的第一个bin
②small bins相关宏
bin 0不存在， 而bin 1 是unsorted bin， 故small bins应当从bin 2 开始存放
相关宏如下：
#define NSMALLBINS 64
#define SMALLBIN_WIDTH MALLOC_ALIGNMENT
#define SMALLBIN_CORRECTION (MALLOC_ALIGNMENT > 2 * SIZE_SZ)
#define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * 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))\
+ SMALLBIN_CORRECTION)
- NSMALLBINS：small bins位于bins下标的终止，即从bin1开始到bin63一共62个bin是属于small bins的，这里需要注意的是不要直接理解为small bins的数量，后面会说明为什么是62个
- SMALLBIN_WIDTH：每个 small bin 之间所储存的chunk的size差值
- SMALLBIN_CORRECTION：查阅了一下
指谷歌，有一种说法是这个宏是用以检查bin是否被破坏的，若被破坏则针对后续的下标相关操作进行修正这个宏一般来说都为0所以我也不懂有什么用，大概可以直接忽视掉，嗯x - MIN_LARGE_SIZE：最小的large bin范围内的chunk的size，只有小于这个size的chunk才属于small bin的范围内，32位下为512，64位下为1024
- in_smallbin_range()：用以检查一个chunk的size是否属于small bin范围内
- smallbin_index()：用以获得一个small bin chun
最低0.47元/天 解锁文章
1602
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
