Linux内存管理的基本原理

1. 内存映射

说到内存,这是我们买电脑时的重要考虑因素之一,现在的笔记本8GB内存已经很普遍了。这里说的8GB,其实是物理内存,也称主存,大多数计算机用的是动态随机访问内存(DRAM)。Linux下只有内核才可以访问物理内存,进程想要访问物理内存必须必须通过内核。Linux内核为每个进程提供了一个独立的虚拟地址空间,这个地址空间是连续的,它的内部又分为内核空间和用户空间。不同字长(也就是单个CPU指令可以处理的数据的最大长度)的处理器,地址空间范围也不同,像32位系统和64位系统,下图展示了它们的虚拟地址空间:

                                         Linux内存管理的基本原理_第1张图片

进程在内核态只能访问内核空间内存,在用户态只能访问用户空间内存。虽然每个进程的地址空间都包含了内核空间,但是这些内核空间都关联了相同的物理内存,而且进程的这么大的地址空间都加起来,必然远大于物理内存。所以,并不是所有的虚拟内存都分配了物理内存,只有那些使用了的虚拟内存会分配物理地址,并且这些虚拟内存和物理内存,是通过内存映射来管理的。内存映射,说白了就是将虚拟内存地址映射到物理内存地址。为了完成映射,内核为每个进程都维护了一张页表,记录虚拟内存地址和物理内存地址的映射关系,如下图:

                                        Linux内存管理的基本原理_第2张图片

页表实际上存储在CPU的内存管理单元的MMU当中,这样,CPU可以直接通过硬件,找出要访问的内存。而当进程访问的虚拟地址在页表中找不到时,系统会产生一个缺页异常,进入内核空间分配物理内存、更新进程页表、再返回用户空间,恢复进程的运行。

前面提过,TLB会影响CPU的内存访问性能。为什么呢?TLB其实是MMU中页表的高速缓存,缓存的是最近使用的数据的页表项,这样可以减少重复的页表查找。由于进程的虚拟地址空间是独立的,而TLB的访问速度远快于MMU,所以减少了进程的上下文切换,可以减少TLB的刷新频率,就可以提高TLB缓存的使用率,进而提高CPU的访问内存的性能。不过要注意,MMU并不以字节为单位来管理内存,而是规定了内存映射的最小单位,也就是页,通常是4KB大小。这样每次内存映射,都需要关联4KB或者4KB整数倍的内存空间。页的大小只有4KB,导致整个页表会非常的大。比如,32位系统就需要100多万个页表项(4GB/4KB),才能实现整个地址空间的映射。为了解决这个问题,Linux提供了两种解决方法,也就是大页(HugePage)和多级页表

Linux正是使用了4级页表来管理内存页,如下图所示,虚拟地址被分为5个部分,前4个表项用于选择页,最后一个索引表示页内偏移。

                                            Linux内存管理的基本原理_第3张图片

再看大页,就是比普通页更大的内存块,常见的有2MB和1GB。大页通常用在使用大量内存的进程上,如DPDK、Oracle等。通过这些机制,在页表的映射下,进程就可以通过虚拟地址访问物理内存了。

2. 虚拟内存

下图展示32位系统虚拟内存的空间分布情况:

                                             Linux内存管理的基本原理_第4张图片

上图可以看出,用户空间内存其实分为几个段:

只读段:包括代码和常量等。

数据段:包括全局变量等。

堆:动态分配内存,从低地址开始向上增长。

文件映射:包括动态库、共享内存等,从高地址向下增长。

栈:包括局部变量、函数调用上下文等。栈的大小固定,一般8MB。

堆和文件映射段的内存是动态分配的,比如说,使用C标准库的malloc() 和 mmap() 就可以分别在他们内分配内存。

对于小块内存(小于128K),C标准库使用 brk() 来分配,通过移动堆顶的位置来分配内存。这些内存不会被释放,而是被缓存起来,可以重复利用。

对于大块内存(大于128K),直接使用内存映射 mmap() 分配,即在文件映射段找一块空闲内存分配出去。

这两种方式各有优缺点:

brk(),可以减少缺页异常的发生,提高内存访问效率。不过,由于这些内存没有归还系统,在内存工作繁忙时,频繁的分配和释放会导致内存碎片。

mmap(),在释放时会直接归还系统,所以每次mmap() 都会发生缺页异常。在内存工作繁忙时,频繁的内存分配会导致大量的缺页异常,使内核的管理负担增大,这也是 malloc 只对大内存使用 mmap的原因。

了解了两种调用方式,还要注意,当两种调用发生后,其实并没有马上分配内存,都只在首次访问时才分配,也就是通过缺页异常进入内核,再由内核来分配。整体来说,Linux使用伙伴系统来管理内存分配。伙伴系统也以页为单位管理内存,并通过相邻页的合并,减少内存碎片化( 比如 brk 造成的内存碎片 )。

在实际系统的运行过程中,还存在大量比页还小的对象,如果为他们也分配单独的页,那就太浪费内存。所以,在用户空间,malloc通过brk() 方式分配的内存,在释放时并不立即归还系统,而是缓存起来准备再利用。在内核空间,Linux则通过slab分配器来管理小内存。你可以把slab看成构建在伙伴系统之上的一个缓存,主要作用是分配并释放内核中小对象。对内存来说,如果只分配不释放,就会造成内存泄漏,甚至耗尽系统内存,所以最终还是要调用free 或 unmap 释放掉不用的内存。

当然系统是不会任由某个进程耗尽所有内存,当发现内存紧张时,系统会通过一系列机制来回收内存。比如通过以下三种方式:

  • 回收缓存,比如使用LRU算法,回收最近最少使用的内存页。
  • 回收不常访问的内存,把不常用的内存通过交换分区写到磁盘中。
  • 杀死进程,内存紧张时系统会通过OOM(Out of Memory),直接杀掉占用大量内存的进程。

其中第二种方式,回收内存时,会用到交换分区,即swap。swap其实就是把一块磁盘空间当内存来使用,把暂时用不到的数据存到磁盘中(换出),当进程访问到这些内存时,再从磁盘读取这些数据到内存中(换入)。不过,通常只会在内存不足的时候,才会发生swap交换,并且由于磁盘读写速度远比内存慢,swap会导致严重的内存性能问题。

第三种方式,其实是内核的一种保护机制。它监控进程的内存使用情况,并且使用oom_score为每个进程的内存使用情况评分。即,进程消耗内存越大,oom_score越大,或者进程占用CPU越多,oom_score越小。也就是,oom_score越大的进程,因为消耗内存越大,越容易被OOM机制杀死。当然,为了实际工作的需要,可以通过/proc文件系统,手动设置进程的oom_adj,从而调整进程的oom_score。oom_adj的范围是 [-17, 15],数值越大,表示进程越容易被OOM杀死,-17表示禁止OOM。比如,用下面命令就可以把sshd进程的oom_adj调小到 -16,这样就不容易被OOM杀死:

echo  -16  > /proc/$(pidof sshd)/oom_adj

3. 查看内存使用

先查看整个系统的内存使用情况:

# 注意不同版本的free输出可能会有所不同
$ free
              total        used        free      shared  buff/cache   available
Mem:        8169348      263524     6875352         668     1030472     7611064
Swap:             0           0           0

free输出包含了物理内存和swap分区的使用情况。

used:已使用内存,包括共享内存。

shared:共享内存。

buff/cache:缓存和缓冲区大小。

available:新进程可用内存大小,包括未使用内存和可回收的缓存。

再看看每个进程的内存使用情况:

# 按下M切换到内存排序
$ top
...
KiB Mem :  8169348 total,  6871440 free,   267096 used,  1030812 buff/cache
KiB Swap:        0 total,        0 free,        0 used.  7607492 avail Mem


  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
  430 root      19  -1  122360  35588  23748 S   0.0  0.4   0:32.17 systemd-journal
 1075 root      20   0  771860  22744  11368 S   0.0  0.3   0:38.89 snapd
 1048 root      20   0  170904  17292   9488 S   0.0  0.2   0:00.24 networkd-dispat
    1 root      20   0   78020   9156   6644 S   0.0  0.1   0:22.92 systemd
12376 azure     20   0   76632   7456   6420 S   0.0  0.1   0:00.01 systemd
12374 root      20   0  107984   7312   6304 S   0.0  0.1   0:00.00 sshd
...

看看跟内存相关的几列数据:

VIRT:进程虚拟内存的大小,只要进程申请过的,即便是没有分配物理内存,也计算在内。

RES:常驻内存大小,也就是实际使用的物理内存大小,不包括 swap 和 共享内存。

SHR:共享内存大小,但不完全是共享内存,比如加载的动态库、程序的代码段等。

%MEM:使用的物理内存占系统总内存的百分比。

4. 解读内存中的 Buffer 和 Cache

# 注意不同版本的free输出可能会有所不同
$ free
              total        used        free      shared  buff/cache   available
Mem:        8169348      263524     6875352         668     1030472     7611064
Swap:             0           0           0

free输出中buff/cache之和代表的是缓存,字面上理解,Buffer是缓冲区,Cache是缓存,两者都是数据在内存中的临时存储。下文中,Buffer 和 Cache都会用英文表示,缓存则通指内存中的临时存储。

首先来查看一下man文档:

buffers
              Memory used by kernel buffers (Buffers in /proc/meminfo)

cache  Memory used by the page cache and slabs (Cached and Slab in /proc/meminfo)

buff/cache
              Sum of buffers and cache

buffers 是内核缓冲区用到的内存,对应的是/proc/meminfo中 Buffers 的值。

cache 是内核页缓存和slab用到的内存,对应的是/proc/meminfo中的 Cached 和 Slab的值之和。

这里只是说明了这些数值的来源是/proc/meminfo,并没说清楚具体含义。

接下来查看man proc  搜索meminfo:

Buffers %lu
                     Relatively  temporary  storage  for raw disk blocks that shouldn't get         
                     tremendously large (20MB or so).
Cached %lu
                     In-memory cache for files read  from  the  disk  (the  page  cache).  
                     Doesn'tinclude SwapCached.
...
Slab %lu
                     In-kernel data structures cache.
SReclaimable %lu (since Linux 2.6.19)
                     Part of Slab, that might be reclaimed, such as caches.
SUnreclaim %lu (since Linux 2.6.19)
                     Part of Slab, that cannot be reclaimed on memory pressure.

Buffers  对原始磁盘块的临时存储,即缓存磁盘的数据,通常不会特别大(20MB左右)。这样,内核就可以把分散的写集中起来,统一优化磁盘的写入,比如多次小的写入合并成单次大的写入。

Cached 从磁盘读取文件的页缓存,即用来缓存从文件读取的数据,这样,下次需要访问这些文件数据时,就可以直接从内存快速获取,不需要从缓慢的磁盘获取。

SReclaimable  是Slab的一部分,表示可回收部分。

SUnreclaim  是Slab的一部分,表示不可回收部分。

这里虽然弄清楚了他们的含义,但是真的就理解了吗?这里提两个问题:

第一个,Buffers 的文档中没有提到是磁盘读数据还是写数据的缓存,网络搜索中说是对写入磁盘数据的缓存,那会不会缓存磁盘读数据呢?

第二个,Cached的文档中说是文件读数据的缓存,那么会不会有写数据的缓存呢?

针对这两个问题,下面使用两个案例说明。

首先,为了减少已有系统缓存的影响,执行下面命令清除系统缓存:

# 清理文件页、目录项、Inodes等各种缓存
$ echo 3 > /proc/sys/vm/drop_caches

场景一、磁盘写和文件写

写文件:

# 每隔1秒输出1组数据
$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
0  0      0 7743608   1112  92168    0    0     0     0   52  152  0  1 100  0  0
 0  0      0 7743608   1112  92168    0    0     0     0   36   92  0  0 100  0  0

使用工具vmstat,输出结果中,重点关注几列:buff、cache、bi、bo。其中,bi、bo分别表示块设备的读取和写入,单位是块/秒,因为Linux中块就是1KB,所以这里等价于 KB/s。

正常情况,空闲系统中这几个值应该都保持不变。在执行以下命令,通过读取随机设备,生成500MB的文件:

$ dd if=/dev/urandom of=/tmp/file bs=1M count=500

然后再观察,vmstat输出结果中buff 和 cache 变化情况:

procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
0  0      0 7499460   1344 230484    0    0     0     0   29  145  0  0 100  0  0
 1  0      0 7338088   1752 390512    0    0   488     0   39  558  0 47 53  0  0
 1  0      0 7158872   1752 568800    0    0     0     4   30  376  1 50 49  0  0
 1  0      0 6980308   1752 747860    0    0     0     0   24  360  0 50 50  0  0
 0  0      0 6977448   1752 752072    0    0     0     0   29  138  0  0 100  0  0
 0  0      0 6977440   1760 752080    0    0     0   152   42  212  0  1 99  1  0
...
 0  1      0 6977216   1768 752104    0    0     4 122880   33  234  0  1 51 49  0
 0  1      0 6977440   1768 752108    0    0     0 10240   38  196  0  0 50 50  0

可以发现,buff基本不变,cache在不停增长,bi只有一次488 KB/s,bo有一次4KB/s,但过一段时间后,才出现大量块设备写,122880KB/s。当dd命令执行结束,cache 停止增长,bo 还会持续一段时间,而且多次bo的结果加起来,才是500MB数据。这个结果和上面的cache定义有区别,上面说的文件读的缓存,这里却是文件写的缓存。

磁盘写:

还是先看看下面磁盘写的案例,再统一分析。下面命令对环境要求高,需要多块磁盘,并且磁盘分区/dev/sdb1还要处于未使用状态。如果你的系统只有一块磁盘,千万不要尝试,否则会造成磁盘分去损坏。

# 首先清理缓存
$ echo 3 > /proc/sys/vm/drop_caches
# 然后运行dd命令向磁盘分区/dev/sdb1写入2G数据
$ dd if=/dev/urandom of=/dev/sdb1 bs=1M count=2048
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
1  0      0 7584780 153592  97436    0    0   684     0   31  423  1 48 50  2  0
 1  0      0 7418580 315384 101668    0    0     0     0   32  144  0 50 50  0  0
 1  0      0 7253664 475844 106208    0    0     0     0   20  137  0 50 50  0  0
 1  0      0 7093352 631800 110520    0    0     0     0   23  223  0 50 50  0  0
 1  1      0 6930056 790520 114980    0    0     0 12804   23  168  0 50 42  9  0
 1  0      0 6757204 949240 119396    0    0     0 183804   24  191  0 53 26 21  0
 1  1      0 6591516 1107960 123840    0    0     0 77316   22  232  0 52 16 33  0

这里发现,磁盘写和文件写的现象还是不同的。写磁盘时,buff 和 cache都在增长,但是buff 增长更快,这说明写磁盘用到大量buffer,这和上面案例之前的解说一致

对比文件写和磁盘写的案例,写文件会用到cache 缓存数据,写磁盘会用到buffer 缓存数据。虽然文档提到cache 只用于读文件,但实际中,写文件也会用到cache 缓存。

场景二、磁盘读 和 文件读案例

读文件:

# 首先清理缓存
$ echo 3 > /proc/sys/vm/drop_caches
# 运行dd命令读取文件数据
$ dd if=/tmp/file of=/dev/null

观察内存和I/O:
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  1      0 7724164   2380 110844    0    0 16576     0   62  360  2  2 76 21  0
 0  1      0 7691544   2380 143472    0    0 32640     0   46  439  1  3 50 46  0
 0  1      0 7658736   2380 176204    0    0 32640     0   54  407  1  4 50 46  0
 0  1      0 7626052   2380 208908    0    0 32640    40   44  422  2  2 50 46  0

观察结果发现,buff不变,而cache逐步增长,与上面解说一致,cache是文件读的页缓存。

读磁盘:

# 首先清理缓存
$ echo 3 > /proc/sys/vm/drop_caches
# 运行dd命令读取文件
$ dd if=/dev/sda1 of=/dev/null bs=1M count=1024


procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
0  0      0 7225880   2716 608184    0    0     0     0   48  159  0  0 100  0  0
 0  1      0 7199420  28644 608228    0    0 25928     0   60  252  0  1 65 35  0
 0  1      0 7167092  60900 608312    0    0 32256     0   54  269  0  1 50 49  0
 0  1      0 7134416  93572 608376    0    0 32672     0   53  253  0  0 51 49  0
 0  1      0 7101484 126320 608480    0    0 32748     0   80  414  0  1 50 49  0

观察结果发现,cache基本不变,而buff增长较快。说明读磁盘,数据缓存在buffer 中。

综合上述两个场景的实验结果:

buffer是对磁盘数据的缓存,cache是对文件数据的缓存,他们机会用在读请求中,也会用在写请求中。

 

 

以上是工作之余的学习总结,因CSDN网站的变态要求,这里不能提供内容来源,敬请谅解。

 

你可能感兴趣的:(Linux性能优化)