1 简介

top 命令是 Linux 上一个常用的系统监控工具，它经常用来监控 Linux 的系统状态，是常用的性能分析工具，能够显示较全的系统资源信息，包括系统负载，CPU 利用分布情况，内存使用，进程资源占用情况等。
如下示例：

top - 15:20:14 up 8 days,  2:19,  1 user,  load average: 0.27, 0.16, 0.11
Tasks: 1060 total,   1 running, 1059 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.1 us,  0.1 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem : 522534.9 total, 501706.3 free,   6081.8 used,  14746.8 buff/cache
MiB Swap:      0.0 total,      0.0 free,      0.0 used. 509887.0 avail Mem 

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                                                                                                                                                                                                 
   6710 root      20   0 8875200 191104  62528 S  11.6   0.0 764:24.32 kubelet                                                                                                                                                                                                 
   4030 openvsw+  10 -10 8359168 315392  19072 S   2.6   0.1 313:08.86 ovs-vswitchd                                                                                                                                                                                            
   7172 root      20   0    9.8g 262080 105664 S   1.0   0.0 147:18.81 etcd                                                                                                                                                                                                    
2601183 root      20   0  225152   8256   3648 R   0.7   0.0   0:02.56 top                                                                                                                                                                                                     
     13 root      20   0       0      0      0 I   0.3   0.0  14:45.23 rcu_sched                                                                                                                                                                                               
   7095 root      20   0  288384  68736   9856 S   0.3   0.0  33:01.24 python                                                                                                                                                                                                  
2582570 root      20   0       0      0      0 I   0.3   0.0   0:00.97 kworker/u194:2-flush-251:0                                                                                                                                                                              
      1 root      20   0   27264  16768   8448 S   0.0   0.0   0:59.07 systemd                                                                                                                                                                                                 
      2 root      20   0       0      0      0 S   0.0   0.0   0:03.97 kthreadd 

这里主要看进程的 CPU%, MEM% 和 load averge 字段。

2 CPU% 字段

该字段指示了进程在一段时间内的 CPU 利用情况，即 cpu 使用的时间比例。
不同平台 top 命令中 cpu 利用率计算方式可能不同，不过大致逻辑是统计程序在用户态和内核态的运行时间除以从启动运行到当前时刻的时间，或者是通过采样某个时间段内任务的运行时间总和算出某个区间内的cpu利用率，下面是一种简单算法：
通过 /proc/PID/stat 读取任务在用户态的运行时间 utime，内核态运行时间 stime，任务开始运行时间 starttime，以及系统的 boot 时间 uptime。
接着根据 cpu% = (utime + stime) * 100 / (HZ * (uptime - starttime)) 计算得到一个 cpu 的利用率。
简单脚本如下：

#!/bin/bash

pid=$1 # 进程 ID
uptime=$(cut -d' ' -f1 /proc/uptime)  # 系统运行时间
stat=$(< /proc/$pid/stat)  # 进程状态信息
utime=$(echo $stat | cut -d' ' -f14)  # 进程用户态运行时间
stime=$(echo $stat | cut -d' ' -f15)  # 进程内核态运行时间
starttime=$(echo $stat | cut -d' ' -f22)  # 进程开始时间
echo "start time $starttime"
hz=$(getconf CLK_TCK)  # 系统时钟频率
totaltime=$((utime + stime))  # 进程总运行时间
seconds=$(echo "scale=2; ($uptime - $starttime / $hz)" | bc)  # 经过的秒数
cpuusage=$(echo "scale=2; 100 * $totaltime / ($hz * $seconds)" | bc)  # CPU 利用率
echo "进程 $pid 的 CPU 利用率为 $cpuusage %"

测试程序：

#include <stdio.h>

int main()
{
	while (1) {
 		int count = 0;
        for (;;) {
        	count++;
			if (count % 10000 == 0)
				break;
        }
		usleep(10);
   }
}
 
进程 5764 的 CPU 利用率为 20.63 %

需要注意上述算法是一个简单算法，演示了 top 中 cpu 利用率的一个计算方式，实际代码中使用时间采样等方式获取到更加精确的 cpu 利用率。

3 MEM% 字段

该字段顾名思义统计的是任务的内存使用率，那么该值如何计算呢，又是统计的哪部份的内存占用呢？如下：
首先我们可以使用 ps aux --sort=-%mem 统计下系统中内存占用率最高的任务，ps 的统计和 top 的统计计算方式一致。

[root@node-2 ~]# ps aux --sort=-%mem
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
ceph     28122  7.1  1.5 5205592 4071872 ?     Ssl  Jul11 125:17 /usr/bin/ceph-osd --cluster ceph -f -i 16 --setuser ceph --setgroup dis
ceph     25883  7.1  1.5 5232948 4059848 ?     Ssl  Jul11 124:00 /usr/bin/ceph-osd --cluster ceph -f -i 15 --setuser ceph --setgroup dis
ceph     23865  6.4  1.5 5220840 4041976 ?     Ssl  Jul11 111:47 /usr/bin/ceph-osd --cluster ceph -f -i 19 --setuser ceph --setgroup dis
ceph     35957  9.0  1.5 5391688 4021308 ?     Ssl  Jul11 158:26 /usr/bin/ceph-osd --cluster ceph -f -i 14 --setuser ceph --setgroup dis
ceph     18263  6.9  1.5 5307556 4018768 ?     Ssl  Jul11 120:55 /usr/bin/ceph-osd --cluster ceph -f -i 18 --setuser ceph --setgroup dis
ceph     20412  7.4  1.4 5111476 3902512 ?     Ssl  Jul11 129:37 /usr/bin/ceph-osd --cluster ceph -f -i 17 --setuser ceph --setgroup dis
diag     62902 20.8  1.0 36009096 2877676 ?    Ssl  Jul11 361:02 /bin/prometheus --web.console.templates=/etc/prometheus/consoles --web.
root     19200  0.6  0.6 2829756 1663784 ?     SLl  Jul11  11:44 mongod -f /etc/mongod.conf --auth
root     16180 59.3  0.6 2359060 1623320 ?     Ssl  Jul11 1037:53 /kube-apiserver --advertise-address=10.50.1.5 --etcd-servers=https://1
root     48824  0.4  0.5 1858596 1511388 ?     Sl   Jul11   7:35 ovsdb-server -vconsole:info -vsyslog:off -vfile:off --log-file=/var/log
systemd+ 48377  1.5  0.5 6644228 1378636 ?     Sl   Jul11  27:22 /usr/sbin/mysqld --wsrep-new-cluster
systemd+ 26533  0.5  0.4 1389572 1089968 ?     Ssl  Jul11   9:08 memcached -v -u memcache -p 11211 -U 0 -c 60000 -m 1024 -I 128m
ceph     20098  1.2  0.3 1558396 988656 ?      Ssl  Jul11  22:31 /usr/bin/ceph-mon --cluster ceph --setuser ceph --setgroup ceph -f -i n
ceph      6832  1.6  0.3 2072256 890892 ?      Ssl  Jul11  29:30 /usr/bin/ceph-osd --cluster ceph -f -i 20 --setuser ceph --setgroup dis
root     43596 68.5  0.3 23389276 866648 ?     Sl   Jul11 

[root@node-3 ~]# free -h
              total        used        free      shared  buff/cache   available
Mem:          251Gi       237Gi       7.9Gi       4.1Gi       5.8Gi       9.6Gi
Swap:            0B          0B          0B
[root@node-3 ~]# 

ps 和 top 命令中显示的内存信息来源于 /proc/pid/status 文件，该文件统计了进程使用的各类系统资源，其中 ps 和 top 显示的内存资源有 VSZ 和 RSS，对应 top 是 VIRT 和 RES，对应 ps 是 VSZ 和 RSS。
VSZ 表示的是内核申请的虚拟内存总量，status 文件中用 VmSize 表示。RSS 表示匿名映射，文件映射，常驻shmem内存(SysV shm，tmpfs和共享匿名映射)这三种映射的内存，这三种驻留在内存的数据，也就是实际的物理内存占用。
status 文件展示：

root@node-3 ~]# cat /proc/2698/status 
...
NSsid:  2698
VmPeak: 140968180 kB
VmSize: 140967424 kB
VmLck:  140933516 kB
VmPin:         0 kB
VmHWM:    492836 kB
VmRSS:    492836 kB
RssAnon:          464204 kB
RssFile:           28404 kB
RssShmem:            228 kB
VmData:   463656 kB
VmStk:       208 kB
VmExe:       116 kB
VmLib:     26932 kB
VmPTE:      1864 kB
VmSwap:        0 kB
HugetlbPages:   16777216 kB
CoreDumping:    0
Threads:        97
SigQ:   3/291773

这里顺便说一下 free 命令计算空闲内存的方式：
首先是 free 的内存计算来自于 /proc/meminfo 文件，每个字段含义需要在内核文档 proc.txt 中确认：

[root@node-2 procps-ng-3.3.15]# cat /proc/meminfo 
MemTotal:       535137152 kB
MemFree:        518735680 kB
MemAvailable:   518809344 kB
Buffers:             192 kB
Cached:          6451136 kB
SwapCached:            0 kB
Active:          3429760 kB
Inactive:        5747264 kB
Active(anon):    2658816 kB
Inactive(anon):  4342784 kB
Active(file):     770944 kB
Inactive(file):  1404480 kB
Unevictable:      298688 kB
Mlocked:          298688 kB
SwapTotal:             0 kB
SwapFree:              0 kB
Dirty:               512 kB
Writeback:             0 kB
AnonPages:       3027200 kB
Mapped:           907264 kB
Shmem:           4367872 kB
KReclaimable:     298752 kB
Slab:            1624704 kB
SReclaimable:     298752 kB
SUnreclaim:      1325952 kB
KernelStack:      124608 kB
PageTables:        67968 kB
NFS_Unstable:          0 kB
Bounce:                0 kB
WritebackTmp:          0 kB
CommitLimit:    267568576 kB
Committed_AS:   15039744 kB
VmallocTotal:   133009506240 kB
VmallocUsed:           0 kB
VmallocChunk:          0 kB
HardwareCorrupted:     0 kB
AnonHugePages:         0 kB
ShmemHugePages:        0 kB
ShmemPmdMapped:        0 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:     524288 kB
Hugetlb:               0 kB

free 命令 Used 计算源码如下：

  mem_used = kb_main_total - kb_main_free - kb_main_cached - kb_main_buffers;
  if (mem_used < 0)
    mem_used = kb_main_total - kb_main_free;
  kb_main_used = (unsigned long)mem_used;

整理为 meminfo 文件内容后如下：

Used = MemTotal - MemFree - Cached - SReclaimable - Buffers
（其中 SReclaimable 是 slab 中可回收内存部分）

计算例子：

正常节点：
              total        used        free      shared  buff/cache   available
Mem:      535137152     9655488   518731584     4367872     6750080   518805248

[root@node-2 procps-ng-3.3.15]# cat /proc/meminfo 
MemTotal:       535137152 kB
MemFree:        518735680 kB
MemAvailable:   518809344 kB
Buffers:             192 kB
Cached:          6451136 kB
SwapCached:            0 kB
Active:          3429760 kB
Inactive:        5747264 kB
Active(anon):    2658816 kB
Inactive(anon):  4342784 kB
Active(file):     770944 kB
Inactive(file):  1404480 kB
Unevictable:      298688 kB
Mlocked:          298688 kB
SwapTotal:             0 kB
SwapFree:              0 kB
Dirty:               512 kB
Writeback:             0 kB
AnonPages:       3027200 kB
Mapped:           907264 kB
Shmem:           4367872 kB
KReclaimable:     298752 kB
Slab:            1624704 kB
SReclaimable:     298752 kB
SUnreclaim:      1325952 kB
KernelStack:      124608 kB
PageTables:        67968 kB
NFS_Unstable:          0 kB
Bounce:                0 kB
WritebackTmp:          0 kB
CommitLimit:    267568576 kB
Committed_AS:   15039744 kB
VmallocTotal:   133009506240 kB
VmallocUsed:           0 kB
VmallocChunk:          0 kB
HardwareCorrupted:     0 kB
AnonHugePages:         0 kB
ShmemHugePages:        0 kB
ShmemPmdMapped:        0 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:     524288 kB
Hugetlb:               0 kB

根据公式计算 Used：
Used =  535137152 -  518735680 - 6451136 - 298752 - 192 = 9651392 符合

那么 Used 包括了其他所有内存使用，包括 kernelstack，pagetable，buddy，slab 等等，基于此有另外两个公式计算总内存量：

MemTotal = MemFree
			+ [Slab + VmallocUsed + PageTables + KernelStack + HardwareCorrupted + Bounce + X] 
			+ [Active + Inactive + Unevictable + (HuagePage_Total * Hugepagesize)]

	 	 = MemFree
			+ [Slab + VmallocUsed + PageTables + KernelStack + HardwareCorrupted + Bounce + X] 
			+ [Cached + AnonPages + Buffers +  (HuagePage_Total * Hugepagesize)]

其中 X 代表 alloc_pages/__get_free_pages 接口分配的内存，这部分不会统计到 meminfo 中。

按照上述规则计算 alloc_pages 使用量：

正常节点：
	518735680
			+ [1624704 + 0 + 67968 + 124608 + 0 + 0 + X]
			+ [3429760 + 5747264 + 298688 + 0] 
			=  530028672
			buddy = 535137152 - 530028672 = 5108480 KB  4.87G

	518735680
			+ [1624704 + 0 + 67968 + 124608 + 0 + 0 + X]
			+ [6451136 + 3027200 + 192 + 0]
			= 530031488
			buddy = 535137152 - 530031488 = 5105664 KB 4.86G
			
差不多正常节点 X = 4.87G，这部分被 alloc_pages 等使用，基本符合预期。

4 load average 平均负载

load average 字段统计了系统在 1分钟/5分钟/15分钟的平均负载，其指标根据 cpu 数量有所不同，数值反应了系统的整体负载情况，数值越高系统负载压力越大。那么如何能够更直观的理解该负载呢？通过计算方式可以很好的理解其 load average 表达的含义。

load average 值来自于 /proc/loadavg 文件前三个数值，该值来自于内核的 sched/loadavg.c calc_global_load 的计算得出，主要统计 1 分钟，5 分钟，15 分钟内的可运行任务数量 + 不可中断睡眠任务（io wait 等）总和计算的平均负载。

其计算方式采用周期衰减旧负载并累加周期内新负载，而更新周期窗口时间为 5s，即 5s 更新一次平均负载，并根据一定算法累加到 1分钟/5分钟/15分钟。

公式大致如下：

...
	active = atomic_long_read(&calc_load_tasks);
	active = active > 0 ? active * FIXED_1 : 0;

	// 更新 1分钟/5分钟/15分钟 平均负载
	avenrun[0] = calc_load(avenrun[0], EXP_1, active);
	avenrun[1] = calc_load(avenrun[1], EXP_5, active);
	avenrun[2] = calc_load(avenrun[2], EXP_15, active);
...

// 其中使用的 EXP_n 为常量系数
EXP_n = 1/5/15 分钟的常量系数：
EXP_1        1884
EXP_5        2014
EXP_15       2037
FIXED_1      2048

// 通过周期衰减旧负载 + 更新周期内新负载得到现在的负载
now_load = old_load(1/5/15) * (EXP_n/FIXED_1) + new_load * (1 - EXP_n/FIXED_1)

即通过周期间隔时间衰减老的平均负载 + 该周期内的平均负载得到现在的平均负载（类似 pelt 算法）。
实际内核计算代码为：
/*
 * a1 = a0 * e + a * (1 - e)
 */
static inline unsigned long
calc_load(unsigned long load, unsigned long exp, unsigned long active)
{
	unsigned long newload;

	newload = load * exp + active * (FIXED_1 - exp);
	if (active >= load)
		newload += FIXED_1-1;

	return newload / FIXED_1;
}

其中 active 为通过周期统计采样时间内所有 cpu 的可运行任务数量 + 不可中断睡眠任务数量总和 * FIXED_1 得到的新负载，如下：

long calc_load_fold_active(struct rq *this_rq, long adjust)
{
	long nr_active, delta = 0;
	// nr_active 统计了当前 cpu 在该周期内的任务数量并累加到 calc_load_tasks 中。
	// 不采用 for_each_prossble_cpu 来一次性统计的原因是：
	// 当大型服务器上 cpu 的数量众多，for_each 方式成本过大，所以采用周期统计累加形式。
	nr_active = this_rq->nr_running - adjust;
	nr_active += (long)this_rq->nr_uninterruptible;

	if (nr_active != this_rq->calc_load_active) {
		delta = nr_active - this_rq->calc_load_active;
		this_rq->calc_load_active = nr_active;
	}

	return delta;
}

上述公式可以这样简单理解：
比如计算 1分钟 的平均负载，假设 old_load 为 1024，当前计算周期内有1个任务可运行和一个任务为不可中断睡眠任务（D 状态任务），那么计算方式如下：

现在的负载 = 旧负载 1024 * 衰减系数（EXP_1/FIXED_1 = 1884/2048） + 2（两个任务）* FIXED_1（2048） * （1 - EXP_1/FIXED_1）

可以看到假设如果只有一个cpu下，并且一直一个任务一直运行，那么平均负载接近 cpu 数量接近为 1，此时可以说 cpu 繁忙。
因此随着 cpu 数量的增多，平均负载繁忙的指标也会增高，并且随着负载衰减，在一个 8 核系统上，1 分钟平均负载在 5 左右可以说系统处于略微繁忙，如果负载小于 1 可以说系统处于空闲。