malloc函数详解 glibc2.27
malloc 函数分析(glibc.2.27)
本人菜一只，如果分析的有错误，请大佬指正。
__libc_malloc函数分析
void * __libc_malloc (size_t bytes)
{
mstate ar_ptr;
void *victim;
//把全局变量__malloc_hook赋给了hook，如果hook不为空，则执行hook。
void *(*hook) (size_t, const void *) = atomic_forced_read (__malloc_hook);
if (__builtin_expect (hook != NULL, 0))
return (*hook)(bytes, RETURN_ADDRESS (0));
#if USE_TCACHE
size_t tbytes;
checked_request2size (bytes, tbytes);//把bytes转换为tcache bytes
size_t tc_idx = csize2tidx (tbytes);//获取tbytes对应的tcache的tc_idx
MAYBE_INIT_TCACHE ();//如果tcache为NULL，初始化tcache
DIAG_PUSH_NEEDS_COMMENT;
//如果tc_idx合法，且对应的tcache不为空，则直接返回该tcahce中的第一个chunk(与fastbin类似)
if (tc_idx < mp_.tcache_bins
&& tcache
&& tcache->entries[tc_idx] != NULL)
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
#endif
if (SINGLE_THREAD_P)//如果是单线程
{
//调用_int_malloc，实现内存分配
victim = _int_malloc (&main_arena, bytes);
/*
#define arena_for_chunk(ptr) \
(chunk_non_main_arena (ptr) ? heap_for_ptr (ptr)->ar_ptr : &main_arena)
过以下检测需要满足的要求，只需满足一条即可
1. victim 为 0
2. IS_MMAPPED 为 1
3. NON_MAIN_ARENA 为 0
*/
assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
&main_arena == arena_for_chunk (mem2chunk (victim)));
return victim;
}
//获取当前的arena,如果是主线程则获得的是main_arena
arena_get (ar_ptr, bytes);
//调用_int_malloc，实现内存分配
victim = _int_malloc (ar_ptr, bytes);
//如果_int_malloc 分配失败，并且我们之前能够找到一个可用arena，可以用另一个arena重试。
if (!victim && ar_ptr != NULL)
{
LIBC_PROBE (memory_malloc_retry, 1, bytes);
ar_ptr = arena_get_retry (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
}
//释放mutex引用的互斥锁对象，因为ptmalloc支持多线程
if (ar_ptr != NULL)
__libc_lock_unlock (ar_ptr->mutex);
/*
#define arena_for_chunk(ptr) \
(chunk_non_main_arena (ptr) ? heap_for_ptr (ptr)->ar_ptr : &main_arena)
过以下检测需要满足的要求，只需满足一条即可
1. victim 为 0
2. IS_MMAPPED 为 1
3. NON_MAIN_ARENA 为 0
*/
assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
ar_ptr == arena_for_chunk (mem2chunk (victim)));
return victim;
}__int_malloc函数分析
REMOVE_FB的功能是取出空闲chunk
#define REMOVE_FB(fb, victim, pp)//摘除一个空闲chunk do { victim = pp; if (victim == NULL) break; } while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim)) != victim); //catomic_compare_and_exchange_val_rel_acq 功能是 如果*fb等于victim，则将*fb存储为victim->fd，返回victim； //其作用是从刚刚得到的空闲chunk链表指针中取出第一个空闲的chunk(victim)，并将链表头设置为该空闲chunk的下一个chunk(victim->fd)如果需要分配的内存大小nb落在fastbin的范围内,尝试从 fast bins 中 分配 chunk
//get_max_fast返回fastbin可以存储内存的最大值，它在ptmalloc的初始化函数malloc_init_state中定义。 if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ())) { idx = fastbin_index (nb);//获得chunk大小nb对应的fastbin索引。 mfastbinptr *fb = &fastbin (av, idx);//通过fastbin取出空闲chunk链表头指针 mchunkptr pp; victim = *fb;//获取对应大小的fastbin的链表中的第一个空闲的chunk
}if (victim != NULL)//如果取到了第一个chunk { if (SINGLE_THREAD_P) //判断是否单线程程序 *fb = victim->fd;//摘除一个空闲chunk else REMOVE_FB (fb, pp, victim);//摘除一个空闲chunk if (__glibc_likely (victim != NULL)) { //由取出的chunk的size计算出来的idx要等于bin的idx //就是检查拿到的chunk的size是否符合该fastbin的大小 size_t victim_idx = fastbin_index (chunksize (victim)); if (__builtin_expect (victim_idx != idx, 0)) malloc_printerr ("malloc(): memory corruption (fast)"); check_remalloced_chunk (av, victim, nb);//什么也没实现 #if USE_TCACHE size_t tc_idx = csize2tidx (nb);//获取对应大小的tcache的idx //如果tchache初始化了，且tc_idx合法 if (tcache && tc_idx < mp_.tcache_bins) { mchunkptr tc_victim; /* 如果tcache没有装满，且fastbin 中还有空闲的chunk，则把fastbin中的chunk 加入到tcache中，直到tcache满了或者fastbin中不存在chunk */ while (tcache->counts[tc_idx] < mp_.tcache_count && (tc_victim = *fb) != NULL) { if (SINGLE_THREAD_P)//判断是否单线程程序 *fb = tc_victim->fd;//取出一个空闲chunk else { REMOVE_FB (fb, pp, tc_victim);//取出一个空闲chunk if (__glibc_unlikely (tc_victim == NULL)) break; } /* static __always_inline void \ tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry *e = (tcache_entry *) chunk2mem (chunk); assert (tc_idx < TCACHE_MAX_BINS); e->next = tcache->entries[tc_idx]; tcache->entries[tc_idx] = e; ++(tcache->counts[tc_idx]); } */ tcache_put (tc_victim, tc_idx);//把fastbin中拿出的chunk加入到tcache链表中 } } #endif void *p = chunk2mem (victim);//把chunk的指针转换成mem的指针 alloc_perturb (p, bytes);//将p的mem部分全部设置为perturb_byte ,默认什么也不做 return p; } }如果需要分配的内存大小nb落在small bin的范围内,尝试从 small bin中 分配 chunk
if (in_smallbin_range (nb)) { idx = smallbin_index (nb);//获取nb对应大小的small bin的idx bin = bin_at (av, idx);//获取idx对应的small bin
}if ((victim = last (bin)) != bin)//如果对应的small bin 非空 { bck = victim->bk; //获得vitcm的后一个chunk if (__glibc_unlikely (bck->fd != victim))//检查small bin链表的完整性 malloc_printerr ("malloc(): smallbin double linked list corrupted"); //设置victim物理相邻的下一个chunk的prev_inuse位 set_inuse_bit_at_offset (victim, nb); bin->bk = bck; bck->fd = bin;//把victim从small bin中移除 if (av != &main_arena) set_non_main_arena (victim);//如果不是主线程则设置NON_MAIN_ARENA位 check_malloced_chunk (av, victim, nb);//默认不做任何操作 #if USE_TCACHE size_t tc_idx = csize2tidx (nb); if (tcache && tc_idx < mp_.tcache_bins) { mchunkptr tc_victim; /* 如果tcache没有装满，且small bin 中还有空闲的chunk，则把small bin中的chunk 加入到tcache中，直到tcache满了或者small bin中不存在chunk */ while (tcache->counts[tc_idx] < mp_.tcache_count&& (tc_victim = last (bin)) != bin) { if (tc_victim != 0) { //获得tc_vitcm的后一个chunk bck = tc_victim->bk; //设置tc_victim物理相邻的下一个chunk的prev_inuse位 set_inuse_bit_at_offset (tc_victim, nb); if (av != &main_arena) set_non_main_arena (tc_victim);//如果不是主线程则设置NON_MAIN_ARENA位 bin->bk = bck; bck->fd = bin; tcache_put (tc_victim, tc_idx);//把small bin中拿出的chunk加入到tcache链表中 } } } #endif void *p = chunk2mem (victim);//把chunk的指针转换成mem的指针 alloc_perturb (p, bytes);//将p的mem部分全部设置为perturb_byte ,默认什么也不做 return p; }如果我们申请的chunk的大小不在small bin的范围，也就是说我们申请的chunk的大小在large bin的范围,如果fastbin中存在chunk，我们在这一步会遍历fastbin，可以合并的块合并，然后加入到unsorted bin中,如果与topchunk相邻则直接合并到top chunk（注意这里是把fastbin中的所有块清空）
else { idx = largebin_index (nb); if (atomic_load_relaxed (&av->have_fastchunks)) malloc_consolidate (av);//合并fastbin中的空闲chunk } #if USE_TCACHE INTERNAL_SIZE_T tcache_nb = 0; size_t tc_idx = csize2tidx (nb);//获取nb对应大小的tcache的idx if (tcache && tc_idx < mp_.tcache_bins) tcache_nb = nb; int return_cached = 0; tcache_unsorted_count = 0; #endif接着我们遍历unsorted bin,寻找合适的chunk.
//如果unsorted bins不为空，从尾到头遍历unsorted bin中的每个chunk while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av)) { bck = victim->bk; if (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0) || __builtin_expect (chunksize_nomask (victim)> av->system_mem, 0)) malloc_printerr ("malloc(): memory corruption"); size = chunksize (victim);
}/* 如果要申请的大小在smallbin范围 且 unsorted chunks 只有一个chunk，且 victim是last_remainder 且 victim的size大于请求的chunk的大小nb加上 (MINSIZE)最小chunk的size,那么就切割remainder,然后返回victim。 last_remainder 是一个 chunk 指针，分配区上次分配 small chunk 时， 从一个 chunk 中分 裂出一个 small chunk 返回给用户，分裂后的剩余部分 形成一个 chunk，last_remainder 就是 指向的这个 chunk。 */ if (in_smallbin_range (nb) && bck == unsorted_chunks (av) && victim == av->last_remainder && (unsigned long) (size) > (unsigned long) (nb + MINSIZE)) { //分割remainder remainder_size = size - nb;//计算分割后剩下的size remainder = chunk_at_offset(victim, nb);//获取remainder的地址 //把remainder加入unsorted bin中 unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder; av->last_remainder = remainder; // 设置last_remainder为remainder remainder->bk = remainder->fd = unsorted_chunks(av); //如果是remainder在large bin的范围，则把fd_nextsize,fd_nextsize清零 if (!in_smallbin_range(remainder_size)) { remainder->fd_nextsize = NULL; remainder->fd_nextsize = NULL; } //设置victim的size set_head(victim, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0)); //设置remainder的size set_head(remainder, remainder_size | PREV_INUSE); //设置remainder的物理相邻的下一个chunk的prev_size set_foot(remainder, remainder_size); check_malloced_chunk(av, victim, nb);//默认不做任何操作 void *p = chunk2mem(victim);//将chunk指针转化为mem指针 alloc_perturb(p, bytes);//将p的mem部分全部设置为bytes ,默认什么也不做 return p; } //把victim从unsorted bin 中移除 unsorted_chunks (av)->bk = bck; bck->fd = unsorted_chunks (av); //如果 victim 的size 与申请的size相等 if (size == nb) { //设置victim物理相邻的下一个chunk的prev_inuse位 set_inuse_bit_at_offset (victim, size); //如果av不是main_arena 也就是说如果不是主进程,设置NON_MAIN_ARENA位 if (av != &main_arena) set_non_main_arena (victim); #if USE_TCACHE //如果对应的tcache没有满，则把他加入到tcache中,设置return标志 if (tcache_nb && tcache->counts[tc_idx] < mp_.tcache_count) { tcache_put (victim, tc_idx); return_cached = 1; continue; } else//如果对应的tcache满了，则直接返回。 { #endif check_malloced_chunk(av, victim, nb); // 默认不做任何操作 void *p = chunk2mem(victim);//把chunk转换为mem指针 alloc_perturb(p, bytes);//将p的mem部分全部设置为bytes ,默认什么也不做 return p; #if USE_TCACHE } #endif } //如果在smallbin的范围,则放到对应的small bin中 if (in_smallbin_range (size)) { victim_index = smallbin_index(size);//获取size对应的smallbin的index bck = bin_at(av, victim_index);//bck指向size对应的smallbin的链表头 //fwd指向size对应的smallbin的链表中的新加入的chunk(small bin使用头插法) fwd = bck->fd; } else//如果不在smallbin的范围，也就是说在large bin 的范围 { victim_index = largebin_index(size);//获取size对应的large bin的index bck = bin_at(av, victim_index);//bck指向size对应的large bin的链表头 fwd = bck->fd;//fwd指向size对应的large bin的链表中的新加入的chunk //如果large bin 非空，在largbin进行按顺序插入 if (fwd != bck) { size |= PREV_INUSE; assert((bck->bk->size & NON_MAIN_ARENA) == 0); /* large bin中的chunk是按从大到小排列的，如果size < large bin 的最后一个chunk，说明size是这个large bin中的最小的，我们把它 加入到此large bin尾部。 */ if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk)) { fwd = bck; bck = bck->bk; /* large bin 中size最小的chunk的fd_nextsize会指向size最大的 那个chunk，也就是首部的chunk。同样，large bin 中size最大的 chunk的bk_nextsize会指向size最小的那个chunk。 victim的bk_nextsize指向large bin原来最小的chunk，它的 bk_nextsize指向最大的那个chunk。那么原来的最小的就成了第二小的了。 把它fd_nextsize和bk_nextsize都修正。 */ victim->fd_nextsize = fwd->fd; victim->bk_nextsize = fwd->fd->bk_nextsize; //最大size的chunk的bk_nextsize，和原来最小chunk的bk_nextsize都指向victim fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; } else //如果victim不是large bin 中最小的chunk { //检查NON_MAIN_ARENA位是否为0 assert (chunk_main_arena (fwd)); //从大到小（从头到尾）找到合适的位置 while ((unsigned long) size < chunksize_nomask (fwd)) { fwd = fwd->fd_nextsize; assert (chunk_main_arena (fwd)); } //如果size刚好相等，就直接加入到其后面省的改fd_nextsize和bk_nextsize了 if ((unsigned long) size == (unsigned long) chunksize_nomask (fwd)) fwd = fwd->fd; else { //size不相等，即size>fwd->size，把victim加入到纵向链表中 victim->fd_nextsize = fwd; victim->bk_nextsize = fwd->bk_nextsize; fwd->bk_nextsize = victim; victim->bk_nextsize->fd_nextsize = victim; } bck = fwd->bk; } } else //如果large bin 为空，将victim加入到纵向列表 victim->fd_nextsize = victim->bk_nextsize = victim; } //#define mark_bin(m, i) ((m)->binmap[idx2block (i)] |= idx2bit (i)) mark_bin(av, victim_index); //把victim加入到的bin的表示为非空 //把victim加入到large bin的链表中 victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim; #if USE_TCACHE ++tcache_unsorted_count; //若达到tcache_unsorted_limit限制且之前已经存入过chunk则在此时取出（默认无限制） if (return_cached && mp_.tcache_unsorted_limit > 0 && tcache_unsorted_count > mp_.tcache_unsorted_limit) { return tcache_get (tc_idx);//返回size对应的tcache的第一个chunk } #endif #define MAX_ITERS 10000 if (++iters >= MAX_ITERS) break;如果unsorted bin中也找不到合适的chunk，且在large bin的范围，继续在largebin中找
#if USE_TCACHE //如果上面没有取出，且之前已经存入过chunk则在此时取出 if (return_cached) { return tcache_get (tc_idx); } #endif //如果unsorted bin中也找不到合适的chunk，且在large bin的范围，继续在largebin中找 if (!in_smallbin_range (nb)) { bin = bin_at (av, idx);
}//如果对应的 bin 不为空 且 其中最大的chunk也很比我们想要的nb大 if ((victim = first (bin)) != bin && (unsigned long) chunksize_nomask (victim) >= (unsigned long) (nb)) { // 反向遍历nextsize纵向链表（从小到大），找到第一个比size大的chunk victim = victim->bk_nextsize; while (((unsigned long) (size = chunksize (victim)) < (unsigned long) (nb))) victim = victim->bk_nextsize; /* 如果取出的chunk不是bin的最后一个chunk，同时该chunk有大小相同的chunk连接在一起 它就会取它前面的那个chunk即 chunk->fd ,因为大小相同的chunk只有一个会被串在 nextsize链上这可以避免额外的bk_nextsize和fd_nextsize的赋值 */ if (victim != last (bin) && chunksize_nomask (victim) == chunksize_nomask (victim->fd)) victim = victim->fd; remainder_size = size - nb;//计算切割后的大小 unlink(av, victim, bck, fwd); //通过unlink将chunk从链表移除 if (remainder_size < MINSIZE) { //如果切割后的大小不足以作为一个chunk，那么就不分割直接将其标志位设为inuse //如果不是main_arena,同时设置NO_main_arena标志位 set_inuse_bit_at_offset(victim, size); if (av != &main_arena) victim->size |= NON_MAIN_ARENA; } else { //如果剩余的大小可以作为一个chunk //获得剩余部分的地址，放入unsorted bin中 remainder = chunk_at_offset (victim, nb); bck = unsorted_chunks (av); fwd = bck->fd; if (__glibc_unlikely (fwd->bk != bck)) malloc_printerr ("malloc(): corrupted unsorted chunks"); remainder->bk = bck; remainder->fd = fwd; bck->fd = remainder; fwd->bk = remainder; //如果剩余部分的大小在largin bin的范围，则清空nextsize字段 if (!in_smallbin_range (remainder_size)) { remainder->fd_nextsize = NULL; remainder->bk_nextsize = NULL; } //设置victim的size set_head(victim, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0)); //设置remainder的size set_head(remainder, remainder_size | PREV_INUSE); //设置remainder的物理相邻的下一个chunk的prev_size set_foot(remainder, remainder_size); } check_malloced_chunk(av, victim, nb);//默认不做任何操作 void *p = chunk2mem(victim);//将chunk指针转化为mem指针 alloc_perturb(p, bytes);//将p的mem部分全部设置为bytes ,默认什么也不做 return p; }如果通过上面的方式从最合适的 small bin 或 large bin 中都没有分配到需要的 chunk，则 查看比当前 bin 的 index 大的 small bin 或 large bin 是否有空闲 chunk 可利用来分配所需的 chunk。
/* 获取下一个相邻 bin 的空闲 chunk 链表，并获取该 bin 对应 binmap 中的 bit 位的值。binmap 字段是一个 int 数组，ptmalloc 用一个 bit 来标识该 bit 对应的 bin 中是否包含空闲 chunk。Binmap 按 block 管理，每个 block 为一个 int，共 32 个 bit，可以表示 32 个 bin 中是否有空闲 chunk 存在。使用 binmap 可以加快查找 bin 是否包含空闲 chunk。这里只查询比所需 chunk 大的 bin 中是否有空闲 chunk 可用。 */ ++idx; bin = bin_at(av, idx);//获取当前bin的下一个bin block = idx2block(idx); map = av->binmap[block];//获取block bit = idx2bit(idx);//获取block中对应的bit /* Idx2bit()宏将 idx 指定的位设置为 1，其它位清零，map 表示一个 block(unsigned int) 值，如果bit 大于 map，意味着比bit对应的bin的size大的bin中无空闲chunk，如果 map 为 0，该 block 所对应的所有 bins 中都没有空闲 chunk， 于是遍历 binmap 的下一个 block，直到找到一个不为 0 的 block 或者遍历完所有的 block。 退出循环遍历后，设置 bin 指向 block 的第一个 bit 对应的 bin，并将 bit 置为 1，表示该 block 中 bit 1 对应的 bin，这个 bin 中如果有空闲 chunk，该 chunk 的大小一定满足要求。 */ for (;;) { /* 如果bit 大于 map，意味着比该bit对应的bin的size大的bin中无空闲chunk，如果 map 为 0，该 block 所对应的所有 bins 中都没有空闲 chunk 。接着在下一个block中寻找 */ if (bit > map || bit == 0) { do { //如果block超过了范围，说明比所需chunk大的bin中没有chunk，直接使用top_chunk if (++block >= BINMAPSIZE) /* out of bins */ goto use_top; //如果block为0,这表明block中的所有bit所对应的bin没有空闲chunk } while ((map = av->binmap[block]) == 0);
/* 在一个block遍历对应的 bin，直到找到一个 bit 不为 0 退出遍历，则该 bit 对于的 bin 中有空闲 chunk 存在。 */ while ((bit & map) == 0) { bin = next_bin(bin); bit <<= 1; assert(bit != 0); }bin = bin_at(av, (block << BINMAPSHIFT)); bit = 1; }
}//获取bin尾部的chunk victim = last(bin); /* 如果 victim 与 bin 链表头指针相同，表示该 bin 中没有空闲 chunk，binmap 中的相应位 设置不准确，将 binmap 的相应 bit 位清零，获取当前 bin 下一个 bin，将 bit 移到下一个 bit 位，即乘以 2。 */ if (victim == bin) { av->binmap[block] = map &= ~bit; /* Write through */ bin = next_bin(bin); bit <<= 1; } else { /* 当前 bin 中的最后一个 chunk 满足要求，获取该 chunk 的大小，计算切分出所需 chunk 后剩余部分的大小，然后将 victim 从 bin 的链表中取出。 */ size = chunksize(victim); assert((unsigned long) (size) >= (unsigned long) (nb)); remainder_size = size - nb;//计算分割后的大小 unlink(av, victim, bck, fwd);//从bin中取出victim /* 如果剩余部分的大小小于 MINSIZE，将整个 chunk 分配给应用层，设置 victim 的状态为 inuse，如果当前分配区为非主分配区，设置 victim 的非主分配区标志位。 */ if (remainder_size < MINSIZE) { set_inuse_bit_at_offset(victim, size); if (av != &main_arena) victim->size |= NON_MAIN_ARENA; } else { //如果剩余的大小可以作为一个chunk //获得剩余部分的地址，放入unsorted bin中 remainder = chunk_at_offset(victim, nb); bck = unsorted_chunks(av); fwd = bck->fd; //这里检查unsorted bin 中的链表头部是否合法 if (__glibc_unlikely(fwd->bk != bck)) { malloc_printerr ("malloc(): corrupted unsorted chunks 2"); } remainder->bk = bck; remainder->fd = fwd; bck->fd = remainder; fwd->bk = remainder; //设置last_remainder为刚刚分割剩余的remainder if (in_smallbin_range(nb)) av->last_remainder = remainder; //如果剩余部分的大小在largin bin的范围，则清空nextsize字段 if (!in_smallbin_range(remainder_size)) { remainder->fd_nextsize = NULL; remainder->bk_nextsize = NULL; } //设置victim的size set_head(victim, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0)); //设置remainder的size set_head(remainder, remainder_size | PREV_INUSE); //设置remainder的物理相邻的下一个chunk的prev_size set_foot(remainder, remainder_size); } check_malloced_chunk(av, victim, nb);//默认不做任何操作 void *p = chunk2mem(victim);//将chunk指针转化为mem指针 alloc_perturb(p, bytes);//将p的mem部分全部设置为bytes ,默认什么也不做 return p; }如果从所有的 bins 中都没有获得所需的 chunk，可能的情况为 bins 中没有空闲 chunk， 或者所需的 chunk 大小很大，下一步将尝试从 top chunk 中分配所需 chunk。
use_top: //如果以上都无法满足我们要申请的chunk的要求，最后使用top_chunk victim = av->top; // victim 指向top chunk size = chunksize(victim);//获取top chunk的size //如果top chunk 满足我们要申请的chunk大小要求（top chunk 的size > 我们要申请的chunk + 最小chunk的size ），那么就分割它。 if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) { remainder_size = size - nb; remainder = chunk_at_offset(victim, nb); av->top = remainder; set_head(victim, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0)); set_head(remainder, remainder_size | PREV_INUSE);
} //如果top chunk 空间不够，且fastbin中有空闲chunk //则触发malloc_consolidate函数合并fastbin中能合并chunk，然后加入到unsorted bin中，如果是与top_chunk相邻的chunk则直接与top_chunk合并， //接着返回for循环开始,从unsorted bin 中继续查找 else if (have_fastchunks(av)) { malloc_consolidate(av); /* restore original bin index */ if (in_smallbin_range(nb)) idx = smallbin_index(nb); else idx = largebin_index(nb); } //如果top chunk 空间不够，且fastbin中没有空闲chunk，就通过sysmalloc从操作系统分配内存。 else { void *p = sysmalloc(nb, av); //这里也是house of orange利用的地方 if (p != NULL) alloc_perturb(p, bytes);//将p的mem部分全部设置为bytes ,默认什么也不做 return p; }check_malloced_chunk(av, victim, nb); void *p = chunk2mem(victim); alloc_perturb(p, bytes); return p;
我们总结一下 malloc 响应用户内存分配要求的具体步骤：
将用户的请求大小转换为实际需要分配的 chunk 空间大小。
获取对应大小的tcache的tc_idx,如果tc_idx合法，且对应的tcache不为空，则直接返回该tcahce中的第一个chunk,分配结束，否则进入下一步。
判断所需分配 chunk 的大小是否满足 chunk_size <= max_fast (max_fast 默认为 64B)。如果是的话，尝试在 fast bins 中取一个所需大小的 chunk 分配给用户。如果可以找到，取出这个chunk返回，把剩下的chunk加入到tcache中，直到tcache满了或者fastbin中不存在chunk，分配结束，否则跳到下一步。
判断所需大小是否处在 small bins 中，如果chunk 大小处在 small bins 中，转到下一步，否则跳到第6步。
根据所需分配的 chunk 的大小，找到具体所在的某个 small bin，尝试从该 bin 的尾部摘取一个恰好满足大小的 chunk，若成功，取出这个chunk返回，把剩下的chunk加入到tcache中，并设置物理相邻的下一个chunk的prev_inuse位，直到tcache满了或者small bin中不存在chunk，分配结束，否则转到第7步。
如果fastbin中存在空闲chunk,遍历 fast bins 中的 chunk，将相邻的 chunk 进行合并， 并链接到 unsorted bin 中。然后转到下一步。
到了这一步，说明需要分配的是一块大的内存，或者 tcache,fastbin和small bins 中找不到合适的 chunk，于是遍历 unsorted bin 中的 chunk。
如果 unsorted bin只有一个 chunk，并且这个 chunk 在上次分配时被分割过，并且所需分配的 chunk 大小属于 small bins，并且 chunk 的大小大于等于需要分配的大小，这种情况下就直 接将该 chunk 进行切割，分配结束。
若chunk的size刚好满足大小，且对应的tcache没有满，则把他加入到tcache中，并跳出这一次的循环继续遍历unsorted bin，如果对应的tcache满了则直接返回，分配结束。
如果以上都不满足，将根据 chunk 的空间大小将其放入 small bins 或是 large bins 中。
如果达到tcache_unsorted_limit限制（默认无限制）且之前已经存入过chunk则在此时，取出size对应的tcache的第一个chunk返回，否则转入下一步。
如果之前已经存入过chunk且上一步没取出，则在此时取出返回我们申请的size对应的tcache的第一个chunk，分配结束。否则进入下一步。
到了这一步，说明需要分配的是一块大的内存，或者tcache， fastbin，small bins 和 unsorted bin 中都找不到合适的 chunk。如果需要分配的是一块大的内存，则跳到下一步，否则跳到第11步
从 large bins 中按照“smallest-first，best-fit”原则，找一个合适的 chunk，从 中划分一块所需大小的 chunk，并将剩下的部分放入 unsorted bin中 。若操作成功，则 分配结束，否则跳到下一步。
如果通过上面的方式从最合适的fastbin,small bin 或 large bin 中都没有分配到需要的 chunk，则 查看比当前 最合适bin 的 index 大的 small bin 或 large bin 是否有空闲 chunk 可利用，来分割得到所需的 chunk，并将剩下的部分放入 unsorted bin中。若操作成功，则 分配结束，否则跳到下一步。
如果以上都无法满足我们要申请的chunk的要求，那么就需要操作 top chunk 来 进行分配了。判断 top chunk 大小是否满足所需 chunk 的大小，如果是，则从 top chunk 中分出一块来。否则转到下一步。
到了这一步，说明 top chunk 也不能满足分配要求。如果fastbin中有空闲chunk则触发malloc_consolidate函数合并fastbin中能合并chunk，然后加入到unsorted bin中，如果是与top_chunk相邻的chunk则直接与top_chunk合并。若操作成功，则 跳转到 7，否则转到下一步
到了这一步，说明，top chunk 也不能满足分配要求，且fastbin中也没有空闲chunk。通过sysmalloc从操作系统分配内存。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章