
malloc 如何工作:glibc 通过两次 brk 系统调用扩展堆
来源标题:What is malloc doing, anyway?
malloc 并非每次分配都向内核申请内存,glibc 会在首次调用时用两次 brk 系统调用一次性扩展堆约 132 KiB,后续 999 次 malloc(16) 直接复用这块内存。文章用 strace 演示了这一过程,并指出系统调用开销约 575 纳秒,因此需要后台记账来减少调用。
以下正文由 AI 翻译自 Hacker News(原文版权归原站所有),可能存在偏差,重要内容请以原文为准。
malloc 的接口非常简单优雅:你申请一定数量的内存,就会得到一个 void 指针,指向一块凭空出现的连续字节。用完之后,你用同一个指针调用 free,这块内存就消失得无影无踪。
但背后到底发生了什么?显然,由于我们运行的是用户空间程序,malloc 必须通过系统调用向内核申请内存。不过,我们可能会分配许多小块内存,而系统调用的开销很大(如下文所测,一次空系统调用耗时 575 纳秒),所以后台会做一些簿记工作。下面我们以 GNU libc(glibc)为例,用一段调用 malloc(16) 一千次的程序来演示。
static void *ptrs[1000];
int main(void) {
for (int i = 0; i < 1000; i++)
ptrs[i] = malloc(16);
用 strace 可以看到,整个循环只发起了两次 brk 系统调用:第一次询问 program break 在哪里(即进程堆的结束地址),第二次把堆扩大 132 KiB。这两次都发生在第一次 malloc 调用中——其余 999 次只是从已分配的内存中取用。
$ strace -e trace=brk,mmap,munmap,write \
./malloc1000 > /dev/null
...
brk(NULL) = 0x59faca231000
brk(0x59faca252000) = 0x59faca252000
+++ exited with 0 +++
你可能在讨论中同时看到 brk 和 sbrk。brk 是一个系统调用,把 program break 设置为传入的地址;sbrk 是 libc 提供的便捷封装,接受一个增量,把 program break 增加该数量。
运行中的进程拥有自己的地址空间,划分为若干区域,包括存放可执行代码的 text、存放已初始化全局变量的 data、存放未初始化全局变量的 bss 等等。下面的程序打印进程各区域中的一个地址。
#define SHOW(label, p) \
printf("%-22s %p\n", label, (void *)(p))
SHOW("main (text)", main);
SHOW("initialised (data)", &initialised);
SHOW("uninitialised (bss)", &uninitialised);
SHOW("malloc(16) (heap)", malloc(16));
SHOW("program break", sbrk(0));
SHOW("printf (libc)", printf);
SHOW("local (stack)", &local);
这些地址从二进制的代码区一路上升到栈区。
$ ./layout
main (text) 0x59c0791d7149
initialised (data) 0x59c0791da020
uninitialised (bss) 0x59c0791da028
malloc(16) (heap) 0x59c0903182b0
program break 0x59c090338000
printf (libc) 0x711dcf7c15b0
local (stack) 0x7ffff86c45ec
其中一些区域会随着程序运行而变化。例如,malloc(16) 会扩大堆并把 break 上移。注意在这次运行中,break 与 libc 中的 printf 相距 23.4 TiB,约为机器 15.6 GiB 物理内存的 1,530 倍。这段范围几乎全部未映射,因此不占用物理内存。
lowhighat starttextdataBSSgapbreak23 TiBunmappedlibcstackmalloc(16)textdataBSSgapheapbreak23 TiBunmappedlibcstack
用 sbrk 实现一个玩具分配器
因为我们可以直接移动 program break,所以可以自己写一个小分配器。这叫做 bump 分配器,因为每次调用只是把我们可用的内存往上顶一顶。
void *my_malloc(size_t size) {
void *p = sbrk(align_up(size));
return p == (void *)-1 ? NULL : p;
void my_free(void *ptr) {
(void)ptr;
这个分配器并不好!它在每次请求时都移动 break,而每次移动都是一次系统调用。我们可以对比一次系统调用和 malloc 的耗时,看看 malloc 为什么向内核申请大块内存再自己切分。下面三个函数各计时一百万次调用。
static void *volatile sink;
static void call_getppid(void) {
syscall(SYS_getppid);
static void call_sbrk(void) {
sink = sbrk(16);
static void call_malloc(void) {
sink = malloc(16);
sbrk(16) 只比空系统调用多花 35 纳秒,而 malloc(16) 比 sbrk(16) 快 22.7 倍。
$ ./syscall-cost
syscall(SYS_getppid) 575.2 ns per call
sbrk(16) 610.1 ns per call
malloc(16) 26.9 ns per call
sbrk(16) / malloc(16) 22.7x
bump 分配器也无法复用已释放的内存。每次请求都紧接在上一次之后,所以在下面的例子中,尽管 b 已被释放,d 仍然排在 c 之后。
$ ./my-bump-1
a = my_malloc(16) start+0
b = my_malloc(1) start+16
c = my_malloc(100) start+32
my_free(b)
d = my_malloc(1) start+144
break start+160
本文余下部分会一步步改进这个分配器。
malloc 实际分配的内存比你申请的更多。这是因为每次分配(或称 chunk)在返回指针之前都有一个大小头;free 正是靠它才能在不传入显式大小的情况下工作。chunk 大小总是 16 的倍数,因此大小的低位始终为零,glibc 就在这些位中存放三个标志。
header24 bytes for the callerheaderp = malloc(24)next chunkchunk:32 bytessize=320A0M1Pone 8-byte wordA:another arenaM:own mappingP:chunk before in use
size_t requests[] = {1, 24, 25, 1000};
size_t count = sizeof requests / sizeof requests[0];
for (size_t i = 0; i < count; i++) {
char *p = malloc(requests[i]);
size_t chunk = ((size_t *)p)[-1] & ~(size_t)7;
printf("%8zu %8zu\n", requests[i], chunk);
每个 chunk 等于请求大小加上 8 字节的头,向上取整到 16 的倍数,最小为 32。取整保证 malloc 返回的每个指针都是 16 字节对齐的,这正是 x86-64 给 max_align_t 的对齐要求,因此这块内存适用于任何 C 类型。32 字节的最小值则为 chunk 释放后存储链表指针留出了空间。
$ ./chunk-header
request chunk
1 32
24 32
25 48
1000 1008
(原文较长,此处译出前 6000 字,完整内容请点「打开原文」。)
正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。