Linux虚拟内存管理(glibc)

Posted 2021-01-01 小僧的功课

转：https://blog.csdn.net/tengxy_cloud/article/details/53067396

https://www.cnblogs.com/purpleraintear/p/6051562.html

 

在使用mysql作为DB开发的兑换券系统中，随着分区表的不断创建，发现mysqld出现了疑似“内存泄露”现象，但通过 valgrind 等工具检测后，并没发现类似的问题(最终原因是由于glibc的内存碎片造成)。

最近在做 MySQL 版本升级时（ 5.1->5.5 ） , 发现了 mysqld 疑似“内存泄露”现象，但通过 valgrind 等工具检测后，并没发现类似的问题。因此，需要深入学习 Linux 的虚拟内存管理方面的内容来解释这个现象。

Linux 的虚拟内存管理有几个关键概念：

1. 每个进程有独立的虚拟地址空间，进程访问的虚拟地址并不是真正的物理地址

2. 虚拟地址可通过每个进程上页表与物理地址进行映射，获得真正物理地址

3. 如果虚拟地址对应物理地址不在物理内存中，则产生缺页中断，真正分配物理地址，同时更新进程的页表；如果此时物理内存已耗尽，则根据内存替换算法淘汰部分页面至物理磁盘中。

基于以上认识，这篇文章通过本人以前对虚拟内存管理的疑惑由浅入深整理了以下十个问题，并通过例子和系统命令尝试进行解答。

1. Linux 虚拟地址空间如何分布？ 32 位和 64 位有何不同？

2. malloc 是如何分配内存的？

3. malloc 分配多大的内存，就占用多大的物理内存空间吗？

4. 如何查看进程虚拟地址空间的使用情况？

5. free 的内存真的释放了吗（还给 OS ） ?

6. 程序代码中 malloc 的内存都有相应的 free ，就不会出现内存泄露了吗？

7. 既然堆内内存不能直接释放，为什么不全部使用 mmap 来分配？

8. 如何查看进程的缺页中断信息？

9. 如何查看堆内内存的碎片情况？

10. 除了 glibc 的 malloc/free ，还有其他第三方实现吗？

一.Linux 虚拟地址空间如何分布？ 32 位和 64 位有何不同？

Linux 使用虚拟地址空间，大大增加了进程的寻址空间，由低地址到高地址分别为：

1. 只读段：该部分空间只能读，不可写，包括代码段、 rodata 段（ C 常量字符串和 #define 定义的常量）
2. 数据段：保存全局变量、静态变量的空间
3. 堆 ：就是平时所说的动态内存， malloc/new 大部分都来源于此。其中堆顶的位置可通过函数 brk 和 sbrk 进行动态调整。
4. 文件映射区域 ：如动态库、共享内存等映射物理空间的内存，一般是 mmap 函数所分配的虚拟地址空间。
5. 栈：用于维护函数调用的上下文空间，一般为 8M ，可通过 ulimit –s 查看。
6. 内核虚拟空间：用户代码不可见的内存区域，由内核管理。

下图是 32 位系统典型的虚拟地址空间分布（来自《深入理解计算机系统》）。

32 位系统有 4G 的地址空间，其中0x08048000~0xbfffffff 是用户空间，0xc0000000~0xffffffff 是内核空间，包括内核代码和数据、与进程相关的数据结构（如页表、内核栈）等。另外， %esp 执行栈顶，往低地址方向变化； brk/sbrk 函数控制堆顶往高地址方向变化。

可通过以下代码验证进程的地址空间分布，其中 sbrk(0) 函数用于返回栈顶指针。

1.  
   #include <stdlib.h>
2.  
   #include <stdio.h>
3.  
   #include <string.h>
4.  
   #include <unistd.h>
5.  
   int global_num = 0;
6.  
   char global_str_arr [65536] = {\'a\'};
7.  
   int main(int argc, char** argv)
8.  
   {
9.  
   char* heap_var = NULL;
10.  
    int local_var = 0;
11.  
    printf("Address of function main 0x%lx\\n", main);
12.  
    printf("Address of global_num 0x%lx\\n", &global_num);
13.  
    printf("Address of global_str_arr 0x%lx ~ 0x%lx\\n", &global_str_arr[0], &global_str_arr[65535]);
14.  
    printf("Top of stack is 0x%lx\\n", &local_var);
15.  
    printf("Top of heap is 0x%lx\\n", sbrk(0));
16.  
    heap_var = malloc(sizeof(char) * 127 * 1024);
17.  
    printf("Address of heap_var is 0x%lx\\n", heap_var);
18.  
    printf("Top of heap after malloc is 0x%lx\\n", sbrk(0));
19.  
    free(heap_var);
20.  
    heap_var = NULL;
21.  
    printf("Top of heap after free is 0x%lx\\n", sbrk(0));
22.  
    return 1;
23.  
    }

32 位系统的结果如下，与上图的划分保持一致，并且栈顶指针在 mallloc 和 free 一个 127K 的存储空间时都发生了变化（增大和缩小）。

1.  
   Address of function main 0x8048474
2.  
   Address of global_num 0x8059904
3.  
   Address of global_str_arr 0x8049900 ~ 0x80598ff
4.  
   Top of stack is 0xbfd0886c
5.  
   Top of heap is 0x805a000
6.  
   Address of heap_var is 0x805a008
7.  
   Top of heap after malloc is 0x809a000
8.  
   Top of heap after free is 0x807b000

但是， 64 位系统结果怎样呢？ 64 位系统是否拥有 2^64 的地址空间吗？

64 位系统运行结果如下：

1.  
   Address of function main 0x400594
2.  
   Address of global_num 0x610b90
3.  
   Address of global_str_arr 0x600b80 ~ 0x610b7f
4.  
   Top of stack is 0x7fff2e9e4994
5.  
   Top of heap is 0x8f5000
6.  
   Address of heap_var is 0x8f5010
7.  
   Top of heap after malloc is 0x935000
8.  
   Top of heap after free is 0x916000

从结果知，与上图的分布并不一致。而事实上， 64 位系统的虚拟地址空间划分发生了改变：

1. 地址空间大小不是 2^32 ，也不是 2^64 ，而一般是 2^48 。因为并不需要 2^64 这么大的寻址空间，过大空间只会导致资源的浪费。 64 位 Linux 一般使用 48 位来表示虚拟地址空间， 40 位表示物理地址，这可通过 /proc/cpuinfo 来查看

   address sizes : 40 bits physical, 48 bits virtual

2. 其中， 0x0000000000000000~0x00007fffffffffff表示用户空间，0xFFFF800000000000~ 0xFFFFFFFFFFFFFFFF表示内核空间，共提供 256TB(2^48) 的寻址空间。这两个区间的特点是，第 47 位与 48~63 位相同，若这些位为 0 表示用户空间，否则表示内核空间。

3. 用户空间由低地址到高地址仍然是只读段、数据段、堆、文件映射区域和栈

二.malloc 是如何分配内存的？

malloc 是 glibc 中内存分配函数，也是最常用的动态内存分配函数，其内存必须通过 free 进行释放，否则导致内存泄露。

关于 malloc 获得虚存空间的实现，与 glibc 的版本有关，但大体逻辑是：

1. 若分配内存小于 128k ，调用 sbrk() ，将堆顶指针向高地址移动，获得新的虚存空间。

2. 若分配内存大于 128k ，调用 mmap() ，在文件映射区域中分配匿名虚存空间。

3. 这里讨论的是简单情况，如果涉及并发可能会复杂一些，不过先不讨论。

其中 sbrk 就是修改栈顶指针位置，而 mmap 可用于生成文件的映射以及匿名页面的内存，这里指的是匿名页面。

而这个 128k ，是 glibc 的默认配置，可通过函数 mallopt 来设置，可通过以下例子说明。

1.  
   #include <stdlib.h>
2.  
   #include <stdio.h>
3.  
   #include <string.h>
4.  
   #include <unistd.h>
5.  
   #include <sys/mman.h>
6.  
   #include <malloc.h>
7.  
   void print_info(
8.  
   char* var_name,
9.  
   char* var_ptr,
10.  
    size_t size_in_kb
11.  
    )
12.  
     
13.  
    {
14.  
    printf("Address of %s(%luk) 0x%lx, now heap top is 0x%lx\\n",
15.  
    var_name, size_in_kb, var_ptr, sbrk(0));
16.  
     
17.  
    }
18.  
    int main(int argc, char** argv)
19.  
    {
20.  
    char *heap_var1, *heap_var2, *heap_var3 ;
21.  
    char *mmap_var1, *mmap_var2, *mmap_var3 ;
22.  
    char *maybe_mmap_var;
23.  
    printf("Orginal heap top is 0x%lx\\n", sbrk(0));
24.  
    heap_var1 = malloc(32*1024);
25.  
    print_info("heap_var1", heap_var1, 32);
26.  
    heap_var2 = malloc(64*1024);
27.  
    print_info("heap_var2", heap_var2, 64);
28.  
    heap_var3 = malloc(127*1024);
29.  
    print_info("heap_var3", heap_var3, 127);
30.  
    printf("\\n");
31.  
    maybe_mmap_var = malloc(128*1024);
32.  
    print_info("maybe_mmap_var", maybe_mmap_var, 128);
33.  
    //mmap
34.  
    mmap_var1 = malloc(128*1024);
35.  
    print_info("mmap_var1", mmap_var1, 128);
36.  
    // set M_MMAP_THRESHOLD to 64k
37.  
    mallopt(M_MMAP_THRESHOLD, 64*1024);
38.  
    printf("set M_MMAP_THRESHOLD to 64k\\n");
39.  
    mmap_var2 = malloc(64*1024);
40.  
    print_info("mmap_var2", mmap_var2, 64);
41.  
    mmap_var3 = malloc(127*1024);
42.  
    print_info("mmap_var3", mmap_var3, 127);
43.  
    return 1;
44.  
    }

这个例子很简单，通过 malloc 申请多个不同大小的动态内存，同时通过接口 print_info 打印变量大小和地址等相关信息，其中 sbrk(0) 可返回堆顶指针位置。另外，粗体部分是将 MMAP 分配的临界点由 128k 转为 64k ，再打印变量地址的不同。

下面是 Linux 64 位机器的执行结果（后文所有例子都是通过 64 位机器上的测试结果）。

1.  
   Orginal heap top is 0x17da000
2.  
   Address of heap_var1(32k) 0x17da010, now heap top is 0x1803000
3.  
   Address of heap_var2(64k) 0x17e2020, now heap top is 0x1803000
4.  
   Address of heap_var3(127k) 0x17f2030, now heap top is 0x1832000
5.  
   Address of maybe_mmap_var(128k) 0x1811c40, now heap top is 0x1832000
6.  
   Address of mmap_var1(128k) 0x7f4a0b1f2010, now heap top is 0x1832000
7.  
   set M_MMAP_THRESHOLD to 64k
8.  
   Address of mmap_var2(64k) 0x7f4a0b1e1010, now heap top is 0x1832000
9.  
   Address of mmap_var3(127k) 0x7f4a0b1c1010, now heap top is 0x1832000

三.malloc 分配多大的内存，就占用多大的物理内存空间吗？

我们知道， malloc 分配的的内存是虚拟地址空间，而虚拟地址空间和物理地址空间使用进程页表进行映射，那么分配了空间就是占用物理内存空间了吗？

首先，进程使用多少内存可通过 ps aux 命令 查看，其中关键的两信息（第五、六列）为：

1. VSZ ， virtual memory size ，表示进程总共使用的虚拟地址空间大小，包括进程地址空间的代码段、数据段、堆、文件映射区域、栈、内核空间等所有虚拟地址使用的总和，单位是 K

2. RSS ， resident set size ，表示进程实际使用的物理内存空间， RSS 总小于 VSZ 。

可通过一个例子说明这个问题：

1.  
   #include <stdlib.h>
2.  
   #include <stdio.h>
3.  
   #include <string.h>
4.  
   #include <unistd.h>
5.  
   #include <sys/mman.h>
6.  
   #include <malloc.h>
7.  
   char ps_cmd[1024];
8.  
   void print_info(
9.  
   char* var_name,
10.  
    char* var_ptr,
11.  
    size_t size_in_kb
12.  
    )
13.  
     
14.  
    {
15.  
    printf("Address of %s(%luk) 0x%lx, now heap top is 0x%lx\\n",
16.  
    var_name, size_in_kb, var_ptr, sbrk(0));
17.  
    system(ps_cmd);
18.  
    }
19.  
     
20.  
    int main(int argc, char** argv)
21.  
    {
22.  
    char *non_set_var, *set_1k_var, *set_5k_var, *set_7k_var;
23.  
    pid_t pid;
24.  
    pid = getpid();
25.  
    sprintf(ps_cmd, "ps aux | grep %lu | grep -v grep", pid);
26.  
    non_set_var = malloc(32*1024);
27.  
    print_info("non_set_var", non_set_var, 32);
28.  
    set_1k_var = malloc(64*1024);
29.  
    memset(set_1k_var, 0, 1024);
30.  
    print_info("set_1k_var", set_1k_var, 64);
31.  
    set_5k_var = malloc(127*1024);
32.  
    memset(set_5k_var, 0, 5*1024);
33.  
    print_info("set_5k_var", set_5k_var, 127);
34.  
    set_7k_var = malloc(64*1024);
35.  
    memset(set_1k_var, 0, 7*1024);
36.  
    print_info("set_7k_var", set_7k_var, 64);
37.  
    return 1;
38.  
    }

该代码扩展了上一个例子print_info能力，处理打印变量信息，同时通过 ps aux 命令获得当前进程的 VSZ 和 RSS 值。并且程序 malloc 一块内存后，会 memset 内存的若干 k 内容。

执行结果为

1.  
   Address of non_set_var(32k) 0x502010, now heap top is 0x52b000
2.  
    
3.  
   mysql 12183 0.0 0.0 2692 452 pts/3 S+ 20:29 0:00 ./test_vsz
4.  
    
5.  
   Address of set_1k_var(64k) 0x50a020, now heap top is 0x52b000
6.  
    
7.  
   mysql 12183 0.0 0.0 2692 456 pts/3 S+ 20:29 0:00 ./test_vsz
8.  
    
9.  
   Address of set_5k_var(127k) 0x51a030, now heap top is 0x55a000
10.  
     
11.  
    mysql 12183 0.0 0.0 2880 464 pts/3 S+ 20:29 0:00 ./test_vsz
12.  
     
13.  
    Address of set_7k_var(64k) 0x539c40, now heap top is 0x55a000
14.  
     
15.  
    mysql 12183 0.0 0.0 2880 472 pts/3 S+ 20:29 0:00 ./test_vsz

由以上结果知：

1. VSZ 并不是每次 malloc 后都增长，是与上一节说的堆顶没发生变化有关，因为可重用堆顶内剩余的空间，这样的 malloc 是很轻量快速的。

2. 但如果 VSZ 发生变化，基本与分配内存量相当，因为 VSZ 是计算虚拟地址空间总大小。

3. RSS 的增量很少，是因为 malloc 分配的内存并不就马上分配实际存储空间，只有第一次使用，如第一次 memset 后才会分配。

4. 由于每个物理内存页面大小是 4k ，不管 memset 其中的 1k 还是 5k 、 7k ，实际占用物理内存总是 4k 的倍数。所以 RSS 的增量总是 4k 的倍数。

5. 因此，不是 malloc 后就马上占用实际内存，而是第一次使用时发现虚存对应的物理页面未分配，产生缺页中断，才真正分配物理页面，同时更新进程页面的映射关系。这也是 Linux 虚拟内存管理的核心概念之一。

四. 如何查看进程虚拟地址空间的使用情况？

进程地址空间被分为了代码段、数据段、堆、文件映射区域、栈等区域，那怎么查询这些虚拟地址空间的使用情况呢？

Linux 提供了 pmap 命令来查看这些信息，通常使用 pmap -d $pid （高版本可提供 pmap -x $pid）查询，如下所示：

1.  
   mysql@ TLOG_590_591:~/vin/test_memory> pmap -d 17867
2.  
    
3.  
   17867: test_mmap
4.  
    
5.  
   START SIZE RSS DIRTY PERM OFFSET DEVICE MAPPING
6.  
    
7.  
   00400000 8K 4K 0K r-xp 00000000 08:01 /home/mysql/vin/test_memory/test_mmap
8.  
    
9.  
   00501000 68K 8K 8K rw-p 00001000 08:01 /home/mysql/vin/test_memory/test_mmap
10.  
     
11.  
    00512000 76K 0K 0K rw-p 00512000 00:00 [heap]
12.  
     
13.  
    0053e000 256K 0K 0K rw-p 0053e000 00:00 [anon]
14.  
     
15.  
    2b3428f97000 108K 92K 0K r-xp 00000000 08:01 /lib64/ld-2.4.so
16.  
     
17.  
    2b3428fb2000 8K 8K 8K rw-p 2b3428fb2000 00:00 [anon]
18.  
     
19.  
    2b3428fc1000 4K 4K 4K rw-p 2b3428fc1000 00:00 [anon]
20.  
     
21.  
    以上是关于Linux虚拟内存管理(glibc)的主要内容，如果未能解决你的问题，请参考以下文章

    Linux虚拟内存管理(glibc)

    glibc内存管理那些事儿

    Linux glibc内存管理：用户态内存分配器——ptmalloc实现原理

    从上到下看linux内存管理--glibc malloc

    Linux系列：glibc程序设计规范与内存管理思想

    Linux系列：glibc程序设计规范与内存管理思想