使用 jemalloc profile memory

对于长时间运行的服务端程序，内存的使用一直是一个非常重要的监控指标，当内存的使用量一直在上升的时候，我们就需要警觉起来，因为很有可能整个系统出现了内存泄露。那么剩下的问题就比较简单了，如何动态的获知哪里有内存泄露呢？

对 Go 的程序来说，我们可以使用语言内置的 pprof 工具非常方便的对内存进行 profile，我们只需要在程序里面 import _ "net/http/pprof"，这样启动的 HTTP server 服务器就能够被直接 profile 了。

但对 Rust，情况就没那么简单了。因为语言并没有内置这个功能，所以我们得想其他办法来解决。Rust 默认使用的是 jemalloc 这个内存分配器，jemalloc 提供了非常方便的 profile 功能。所以我们自然将目光放在了如何用 jemalloc 来 profile memory 以及如何与 Rust 整合上面了。

要打开 jemalloc 的 profile 功能，在编译的时候我们需要显示的带上 --enable-prof 选项，通常在 Linux 下面我们会安装 libunwind 库，这样 prof 默认就会使用 libunwind 了。另外，为了不跟系统的 malloc 这些函数有命名冲突，这里显示的给 jemalloc 加上了前缀，使用 --with-jemalloc-prefix="je_"，这样我们外面就会使用 je_malloc 这种的函数名字了。

我们用官网非常简单的例子来说明内存泄露问题，如下：

 

void do_something(size_t i)
{
    // Leak some memory.
    je_malloc(i * 100);
}

上面的函数有一个典型的内存泄漏，我们调用 1000 次：

 

for (i = 0; i < 1000; i++) {
    do_something(i);
}

剩下的就是如何来定位内存问题了。

Mem Statistics

首先我们来看看 jemalloc 自己提供的统计信息，我们可以直接使用 je_malloc_stats_print(NULL, NULL, NULL) 来将 memory 的统计输出到 stderr 上面，但这个函数输出的东西比较多，并不利于实时的查看。多数时候，我们都是使用 je_mallctl 函数，得到一些关键的统计数据，然后发送给 Prometheus 来展示，这样我们就能够在 Prometheus 里面观察到整个 jemalloc 内存变化的曲线，如果持续上升，就需要报警了。

 

uint64_t epoch = 1;
size_t sz = sizeof(epoch);
je_mallctl("epoch", &epoch, &sz, &epoch, sz);

size_t allocated, active, mapped;
sz = sizeof(size_t);
je_mallctl("stats.allocated", &allocated, &sz, NULL, 0);
je_mallctl("stats.active", &active, &sz, NULL, 0);
je_mallctl("stats.mapped", &mapped, &sz, NULL, 0);

printf("allocated/active/mapped: %zu/%zu/%zu\n", allocated, active, mapped);

上面我们在每次 do_something 后面得到 allocated，active 以及 mapped 这些指标，然后输出：

 

allocated/active/mapped: 54919648/58540032/64831488
allocated/active/mapped: 55034336/58658816/64950272
allocated/active/mapped: 55149024/58777600/65069056
allocated/active/mapped: 55263712/58896384/65187840

上面需要注意，我们需要用 epoch 来让统计的 cache 更新。

Leak Check

通过统计，我们能看到整个内存的变化曲线，但到底哪里有内存问题呢？我们可以在程序结束的时候显示的输出内存泄露。仍然使用上面的程序，我们使用 JE_MALLOC_CONF="prof_leak:true,lg_prof_sample:0,prof_final:true" ./leak 来执行，当程序退出之后，会生成一个 prof heap 的文件，我们用 jeprof 工具就可以知道内存泄露了。

 

jeprof leak jeprof.9001.0.f.heap

Using local file leak.
Using local file jeprof.9001.0.f.heap.
Welcome to jeprof!  For help, type 'help'.
(jeprof) top
Total: 52.1 MB
    52.1 100.0% 100.0%     52.1 100.0% je_prof_backtrace
    0.0   0.0% 100.0%     52.1 100.0% __libc_start_main
    0.0   0.0% 100.0%     52.1 100.0% _start
    0.0   0.0% 100.0%     52.1 100.0% do_something
    0.0   0.0% 100.0%     52.1 100.0% imalloc (inline)
    0.0   0.0% 100.0%     52.1 100.0% imalloc_body (inline)
    0.0   0.0% 100.0%     52.1 100.0% je_malloc
    0.0   0.0% 100.0%     52.1 100.0% je_prof_alloc_prep (inline)
    0.0   0.0% 100.0%     52.1 100.0% main

Heap Profiling

使用上面的方式，我们只能在程序结束的时候输出内存泄露，实际并不适用于长时间运行的程序，幸运的时候，我们可以通过 jemalloc 的一些参数以及 mallctl 函数来显示的对内存进行 profile。在运行程序之前，我们需要设置 export JE_MALLOC_CONF="prof:true,prof_prefix:jeprof.out"，它用来告诉 jemalloc 显示的打开 prof，同时自动的生成 profile 文件名。

在代码里面，我们可以使用 mallctl("prof.dump", NULL, NULL, NULL, 0); 来对当前执行的程序生成一个 mem dump，然后过一段时间之后，用相同的方法再次生成一个，在用 jeprof 工具对比两次的 dump，就大概能知道是否有内存问题了。

具体到上面的例子，我们在程序的开始和结束都使用 mallctl dump 一次 memory，然后对两次生成的 profile 文件进行对比:

 

jeprof --base=jeprof.out.19792.0.m0.heap profile jeprof.out.19792.1.m1.heap

Using local file profile.
Using local file jeprof.out.19792.1.m1.heap.
Welcome to jeprof!  For help, type 'help'.
(jeprof) top
Total: 53.1 MB
    53.1 100.0% 100.0%     53.1 100.0% je_prof_backtrace
    0.0   0.0% 100.0%     53.1 100.0% __libc_start_main
    0.0   0.0% 100.0%     53.1 100.0% _start
    0.0   0.0% 100.0%     53.1 100.0% do_something
    0.0   0.0% 100.0%     53.1 100.0% imalloc (inline)
    0.0   0.0% 100.0%     53.1 100.0% imalloc_body (inline)
    0.0   0.0% 100.0%     53.1 100.0% je_malloc
    0.0   0.0% 100.0%     53.1 100.0% je_prof_alloc_prep (inline)
    0.0   0.0% 100.0%     53.1 100.0% main

Rust Customized Allocator

上面说完了在 C 里面使用 jemalloc 来看内存问题，那么对于 Rust 语言来说，我们怎么处理呢？Rust 默认使用的就是 jemalloc，但发布的版本里面 jemalloc 并没有带上 profile 的功能，所以需要重新编译 Rust，对于我们来说，因为要实时的跟进 Rust 的版本，这并不是一个好办法。

幸运的是，Rust 提供了 custom allocator 的功能，也就是能使用自定义的 allocator，这样对我们来说就简单很多了，使用一个打开了 profile 功能的 jemalloc 用作自定义的 allocator，这样就能通过 mallctl 来 profile memory 了。更幸运的是，Rust 的一个开发者已经提供了相关的 allocator，我们可以直接使用。

我们可以构造一个非常简单的 case，使用 mem::forget：

 

fn do_something()
{
   let mut bad_vec = Vec::new();
   for _ in 0..1024 {
       bad_vec.push('0');
   }
   mem::forget(bad_vec);
}

在这个函数前后，我们都使用 mallctl ，如下:

 

let epoch_name = "prof.dump";
let epoch_c_name = CString::new(epoch_name).unwrap();
mallctl(epoch_c_name.as_ptr(), null_mut(), null_mut(), null_mut(), 0);

执行之后，就会生成两个 profile 文件，使用 jeprof 之后，得到:

 

(jeprof) top
Total: 0.5 MB
     0.5 100.0% 100.0%      0.5 100.0% jemallocator::__rust_reallocate
     0.0   0.0% 100.0%      0.5 100.0% __libc_start_main
     0.0   0.0% 100.0%      0.5 100.0% _start
     0.0   0.0% 100.0%      0.5 100.0% alloc::heap::reallocate::h1264a9399460da6c
     0.0   0.0% 100.0%      0.5 100.0% alloc::raw_vec::{{impl}}::double
     0.0   0.0% 100.0%      0.5 100.0% collections::vec::{{impl}}::push
     0.0   0.0% 100.0%      0.5 100.0% core::ops::FnOnce::call_once (inline)
     0.0   0.0% 100.0%      0.5 100.0% main
     0.0   0.0% 100.0%      0.5 100.0% my_allocator::do_something::h4ffe20b1f68a3f80
     0.0   0.0% 100.0%      0.5 100.0% my_allocator::main::hffe46171bdd5ea12

小结

内存问题一直是长时间运行程序需要处理的一个棘手问题，虽然 Rust 相比 C 以及 CPP，在内存处理上面有了很大的改善，但我们仍然可能会有引用泄露等问题出现，这些问题很难通过直接浏览代码，看 log 和 metrics 来看出来的，而 profile 恰恰能很好的解决，所以这也是我们一直想在 TiKV 上面加入 profile memory 的原因。

需要注意，加入 profile 之后，会影响系统的性能，所以通常，我们都会采用 sample 的方式或者动态的打开或者关闭 profile 功能。譬如，假设我们要 profile memory，就使用 mallctl 将 prof.active 打开，一段时间，在使用 mallctl dump 出 memory，然后在关闭 profile。

另外，除了 jemalloc，其实 tcmalloc 也照样能支持 profile memory，只是因为 Rust 默认使用的是 jemalloc，我们最终我们还是决定基于 jemalloc 来使用。

作者：siddontang
链接：https://www.jianshu.com/p/5fd2b42cbf3d
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。