【性能】什么是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的内存不足时，需要垮节点访问内存，节点接的访问速度慢。
什么是SMP （对称多处理器）
SMP(Symmetric Multi-Processor)对称多CPU
对称多处理器结构：
1、服务器中多个CPU对称工作，无主次或从属关系。
2、各CPU共享相同的物理内存，每个 CPU访问内存中的任何地址所需时间是相同的。
因此SMP也被称为一致存储器访问结构(UMA：Uniform Memory Access)。
SMP服务器的主要特征是共享，系统中所有资源(CPU、内存、I/O等)都是共享的。也正是由于这种特征，导致了SMP服务器的主要问题，那就是它的扩展能力非常有限。由于每个CPU必须通过相同的内存总线访问相同的内存资源，因此随着CPU数量的增加，内存访问冲突将迅速增加，最终会造成CPU资源的浪费，使 CPU性能的有效性大大降低。
有实验数据表明，SMP型的服务器CPU最好是2-4颗就OK了，多余的就浪费了。
由于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）连接到北桥芯片，然后北桥芯片连接到内存——内存控制器集成在北桥芯片里面。
这种架构被称为 UMA1（Uniform Memory Access, 一致性内存访问 ）：总线模型保证了 CPU 的所有内存访问都是一致的，不必考虑不同内存地址之间的差异。
在 UMA 架构下，CPU 和内存之间的通信全部都要通过前端总线。而提高性能的方式，就是不断地提高 CPU、前端总线和内存的工作频率。
后面的故事，大部分人都很清楚：因为物理条件的限制，不断提高工作频率的路子走不下去了。CPU 性能的提升开始从提高主频转向增加 CPU 数量（多核、多 CPU）。越来越多的 CPU 对前端总线的争用，使前端总线成为了瓶颈。为了消除 UMA 架构的瓶颈，NUMA2（Non-Uniform Memory Access, 非一致性内存访问）架构诞生了：
- CPU 厂商把内存控制器集成到 CPU 内部，一般一个 CPU socket 会有一个独立的内存控制器。
- 每个 CPU scoket 独立连接到一部分内存，这部分 CPU 直连的内存称为“本地内存”。
- 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
- CPU 被分成 node 0 和 node 1 两组（这台机器有两个 CPU Socket）。
- 一组 CPU 分配到 96 GB 的内存（这台机器总共有 192GB 内存）。
- 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 命令还有几个重要选项：
--cpubind=0： 绑定到 node 0 的 CPU 上执行。--membind=1： 只在 node 1 上分配内存。--interleave=nodes：nodes 可以是 all、N,N,N 或 N-N，表示在 nodes 上轮循（round robin）分配内存。--physcpubind=cpus：cpus 是 /proc/cpuinfo 中的 processor（超线程） 字段，cpus 的格式与 --interleave=nodes 一样，表示绑定到 cpus 上运行。--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
参考资料
- UMA（Uniform Memory Access, 一致性内存访问）：https://en.wikipedia.org/wiki/Uniform_memory_access
- NUMA（Non-Uniform Memory Access, 非一致性内存访问）：https://en.wikipedia.org/wiki/Non-uniform_memory_access
- numactl：https://linux.die.net/man/8/numactl
- 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/
- A brief update on NUMA and MySQL：http://blog.jcole.us/2012/04/16/a-brief-update-on-numa-and-mysql/
- NUMA架构的CPU -- 你真的用好了么？：http://cenalulu.github.io/linux/numa/
- Thread and Memory Placement on NUMA Systems: Asymmetry Matters：https://www.usenix.org/conference/atc15/technical-session/presentation/lepers
- NUMA (Non-Uniform Memory Access): An Overview：https://queue.acm.org/detail.cfm?id=2513149
- NUMA Memory Policy：https://www.kernel.org/doc/html/latest/admin-guide/mm/numa_memory_policy.html
- 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)
由于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 494286252other_node过高意味着需要重新规划numa.
旧内容
什么是NUMA(Non-Uniform Memory Access)
NUMA VS. UMA
NUMA(Non-Uniform Memory Access)非均匀内存访问架构是指多处理器系统中，内存的访问时间是依赖于处理器和内存之间的相对位置的。 这种设计里存在和处理器相对近的内存，通常被称作本地内存；还有和处理器相对远的内存， 通常被称为非本地内存。
UMA(Uniform Memory Access)均匀内存访问架构则是与NUMA相反，所以处理器对共享内存的访问距离和时间是相同的。由此可知，不论是NUMA还是UMA都是SMP架构的一种设计和实现上的选择。
NUMA的诞生背景
作者：柴可夫斯猫
链接：https://zhuanlan.zhihu.com/p/67558970
在NUMA出现之前，CPU朝着高频率的方向发展遇到了天花板，转而向着多核心的方向发展。
在一开始，内存控制器还在北桥中，所有CPU对内存的访问都要通过北桥来完成。此时所有CPU访问内存都是“一致的”，如下图所示：
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）进行通信，如下图所示：
什么是SMP
SMP VS. AMP
- SMP(Symmetric Multiprocessing)， 即对称多处理器架构，是目前最常见的多处理器计算机架构。
- AMP(Asymmetric Multiprocessing)， 即非对称多处理器架构，则是与SMP相对的概念。
那么两者之间的主要区别是什么呢？ 总结下来有这么几点，
- SMP的多个处理器都是同构的，使用相同架构的CPU；而AMP的多个处理器则可能是异构的。
- SMP的多个处理器共享同一内存地址空间；而AMP的每个处理器则拥有自己独立的地址空间。
- SMP的多个处理器操通常共享一个操作系统的实例；而AMP的每个处理器可以有或者没有运行操作系统，运行操作系统的CPU也是在运行多个独立的实例。
- SMP的多处理器之间可以通过共享内存来协同通信；而AMP则需要提供一种处理器间的通信机制。
《》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 相同。但是差距比较小。