Linux虚拟内存管理(glibc)

在使用mysql作为DB开发的兑换券系统中，随着分区表的不断创建，发现mysqld出现了疑似“内存泄露”现象，但通过 valgrind

等工具检测后，并没发现类似的问题(最终原因是由于glibc的内存碎片造成)。

因此，需要深入学习 Linux

的虚拟内存管理方面的内容来解释这个现象；Linux

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

1、每个进程都有独立的虚拟地址空间，进程访问的虚拟地址并不是真正的物理地址； 2、虚拟地址可通过每个进程上的页表(在每个进程的内核虚拟地址空间)与物理地址进行映射，获得真正物理地址； 3、如果虚拟地址对应物理地址不在物理内存中，则产生缺页中断，真正分配物理地址，同时更新进程的页表；如果此时物理内存已耗尽，则根据内存替换算法淘汰部分页面至物理磁盘中。 基于以上认识，进行了如下分析：一、Linux

虚拟地址空间如何分布？

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

函数控制堆顶_edata往高地址方向变化。

64位系统结果怎样呢？ 64 位系统是否拥有 2^64

的地址空间吗？ 事实上， 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、用户空间由低地址到高地址仍然是只读段、数据段、堆、文件映射区域和栈；

三、如何查看堆内内存的碎片情况 ？

glibc 提供了以下结构和接口来查看堆内内存和 mmap

的使用情况。 struct mallinfo { int

arena; int ordblks; int

smblks; int

hblks; int

hblkhd; int

usmblks; int fsmblks; int uordblks;

int fordblks;

int keepcost;

};

struct

mallinfo mallinfo();

void malloc_stats();

可通过以下例子来验证mallinfo和malloc_stats输出结果。

#include  #include  #include  #include  #include  #include

size_t heap_malloc_total,

heap_free_total,mmap_total, mmap_count;

void print_info() { struct

mallinfo mi = mallinfo(); printf("count

by

itself:\n"); printf("\theap_malloc_total=%lu heap_free_total=%lu

heap_in_use=%lu\n\tmmap_total=%lu

mmap_count=%lu\n", heap_malloc_total*1024, heap_free_total*1024,

heap_malloc_total*1024-heap_free_total*1024,

mmap_total*1024,

mmap_count); printf("count by

mallinfo:\n"); printf("\theap_malloc_total=%lu

heap_free_total=%lu heap_in_use=%lu\n\tmmap_total=%lu

mmap_count=%lu\n", mi.arena, mi.fordblks, mi.uordblks, mi.hblkhd, mi.hblks); printf("from

malloc_stats:\n"); malloc_stats(); }

#define ARRAY_SIZE 200 int main(int argc, char** argv) { char**

ptr_arr[ARRAY_SIZE]; int

i; for(

i = 0; i < ARRAY_SIZE; i++) { ptr_arr[i] = malloc(i * 1024); if

( i <

128) //glibc默认128k以上使用mmap

{

heap_malloc_total += i; }

else {

mmap_total

+= i; mmap_count++; } } print_info();

for( i = 0;

i < ARRAY_SIZE; i++) { if ( i % 2 == 0) continue; free(ptr_arr[i]);

if ( i < 128) {

heap_free_total += i; }

else { mmap_total -= i; mmap_count--; } } printf("\nafter

free\n"); print_info();

return

1; }

该例子第一个循环为指针数组每个成员分配索引位置 (KB)

大小的内存块，并通过 128 为分界分别对 heap 和 mmap 内存分配情况进行计数；

第二个循环是 free

索引下标为奇数的项，同时更新计数情况。通过程序的计数与mallinfo/malloc_stats 接口得到结果进行对比，并通过

print_info打印到终端。

下面是一个执行结果： count by itself: heap_malloc_total=8323072 heap_free_total=0

heap_in_use=8323072 mmap_total=12054528 mmap_count=72 count by mallinfo: heap_malloc_total=8327168 heap_free_total=2032

heap_in_use=8325136 mmap_total=12238848 mmap_count=72

from malloc_stats: Arena 0: system

bytes = 8327168 in use

bytes = 8325136 Total (incl. mmap): system

bytes = 20566016 in use

bytes = 20563984 max mmap regions

= 72 max mmap bytes = 12238848

after

free

count by itself: heap_malloc_total=8323072 heap_free_total=4194304

heap_in_use=4128768 mmap_total=6008832 mmap_count=36

count by mallinfo: heap_malloc_total=8327168 heap_free_total=4197360

heap_in_use=4129808 mmap_total=6119424 mmap_count=36

from malloc_stats: Arena 0: system

bytes = 8327168 in use

bytes = 4129808 Total (incl. mmap): system

bytes = 14446592 in use

bytes = 10249232 max mmap regions

= 72 max mmap bytes = 12238848

由上可知，程序统计和mallinfo 得到的信息基本吻合，其中 heap_free_total

表示堆内已释放的内存碎片总和。 如果想知道堆内究竟有多少碎片，可通过 mallinfo 结构中的

fsmblks 、smblks 、ordblks 值得到，这些值表示不同大小区间的碎片总个数，这些区间分别是 0~80 字节，80~512

字节，512~128k。如果 fsmblks 、 smblks

的值过大，那碎片问题可能比较严重了。 不过， mallinfo

结构有一个很致命的问题，就是其成员定义全部都是 int ，在 64 位环境中，其结构中的

uordblks/fordblks/arena/usmblks

很容易就会导致溢出，应该是历史遗留问题，使用时要注意！

四、既然堆内内存brk和sbrk不能直接释放，为什么不全部使用 mmap

来分配，munmap直接释放呢？ 既然堆内碎片不能直接释放，导致疑似“内存泄露”问题，为什么

malloc 不全部使用 mmap 来实现呢(mmap分配的内存可以会通过 munmap 进行 free

，实现真正释放)？而是仅仅对于大于 128k 的大块内存才使用 mmap ？

其实，进程向 OS 申请和释放地址空间的接口 sbrk/mmap/munmap

都是系统调用，频繁调用系统调用都比较消耗系统资源的。并且， mmap 申请的内存被 munmap

后，重新申请会产生更多的缺页中断。例如使用 mmap 分配 1M 空间，第一次调用产生了大量缺页中断 (1M/4K 次 )

，当munmap 后再次分配 1M 空间，会再次产生大量缺页中断。缺页中断是内核行为，会导致内核态CPU消耗较大。另外，如果使用

mmap 分配小内存，会导致地址空间的分片更多，内核的管理负担更大。

同时堆是一个连续空间，并且堆内碎片由于没有归还

OS ，如果可重用碎片，再次访问该内存很可能不需产生任何系统调用和缺页中断，这将大大降低 CPU

的消耗。 因此， glibc 的 malloc 实现中，充分考虑了 sbrk 和 mmap

行为上的差异及优缺点，默认分配大块内存 (128k) 才使用 mmap 获得地址空间，也可通过

mallopt(M_MMAP_THRESHOLD, ) 来修改这个临界值。

五、如何查看进程的缺页中断信息？

可通过以下命令查看缺页中断信息 ps -o majflt,minflt -C  ps -o majflt,minflt -p  其中:: majflt 代表 major fault ，指大错误；

minflt

代表 minor fault ，指小错误。

这两个数值表示一个进程自启动以来所发生的缺页中断的次数。

其中 majflt 与 minflt 的不同是::

majflt 表示需要读写磁盘，可能是内存对应页面在磁盘中需要load

到物理内存中，也可能是此时物理内存不足，需要淘汰部分物理页面至磁盘中。

六、除了 glibc 的

malloc/free ，还有其他第三方实现吗？

其实，很多人开始诟病 glibc 内存管理的实现，特别是高并发性能低下和内存碎片化问题都比较严重，因此，陆续出现一些第三方工具来替换

glibc 的实现，最著名的当属 google 的tcmalloc和facebook 的jemalloc

。 网上有很多资源，可以自己查(只用使用第三方库，代码不用修改，就可以使用第三方库中的malloc)。