# 参数
- -c 统计每一系统调用的所执行的时间,次数和出错的次数等.
- -d 输出strace关于标准错误的调试信息.
- -f 跟踪由fork调用所产生的子进程.
- -ff 如果提供-o filename,则所有进程的跟踪结果输出到相应的filename.pid中,pid是各进程的进程号.
- -F 尝试跟踪vfork调用.在-f时,vfork不被跟踪.
- -h 输出简要的帮助信息.
- -i 输出系统调用的入口指针.
- -q 禁止输出关于脱离的消息.
- -r 打印出相对时间关于,,每一个系统调用.
- -t 在输出中的每一行前加上时间信息.
- -tt 在输出中的每一行前加上时间信息,微秒级.
- -ttt 微秒级输出,以秒了表示时间.
- -T 显示每一调用所耗的时间.
- -v 输出所有的系统调用.一些调用关于环境变量,状态,输入输出等调用由于使用频繁,默认不输出.
- -V 输出strace的版本信息.
- -x 以十六进制形式输出非标准字符串
- -xx 所有字符串以十六进制形式输出.
- -a column 设置返回值的输出位置.默认 为40.
- -e expr 指定一个表达式,用来控制如何跟踪.格式：[qualifier=][!]value1[,value2]...
qualifier只能是 trace,abbrev,verbose,raw,signal,read,write其中之一.value是用来限定的符号或数字.默认的 qualifier是 trace.感叹号是否定符号.例如:-eopen等价于 -e trace=open,表示只跟踪open调用.而-etrace!=open 表示跟踪除了open以外的其他调用.有两个特殊的符号 all 和 none. 注意有些shell使用!来执行历史记录里的命令,所以要使用\\.
- -e trace=set 只跟踪指定的系统 调用.例如:-e trace=open,close,rean,write表示只跟踪这四个系统调用.默认的为set=all.
- -e trace=file 只跟踪有关文件操作的系统调用.
- -e trace=process 只跟踪有关进程控制的系统调用.
- -e trace=network 跟踪与网络有关的所有系统调用.
- -e strace=signal 跟踪所有与系统信号有关的 系统调用
- -e trace=ipc 跟踪所有与进程通讯有关的系统调用
- -e abbrev=set 设定strace输出的系统调用的结果集.-v 等与 abbrev=none.默认为abbrev=all.
- -e raw=set 将指定的系统调用的参数以十六进制显示.
- -e signal=set 指定跟踪的系统信号.默认为all.如 signal=!SIGIO(或者signal=!io),表示不跟踪SIGIO信号.
- -e read=set 输出从指定文件中读出 的数据.例如: -e read=3,5
- -e write=set 输出写入到指定文件中的数据.
- -o filename 将strace的输出写入文件filename
- -p pid 跟踪指定的进程pid.
- -s strsize 指定输出的字符串的最大长度.默认为32.文件名一直全部输出.
- -u username 以username的UID和GID执行被跟踪的命令

# 查看php-fpm master进程的系统调用
```shell
[root@cpc-dev01 work]# strace -p 175664
strace: Process 175664 attached
epoll_wait(11, [], 1, 322)              = 0
epoll_wait(11, [], 1, 333)              = 0
epoll_wait(11, [], 1, 94)               = 0
getsockopt(10, SOL_TCP, TCP_INFO, "\n\0\0\0\0\0\0\0@B\17\0\0\0\0\0\30\2\0\0\0\0\0\0\0\0\0\0\200\0\0\0"..., [104]) = 0
epoll_wait(11, [], 1, 239)              = 0
epoll_wait(11, [], 1, 333)              = 0
epoll_wait(11, [], 1, 333)              = 0
epoll_wait(11, [], 1, 94)               = 0
getsockopt(10, SOL_TCP, TCP_INFO, "\n\0\0\0\0\0\0\0@B\17\0\0\0\0\0\30\2\0\0\0\0\0\0\0\0\0\0\200\0\0\0"..., [104]) = 0
epoll_wait(11, [], 1, 239)              = 0
epoll_wait(11, [], 1, 333)              = 0
epoll_wait(11, [], 1, 269)              = 0
epoll_wait(11, [], 1, 64)               = 0
epoll_wait(11, [], 1, 94)               = 0
getsockopt(10, SOL_TCP, TCP_INFO, "\n\0\0\0\0\0\0\0@B\17\0\0\0\0\0\30\2\0\0\0\0\0\0\0\0\0\0\200\0\0\0"..., [104]) = 0
```

# 统计一下mysql系统调用
```
[root@00h ~]# strace -p 2940 -c
strace: Process 2940 attached
^Cstrace: Process 2940 detached
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 75.28    0.001836        1836         1           poll
 18.00    0.000439         439         1           restart_syscall
  6.40    0.000156          39         4           futex
  0.33    0.000008           4         2           accept
------ ----------- ----------- --------- --------- ----------------
100.00    0.002439                     8           total
```

可以使用strace对应用的系统调用和信号传递的跟踪结果来对应用进行分析

strace,用法,使用,参数


[toc]

# CPU高的原因

负载首先看的是top(htop也可以)，可以定位到是哪个进程（线上服务也不会运行多个服务的）

但是进程是因为什么导致的进程负载高？

- **CPU密集型进程**: 使用大量CPU会导致平均负载高，与平均负载一致
- **I/O密集型**: 等待I/O也会导致平均负载升高，但是CPU使用率不一定很高
- **上下文切换**: 大量的上下文切换也会导致CPU负载变高，此时CPU 使用率也会比较高
  - 进程上下文切换
    - 内核调度（优先级/时间片）
    - 系统资源不足
    - sleep
    - 硬件中断
  - 线程上下文切换
  - 中断上下文切换

# 负载

**单核处理器**

"load average"的值越低，比如等于0.2或0.3，就说明电脑的工作量越小，系统负荷比较轻。

系统负荷为1.0，意味着大桥的所有路段都有车，也就是说大桥已经"满"了。但是必须注意的是，直到此时大桥还是能顺畅通行的

系统负荷为1.7，意味着车辆太多了，大桥已经被占满了（100%），后面等着上桥的车辆为桥面车辆的70%。

CPU的系统负荷，基本上等同于上面的类比。大桥的通行能力，就是CPU的最大工作量；桥梁上的车辆，就是一个个等待CPU处理的进程（process）。

**经验法则**

当系统负荷持续大于0.7，你必须开始调查了，问题出在哪里，防止情况恶化。

当系统负荷持续大于1.0，你必须动手寻找解决办法，把这个值降下来。

当系统负荷达到5.0，就表明你的系统有很严重的问题，长时间没有响应，或者接近死机了。你不应该让系统达到这个值。

**多处理器**

2个CPU表明系统负荷可以达到2.0，此时每个CPU都达到100%的工作量。推广开来，n个CPU的电脑，可接受的系统负荷最大为n.0

## 工具

其他工具用法: [高负载定位的常用工具以及用法分析](./负载高定位工具.md)

### Stress:  (模拟负载高的场景) 

> 详细用法来自： [sparkdev](https://www.cnblogs.com/sparkdev/p/10354947.html)

 - `-v`: verbose 详情

 - `-q`: quiet  程序在运行的过程中不输出信息

 - `-n`: dry-run 演练，并不实际执行

 - `-t`: timeout 超时

 - `-c`: 多少进程计算sqrt(平方根)

 - `-i`: 多少进程调用sync(脏页同步到磁盘)

 - `-m`: 多少进程调用内存malloc/free(内存申请释放)

- `--vm-bytes B`  每个进程总计申请多少字节内存

- `--vm-stride B`  内存赋值时间隔多少字节

  不断的给部分内存赋值，让 COW(Copy On Write)发生。只要指定了内存相关的选项，这个操作就会执行，只是大小为默认的 4096。赋值内存的比例由参数决定：

```
for (i = 0; i < bytes; i += stride)
ptr[i] = 'Z';           /* Ensure that COW happens.  */
```
bytes 为消耗的总内存大小，stride 为间隔。
该参数会影响 CPU 状态 us 和 sy：

- us: 用户空间占用CPU百分比
- sy: 内核空间占用CPU百分比

```
$ stress --vm 2 --vm-bytes 500M --vm-stride 64
$ top
%Cpu(s): 21.3 us, 32.1 sy
```

```
$ stress --vm 2 --vm-bytes 500M --vm-stride 1M
$ top
%Cpu(s):  0.7 us, 36.3 sy
```

- `--vm-stride` 值增大就意味着减少赋值，用户空间占用CPU的比率就小了
- `--vm-hang N`: 每个消耗内存的进程在分配到内存后转入睡眠状态 N 秒，然后释放内存，一直重复执行这个过程, CPU空闲出来了，US就会降低了
- `--vm-keep`: 一直占用内存，区别于不断的释放和重新分配(默认是不断释放并重新分配内存)

```
$ stress --vm 2 --vm-bytes 500M --vm-keep
%Cpu(s): 50.4 us,  0.3 sy

$ stress --vm 2 --vm-bytes 500M --vm-hang 5
%Cpu(s):  1.8 us,  7.8 sy
```

- `-d`: （`--hadd`） 产生 N 个不断执行 write 和 unlink 函数的进程(创建文件，写入内容，删除文件)

  - `--hadd-bytes B`  指定文件大小
  
  ```
  $ stress -d 3 --hdd-bytes 10M
  $ pidstat -d 3
  11时34分30秒   UID       PID   kB_rd/s   kB_wr/s kB_ccwr/s  Command
  11时34分33秒  1000     20879      0.00      1.33      0.00  java
  11时34分33秒     0     23086      0.00 308237.87 309581.40  stress
  11时34分33秒     0     23087      0.00 346640.53 347003.32  stress
  11时34分33秒     0     23088      0.00 329619.93 326591.36  stress
  ```

## 场景一：CPU密集型

```
$ stress -c 1 time 600
$ watch -d uptime

Every 2.0s: uptime
23:39:14 up 10 days, 15:03,  3 users,  load average: 1.17, 0.82, 0.40

$ mpstat -P ALL 5
23时35分39秒  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
23时35分44秒  all   26.35    0.00    1.00    0.00    0.00    0.05    0.00    0.00    0.00   72.60
23时35分44秒    0    0.60    0.00    1.00    0.00    0.00    0.00    0.00    0.00    0.00   98.40
23时35分44秒    1  100.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00
23时35分44秒    2    3.41    0.00    1.41    0.00    0.00    0.00    0.00    0.00    0.00   95.18
23时35分44秒    3    1.21    0.00    1.61    0.00    0.00    0.00    0.00    0.00    0.00   97.18
```

CPU密集型是因为进程进行了大量的运算工作的导致的，通过`mpstat`可以轻松判断出来、

> todo: 如何对代码定位问题

特点:

- `usr` 高，进程一直处于用户态运行
- `sys` 低
- `iowait` 低

## 场景二：I/O 密集型

```
$ stress -i 5 --timeout 600
$ watch -d uptime
Every 2.0s: uptime                                                                                  Sat Aug  8 00:18:56 2020
 00:18:56 up 10 days, 15:43,  3 users,  load average: 0.95, 0.75, 0.43
$ mpstat -P ALL 3
13时42分04秒  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
13时42分07秒  all    2.04    0.00   43.20    1.02    0.00    0.09    0.00    0.00    0.00   53.66
13时42分07秒    0    4.10    0.00   42.66    0.00    0.00    0.00    0.00    0.00    0.00   53.24
13时42分07秒    1    0.68    0.00   43.69    0.34    0.00    0.00    0.00    0.00    0.00   55.29
13时42分07秒    2    2.03    0.00   42.23    0.34    0.00    0.00    0.00    0.00    0.00   55.41
13时42分07秒    3    1.70    0.00   44.22    3.06    0.00    0.00    0.00    0.00    0.00   51.02
$ top
top - 13:49:30 up 12 days,  5:13,  5 users,  load average: 2.07, 1.08, 1.44
Tasks: 169 total,   1 running, 168 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.9 us, 41.4 sy,  0.0 ni, 55.0 id,  0.5 wa,  0.0 hi,  0.1 si,  0.0 st
KiB Mem :  7924044 total,  1278284 free,  5345032 used,  1300728 buff/cache
KiB Swap:  2097148 total,  2095868 free,     1280 used.  2109988 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 3092 root      20   0    7308     96      0 D  28.2  0.0   0:09.30 stress
 3094 root      20   0    7308     96      0 D  27.9  0.0   0:09.37 stress
 3091 root      20   0    7308     96      0 D  27.6  0.0   0:09.36 stress
 3093 root      20   0    7308     96      0 D  27.6  0.0   0:09.31 stress
 3095 root      20   0    7308     96      0 D  26.9  0.0   0:09.35 stress
```

I/O密集型是因为进行了大量的磁盘读写导致的负载高，其实磁盘和内存之间是有 [**页缓存**](./页缓存.md) 来缓冲磁盘和内存速度差异的，

- 低频的读写文件是不会引起`iowait`偏高的，`iowait`高的原因是因为调用 `sync` / `fsync` 频繁的刷新脏页导致iowait过高，此时是处于内核态运行的所以 `sys`也会偏高
- 高频的大量读写文件会直接触发 脏页刷新，`iowait`/`sys`会较高

而上面`sys`较高，`iowait`低的原因，只是因为高频的调用了`sync`，没有脏页（没有高频的写文件）

## 场景三：大量进程的场景

```
$ stress -c 8 
$ watch -d uptime
Every 2.0s: uptime                                                                                                                Sun Aug  9 13:19:04 2020

 13:19:05 up 12 days,  4:43,  5 users,  load average: 7.44, 3.23, 1.30
$ mpstat -P ALL 3
14时32分28秒  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
14时32分31秒  all   99.42    0.00    0.58    0.00    0.00    0.00    0.00    0.00    0.00    0.00
14时32分31秒    0   99.67    0.00    0.33    0.00    0.00    0.00    0.00    0.00    0.00    0.00
14时32分31秒    1   98.00    0.00    2.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00
14时32分31秒    2   99.67    0.00    0.33    0.00    0.00    0.00    0.00    0.00    0.00    0.00
14时32分31秒    3  100.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00
$ pidstat -u 3
14时32分56秒   UID       PID    %usr %system  %guest    %CPU   CPU  Command
14时32分59秒     0     19290    0.00    0.33    0.00    0.33     3  mpstat
14时32分59秒     0     19450    0.33    1.33    0.00    1.67     0  pidstat
14时32分59秒     0     19491   48.67    0.00    0.00   48.67     3  stress
14时32分59秒     0     19492   49.33    0.00    0.00   49.33     1  stress
14时32分59秒     0     19493   48.67    0.00    0.00   48.67     3  stress
14时32分59秒     0     19494   48.67    0.00    0.00   48.67     0  stress
14时32分59秒     0     19495   50.33    0.00    0.00   50.33     2  stress
14时32分59秒     0     19496   48.67    0.00    0.00   48.67     0  stress
14时32分59秒     0     19497   49.33    0.00    0.00   49.33     2  stress
14时32分59秒     0     19498   49.33    0.33    0.00   49.67     1  stress
$ vmstat 3
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 8  0   1280 1271004    148 1301392    0    0     0     1    5    1  2  1 97  0  0
 8  0   1280 1271000    148 1301380    0    0     0     3 4414 1760 98  2  0  0  0
 8  0   1280 1267432    148 1301368    0    0     0     0 4370 1636 98  2  0  0  0
```

系统是4H8G

- mpstat的4个CPU `usr` 一直是100%
- pidstat的8个stress进程，各占用每个CPU的50%
- vmstat的 `r` 正在运行的进程队列是 8



## 场景四：大量的上下文切换

使用sysbench模拟大量的线程

```
$ sysbench --threads=10 --time=10 threads run
```

```
top - 09:18:26 up 14 days, 42 min,  2 users,  load average: 2.58, 0.66, 1.30
Tasks: 161 total,   1 running, 160 sleeping,   0 stopped,   0 zombie
%Cpu(s): 16.2 us, 76.0 sy,  0.0 ni,  7.8 id,  0.0 wa,  0.0 hi,  0.1 si,  0.0 st
KiB Mem :  7924044 total,  1689024 free,  5740484 used,   494536 buff/cache
KiB Swap:  2097148 total,  1800444 free,   296704 used.  1734212 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 7640 root      20   0   95116   3972   2824 S 351.5  0.1   1:41.20 sysbench
```

- 负载高
- sy 内核态CPU高
- sysbench 进程

```
$ vmstat -S M 3
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 6  0    289   1649      0    482    0    0     1     3    8    1  2  1 97  0  0
 7  0    289   1649      0    482    0    0     0     1 23407 347642 14 76  9  0  0
 7  0    289   1648      0    482    0    0     0     0 21909 339189 16 76  8  0  0
 7  0    289   1649      0    482    0    0     0     0 23330 344468 16 75  9  0  0
```

- r: 运行队列高
- in：中断高
- cs：上下文切换次数高

```
$ pidstat -p 7640 -wt 3
09时21分22秒   UID      TGID       TID   cswch/s nvcswch/s  Command
09时21分25秒     0      7640         -      0.00      0.00  sysbench
09时21分25秒     0         -      7640      0.00      0.00  |__sysbench
09时21分25秒     0         -      7641   8870.00  23660.33  |__sysbench
09时21分25秒     0         -      7642  10428.00  20367.67  |__sysbench
09时21分25秒     0         -      7643  10766.67  19406.67  |__sysbench
09时21分25秒     0         -      7644  10391.67  18603.00  |__sysbench
09时21分25秒     0         -      7645  10480.00  21960.33  |__sysbench
09时21分25秒     0         -      7646  10012.67  18224.00  |__sysbench
09时21分25秒     0         -      7647   9655.00  18724.33  |__sysbench
09时21分25秒     0         -      7648  10216.33  20583.00  |__sysbench
09时21分25秒     0         -      7649  10317.67  20421.00  |__sysbench
09时21分25秒     0         -      7650  10450.67  20246.67  |__sysbench
```

通过top知道负载高的原因

- 内核态的运行导致

vmstat定位负载高的原因：

- 上下文切换高导致
- 中断导致
- 运行队列有等待运行进程

pidstat定位负载高的原因：

- 可以看到sysbench 出来很多的子线程

# 负载与参数

分析

- CPU使用率高，如何定位进程和是进程的哪个函数导致的？

## CPU使用率高，如何定位进程和是进程的哪个函数导致的？

CPU使用率高定位是哪个进程，我们可以使用的工具有：

- top/htop
- pidstat
- ps

如何定位是进程的哪个函数导致的？







借助stress、iostat、mpstat、pidstat定位负载高的进程

服务器CPU高问题排查思路


# 安装
```
yum install sysstat
```

# 实例1：显示所有设备负载情况
```
iostat

Linux 2.6.32-754.2.1.el6.x86_64 (iZ2zej76z8h545jaqmtldsZ) 	2019年01月20日 	_x86_64_	(4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
          16.00    0.00    4.59    0.03    0.00   79.37

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
vda              13.70         0.66       241.78    5414754 1984862152
vdb               0.00         0.00         0.00       1440          0
```

cpu属性值说明：
- %user：CPU处在用户模式下的时间百分比。
- %nice：CPU处在带NICE值的用户模式下的时间百分比。
- %system：CPU处在系统模式下的时间百分比。
- %iowait：CPU等待输入输出完成时间的百分比。
- %steal：管理程序维护另一个虚拟处理器时，虚拟CPU的无意识等待时间百分比。
- %idle：CPU空闲时间百分比。
> 注：如果%iowait的值过高，表示硬盘存在I/O瓶颈，%idle值高，表示CPU较空闲，如果%idle值高但系统响应慢时，有可能是CPU等待分配内存，此时应加大内存容量。%idle值如果持续低于10，那么系统的CPU处理能力相对较低，表明系统中最需要解决的资源是CPU。

disk属性值说明：
rrqm/s: 每秒进行 merge 的读操作数目。即 rmerge/s
wrqm/s: 每秒进行 merge 的写操作数目。即 wmerge/s
r/s: 每秒完成的读 I/O 设备次数。即 rio/s
w/s: 每秒完成的写 I/O 设备次数。即 wio/s
rsec/s: 每秒读扇区数。即 rsect/s
wsec/s: 每秒写扇区数。即 wsect/s
rkB/s: 每秒读K字节数。是 rsect/s 的一半，因为每扇区大小为512字节。
wkB/s: 每秒写K字节数。是 wsect/s 的一半。
avgrq-sz: 平均每次设备I/O操作的数据大小 (扇区)。
avgqu-sz: 平均I/O队列长度。
await: 平均每次设备I/O操作的等待时间 (毫秒)。
svctm: 平均每次设备I/O操作的服务时间 (毫秒)。
%util: 一秒中有百分之多少的时间用于 I/O 操作，即被io消耗的cpu百分比
备注：如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；如果 await 远大于 svctm，说明I/O 队列太长，io响应太慢，则需要进行必要优化。如果avgqu-sz比较大，也表示有当量io在等待。

# 实例2：定时显示所有信息
```
iostat 2 3
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
10.81    0.00   14.11    0.18    0.00   74.90

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               1.95         1.48        70.88    9145160  437106156
dm-0              3.08         0.55        24.34    3392770  150088376
dm-1              5.83         0.93        46.49    5714522  286728384
dm-2              0.01         0.00         0.05      23930     289288

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
22.62    0.00   19.67    0.26    0.00   57.46

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               2.50         0.00        28.00          0         56
dm-0              0.00         0.00         0.00          0          0
dm-1              3.50         0.00        28.00          0         56
dm-2              0.00         0.00         0.00          0          0

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
22.69    0.00   19.62    0.00    0.00   57.69

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.00         0.00         0.00          0          0
dm-0              0.00         0.00         0.00          0          0
dm-1              0.00         0.00         0.00          0          0
dm-2              0.00         0.00         0.00          0          0
说明：每隔 2秒刷新显示，且显示3次
```

# 实例3：查看TPS和吞吐量
```
iostat -d -k 1 1
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda               1.95         0.74        35.44    4572712  218559410
dm-0              3.08         0.28        12.17    1696513   75045968
dm-1              5.83         0.46        23.25    2857265  143368744
dm-2              0.01         0.00         0.02      11965     144644
```
- tps：该设备每秒的传输次数（Indicate the number of transfers per second that were issued to the device.）。“一次传输”意思是“一次I/O请求”。多个逻辑请求可能会被合并为“一次I/O请求”。“一次传输”请求的大小是未知的。
- kB_read/s：每秒从设备（drive expressed）读取的数据量；
- kB_wrtn/s：每秒向设备（drive expressed）写入的数据量；
- kB_read：读取的总数据量；kB_wrtn：写入的总数量数据量；
这些单位都为Kilobytes。

上面的例子中，我们可以看到磁盘sda以及它的各个分区的统计数据，当时统计的磁盘总TPS是1.95，下面是各个分区的TPS。（因为是瞬间值，所以总TPS并不严格等于各个分区TPS的总和）

## 实例4：查看设备使用率（%util）和响应时间（await）
```
iostat -dx 5 
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sda               0.02     7.25    0.04    1.90     0.74    35.47    37.15     0.04   19.13   5.58   1.09
dm-0              0.00     0.00    0.04    3.05     0.28    12.18     8.07     0.65  209.01   1.11   0.34
dm-1              0.00     0.00    0.02    5.82     0.46    23.26     8.13     0.43   74.33   1.30   0.76
dm-2              0.00     0.00    0.00    0.01     0.00     0.02     8.00     0.00    5.41   3.28   0.00
```
- rrqm/s： 每秒进行 merge 的读操作数目.即 delta(rmerge)/s
- wrqm/s： 每秒进行 merge 的写操作数目.即 delta(wmerge)/s
- r/s： 每秒完成的读 I/O 设备次数.即 delta(rio)/s
- w/s： 每秒完成的写 I/O 设备次数.即 delta(wio)/s
- rsec/s： 每秒读扇区数.即 delta(rsect)/s
- wsec/s： 每秒写扇区数.即 delta(wsect)/s
- rkB/s： 每秒读K字节数.是 rsect/s 的一半,因为每扇区大小为512字节.(需要计算)
- wkB/s： 每秒写K字节数.是 wsect/s 的一半.(需要计算)
- avgrq-sz：平均每次设备I/O操作的数据大小 (扇区).delta(rsect+wsect)/delta(rio+wio)
- avgqu-sz：平均I/O队列长度.即 delta(aveq)/s/1000 (因为aveq的单位为毫秒).
- await： 平均每次设备I/O操作的等待时间 (毫秒).即 delta(ruse+wuse)/delta(rio+wio)
- svctm： 平均每次设备I/O操作的服务时间 (毫秒).即 delta(use)/delta(rio+wio)
- %util： 一秒中有百分之多少的时间用于 I/O 操作,或者说一秒中有多少时间 I/O 队列是非空的，即 delta(use)/s/1000 (因为use的单位为毫秒)
> 如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。 idle小于70% IO压力就较大了，一般读取速度有较多的wait。 同时可以结合vmstat 查看查看b参数(等待资源的进程数)和wa参数(IO等待所占用的CPU时间的百分比，高过30%时IO压力高)。

另外 await 的参数也要多和 svctm 来参考。差的过高就一定有 IO 的问题。

avgqu-sz 也是个做 IO 调优时需要注意的地方，这个就是直接每次操作的数据的大小，如果次数多，但数据拿的小的话，其实 IO 也会很小。如果数据拿的大，才IO 的数据会高。也可以通过 avgqu-sz × ( r/s or w/s ) = rsec/s or wsec/s。也就是讲，读定速度是这个来决定的。

svctm 一般要小于 await (因为同时等待的请求的等待时间被重复计算了)，svctm 的大小一般和磁盘性能有关，CPU/内存的负荷也会对其有影响，请求过多也会间接导致 svctm 的增加。await 的大小一般取决于服务时间(svctm) 以及 I/O 队列的长度和 I/O 请求的发出模式。如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；如果 await 远大于 svctm，说明 I/O 队列太长，应用得到的响应时间变慢，如果响应时间超过了用户可以容许的范围，这时可以考虑更换更快的磁盘，调整内核 elevator 算法，优化应用，或者升级 CPU。

队列长度(avgqu-sz)也可作为衡量系统 I/O 负荷的指标，但由于 avgqu-sz 是按照单位时间的平均值，所以不能反映瞬间的 I/O 洪水。

形象的比喻：
- r/s+w/s 类似于交款人的总数
- 平均队列长度(avgqu-sz)类似于单位时间里平均排队人的个数
- 平均服务时间(svctm)类似于收银员的收款速度
- 平均等待时间(await)类似于平均每人的等待时间
- 平均I/O数据(avgrq-sz)类似于平均每人所买的东西多少
- I/O 操作率 (%util)类似于收款台前有人排队的时间比例
- 设备IO操作:总IO(io)/s = r/s(读) +w/s(写)

平均等待时间=单个I/O服务器时间*(1+2+...+请求总数-1)/请求总数

每秒发出的I/0请求很多,但是平均队列就4,表示这些请求比较均匀,大部分处理还是比较及时。

iostat文档


```
vmstat 5

procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0      0 966440 215852 1476524    0    0     0    30    1    1 16  5 79  0  0
 0  0      0 964680 215852 1476520    0    0     0    86 1869 1031  7  2 91  0  0
 0  0      0 964184 215852 1476560    0    0     0   266 1399  914  5  1 94  0  0
 5  0      0 963440 215852 1476496    0    0     0   105 2439 1284 12  3 85  0  0
 0  0      0 965920 215852 1476528    0    0     0    69 2468 1322 15  6 79  0  0
 0  0      0 964904 215852 1476620    0    0     0    64 2121 1169  9  1 90  0  0
 0  0      0 965176 215852 1476656    0    0     0   117 4030 1761 23  6 71  0  0
 2  0      0 965424 215852 1476700    0    0     0    94 3611 1679 22  8 70  0  0
```

procs: 
- `r` 代表多少进程正在等待cpu*, 
- `b`显示多少进程在不可中断的休眠(通常意味在等待系统io eg. 磁盘，网络，用户输入等)

memory: 
- swapd: 显示多少块被换出到了磁盘(页面交换)
- free: 多少块是空闲，未被使用
- buffer: 多少被用作缓冲
- cache: 多少被用作操作系统的缓存

swap:显示页面交换活动，每秒有多少块正在被换入(从磁盘)和换出(到磁盘)
- si
- so

io: 显示有多少块从磁盘读取(io)和写出(bo),反映了磁盘io

system: 显示了每秒中断(in)和上下文切换(cs)的数量

cpu: 显示cpu时间花费在各类操作的百分比，包括执行用户代码(非内核)，执行系统代码(内核)，空闲，以及等待I/O

> linux块的大小是1024字节

vmstat.md


[toc]

# top(系统正在执行的进程的相关信息)

top是我定位问题的想到的第一个命令，用的最多的命令

```
top - 13:49:30 up 12 days,  5:13,  5 users,  load average: 2.07, 1.08, 1.44
Tasks: 169 total,   1 running, 168 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.9 us, 41.4 sy,  0.0 ni, 55.0 id,  0.5 wa,  0.0 hi,  0.1 si,  0.0 st
KiB Mem :  7924044 total,  1278284 free,  5345032 used,  1300728 buff/cache
KiB Swap:  2097148 total,  2095868 free,     1280 used.  2109988 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 3092 root      20   0    7308     96      0 D  28.2  0.0   0:09.30 stress
 3094 root      20   0    7308     96      0 D  27.9  0.0   0:09.37 stress
 3091 root      20   0    7308     96      0 D  27.6  0.0   0:09.36 stress
 3093 root      20   0    7308     96      0 D  27.6  0.0   0:09.31 stress
 3095 root      20   0    7308     96      0 D  26.9  0.0   0:09.35 stress
```

第一行：(同uptime显示的信息) 系统时间、当前登录用户数，负载均衡：1分钟 5分钟 15分钟

第二行：进程统计数据

- total: 进程数
- running：运行进程数
- slepping：处于休眠状态的进程数
- stopped：停止的进程数
- zombie：僵尸进程数

第三行: CPU统计数据，百分比

- us：用户态占比
- sy：内核态占比
- ni：改变过优先级的进程占用CPU的百分比
- id：空闲占比
- wa：io等待占比
- hi：软中断
- si：硬中断

> 显示每个CPU的运行情况，按 1

第四行/第五行：内存的统计数据

- total：总内存
- free：空闲内存
- used：使用中的内存
- buff：用作内核缓冲区的内存

表格各字段含义：

| PID    | USER     | PR                 | NI  |VIRT| RES |SHR|
| ------ | -------- | ------------------ | ---- |---| ---|---|
| 进程号 | 运行用户 | 优先级，越小越优先 |      |虚拟内存| 物理内存 |共享内存|

---

| SHR      | S        | %CPU |%MEM|TIME+|COMMAND|
| -------- | -------- | ---- |---|---|---|
| 共享内存 | 进程状态 | CPU使用百分比 |内存使用百分比|占用CPU使用时间的累加值|运行命令|

进程状态:

- R:(Running) 运行状态
- D:(uninterruptible slepp) 不可中断睡眠状态，等待IO资源时会出现
- S:(Sleep) 睡眠状态
- T:(Stop) 终止状态，调试会进入终止状态
- Z:(Zombie) 僵尸进程

top命令操作指令:

- c: 显示完全命令
- P: CPU使用率排序
- M: 内存使用率排序
- T: 按占用CPU的总时间排序
- R: 高亮正在运行的程序
- q: 退出


# mpstat: (单个CPU维度的统计数据)

- `-P`: 指定CPU编号
  - `ALL`: 全部CPU

```
$ mpstat -P ALL 2 5
```

显示所有的进程，每2秒显示一次

# pidstat: (进程线程级别的统计数据)

sysstat工具的一个命令, 监控全部或指定进程的CPU、内存、线程、设备IO等系统资源的占用情况,`pidstat`首次运行时显示自系统启动开始的各项统计信息，之后运行`pidstat`将显示自上次运行该命令以后的统计信息

- `-C`: 正则匹配 启动命令 关键字

- `-l`: 显示 命令详情，包括启动参数

- `-p`: 指定进程号
  - `SELF`: 直显示pidstat的统计数据
  - `ALL`: 显示所有进程的统计数据

- `-r`: 内存统计数据

  ```
  $ pidstat -r -l 3
  平均时间:   UID       PID  minflt/s  majflt/s     VSZ    RSS   %MEM  Command
  平均时间:     0         1      4.07      0.00  191024   4068   0.05  /usr/lib/systemd/systemd --switched-root --system --deserialize 22
  平均时间:     0       780      1.44      0.00   21656   1224   0.02  /usr/sbin/irqbalance --foreground
  平均时间:     0       913      0.07      0.00  714272  18072   0.23  /data/frp/frp_0.33.0_linux_amd64/frpc -c /data/frp/frp_0.33.0_linux_amd64/frpc.ini
  平均时间:     0      1784      0.00      0.00 1621172  48480   0.61  /usr/bin/dockerd-current --add-runtime docker-runc=/usr/libexec/docker/docker-runc-current --default-runtime=docker-runc --exec
  平均时间:  1000     20879      5.96      0.00 8038196 4665088  58.87  /usr/share/elasticsearch/jdk/bin/java -Des.networkaddress.cache.ttl=60 -Des.networkaddress.cache.negative.ttl=10 -XX:+AlwaysPre
  平均时间:  1000     21111    111.54      0.00 1735056 361671   4.56  /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli --cpu.cgroup.path.override=/ --cpuacct.cgroup.path.over
  平均时间:     0     26952     69.29      0.00  108356   1223   0.02  pidstat -r -l 3
  平均时间:     0     28871      0.04      0.00  160888   5812   0.07  sshd: root@pts/0,pts/1,pts/2,pts/4
  ```

- `-s`: 堆栈利用率

  - `StkSize`: 预留内存，但是未使用
  - `StkRef`: 已经使用的内存

- `-d`:  I/O 的统计数据

  ```
  $ pidstat -d 3
  11时34分30秒   UID       PID   kB_rd/s   kB_wr/s kB_ccwr/s  Command
  11时34分33秒  1000     20879      0.00      1.33      0.00  java
  11时34分33秒     0     23086      0.00 308237.87 309581.40  stress
  11时34分33秒     0     23087      0.00 346640.53 347003.32  stress
  11时34分33秒     0     23088      0.00 329619.93 326591.36  stress
  ```

  - `kB_rd/s` : 每秒读磁盘
  - `KB_wr/s`:  每秒写磁盘
  - `KB_ccwr/s`: 脏页刷新数

- `-T`: 是否显示子进程/子线程

  - `TASK`: 不显示子进程/子线程
  - `CHILD`: 显示指定进程和其子进程/子线程
  - `ALL`: 显示所有进程和其子进程/子线程

- `-w`: 上下文切换统计数据

  - `cswch/s` : 每秒自愿上下文切换次数
  - `nvcswch/s`: 每秒非自愿上下文切换次数

- `-t`: 显示子线程

  - 显示进程号(TGID)和线程号(TID)

- `-u`: CPU统计数据

- `-U`: 指定用户

# vmstat: (虚拟内存状态)

`-S` :  k, K, m or M 显示单位，默认kb

```
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0   1280 1247128    148 1326668    0    0     0     1    1    7  2  1 97  0  0
 0  0   1280 1247440    148 1326664    0    0     0     0  821 1592  2  1 97  0  0
 0  0   1280 1247316    148 1326664    0    0     0     7  342  396  2  0 98  0  0
 0  0   1280 1248076    148 1326660    0    0     0     0  869 1462  3  1 96  0  0
```

procs (进程)

- r：运行队列中进程数量
- b: 等待IO的进程数量

memory(内存)

- swpd: 虚拟内存大小
- free：空闲物理内存大小
- buffer 缓冲区的内存大小
- cache 缓存的内存大小

swap

- si：从磁盘写入内存的大小
- so：从内存到磁盘的大小

io（每块1KB）

- bi：每秒读取的块数
- bo：每秒写入的块数

system

- in：每秒中断次数
- cs：没秒上下文切换的次数

CPU：

- us：用户态百分比
- sy：内核态百分比
- id：空闲百分比
- wa：等待io的百分比

# sysbench 基础测试工具

1. cpu性能
2. 磁盘IO性能
3. 调度程序性能
4. 内存分配及传输速度
5. POSIX线程性能
6. 数据库性能

使用姿势：

```
sysbench [options]... [testname] [command]
```

options：

- --threads: 线程数
- --time： 运行时间 秒
- --thread-stack-size： 每个线程堆栈大小

testname:

- fileio: 磁盘io性能
- cpu： cpu性能
- memory:  内存分配及传输速度
- threads：posix线程性能
- mutex： 互斥锁性能测试

commands:

- prepare: 准备阶段
- run： 运行
- cleanup：清理
- help： 帮助

**线程性能压测**

> 线程无需prepare和cleanup 直接run即可

```shell
$ sysbench --threads=10 threads run
General statistics:
    total time:                          10.0208s
    total number of events:              5342

Latency (ms):
         min:                                    2.36
         avg:                                   18.73
         max:                                  152.47
         95th percentile:                       70.55
         sum:                               100069.68

Threads fairness:
    events (avg/stddev):           534.2000/22.05
    execution time (avg/stddev):   10.0070/0.01
```

**数据库性能压测**

社区提供的脚本：

```
/usr/share/sysbench/bulk_insert.lua
/usr/share/sysbench/oltp_common.lua
/usr/share/sysbench/oltp_delete.lua
/usr/share/sysbench/oltp_insert.lua
/usr/share/sysbench/oltp_point_select.lua
/usr/share/sysbench/oltp_read_only.lua
/usr/share/sysbench/oltp_read_write.lua
/usr/share/sysbench/oltp_update_index.lua
/usr/share/sysbench/oltp_update_non_index.lua
/usr/share/sysbench/oltp_write_only.lua
/usr/share/sysbench/select_random_points.lua
/usr/share/sysbench/select_random_ranges.lua
```

>  On-Line Transaction Processing联机事务处理过程(*OLTP*)

准备数据（prepare）：

```shell
$ sysbench /usr/share/sysbench/oltp_read_only.lua --mysql-host=127.0.0.1 --mysql-port=3306 --mysql-user=root --mysql-password='' --mysql-db=sbtest --db-driver=mysql --tables=10 --table-size=1000000 --report-interval=10 --threads=128 --time=120 prepare
```

压测 (run):

```shell
$ sysbench /usr/share/sysbench/oltp_read_only.lua --mysql-host=127.0.0.1 --mysql-port=3306 --mysql-user=root --mysql-password='' --mysql-db=sbtest --db-driver=mysql --tables=10 --table-size=1000000 --report-interval=10 --threads=128 --time=120 run
```

```
[ 10s ] thds: 128 tps: 83.61 qps: 1460.28 (r/w/o: 1280.37/0.00/179.91) lat (ms,95%): 3151.62 err/s: 0.00 reconn/s: 0.00
[ 20s ] thds: 128 tps: 114.82 qps: 1829.74 (r/w/o: 1600.00/0.00/229.74) lat (ms,95%): 3267.19 err/s: 0.00 reconn/s: 0.00
[ 30s ] thds: 128 tps: 116.70 qps: 1862.06 (r/w/o: 1628.67/0.00/233.40) lat (ms,95%): 3208.88 err/s: 0.00 reconn/s: 0.00
[ 40s ] thds: 128 tps: 125.20 qps: 2015.85 (r/w/o: 1765.55/0.00/250.29) lat (ms,95%): 1803.47 err/s: 0.00 reconn/s: 0.00
[ 50s ] thds: 128 tps: 123.80 qps: 1954.32 (r/w/o: 1706.71/0.00/247.60) lat (ms,95%): 1618.78 err/s: 0.00 reconn/s: 0.00
[ 60s ] thds: 128 tps: 119.30 qps: 1925.28 (r/w/o: 1686.69/0.00/238.60) lat (ms,95%): 1771.29 err/s: 0.00 reconn/s: 0.00
[ 70s ] thds: 128 tps: 119.49 qps: 1922.65 (r/w/o: 1683.77/0.00/238.88) lat (ms,95%): 1739.68 err/s: 0.00 reconn/s: 0.00
[ 80s ] thds: 128 tps: 120.21 qps: 1919.50 (r/w/o: 1679.09/0.00/240.41) lat (ms,95%): 1771.29 err/s: 0.00 reconn/s: 0.00
[ 90s ] thds: 128 tps: 121.11 qps: 1931.94 (r/w/o: 1689.52/0.00/242.42) lat (ms,95%): 1739.68 err/s: 0.00 reconn/s: 0.00
[ 100s ] thds: 128 tps: 121.90 qps: 1964.95 (r/w/o: 1721.16/0.00/243.79) lat (ms,95%): 1618.78 err/s: 0.00 reconn/s: 0.00
[ 110s ] thds: 128 tps: 122.40 qps: 1943.02 (r/w/o: 1698.23/0.00/244.79) lat (ms,95%): 1803.47 err/s: 0.00 reconn/s: 0.00
[ 120s ] thds: 128 tps: 120.79 qps: 1928.00 (r/w/o: 1686.71/0.00/241.29) lat (ms,95%): 1648.20 err/s: 0.00 reconn/s: 0.00
SQL statistics:
    queries performed:
        read:                            199108 // 总select数量
        write:                           0
        other:                           28444
        total:                           227552
    transactions:                        14222  (117.57 per sec.) // tps
    queries:                             227552 (1881.20 per sec.) // qps
    ignored errors:                      0      (0.00 per sec.)
    reconnects:                          0      (0.00 per sec.)

General statistics:
    total time:                          120.9538s
    total number of events:              14222

Latency (ms):
         min:                                   13.84 // 最小响应时间
         avg:                                 1084.70 // 平均响应时间
         max:                                 5281.53 // 最大响应时间
         95th percentile:                     2120.76 // 95分位响应时间
         sum:                             15426627.71 // 总时间

Threads fairness:
    events (avg/stddev):           111.1094/4.84
    execution time (avg/stddev):   120.5205/0.26
```

> 这是早期的联想电脑装的linux，本身不带固态，4H8G配置

清理数据：

```shell
$ sysbench /usr/share/sysbench/oltp_read_only.lua --mysql-host=127.0.0.1 --mysql-port=3306 --mysql-user=root --mysql-password='' --mysql-db=sbtest --db-driver=mysql --tables=10 --table-size=1000000 --report-interval=10 --threads=128 --time=120 cleanup
```

**磁盘IO压测**

options：

- --file-num=N  文件数量 128

- --file-block-size=N 写入块的大小 16K

- --file-total-size=SIZE 每个文件的大小 2G

- --file-test-mode=STRING 

  - seqwr（顺序写）
  - seqrewr（顺序读写）
  - seqrd（顺序读）
  - rndrd（随机读）
  - rndwr（随机写）
  - rndrw（随机读写）

- --file-io-mode=STRING 

  - sync 同步 默认
  - async 异步
  - mmap map映射

- --file-fsync-freq=N 调用fysnc同步磁盘的频率 （0不调用）100

- --file-fsync-all=[off|on] 每次写完文件立即 fsync  off

- --file-fsync-end=[off|on] 测试结束执行 fsync on

- --file-fsync-mode=STRING

  - fsync 默认

  - fdatasync 

  - > sync 只是将修改过的块缓冲区加入同步队列，直接返回，不等待写磁盘操作完成
    >
    > fsync 只对单一文件起作用，等待写磁盘完成，fsync会同步文件属性
    >
    > fdatasync 只同步文件数据部分

- --file-merged-requests=N 合并IO请求 0（不合并）
- --file-rw-ratio=N 读写比例 1.5 （2:1）

# lsof(列出系统打开的工具)

主要用途：查看进程打开的mysql连接，文件，网络连接等

1. 普通文件
2. 目录
3. 网络文件系统的文件
4. 字符或设备文件
5. (函数)共享库
6. 管道，命名管道
7. 符号链接
8. 网络文件（例如：NFS file、网络socket，unix域名socket）
9. 还有其它类型的文件，等等

**命令参数**

- `-c <进程名>` 
  - `losf -c mysqld`： 列出mysql进程打开的文件
- `+d <目录>` 列出目录下被打开的文件
  - `lsof +d /data/mysql` 列出 /data/mysql 目录下被打开的文件
- `+D <目录>` 递归列出目录下被打开的文件
- `-i <条件> ` 列出符合条件的进程 
  - `lsof -i 4` / `lsof -i 6`：列出打开ipv4/ipv6网络的进程
  - `lsof -i @<域名>`：列出与域名建立连接的进程
  - `lsof -i :<端口>`：列出占用端口的进程
  - `losf -i tcop -p 1969`: 列出1969进程建立的所有tcp连接
- `-p <进程号>` 
  - `lsof -p 1969` 列出 1969 进程 打开的文件

