CPU相关的学习

我理解的CPU

目前对cpu的了解停留在这个水平
查看CPU型号：

1
2
cat /proc/cpuinfo |grep model |tail -n 1
model name	: Intel(R) Xeon(R) CPU E5-2620 v2 @ 2.10GHz

查看有多少processor：

1
2
cat /proc/cpuinfo |grep processor|tail -n 1
processor	: 23

然后对性能要求就是主频越高越好，processor越多越好，其它的知道的很少，由于需要做性能相关调优，所以对CPU这一块做一个系统的学习，如果参考网上的一些CEPH性能调优的资料，很多地方都是让关闭numa，以免影响性能，这个从来都是只有人给出答案，至于为什么，对不对，适合不适合你的环境，没有人给出来，没有数据支持的调优都是耍流氓

单核和多核

在英文里面，单核（single-core）和多核（multi-core）多称作uniprocessor和multiprocessor，这里先对这些概念做一个说明：

这里所说的core（或processor），是一个泛指，是从使用者（或消费者）的角度看计算机系统。因此，core，或者processor，或者处理器（CPU），都是逻辑概念，指的是一个可以独立运算、处理的核心。

而这个核心，可以以任何形式存在，例如：单独的一个chip（如通常意义上的单核处理器）；一个chip上集成多个核心（如SMP，symmetric multiprocessing）；一个核心上实现多个hardware context，以支持多线程（如SMT，Simultaneous multithreading）；等等。这是从硬件实现的角度看的。
最后，从操作系统进程调度的角度，又会统一看待这些不同硬件实现的核心，例如上面开始所提及的CPU（24个CPUs，从0编号开始），因为它们都有一个共同的特点：执行进程（或线程）。

NUNA与SMP的概念

NUMA(Non-Uniform Memory Access，非一致性内存访问)和SMP(Symmetric Multi-Processor，对称多处理器系统)是两种不同的CPU硬件体系架构

SMP（Symmetric Multi-Processing）的主要特征是共享，所有的CPU共享使用全部资源，例如内存、总线和I/O，多个CPU对称工作，彼此之间没有主次之分，平等地访问共享的资源，这样势必引入资源的竞争问题，从而导致它的扩展内力非常有限。特别是在现在一台机器CPU核心比较多，内存比较大的情况

NUMA技术将CPU划分成不同的组（Node)，每个Node由多个CPU组成，并且有独立的本地内存、I/O等资源。Node之间通过互联模块连接和沟通，因此除了本地内存外，每个CPU仍可以访问远端Node的内存，只不过效率会比访问本地内存差一些，我们用Node之间的距离（Distance，抽象的概念）来定义各个Node之间互访资源的开销。

本章主要是去做NUMA的相关探索，下图是一个多核系统简单的topology

![coremuti.gif-23.7kB][2]

Node->Socket->Core->Processor(Threads)

如果你只知道CPU这么一个概念，那么是无法理解CPU的拓扑的。事实上，在NUMA架构下，CPU的概念从大到小依次是：Node、Socket、Core、Processor

  • Sockets 可以理解成主板上cpu的插槽数，物理cpu的颗数，一般同一socket上的core共享三级缓存
  • Cores 而Socket中的每个核心被称为Core,常说的核,核有独立的物理资源.比如单独的一级二级缓存什么的
  • Threads 为了进一步提升CPU的处理能力，Intel又引入了HT（Hyper-Threading，超线程)的技术，一个Core打开HT之后，在OS看来就是两个核，当然这个核是逻辑上的概念，所以也被称为Logical Processor,如果不开超线程,threads应该与cores相等,如果开了超线程,threads应该是cores的倍数.相互之间共享物理资源
  • Nodes 上图的多核图中没有涉及， Node是NUMA体系中的概念．由于SMP体系中各个CPU访问内存只能通过单一的通道．导致内存访问成为瓶颈,cpu再多也无用．后来引入了NUMA．通过划分node,每个node有本地RAM,这样node内访问RAM速度会非常快．但跨Node的RAM访问代价会相对高一点，下面看一下两种架构的明显区别

smpnuma.png-67.5kB

由此可以总结这样的逻辑关系(包含):Node > Socket > Core > Thread 区分这几个概念为了了解cache的分布,因为cpu绑定的目的就是提高cache的命中率,降低cpu颠簸.所以了解cache与cpu之间的mapping关系是非常重要的.通常来讲:

  • 同Socket内的cpu共享三级级缓存
  • 每个Core有自己独立的二级缓存
  • 一个Core上超线程出来的Threads,避免绑定，看似可能会提高L2 cache命中率,但也可能有严重的cpu争抢，导致性能非常差.

查看CPU信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@server9 ~]# lscpu 
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                24
On-line CPU(s) list:   0-23
Thread(s) per core:    2
Core(s) per socket:    6
Socket(s):             2
NUMA node(s):          2
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 62
Model name:            Intel(R) Xeon(R) CPU E5-2620 v2 @ 2.10GHz
Stepping:              4
CPU MHz:               1607.894
BogoMIPS:              4205.65
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              256K
L3 cache:              15360K
NUMA node0 CPU(s):     0-5,12-17
NUMA node1 CPU(s):     6-11,18-23

2颗6核双线程，一共是24 processors,也可以看到是NUMA体系，可以使用以下命令详细查看numa信息.非NUMA体系时,所有cpu都划分为一个Node

1
2
3
4
5
6
7
8
9
10
11
12
[root@server9 ~]# numactl --hardware
available: 2 nodes (0-1)
node 0 cpus: 0 1 2 3 4 5 12 13 14 15 16 17
node 0 size: 31880 MB
node 0 free: 19634 MB
node 1 cpus: 6 7 8 9 10 11 18 19 20 21 22 23
node 1 size: 32253 MB
node 1 free: 29315 MB
node distances:
node   0   1 
  0:  10  21 
  1:  21  10

cpu的id不连续的原因是开启了超线程，超线程的cpuid是从新的ID开始计数的，也就是从12开始计数的

两个node，每个node32G内存左右，这台机器我的物理内存是64G

通过命令行查看cpu信息

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
# 获取cpu名称与主频
cat /proc/cpuinfo | grep 'model name'  | cut -f2 -d: | head -n1 | sed 's/^ //'

# 获取逻辑核数
cat /proc/cpuinfo | grep 'model name'  | wc -l

# 获取物理核数
cat /proc/cpuinfo | grep 'physical id' | sort | uniq | wc -l

# 查看cpu的flags
cat /proc/cpuinfo | grep flags | uniq | cut -f2 -d : | sed 's/^ //'

# 是否打开超线程（检查 physical id * cpu cores 与 processor的比例 1:1为未开启）
cat /proc/cpuinfo 

# 查看cache大小,X自省替换
sudo cat /sys/devices/system/cpu/cpuX/cache/indexX/size

# 查看各个cpu之间与cache的mapping
cat /sys/devices/system/cpu/cpuX/cache/indexX/shared_cpu_list

# 获取CPU分布的信息（id-> core信息）（这一个可以看出来CPU0和CPU12在同一个core）
egrep 'processor|core id|physical id' /proc/cpuinfo | cut -d : -f 2 | paste - - -  | awk '{print "CPU"$1"\tsocket "$2" core "$3}'
CPU0	socket 0 core 0
CPU1	socket 0 core 1
CPU2	socket 0 core 2
CPU3	socket 0 core 3
CPU4	socket 0 core 4
CPU5	socket 0 core 5
CPU6	socket 1 core 0
CPU7	socket 1 core 1
CPU8	socket 1 core 2
CPU9	socket 1 core 3
CPU10	socket 1 core 4
CPU11	socket 1 core 5
CPU12	socket 0 core 0
CPU13	socket 0 core 1
CPU14	socket 0 core 2
CPU15	socket 0 core 3
CPU16	socket 0 core 4
CPU17	socket 0 core 5
CPU18	socket 1 core 0
CPU19	socket 1 core 1
CPU20	socket 1 core 2
CPU21	socket 1 core 3
CPU22	socket 1 core 4
CPU23	socket 1 core 5

lscpu,numactl都是读取proc,sys文件系统信息并进行格式化，输出人性化的内容．当没有网络,而lscpu,numactl都没有安装时，只能使用这种命令行方式了

能用工具还是用工具，工具就是解放双手的

Cpu Topology可视化

lstopo 指令由 hwloc 数据包提供，创建了用户的系统示意图。lstopo-no-graphics 指令提供详尽的文本输出
通过lscpu与numactl获取的信息，必要的时候查询了/sys/devices/system/cpu/cpuX/*的数据将正在使用的 Intel(R) Xeon(R) CPU E5-2620 v2 @ 2.10GHz的topology进行可视化
详细的cache信息可以通过sysfs查看

1
2
ls /sys/devices/system/cpu/cpu0/cache/
index0 index1 index2 index3

包含以下4个目录：

  • index0:1级数据cache
  • index1:1级指令cache
  • index2:2级cache
  • index3:3级cache,对应cpuinfo里的cache

目录里的文件是cache信息描述，以本机的cpu0/index0为例简单解释一下：

文件 内容 说明
type Data 数据cache，如果查看index1就是Instruction
Level 1 L1
Size 32K 大小为32K
coherency_line_size 64 644128=32K
physical_line_partition 1
ways_of_associativity 4
number_of_sets 128
shared_cpu_map 00000101 表示这个cache被CPU0和CPU8 share

解释一下shared_cpu_map内容的格式：
表面上看是2进制，其实是16进制表示，每个bit表示一个cpu，1个数字可以表示4个cpu 截取00000101的后4位，转换为2进制表示

|CPU id|15|14|13|12|11|10|9|8|7|6|5|4|3|2|1|0|
| :—: | :—: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: |
|0×0101的2进制表示|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|1|

0101表示cpu8和cpu0，即cpu0的L1 data cache是和cpu8共享的。
也可以使用上面提到的lstopo-no-graphics命令进行查询

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
[root@server9 ~]# lstopo-no-graphics 
Machine (63GB)
  NUMANode L#0 (P#0 31GB)
    Socket L#0 + L3 L#0 (15MB)
      L2 L#0 (256KB) + L1d L#0 (32KB) + L1i L#0 (32KB) + Core L#0
        PU L#0 (P#0)
        PU L#1 (P#12)
      L2 L#1 (256KB) + L1d L#1 (32KB) + L1i L#1 (32KB) + Core L#1
        PU L#2 (P#1)
        PU L#3 (P#13)
      L2 L#2 (256KB) + L1d L#2 (32KB) + L1i L#2 (32KB) + Core L#2
        PU L#4 (P#2)
        PU L#5 (P#14)
      L2 L#3 (256KB) + L1d L#3 (32KB) + L1i L#3 (32KB) + Core L#3
        PU L#6 (P#3)
        PU L#7 (P#15)
      L2 L#4 (256KB) + L1d L#4 (32KB) + L1i L#4 (32KB) + Core L#4
        PU L#8 (P#4)
        PU L#9 (P#16)
      L2 L#5 (256KB) + L1d L#5 (32KB) + L1i L#5 (32KB) + Core L#5
        PU L#10 (P#5)
        PU L#11 (P#17)
    HostBridge L#0
      PCIBridge
        PCI 1000:0086
      PCIBridge
        PCI 8086:1521
          Net L#0 "enp4s0f0"
        PCI 8086:1521
          Net L#1 "enp4s0f1"
        PCI 8086:1521
          Net L#2 "enp4s0f2"
        PCI 8086:1521
          Net L#3 "enp4s0f3"
      PCIBridge
        PCI 8086:10fb
          Net L#4 "enp6s0f0"
        PCI 8086:10fb
          Net L#5 "enp6s0f1"
      PCIBridge
        PCI 8086:1d6b
      PCIBridge
        PCI 102b:0532
          GPU L#6 "card0"
          GPU L#7 "controlD64"
      PCI 8086:1d02
        Block L#8 "sda"
  NUMANode L#1 (P#1 31GB) + Socket L#1 + L3 L#1 (15MB)
    L2 L#6 (256KB) + L1d L#6 (32KB) + L1i L#6 (32KB) + Core L#6
      PU L#12 (P#6)
      PU L#13 (P#18)
    L2 L#7 (256KB) + L1d L#7 (32KB) + L1i L#7 (32KB) + Core L#7
      PU L#14 (P#7)
      PU L#15 (P#19)
    L2 L#8 (256KB) + L1d L#8 (32KB) + L1i L#8 (32KB) + Core L#8
      PU L#16 (P#8)
      PU L#17 (P#20)
    L2 L#9 (256KB) + L1d L#9 (32KB) + L1i L#9 (32KB) + Core L#9
      PU L#18 (P#9)
      PU L#19 (P#21)
    L2 L#10 (256KB) + L1d L#10 (32KB) + L1i L#10 (32KB) + Core L#10
      PU L#20 (P#10)
      PU L#21 (P#22)
    L2 L#11 (256KB) + L1d L#11 (32KB) + L1i L#11 (32KB) + Core L#11
      PU L#22 (P#11)
      PU L#23 (P#23)

这个得到的是文本的拓扑，这个转换成一个图看的要清楚一些
nodesock.png-45.9kB

NUMA分组信息

  • 通过图可以看到cpu为numa架构,且有两个node
  • 将同一socket内的cpu(threads)都划分在一个node中.通过上图也解释了node中cpu序列不连续的问题.因为同一个Core上的两个Threads是超线程出来的.超线程Thread的cpu id在原有的core id基础上增长的
  • 每个node中有32G左右的本地RAM可用

cache信息

  • 每个core都有独立的二级缓存,而不是socket中所有的core共享二级缓存
  • 同node中的cpu共享三级缓存
  • 跨node的内存访问的花费要大些

cpu绑定注意的几点

  • Numa体系中,如果夸node绑定,性能会下降.因为L3 cache命中率低,跨node内存访问代价高.
  • 绑定同Node,同一个Core中的两个超线程出来的cpu,性能会急剧下降.cpu密集型的线程硬件争用严重.”玩转CPU Topology”中也提到了.
  • Numa架构可能引起swap insanity.需要注意

测试CPU绑定性能

这个部分就不在这里赘述了，上面是把cpu比较清晰的剥离出来，至于效果，需要在实际环境当中去验证了，有可能变坏，也有可能变好

本篇参考了很多网络上的很多其他资料