【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP

目录

简略说明

什么是SMP (对称多处理器)

什么是 NUMA?

NUMA 的设置

测试 NUMA

Linux 的 NUMA 策略

附录1 NUMA(Non-Uniform Memory Access)

NUMA(Non-Uniform Memory Access)

关闭NUMA

调优

附录3 调优例子2

旧内容

什么是NUMA(Non-Uniform Memory Access)

NUMA的诞生背景

NUMA构架细节

什么是SMP


简略说明

SMP

就是 对称多处理器 ,就是所有的cpu 必须通过相同的内存总线访问相同的内存资源。所以所有cpu访问内存等资源的速度是一样的,即对称。

缺点:CPU数量的增加,内存访问冲突将迅速增加,最终会造成CPU资源的浪费,使 CPU性能的有效性大大降低

NUMA

将CPU划分到多个Node中,每个node有自己独立的内存空间。各个node之间通过高速互联通讯

CPU访问不同类型节点内存的速度是不相同的,访问本地节点的速度最快,访问远端节点的速度最慢,即访问速度与节点的距离有关,距离越远访问速度越慢,即非一致

缺点:本node的内存不足时,需要垮节点访问内存,节点接的访问速度慢。

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第1张图片

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第2张图片

什么是SMP (对称多处理器)

SMP(Symmetric Multi-Processor)对称多CPU

对称多处理器结构:

1、服务器中多个CPU对称工作,无主次或从属关系。

2、各CPU共享相同的物理内存,每个 CPU访问内存中的任何地址所需时间是相同的。

因此SMP也被称为一致存储器访问结构(UMA:Uniform Memory Access)。

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第3张图片

SMP服务器的主要特征是共享,系统中所有资源(CPU、内存、I/O等)都是共享的。也正是由于这种特征,导致了SMP服务器的主要问题,那就是它的扩展能力非常有限。由于每个CPU必须通过相同的内存总线访问相同的内存资源,因此随着CPU数量的增加,内存访问冲突将迅速增加,最终会造成CPU资源的浪费,使 CPU性能的有效性大大降低。

有实验数据表明,SMP型的服务器CPU最好是2-4颗就OK了,多余的就浪费了。

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第4张图片

由于SMP在扩展能力上的限制,人们开始探究如何进行有效地扩展从而构建大型系统的技术,NUMA就是这种努力下的结果之一。

(摘自:https://blog.csdn.net/qq_21127151/article/details/106822131)

什么是 NUMA?

转自:每个程序员都应该知道的 CPU 知识:https://zhuanlan.zhihu.com/p/336365600

早期的计算机,内存控制器还没有整合进 CPU,所有的内存访问都需要经过北桥芯片来完成。如下图所示,CPU 通过前端总线(FSB,Front Side Bus)连接到北桥芯片,然后北桥芯片连接到内存——内存控制器集成在北桥芯片里面。

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第5张图片

这种架构被称为 UMA1(Uniform Memory Access, 一致性内存访问 ):总线模型保证了 CPU 的所有内存访问都是一致的,不必考虑不同内存地址之间的差异。

在 UMA 架构下,CPU 和内存之间的通信全部都要通过前端总线。而提高性能的方式,就是不断地提高 CPU、前端总线和内存的工作频率。

后面的故事,大部分人都很清楚:因为物理条件的限制,不断提高工作频率的路子走不下去了。CPU 性能的提升开始从提高主频转向增加 CPU 数量(多核、多 CPU)。越来越多的 CPU 对前端总线的争用,使前端总线成为了瓶颈。为了消除 UMA 架构的瓶颈,NUMA2(Non-Uniform Memory Access, 非一致性内存访问)架构诞生了:

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第6张图片

  1. CPU 厂商把内存控制器集成到 CPU 内部,一般一个 CPU socket 会有一个独立的内存控制器。
  2. 每个 CPU scoket 独立连接到一部分内存,这部分 CPU 直连的内存称为“本地内存”。
  3. CPU 之间通过 QPI(Quick Path Interconnect) 总线进行连接。CPU 可以通过 QPI 总线访问不和自己直连的“远程内存”。

和 UMA 架构不同,在 NUMA 架构下,内存的访问出现了本地和远程的区别:访问远程内存的延时会明显高于访问本地内存。

NUMA 的设置

Linux 有一个命令 numactl3 可以查看或设置 NUMA 信息。

  • 执行 numactl --hardware 可以查看硬件对 NUMA 的支持信息:
# numactl --hardware
available: 2 nodes (0-1)
node 0 cpus: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
node 0 size: 96920 MB
node 0 free: 2951 MB
node 1 cpus: 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
node 1 size: 98304 MB
node 1 free: 33 MB
node distances:
node   0   1 
  0:  10  21 
  1:  21  10
  1. CPU 被分成 node 0 和 node 1 两组(这台机器有两个 CPU Socket)。
  2. 一组 CPU 分配到 96 GB 的内存(这台机器总共有 192GB 内存)。
  3. node distances 是一个二维矩阵,node[i][j] 表示 node i 访问 node j 的内存的相对距离。比如 node 0 访问 node 0 的内存的距离是 10,而 node 0 访问 node 1 的内存的距离是 21。
  • 执行 numactl --show 显示当前的 NUMA 设置:
# numactl --show
policy: default
preferred node: current
physcpubind: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 
cpubind: 0 1 
nodebind: 0 1 
membind: 0 1 
  • numactl 命令还有几个重要选项:
  1. --cpubind=0: 绑定到 node 0 的 CPU 上执行。
  2. --membind=1: 只在 node 1 上分配内存。
  3. --interleave=nodes:nodes 可以是 all、N,N,N 或 N-N,表示在 nodes 上轮循(round robin)分配内存。
  4. --physcpubind=cpus:cpus 是 /proc/cpuinfo 中的 processor(超线程) 字段,cpus 的格式与 --interleave=nodes 一样,表示绑定到 cpus 上运行。
  5. --preferred=1: 优先考虑从 node 1 上分配内存。
  • numactl 命令的几个例子:
# 运行 test_program 程序,参数是 argument,绑定到 node 0 的 CPU 和 node 1 的内存
numactl --cpubind=0 --membind=1 test_program arguments

# 在 processor 0-4,8-12 上运行 test_program
numactl --physcpubind=0-4,8-12 test_program arguments

# 轮询分配内存
numactl --interleave=all test_program arguments

# 优先考虑从 node 1 上分配内存
numactl --preferred=1

测试 NUMA

#include 

#include 
#include 
#include 

int main(int argc, char** argv) {
  int size = std::stoi(argv[1]);
  std::vector> data(size, std::vector(size));

  struct timeval b;
  gettimeofday(&b, nullptr);
  # 按列遍历,避免 CPU cache 的影响
  for (int col = 0; col < size; ++col) {
    for (int row = 0; row < size; ++row) {
      data[row][col] = rand();
    }
  }

  struct timeval e;
  gettimeofday(&e, nullptr);

  std::cout << "Use time "
            << e.tv_sec * 1000000 + e.tv_usec - b.tv_sec * 1000000 - b.tv_usec
            << "us" << std::endl;
}

# numactl --cpubind=0 --membind=0 ./numa_test 20000
Use time 16465637us
# numactl --cpubind=0 --membind=1 ./numa_test 20000 
Use time 21402436us

可以看出,测试程序使用远程内存比使用本地内存慢了接近 30%

Linux 的 NUMA 策略

Linux 识别到 NUMA 架构后,默认的内存分配方案是:优先从本地分配内存。如果本地内存不足,优先淘汰本地内存中无用的内存。使内存页尽可能地和调用线程处在同一个 node。

这种默认策略在不需要分配大量内存的应用上一般没什么问题。但是对于数据库这种可能分配超过一个 NUMA node 的内存量的应用来说,可能会引起一些奇怪的性能问题。

下面是在网上看到的的例子:由于 Linux 默认的 NUMA 内存分配策略,导致 MySQL 在内存比较充足的情况下,出现大量内存页被换出,造成性能抖动的问题。

  • The MySQL “swap insanity” problem and the effects of the NUMA architecture4
  • A brief update on NUMA and MySQL5

参考资料

  1. UMA(Uniform Memory Access, 一致性内存访问):https://en.wikipedia.org/wiki/Uniform_memory_access
  2. NUMA(Non-Uniform Memory Access, 非一致性内存访问):https://en.wikipedia.org/wiki/Non-uniform_memory_access
  3. numactl:https://linux.die.net/man/8/numactl
  4. The MySQL “swap insanity” problem and the effects of the NUMA architecture:http://blog.jcole.us/2010/09/28/mysql-swap-insanity-and-the-numa-architecture/
  5. A brief update on NUMA and MySQL:http://blog.jcole.us/2012/04/16/a-brief-update-on-numa-and-mysql/
  6. NUMA架构的CPU -- 你真的用好了么?:http://cenalulu.github.io/linux/numa/
  7. Thread and Memory Placement on NUMA Systems: Asymmetry Matters:https://www.usenix.org/conference/atc15/technical-session/presentation/lepers
  8. NUMA (Non-Uniform Memory Access): An Overview:https://queue.acm.org/detail.cfm?id=2513149
  9. NUMA Memory Policy:https://www.kernel.org/doc/html/latest/admin-guide/mm/numa_memory_policy.html
  10. What is NUMA?:https://www.kernel.org/doc/html/latest/vm/numa.html

发布于 2020-12-12 10:19

附录1 NUMA(Non-Uniform Memory Access)

NUMA(Non-Uniform Memory Access)

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第7张图片

由于SMP在扩展能力上的限制,人们开始探究如何进行有效地扩展从而构建大型系统的技术,NUMA就是这种努力下的结果之一。利用NUMA技术,可以把几十个CPU(甚至上百个CPU)组合在一个服务器内。NUMA服务器的基本特征是具有多个CPU模块,每个CPU模块由多个CPU(如4个)组成,并且具有独立的本地内存、I/O槽口等。

由于其节点之间可以通过互联模块(如称为Crossbar Switch)进行连接和信息交互,因此每个CPU可以访问整个系统的内存(这是NUMA系统与MPP系统的重要差别)。

显然,访问本地内存的速度将远远高于访问远地内存(系统内其它节点的内存)的速度,这也是非一致存储访问NUMA的由来。

由于这个特点,为了更好地发挥系统性能,开发应用程序时需要尽量减少不同CPU模块之间的信息交互。利用NUMA技术,可以较好地解决原来SMP系统的扩展问题,在一个物理服务器内可以支持上百个CPU。比较典型的NUMA服务器的例子包括HP的Superdome、SUN15K、IBMp690等。

每个CPU模块之间都是通过互联模块进行连接和信息交互,CPU都是互通互联的,同时,每个CPU模块平均划分为若干个Chip(不多于4个),每个Chip都有自己的内存控制器及内存插槽。

在NUMA中还有三个节点的概念:

本地节点:对于某个节点中的所有CPU,此节点称为本地节点。

邻居节点:与本地节点相邻的节点称为邻居节点。

远端节点:非本地节点或邻居节点的节点,称为远端节点。

邻居节点和远端节点,都称作非本地节点(Off Node)。

CPU访问不同类型节点内存的速度是不相同的,访问本地节点的速度最快,访问远端节点的速度最慢,即访问速度与节点的距离有关,距离越远访问速度越慢,此距离称作Node Distance。应用程序要尽量的减少不通CPU模块之间的交互,如果应用程序能有方法固定在一个CPU模块里,那么应用的性能将会有很大的提升。

原文链接:Linux numactl命令与多核调优

附录2 numactl相关命令

安装

#yum install numactl -y

验证系统是否支持numa

dmesg | grep -i numa查看输出结果:
如果输出结果为:
No NUMA configuration found
说明numa为disable,如果不是上面的内容说明numa为enable

查看numa状态

# numactl  --show
policy: default
preferred node: current
physcpubind: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
cpubind: 0 1
nodebind: 0 1
membind: 0 1
1234567

列举系统上的NUMA节点

#numactl --hardware  

查看详细内容

# numastat
                           node0           node1
numa_hit              1296554257       918018444
numa_miss                8541758        40297198
numa_foreign            40288595         8550361
interleave_hit             45651           45918
local_node            1231897031       835344122
other_node              64657226        82674322
12345678

说明:

numa_hit—命中的,也就是为这个节点成功分配本地内存访问的内存大小

numa_miss—把内存访问分配到另一个node节点的内存大小,这个值和另一个node的numa_foreign相对应。

numa_foreign–另一个Node访问我的内存大小,与对方node的numa_miss相对应

local_node----这个节点的进程成功在这个节点上分配内存访问的大小

other_node----这个节点的进程 在其它节点上分配的内存访问大小

很明显,miss值和foreign值越高,就要考虑绑定的问题。

关闭NUMA

方法一:通过bios关闭
BIOS:interleave = Disable / Enable
方法二:通过OS关闭
1、编辑 /etc/default/grub 文件,加上:numa=off
GRUB_CMDLINE_LINUX="crashkernel=auto numa=off rd.lvm.lv=centos/root rd.lvm.lv=centos/swap rhgb quiet"
2、重新生成 /etc/grub2.cfg 配置文件:
# grub2-mkconfig -o /etc/grub2.cfg

调优

NUMA的内存分配策略

1. 缺省(default):总是在本地节点分配(分配在当前进程运行的节点上);
2. 绑定(bind):强制分配到指定节点上;
3. 交叉(interleave):在所有节点或者指定的节点上交织分配;
4. 优先(preferred):在指定节点上分配,失败则在其他节点上分配。
因为NUMA默认的内存分配策略是优先在进程所在CPU的本地内存中分配,会导致CPU节点之间内存分配不均衡,当某个CPU节点的内存不足时,会导致swap产生,而不是从远程节点分配内存。这就是所谓的swap insanity 现象。
在实际使用中,可能存在存在不同进程对内存消耗不同,可以考虑按照需求绑定到不同的核上

查看cpu和内存使用情况

# numactl --hardware
available: 2 nodes (0-1)
node 0 cpus: 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
node 0 size: 64337 MB
node 0 free: 1263 MB
node 1 cpus: 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31
node 1 size: 64509 MB
node 1 free: 30530 MB
node distances:
node   0   1
  0:  10  21
  1:  21  10
123456789101112

cpu0 可用 内存  1263 MB
cpu1 可用内存 30530 MB

当cpu0上申请内存超过1263M时必定使用swap,这个是很不合理的。

这里假设我要执行一个java param命令,此命令需要1G内存;一个python param命令,需要8G内存。

最好的优化方案时python在node1中执行,而java在node0中执行,那命令是:

#numactl --cpubind=0 --membind=0 python param
#numactl --cpubind=1 --membind=1 java param

内核参数overcommit_memory

它是 内存分配策略,可选值:0、1、2。

它是 内存分配策略,可选值:0、1、2。

- 0:表示内核将检查是否有足够的可用内存供应用进程使用;如果有足够的可用内存,内存申请允许;否则,内存申请失败,并把错误返回给应用进程。
- 1:表示内核允许分配所有的物理内存,而不管当前的内存状态如何。
- 2:表示内核允许分配超过所有物理内存和交换空间总和的内存

内核参数zone_reclaim_mode:

可选值0、1
当某个节点可用内存不足时:
1、如果为0的话,那么系统会倾向于从其他节点分配内存
2、如果为1的话,那么系统会倾向于从本地节点回收Cache内存多数时候,Cache对性能很重要,所以0是一个更好的选择

mongodb的NUMA问题

mongodb日志显示如下:

mongodb日志显示如下:
WARNING: You are running on a NUMA machine.
We suggest launching mongod like this to avoid performance problems:
numactl –interleave=all mongod [other options]

解决方案,临时修改numa内存分配策略为 interleave=all (在所有node节点进行交织分配的策略):

1.在原启动命令前面加numactl –interleave=all
如# numactl --interleave=all ${MONGODB_HOME}/bin/mongod --config conf/mongodb.conf
2.修改内核参数
echo 0 > /proc/sys/vm/zone_reclaim_mode ; echo "vm.zone_reclaim_mode = 0" >> /etc/sysctl.conf

原文链接:Linux numactl命令与多核调优

附录3 调优例子2

Linux提供了一个一个手工调优的命令numactl(默认不安装),首先你可以通过它查看系统的numa状态:

root@dc-skyeye:/usr/bin# numactl --hardware
available: 2 nodes (0-1)
node 0 cpus: 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
node 0 size: 131037 MB
node 0 free: 3019 MB
node 1 cpus: 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31
node 1 size: 131071 MB
node 1 free: 9799 MB
node distances:
node 0 1
 0: 10 20
 1: 20 10

此系统共有2个node,各领取16个CPU和128G内存。

这里假设我要执行一个java param命令,此命令需要120G内存,一个python param命令,需要16G内存。最好的优化方案时python在node0中执行,而java在node1中执行,那命令是:

# numactl --cpubind=0 --membind=0 python param
# numactl --cpubind=1 --membind=1 java param

当然,也可以自找没趣

# numactl --cpubind=0 --membind=0,1 java param

对于一口气吃掉内存大半的MongoDB,我的配置是:

# numactl --interleave=all mongod -f /etc/mongod.conf

即分配所有的node供其使用,这也是官方推荐的用法。

通过numastat命令可以查看numa状态

# numastat
 node0 node1
numa_hit 1775216830 6808979012
numa_miss 4091495 494235148
numa_foreign 494235148 4091495
interleave_hit 52909 53004
local_node 1775205816 6808927908
other_node 4102509 494286252

other_node过高意味着需要重新规划numa.

旧内容

什么是NUMA(Non-Uniform Memory Access)

NUMA VS. UMA

NUMA(Non-Uniform Memory Access)非均匀内存访问架构是指多处理器系统中,内存的访问时间是依赖于处理器和内存之间的相对位置的。 这种设计里存在和处理器相对近的内存,通常被称作本地内存;还有和处理器相对远的内存, 通常被称为非本地内存

UMA(Uniform Memory Access)均匀内存访问架构则是与NUMA相反,所以处理器对共享内存的访问距离和时间是相同的。由此可知,不论是NUMA还是UMA都是SMP架构的一种设计和实现上的选择。

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第8张图片

NUMA的诞生背景

作者:柴可夫斯猫
链接:https://zhuanlan.zhihu.com/p/67558970
 

在NUMA出现之前,CPU朝着高频率的方向发展遇到了天花板,转而向着多核心的方向发展。

在一开始,内存控制器还在北桥中,所有CPU对内存的访问都要通过北桥来完成。此时所有CPU访问内存都是“一致的”,如下图所示:

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第9张图片

UMA

这样的架构称为UMA(Uniform Memory Access),直译为“统一内存访问”,这样的架构对软件层面来说非常容易,总线模型保证所有的内存访问是一致的,即每个处理器核心共享相同的内存地址空间。但随着CPU核心数的增加,这样的架构难免遇到问题,比如对总线的带宽带来挑战、访问同一块内存的冲突问题。为了解决这些问题,有人搞出了NUMA。

NUMA构架细节

NUMA 全称 Non-Uniform Memory Access,译为“非一致性内存访问”。这种构架下,不同的内存器件和CPU核心从属不同的 Node,每个 Node 都有自己的集成内存控制器(IMC,Integrated Memory Controller)。

在 Node 内部,架构类似SMP,使用 IMC Bus 进行不同核心间的通信;不同的 Node 间通过QPI(Quick Path Interconnect)进行通信,如下图所示:

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第10张图片

什么是SMP

SMP VS. AMP

  • SMP(Symmetric Multiprocessing), 即对称多处理器架构,是目前最常见的多处理器计算机架构。
  • AMP(Asymmetric Multiprocessing), 即非对称多处理器架构,则是与SMP相对的概念。

那么两者之间的主要区别是什么呢? 总结下来有这么几点,

  1. SMP的多个处理器都是同构的,使用相同架构的CPU;而AMP的多个处理器则可能是异构的。
  2. SMP的多个处理器共享同一内存地址空间;而AMP的每个处理器则拥有自己独立的地址空间。
  3. SMP的多个处理器操通常共享一个操作系统的实例;而AMP的每个处理器可以有或者没有运行操作系统,运行操作系统的CPU也是在运行多个独立的实例。
  4. SMP的多处理器之间可以通过共享内存来协同通信;而AMP则需要提供一种处理器间的通信机制。

【性能】什么是NUMA(Non-Uniform Memory Access)|什么是SMP_第11张图片

《》https://houmin.cc/posts/b893097a/NUMA架构详解《》https://houmin.cc/posts/b893097a/ 

numa查看和命令

命令:

yum install numactl

numastat

numactl --hardware

cat  /sys/class/net/enp129s0f0/device/numa_node 

mpstat -P ALL

lscpu

1、centos 安装支持numa命令

yum install numactl

2、验证系统是否支持numa

dmesg | grep -i numa查看输出结果:
如果输出结果为:
No NUMA configuration found
说明numa为disable,如果不是上面的内容说明numa为enable

3、查看numa的状态 numastat

numastat

numa_hit是打算在该节点上分配内存,最后从这个节点分配的次数;

num_miss是打算在该节点分配内存,最后却从其他节点分配的次数;

num_foregin是打算在其他节点分配内存,最后却从这个节点分配的次数;

interleave_hit是采用interleave策略最后从该节点分配的次数;

local_node该节点上的进程在该节点上分配的次数

other_node是其他节点进程在该节点上分配的次数

4、查看numa相关信息,包括每个node内存大小,每个node中的逻辑cpu

numactl --hardware

lscpu命令也可以查看呢cpu和node的关系

5、查看网卡对应的numa node

enp129s0f0是网卡的名字

cat  /sys/class/net/enp129s0f0/device/numa_node 

6、查看cpu负载

mpstat -P ALL(需要安装sysstat)

7、 测试(访问不同节点的内存的IO)(参考linux NUMA技术_未央君x的博客-CSDN博客)

1)  write 测试

# numactl --cpubind=0 --membind=0 dd if=/dev/zero of=/dev/shm/A bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB) copied, 0.823497 s, 1.3 GB/s

# numactl --cpubind=0 --membind=1 dd if=/dev/zero of=/dev/shm/A bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB) copied, 0.936182 s, 1.1 GB/s

明显访问同一节点的内存速度比访问不同节点内存的速度快。

2) read 测试

# numactl --cpubind=0 --membind=0 dd if=/dev/shm/A of=/dev/null  bs=1K count=1024K
1048576+0 records in
1048576+0 records out
1073741824 bytes (1.1 GB) copied, 1.09543 s, 980 MB/s

  # numactl --cpubind=0 --membind=1 dd if=/dev/shm/A of=/dev/null  bs=1K count=1024K
1048576+0 records in
1048576+0 records out
1073741824 bytes (1.1 GB) copied, 1.11862 s, 960 MB/s

结论和write 相同。但是差距比较小。

你可能感兴趣的:(扩展知识,linux,NUMA)