对于CPU和NUMA架构的介绍本文不再做叙述，感兴趣的可自行查看：Linux–CPU简述，Linux–内存管理浅谈。

进程绑定NUMA节点或cpu核心的意义

NUMA 架构将内存和cpu分散在不同的 NUMA 节点上，每个节点都有自己的本地内存和cpu处理器，将进程绑定到特定的 NUMA 节点或cpu上，可以让进程直接访问本地内存和CPU，减少访问远程节点开销，提高访问速度，从而提高程序性能。

注：不可多进程绑定同一个节点或cpu，这样反而会使该节点产生资源竞争，降低性能。

查看NUMA架构的信息

[root@test ~]# yum -y install numactl
[root@test ~]# numactl -H
available: 2 nodes (0-1)    #有两个NUMA节点，编号0,1
node 0 cpus: 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30    #节点0包含的cpu核心编号
node 0 size: 65442 MB       #节点0共有65442MB的内存容量
node 0 free: 5901 MB        #节点0当前有5091MB的内存空闲
node 1 cpus: 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31
node 1 size: 65536 MB
node 1 free: 5133 MB
node distances:            #不同node之间发访问距离(跳数)，如[0,0] 表示node 0的本地内存访问距离为10。跳数(hops)：表示从一个节点到达另一个节点所需的内存访问步骤数，并不是一个精确的时间或距离单位，而是一种相对指标。
node   0   1 
  0:  10  21 
  1:  21  10 
[root@test ~]#

[root@test ~]# lscpu
...
#系统的NUMA节点和 CPU 核心编号的映射
NUMA node0 CPU(s):     0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30
NUMA node1 CPU(s):     1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31
...
[root@test ~]#

[root@test ~]# yum -y install hwloc
[root@test ~]# lstopo-no-graphics 
Machine (128GB total)    　　 #总共有128GB内存
  NUMANode L#0 (P#0 64GB)    #节点 L#0 有64GB内存
    Package L#0 + L3 L#0 (20MB)
      L2 L#0 (256KB) + L1d L#0 (32KB) + L1i L#0 (32KB) + Core L#0
        PU L#0 (P#0)
        PU L#1 (P#16)
      L2 L#1 (256KB) + L1d L#1 (32KB) + L1i L#1 (32KB) + Core L#1
        PU L#2 (P#2)
        PU L#3 (P#18)
      L2 L#2 (256KB) + L1d L#2 (32KB) + L1i L#2 (32KB) + Core L#2
        PU L#4 (P#4)
        PU L#5 (P#20)
      L2 L#3 (256KB) + L1d L#3 (32KB) + L1i L#3 (32KB) + Core L#3
        PU L#6 (P#6)
        PU L#7 (P#22)
      L2 L#4 (256KB) + L1d L#4 (32KB) + L1i L#4 (32KB) + Core L#4
        PU L#8 (P#8)
        PU L#9 (P#24)
      L2 L#5 (256KB) + L1d L#5 (32KB) + L1i L#5 (32KB) + Core L#5
        PU L#10 (P#10)
        PU L#11 (P#26)
      L2 L#6 (256KB) + L1d L#6 (32KB) + L1i L#6 (32KB) + Core L#6
        PU L#12 (P#12)
        PU L#13 (P#28)
      L2 L#7 (256KB) + L1d L#7 (32KB) + L1i L#7 (32KB) + Core L#7
        PU L#14 (P#14)
        PU L#15 (P#30)
    HostBridge L#0
      PCIBridge
        PCI 1000:005d
          Block L#0 "sda"
      PCIBridge
        2 x { PCI 8086:154d }
      PCIBridge
        4 x { PCI 8086:1521 }
      PCI 8086:8d62
      PCIBridge
        PCIBridge
          PCIBridge
            PCIBridge
              PCI 102b:0534
                GPU L#1 "card0"
                GPU L#2 "controlD64"
      PCI 8086:8d02
  NUMANode L#1 (P#1 64GB) + Package L#1 + L3 L#1 (20MB)
    L2 L#8 (256KB) + L1d L#8 (32KB) + L1i L#8 (32KB) + Core L#8
      PU L#16 (P#1)
      PU L#17 (P#17)
    L2 L#9 (256KB) + L1d L#9 (32KB) + L1i L#9 (32KB) + Core L#9
      PU L#18 (P#3)
      PU L#19 (P#19)
    L2 L#10 (256KB) + L1d L#10 (32KB) + L1i L#10 (32KB) + Core L#10
      PU L#20 (P#5)
      PU L#21 (P#21)
    L2 L#11 (256KB) + L1d L#11 (32KB) + L1i L#11 (32KB) + Core L#11
      PU L#22 (P#7)
      PU L#23 (P#23)
    L2 L#12 (256KB) + L1d L#12 (32KB) + L1i L#12 (32KB) + Core L#12
      PU L#24 (P#9)
      PU L#25 (P#25)
    L2 L#13 (256KB) + L1d L#13 (32KB) + L1i L#13 (32KB) + Core L#13
      PU L#26 (P#11)
      PU L#27 (P#27)
    L2 L#14 (256KB) + L1d L#14 (32KB) + L1i L#14 (32KB) + Core L#14
      PU L#28 (P#13)
      PU L#29 (P#29)
    L2 L#15 (256KB) + L1d L#15 (32KB) + L1i L#15 (32KB) + Core L#15
      PU L#30 (P#15)
      PU L#31 (P#31)
[root@test ~]#

绑定

注：下述绑定方法都属于临时绑定，进程重启后失效；要永久生效，请在应用程序中设置绑定或配置文件里提前配置。

绑定NUMA节点

#运行前执行，将进程运行的cpu跟内存绑定到节点0上
numactl --cpunodebind=0 --membind=0 程序名

#接启动命令
numactl --cpunodebind=0 --membind=0 /usr/sbin/nginx

查看进程运行内存信息

[root@test ~]# numastat -p 223736

Per-node process memory usage (in MBs) for PID 223736 (nginx)
                           Node 0          Node 1           Total
                  --------------- --------------- ---------------
Huge                         0.00            0.00            0.00　　#使用的大页内存
Heap                         0.94            0.00            0.94　　#堆内存
Stack                        0.02            0.00            0.02　　#栈内存
Private                      1.17            0.07            1.24　　#其他使用内存
----------------  --------------- --------------- ---------------
Total                        2.13            0.07            2.21

查看进程绑定cpu核心

[root@test ~]# taskset -c -p 223736
pid 223736's current affinity list: 0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30

查看进程的 PID、所运行的 CPU 核心编号以及命令名称

[root@test ~]# ps -o pid,psr,comm -p 223736
   PID PSR COMMAND
223736  22 nginx

绑定cpu核心

#绑定运行在6号cpu上
taskset -c 6 /usr/sbin/nginx

#绑定运行在0-6号cpu上
taskset -c 0,6 /usr/sbin/nginx#绑定到NUMA架构1号节点上numactl --cpubind=1 /usr/sbin/nginxnumactl --cpunodebind=1 /usr/sbin/nginx

查看进程运行在哪个cpu上

[root@test ~]# taskset -c -p 219877
pid 219877's current affinity list: 6

[root@test ~]# ps -o pid,psr,comm -p 219877
   PID PSR COMMAND
219877   6 nginx

References

• NUMA – Proxmox Wiki
• What does enabling NUMA on my VMs actually do?
• 虚拟机绑核 – KunPeng BoostKit
• Linux–进程绑定NUMA节点或CPU核心

什么是 buff/cache？

在 Linux 2.4 的内存管理中，buffer 指 Linux 内存的：Buffer cache。cache 指 Linux 内存中的：Page cache。一般呢，是这么解释两者的。

• A buffer is someting that has yet to be ‘written’ to disk.
• A cache is someting that has been ‘read’ from the disk and stored for later use.

翻译过来就是说：

1. buffer (buff) 是用来缓存尚未 “写入” 磁盘的内容。
2. cache 是用来缓存从磁盘 “读取” 出来的东西。

所以 buffer 被用来当成对 io 设备写的缓存。而 cache 被用来当作对 io 设备的读缓存。这里的 io 设备，主要指的是块设备文件和文件系统上的普通文件。

但是在 Linux 2.6 以后，它们的意义不一样了。

在 Linux 2.6 之后 Linux 将他们统一合并到了 Page cache 作为文件层的缓存。而 buffer 则被用作 block 层的缓存。
block 层的缓存是什么意思呢，你可以认为一个 buffer 是一个 physical disk block 在内存的代表，用来将内存中的 pages 映射为 disk blocks，这部分被使用的内存被叫做 buffer。

buffer 里面的 pages，指的是 Page cache 中的 pages，所以，buffer 也可以被认为 Page cache 的一部分。

或者简单来说，buffer 负责裸设备相关的缓存，cache 负责文件系统的缓存。

Buffer 的具体职责

在当前的系统实现里，buffer 主要是设计用来在系统对块设备进行读写时作为缓存来使用。这意味着对块的操作会使用 buffer 进行缓存，比如我们在格式化文件系统的时候。

但是一般情况下两个缓存系统是一起配合使用的，比如当我们对一个文件进行写操作的时候，cache 的内容会被改变，而 buffer 则用来将 cache 的 page 标记为不同的缓冲区，并记录是哪一个缓冲区被修改了。

这样，内核在后续执行脏数据的回写（writeback）时，就不用将整个 page 写回，而只需要写回修改的部分即可。

Cache 的具体职责

cache 主要用来作为文件系统上的文件数据的缓存来用，当进程对文件有 read/write 操作的时候。包括将文件映射到内存的系统调用 mmap，就会用到 cache。

因为 cache 被作为文件类型的缓存来用，所以事实上也负责了大部分的块设备文件的缓存工作。

怎么回收 buff/cache？

Linux 内核会在内存将要耗尽的时候，自动触发内存回收的工作，以便释放出内存给急需内存的进程使用。

但是这种回收的工作也并不是没有成本。

理解 cache 是干什么的就知道，cache 中存在着一部分 write 操作的数据。所以必须保证 cache 中的数据跟对应文件中的数据一致，才能对 cache 进行释放。

于是伴随着 cache 清除的行为的，一般都是系统 IO 飙高。这是因为内核要将 cache 中缓存的 write 数据进行回写。

我们可以使用下面这个文件来人工触发缓存清除的操作，Linux 提供了三种清空方式：

1. echo 1 > /proc/sys/vm/drop_caches # 仅清除页面缓存
2. echo 2 > /proc/sys/vm/drop_caches # 清除目录项和 inode
3. echo 3 > /proc/sys/vm/drop_caches # 清除页面缓存、目录项以及 inode

但是这种放时只能在执行的当时起作用，过一段时间之后又会发现内存被占满，怎么办呢？

实际上内核提供了 vm.vfs_cache_pressure 参数用来控制缓冲区的回收频率，我们可以调整它。

这个参数是用来控制内核回收 VFS 缓存的频率。修改这个值会提高或者降低回收 VFS 缓存的频率。值可以设置为 0-200 中的任意值。越大回收频率越快，可以把 vm.vfs_cache_pressure 赋值为 200 来获得最快的回收频率。这个值默认值一般为 100。

另外也可以使用 slabtop 分析内存使用情况。一般情况下，dentry 和 *_inode_cache 值越高回收的效果越好。

为什么是 dentry 和 *_inode_cache 呢，这是因为当读写文件时内核会为该文件对象建立一个 dentry，并将其缓存起来，方便下一次读写时直接从内存中取出提高效率。

一些措施

内核参数

可以通过配置 vm.vfs_cache_pressure 参数，控制系统回收 directory entries 和 inode 缓存的倾向程度

Linux Kernel 文档描述如下：

此百分比值控制内核回收用于缓存 directory 和 inode 对象的内存的趋势。 在默认值 vfs_cache_pressure=100 时，内核将尝试以 pagecache 和 swapcache 回收的“公平”速率回收 dentry 和 inode。减小 vfs_cache_pressure 会导致内核更倾向于保留 dentry 和 inode 缓存。当 vfs_cache_pressure=0 时，由于内存压力，内核永远不会回收 dentry 和 inode，这很容易导致内存不足的情况。将 vfs_cache_pressure 增加到 100 以上会导致内核更喜欢回收 dentry 和 inode。 将 vfs_cache_pressure 显著增加到 100 以上可能会对性能产生负面影响。回收代码需要使用各种锁来查找可释放的目录和 inode 对象。当 vfs_cache_pressure=1000 时，它将查找比可用对象多 10 倍的可用对象。

可尝试将该值调整为 200 使得比默认值更积极地回收缓存，要持久化配置 vm.vfs_cache_pressure 为 200，你可以通过以下几种方法：

1. 通过 /etc/sysctl.conf 文件（推荐方法）：

# 使用文本编辑器打开 /etc/sysctl.conf
sudo vim /etc/sysctl.conf

# 添加或修改以下行
vm.vfs_cache_pressure = 200

# 使配置生效
sudo sysctl -p

2. 通过创建 /etc/sysctl.d/ 目录下的配置文件：

# 创建新的配置文件
sudo vim /etc/sysctl.d/99-vfs-cache-pressure.conf

# 添加以下行
vm.vfs_cache_pressure = 200

# 使配置生效
sudo sysctl --system

手动清理

$ sync
$ echo 1 > /proc/sys/vm/drop_caches
$ echo 2 > /proc/sys/vm/drop_caches
$ echo 3 > /proc/sys/vm/drop_caches

自动定时清理

不推荐这么做

1、创建脚本cleanCache.sh

#!/bin/bash#每两小时清除一次缓存
echo "开始清除缓存"
sync;sync;sync #写入硬盘，防止数据丢失
sleep 10#延迟10秒
echo 1 > /proc/sys/vm/drop_caches
echo 2 > /proc/sys/vm/drop_caches
echo 3 > /proc/sys/vm/drop_caches

2、创建定时任务

crontab -e #弹出配置文件

3、添加定时任务执行频率

#分　 时　 日　 月　 周　 命令
0 */2 * * * /usr/local/bin/cleanCache.sh

4、设置crond启动以及开机自启

systemctl start crond.service
systemctl enable crond.service

5、查看定时任务是否被执行

cat /var/log/cron | grep cleanCache

References

• 为什么 Linux buffer/cache 内存占用很高？具体原因以及解决办法
• Linux中buff-cache占用过高解决手段
• vfs_cache_pressure – Linux Kernel Docs

这个看似简单的编辑器为用户提供了许多易于学习和使用的命令。 这款产生自资源极其有限时期的产物，似乎还很有助于理解 vi/vim 和 emacs 的一些设计。

GNU ed 命令是一个行编辑器。它被认为是标准的 Unix 文本编辑器，因为它是首个出现在 Unix 的文本编辑器，并且它曾经无处不在，你在任何一个 POSIX 系统中都能找到它（通常来说，你现在也可以）。在某种程度上，你可以很容易看出来它是第一个文本编辑器，因为它在许多方面的功能都十分基础。和其他大多数的文本编辑器不同，它不会打开一个属于自己的窗口或显示区域，事实上，在默认情况下，它甚至不会提示用户输入文字。从另一个方面来说，它在交互功能上的缺失也可以成为一个优点。它是一个多功能的编辑器，你可以用简短的命令控制它，无论是在交互式的命令行中，还是在编写的 shell 脚本里。

安装 ed

如果你正在使用 Linux 或者 BSD 的话，你很可能已经默认安装了 ed（在 Linux 上是 GNU 版 ed，而在 BSD 上是 BSD 版 ed）。但是，一些极简的环境可能没有包括 ed，这也没关系，你的发行版的软件仓库中很可能有 ed 可供下载。macOS 默认安装了 BSD 版 ed。

# archlinux
$ sudo pacman -S ed

启动 ed

当你启动 ed 的时候，你的终端提示符不见了，看起来好像是 ed 停止运行了。其实它没有，它只是在等待你输入指令而已。

$ ed

为使 ed 显示更详细的信息，你可以输入命令 p 让它返回一个提示符：

$ ed
p
?

这个问号（?）是默认的 ed 提示符。

缓冲区

当 ed 激活时，你其实是在和一个叫 缓冲区buffer 的东西打交道。缓冲区是内存中的一块区域。你并不会直接编辑文件，而是在编辑它对应的缓冲区。当你退出 ed 却没有把修改保存到磁盘的文件上时，所有的修改都会丢失，因为它们只在缓冲区里存在。（这对于一个已经习惯了初始的 草图缓冲区scratch buffer 的资深 Emacs 用户可能很耳熟。）

使用 ed 输入文本

启动 ed 后，你处于命令模式。这意味着你可以向编辑器发送指令，比如让它显示一个提示符，而不是空白区域。你可以使用 a 命令开始附加文本到当前的缓冲区，使用一个实心的点 . 来终止输入。比如，下面的这个例子往缓冲区里附加了两行文字（“hello world” 和 “hello ed”）：

?
a
hello world
hello ed
.

使用点 . 终止输入后，你将回到命令模式。

查看缓冲区

怎样查看当前缓冲区里都有什么呢？你可以输入想要查看的行号，也可以使用 ,p 命令来显示所有的行：

?
1
hello world
2
hello ed
,p
hello world
hello ed

写入文件

如果你现在对文本很满意，你可以使用 w 命令把缓冲区写入到文件中，后面跟上目标文件名：

?
w example.txt
19

写操作后显示的那个数字代表着写入到文件中的字符数。

读取文件

除了使用 ed 来读取文本，你也可以使用 r 命令把一个已经存在的文件加载到到缓冲区里：

?
r myfile.txt

另外，你也可以在启动 ed 时，在它后面加上你想要加载到缓冲区里的文件名：

$ ed myfile.txt

编辑缓冲区

鉴于 ed 是一个文本编辑器，你当然可以使用一种特殊的语法来编辑缓冲区里的文本。使用 sed 或 vim 的用户或许会觉得这个语法很熟悉。假设现在缓冲区里已经加载了一个文件：

$ ed myfile.txt
,p
This is an example document.
There is some text, but not much.
There is some errors, but not much.

如果你要把第一句话中的 document 修改为 file，你可以先选择目标行（1），然后使用 s 命令调用搜索函数，后面跟着搜索文本和替换文本：

?
1
This is an example document.
s/document/file/
1
This is an example file.

如果你要编辑其他行，步骤也是一样的，只需提供一个不同的行号即可：

?
3
There is some errors, but not much.
s/is/are/
s/much/many/

你可以使用 ,p 命令来看到你对缓冲区的历史编辑记录：

This is an example file.
There is some text, but not much.
There are some errors, but not many.

当然，这些修改只存在于缓冲区里。你如果在 ed 编辑器外查看这个文件，你只会看到原始的文本：

$ cat myfile.txt
This is an example document.
There is some text, but not much.
There is some errors, but not much.

如果你要把这些修改保存回文件中，使用 w 命令即可：

w myfile.txt
258

清空缓冲区

如果想要得到一个新的缓冲区，以此来打开一个新的文件，或者把一个新的文件加载到不同的环境中，你可以使用 c 命令。使用这个清空缓冲区后，什么也不会输出，因为缓冲已经是空的了：

c
,p

退出

如果要退出当前的 ed 会话，你可以使用 q 命令。它并不会给你一个保存缓冲区的机会，所以你要确保自己在这之前执行了保存操作。

尝试一下 ed 吧

ed 还可以做到很多事情，学习 ed 可以让你知道它和部分的 vim 是如何工作的。我并没有尝试使用 ed 来写这篇文章，老实说，我也不认为它是通常意义上的最佳文本编辑器。但是，ed 仍然是一个出色的编辑器。通过阅读它的文档，你可以很轻松地学会它。在 GNU 系统上，你可以使用 info ed 来查看它的操作手册。

References

• https://opensource.com/article/20/12/gnu-ed
• 在 Linux 终端上使用行编辑器 ed