NUMA体系结构详解

转自：http://blog.csdn.net/ustc_dylan/article/details/45667227

 由于OpenStack Kilo增加很多针对NUMA体系结构的增强功能，所以又重新温习了下NUMA相关的知识，简单做个笔记。

   1. NUMA的几个概念（Node，socket，core，thread）

   对于socket，core和thread会有不少文章介绍，这里简单说一下，具体参见下图：

    一句话总结：socket就是主板上的CPU插槽; Core就是socket里独立的一组程序执行的硬件单元，比如寄存器，计算单元等; Thread：就是超线程hyperthread的概念，逻辑的执行单元，独立的执行上下文，但是共享core内的寄存器和计算单元。

   NUMA体系结构中多了Node的概念，这个概念其实是用来解决core的分组的问题，具体参见下图来理解（图中的OS CPU可以理解thread，那么core就没有在图中画出），从图中可以看出每个Socket里有两个node，共有4个socket，每个socket 2个node，每个node中有8个thread，总共4（Socket）× 2（Node）× 8 （4core × 2 Thread） = 64个thread。

   另外每个node有自己的内部CPU，总线和内存，同时还可以访问其他node内的内存，NUMA的最大的优势就是可以方便的增加CPU的数量，因为Node内有自己内部总线，所以增加CPU数量可以通过增加Node的数目来实现，如果单纯的增加CPU的数量，会对总线造成很大的压力，所以UMA结构不可能支持很多的核。

                                  《此图出自：NUMA Best Practices for Dell PowerEdge 12th Generation Servers》

    根据上面提到的，由于每个node内部有自己的CPU总线和内存，所以如果一个虚拟机的vCPU跨不同的Node的话，就会导致一个node中的CPU去访问另外一个node中的内存的情况，这就导致内存访问延迟的增加。在有些特殊场景下，比如NFV环境中，对性能有比较高的要求，就非常需要同一个虚拟机的vCPU尽量被分配到同一个Node中的pCPU上，所以在OpenStack的Kilo版本中增加了基于NUMA感知的虚拟机调度的特性。（OpenStack Kilo中NFV相关的功能具体参见：《OpenStack Kilo新特性解读和分析（1）》）

2. 如何查看机器的NUMA拓扑结构

   比较常用的命令就是lscpu，具体输出如下：

[python] view plain copy

 

1. dylan@hp3000:~$ lscpu   
2. Architecture:          x86_64  
3. CPU op-mode(s):        32-bit, 64-bit  
4. Byte Order:            Little Endian  
5. CPU(s):                48                                       //共有48个逻辑CPU（threads）  
6. On-line CPU(s) list:   0-47  
7. Thread(s) per core:    2                               //每个core有2个threads  
8. Core(s) per socket:    6                                //每个socket有6个cores  
9. Socket(s):             4                                      //共有4个sockets  
10. NUMA node(s):          4                               //共有4个NUMA nodes  
11. Vendor ID:             GenuineIntel  
12. CPU family:            6  
13. Model:                 45  
14. Stepping:              7  
15. CPU MHz:               1200.000  
16. BogoMIPS:              4790.83  
17. Virtualization:        VT-x  
18. L1d cache:             32K                           //L1 data cache 32k  
19. L1i cache:             32K                            //L1 instruction cache 32k  （牛x机器表现，冯诺依曼+哈弗体系结构）  
20. L2 cache:              256K  
21. L3 cache:              15360K  
22. NUMA node0 CPU(s):     0-5,24-29        
23. NUMA node1 CPU(s):     6-11,30-35  
24. NUMA node2 CPU(s):     12-17,36-41  
25. NUMA node3 CPU(s):     18-23,42-47  

从上图输出，可以看出当前机器有4个sockets，每个sockets包含1个numa node，每个numa node中有6个cores，每个cores包含2个thread，所以总的threads数量=4（sockets）×1（node）×6（cores）×2（threads）=48.

另外，也可以通过下面的脚本来打印出当前机器的socket，core和thread的数量。

[python] view plain copy

 

1. #!/bin/bash  
2.   
3. # Simple print cpu topology  
4. # Author: kodango  
5.   
6. function get_nr_processor()  
7. {  
8.     grep '^processor' /proc/cpuinfo | wc -l  
9. }  
10.   
11. function get_nr_socket()  
12. {  
13.     grep 'physical id' /proc/cpuinfo | awk -F: '{  
14.             print $2 | "sort -un"}' | wc -l  
15. }  
16.   
17. function get_nr_siblings()  
18. {  
19.     grep 'siblings' /proc/cpuinfo | awk -F: '{  
20.             print $2 | "sort -un"}'  
21. }  
22.   
23. function get_nr_cores_of_socket()  
24. {  
25.     grep 'cpu cores' /proc/cpuinfo | awk -F: '{  
26.             print $2 | "sort -un"}'  
27. }  
28.   
29. echo '===== CPU Topology Table ====='  
30. echo  
31.   
32. echo '+--------------+---------+-----------+'  
33. echo '| Processor ID | Core ID | Socket ID |'  
34. echo '+--------------+---------+-----------+'  
35.   
36. while read line; do  
37.     if [ -z "$line" ]; then  
38.         printf '| %-12s | %-7s | %-9s |\n' $p_id $c_id $s_id  
39.         echo '+--------------+---------+-----------+'  
40.         continue  
41.     fi  
42.   
43.     if echo "$line" | grep -q "^processor"; then  
44.         p_id=`echo "$line" | awk -F: '{print $2}' | tr -d ' '`   
45.     fi  
46.   
47.     if echo "$line" | grep -q "^core id"; then  
48.         c_id=`echo "$line" | awk -F: '{print $2}' | tr -d ' '`   
49.     fi  
50.   
51.     if echo "$line" | grep -q "^physical id"; then  
52.         s_id=`echo "$line" | awk -F: '{print $2}' | tr -d ' '`   
53.     fi  
54. done < /proc/cpuinfo  
55.   
56. echo  
57.   
58. awk -F: '{   
59.     if ($1 ~ /processor/) {  
60.         gsub(/ /,"",$2);  
61.         p_id=$2;  
62.     } else if ($1 ~ /physical id/){  
63.         gsub(/ /,"",$2);  
64.         s_id=$2;  
65.         arr[s_id]=arr[s_id] " " p_id  
66.     }  
67. }   
68.   
69. END{  
70.     for (i in arr)   
71.         printf "Socket %s:%s\n", i, arr[i];  
72. }' /proc/cpuinfo  
73.   
74. echo  
75. echo '===== CPU Info Summary ====='  
76. echo  
77.   
78. nr_processor=`get_nr_processor`  
79. echo "Logical processors: $nr_processor"  
80.   
81. nr_socket=`get_nr_socket`  
82. echo "Physical socket: $nr_socket"  
83.   
84. nr_siblings=`get_nr_siblings`  
85. echo "Siblings in one socket: $nr_siblings"  
86.   
87. nr_cores=`get_nr_cores_of_socket`  
88. echo "Cores in one socket: $nr_cores"  
89.   
90. let nr_cores*=nr_socket  
91. echo "Cores in total: $nr_cores"  
92.   
93. if [ "$nr_cores" = "$nr_processor" ]; then  
94.     echo "Hyper-Threading: off"  
95. else  
96.     echo "Hyper-Threading: on"  
97. fi  
98.   
99. echo  
100. echo '===== END ====='