返回资讯中心
外部精选
软件工程
#社区热议

malloc 如何工作:glibc 通过两次 brk 系统调用扩展堆

来源标题:What is malloc doing, anyway?

malloc 并非每次分配都向内核申请内存,glibc 会在首次调用时用两次 brk 系统调用一次性扩展堆约 132 KiB,后续 999 次 malloc(16) 直接复用这块内存。文章用 strace 演示了这一过程,并指出系统调用开销约 575 纳秒,因此需要后台记账来减少调用。

Hacker Newsbenmandrew2026/11/9 · 8 天前30 分钟阅读

以下正文由 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 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →