Glibc内存管理--ptmalloc2源代码分析（二十三）
5.6.5 new_heap()
New_heap() 函数负责从 mmap 区域映射一块内存来作为 sub_heap ，在 32 位系统上，该函数每次映射 1M 内存，映射的内存块地址按 1M 对齐；在 64 为系统上，该函数映射 64M 内存，映射的内存块地址按 64M 对齐。 New_heap() 函数只是映射一块虚拟地址空间，该空间不可读写，不会被 swap 。 New_heap() 函数的实现源代码如下：
/* If consecutive mmap (0, HEAP_MAX_SIZE << 1, ...) calls return decreasing
addresses as opposed to increasing, new_heap would badly fragment the
address space. In that case remember the second HEAP_MAX_SIZE part
aligned to HEAP_MAX_SIZE from last mmap (0, HEAP_MAX_SIZE << 1, ...)
call (if it is already aligned) and try to reuse it next time. We need
no locking for it, as kernel ensures the atomicity for us - worst case
we'll call mmap (addr, HEAP_MAX_SIZE, ...) for some value of addr in
multiple threads, but only one will succeed. */
static char *aligned_heap_area;
/* Create a new heap. size is automatically rounded up to a multiple
of the page size. */
static heap_info *
internal_function
#if __STD_C
new_heap(size_t size, size_t top_pad)
#else
new_heap(size, top_pad) size_t size, top_pad;
#endif
{
size_t page_mask = malloc_getpagesize - 1;
char *p1, *p2;
unsigned long ul;
heap_info *h;
if(size+top_pad < HEAP_MIN_SIZE)
size = HEAP_MIN_SIZE;
else if(size+top_pad <= HEAP_MAX_SIZE)
size += top_pad;
else if(size > HEAP_MAX_SIZE)
return 0;
else
size = HEAP_MAX_SIZE;
size = (size + page_mask) & ~page_mask;
调整size 的大小， size 的最小值为 32K, 最大值 HEAP_MAX_SIZE 在不同的系统上不同，在 32 位系统为 1M ， 64 位系统为 64M ，将 size 的大小调整到最小值与最大值之间，并以页对齐，如果 size 大于最大值，直接报错。
/* A memory region aligned to a multiple of HEAP_MAX_SIZE is needed.
No swap space needs to be reserved for the following large
mapping (on Linux, this is the case for all non-writable mappings
anyway). */
p2 = MAP_FAILED;
if(aligned_heap_area) {
p2 = (char *)MMAP(aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE,
MAP_PRIVATE|MAP_NORESERVE);
aligned_heap_area = NULL;
if (p2 != MAP_FAILED && ((unsigned long)p2 & (HEAP_MAX_SIZE-1))) {
munmap(p2, HEAP_MAX_SIZE);
p2 = MAP_FAILED;
}
}
全局变量 aligned_heap_area 是上一次调用 mmap 分配内存的结束虚拟地址，并已经按照 HEAP_MAX_SIZE 大小对齐。如果 aligned_heap_area 不为空，尝试从上次映射结束地址开始映射大小为 HEAP_MAX_SIZE 的内存块，由于全局变量 aligned_heap_area 没有锁保护，可能存在多个线程同时 mmap() 函数从 aligned_heap_area 开始映射新的虚拟内存块，操作系统会保证只会有一个线程会成功，其它在同一地址映射新虚拟内存块都会失败。无论映射是否成功，都将全局变量 aligned_heap_area 设置为 NULL 。如果映射成功，但返回的虚拟地址不是按 HEAP_MAX_SIZE 大小对齐的，取消该区域的映射，映射失败。
if(p2 == MAP_FAILED) {
p1 = (char *)MMAP(0, HEAP_MAX_SIZE<<1, PROT_NONE,
MAP_PRIVATE|MAP_NORESERVE);
全局变量 aligned_heap_area 为 NULL ，或者从 aligned_heap_area 开始映射失败了，尝试映射 2 倍 HEAP_MAX_SIZE 大小的虚拟内存，便于地址对齐，因为在最坏可能情况下，需要映射 2 倍 HEAP_MAX_SIZE 大小的虚拟内存才能实现地址按照 HEAP_MAX_SIZE 大小对齐。
if(p1 != MAP_FAILED) {
p2 = (char *)(((unsigned long)p1 + (HEAP_MAX_SIZE-1))
& ~(HEAP_MAX_SIZE-1));
ul = p2 - p1;
if (ul)
munmap(p1, ul);
else
aligned_heap_area = p2 + HEAP_MAX_SIZE;
munmap(p2 + HEAP_MAX_SIZE, HEAP_MAX_SIZE - ul);
映射2 倍 HEAP_MAX_SIZE 大小的虚拟内存成功，将大于等于 p1 并按 HEAP_MAX_SIZE 大小对齐的第一个虚拟地址赋值给 p2 ， p2 作为 sub_heap 的起始虚拟地址， p2+ HEAP_MAX_SIZE 作为 sub_heap 的结束地址，并将 sub_heap 的结束地址赋值给全局变量 aligned_heap_area ，最后还需要将多余的虚拟内存还回给操作系统。
} else {
/* Try to take the chance that an allocation of only HEAP_MAX_SIZE
is already aligned. */
p2 = (char *)MMAP(0, HEAP_MAX_SIZE, PROT_NONE, MAP_PRIVATE|MAP_NORESERVE);
if(p2 == MAP_FAILED)
return 0;
if((unsigned long)p2 & (HEAP_MAX_SIZE-1)) {
munmap(p2, HEAP_MAX_SIZE);
return 0;
}
映射2 倍 HEAP_MAX_SIZE 大小的虚拟内存失败了，再尝试映射 HEAP_MAX_SIZE 大小的虚拟内存，如果失败，返回；如果成功，但该虚拟地址不是按照 HEAP_MAX_SIZE 大小对齐的，返回。
}
}
if(mprotect(p2, size, PROT_READ|PROT_WRITE) != 0) {
munmap(p2, HEAP_MAX_SIZE);
return 0;
}
h = (heap_info *)p2;
h->size = size;
h->mprotect_size = size;
THREAD_STAT(stat_n_heaps++);
调用 mprotect() 函数将 size 大小的内存设置为可读可写，如果失败，解除整个 sub_heap 的映射。然后更新 heap_info 实例中的相关字段。
return h; }
5.6.6 get_free_list()和reused_arena()
这两个函数在开启了 PER_THRAD 优化时用于获取分配区（ arena ）， arena_get2 首先调用 get_free_list() 尝试获得 arena ，如果失败在尝试调用 reused_arena() 获得 arena ，如果仍然没有获得分配区，调用 _int_new_arena() 创建一个新的分配区。 Get_free_list() 函数的源代码如下：
static mstate
get_free_list (void)
{
mstate result = free_list;
if (result != NULL)
{
(void)mutex_lock(&list_lock);
result = free_list;
if (result != NULL)
free_list = result->next_free;
(void)mutex_unlock(&list_lock);
if (result != NULL)
{
(void)mutex_lock(&result->mutex);
tsd_setspecific(arena_key, (Void_t *)result);
THREAD_STAT(++(result->stat_lock_loop));
}
}
return result;
}
这个函数实现很简单，首先查看 arena 的 free_list 中是否为 NULL ，如果不为 NULL ，获得全局锁 list_lock ，将 free_list 的第一个 arena 从单向链表中取出，解锁 list_lock 。如果从 free_list 中获得一个 arena ，对该 arena 加锁，并将该 arena 加入线程的私有实例中。
reused_arena() 函数的源代码实现如下：
static mstate
reused_arena (void)
{
if (narenas <= mp_.arena_test)
return NULL;
首先判断全局分配区的总数是否小于分配区的个数的限定值（ arena_test ）， 在 32 位系统上 arena_test 默认值为 2 ， 64 位系统上的默认值为 8 ，如果当前进程的分配区数量没有达到限定值，直接返回 NULL 。
static int narenas_limit;
if (narenas_limit == 0)
{
if (mp_.arena_max != 0)
narenas_limit = mp_.arena_max;
else
{
int n = __get_nprocs ();
if (n >= 1)
narenas_limit = NARENAS_FROM_NCORES (n);
else
/* We have no information about the system. Assume two
cores. */
narenas_limit = NARENAS_FROM_NCORES (2);
}
}
if (narenas < narenas_limit)
return NULL;
设定全局变量 narenas_limit ，如果应用层设置了进程的最大分配区个数（ arena_max ），将 arena_max 赋值给 narenas_limit ，否则根据系统的 cpu 个数和系统的字大小设定 narenas_limit 的大小， narenas_limit 的大小默认与 arena_test 大小相同。然后再次判断进程的当前分配区个数是否达到了分配区的限制个数，如果没有达到限定值，返回。
mstate result;
static mstate next_to_use;
if (next_to_use == NULL)
next_to_use = &main_arena;
result = next_to_use;
do
{
if (!mutex_trylock(&result->mutex))
goto out;
result = result->next;
}
while (result != next_to_use);
/* No arena available. Wait for the next in line. */
(void)mutex_lock(&result->mutex);
out:
tsd_setspecific(arena_key, (Void_t *)result);
THREAD_STAT(++(result->stat_lock_loop));
next_to_use = result->next;
全局变量 next_to_use 指向下一个可能可用的分配区，该全局变量没有锁保护，主要用于记录上次遍历分配区循环链表到达的位置，避免每次都从同一个分配区开始遍历，导致从某个分配区分配的内存过多。首先判断 next_to_use 是否为 NULL ，如果是，将主分配区赋值给 next_to_use 。然后从 next_to_use 开始遍历分配区链表，尝试对遍历的分配区加锁，如果加锁成功，退出循环，如果遍历分配区循环链表中的所有分配区，尝试加锁都失败了，等待获得 next_to_use 指向的分配区的锁。执行到 out 的代码，意味着已经获得一个分配区的锁，将该分配区加入线程私有实例，并将当前分配区的下一个分配区赋值给 next_to_use 。
return result; }