Linux中计算特定CPU使用率案例详解

只是一种无奈

Linux中计算特定CPU使用率 需求解决方案拓展参考
需求

在Linux中可以通过top指令查看某一进程占用的CPU情况，也可以查看某一个CPU使用率情况（先top指令，然后按数字“1”键即可显示每一个CPU的使用情况），如下图：

而我们的需求是：如何得到一个CPU的占用率呢？
解决方案

1. 背景知识
在/proc/stat中可以查看每一个CPU的使用情况的，如下图：

其中cpu(0/1/2/…)后面的那十个数字含义如下：

1. /proc/stat
   
2. kernel/system statistics.  Varies with architecture.  
   
3. Common entries include:
   
4. 
   
5.      user nice system idle iowait  irq  softirq steal guest guest_nice
   
6. cpu  4705 356  584    3699   23    23     0       0     0        0
   
7. cpu0 1393280 32966 572056 13343292 6130 0 17875 0 23933 0
   
8.    The amount of time, measured in units of USER_HZ
   
9.    (1/100ths of a second on most architectures, use
   
10.    sysconf(_SC_CLK_TCK) to obtain the right value), that
    
11.    the system ("cpu" line) or the specific CPU ("cpuN"
    
12.    line) spent in various states:
    
13. 
    
14.    user   (1) Time spent in user mode.
    
15. 
    
16.    nice   (2) Time spent in user mode with low priority
    
17.           (nice).
    
18. 
    
19.    system (3) Time spent in system mode.
    
20. 
    
21.    idle   (4) Time spent in the idle task.  This value
    
22.           should be USER_HZ times the second entry in the
    
23.           /proc/uptime pseudo-file.
    
24. 
    
25.    iowait (since Linux 2.5.41)
    
26.           (5) Time waiting for I/O to complete.  This
    
27.           value is not reliable, for the following rea‐
    
28.           sons:
    
29. 
    
30.           1. The CPU will not wait for I/O to complete;
    
31.              iowait is the time that a task is waiting for
    
32.              I/O to complete.  When a CPU goes into idle
    
33.              state for outstanding task I/O, another task
    
34.              will be scheduled on this CPU.
    
35. 
    
36.           2. On a multi-core CPU, the task waiting for I/O
    
37.              to complete is not running on any CPU, so the
    
38.              iowait of each CPU is difficult to calculate.
    
39. 
    
40.           3. The value in this field may decrease in cer‐
    
41.              tain conditions.
    
42. 
    
43.    irq (since Linux 2.6.0-test4)
    
44.           (6) Time servicing interrupts.
    
45. 
    
46.    softirq (since Linux 2.6.0-test4)
    
47.           (7) Time servicing softirqs.
    
48. 
    
49.    steal (since Linux 2.6.11)
    
50.           (8) Stolen time, which is the time spent in
    
51.           other operating systems when running in a virtu‐
    
52.           alized environment
    
53. 
    
54.    guest (since Linux 2.6.24)
    
55.           (9) Time spent running a virtual CPU for guest
    
56.           operating systems under the control of the Linux
    
57.           kernel.
    
58. 
    
59.    guest_nice (since Linux 2.6.33)
    
60.           (10) Time spent running a niced guest (virtual
    
61.           CPU for guest operating systems under the con‐
    
62.           trol of the Linux kernel).

复制代码

2.计算具体CPU使用率
有了上面的背景知识，接下来我们就可以计算具体CPU的使用情况了。具体计算方式如下：

1. Total CPU time since boot = user+nice+system+idle+iowait+irq+softirq+steal
   
2. Total CPU Idle time since boot = idle + iowait
   
3. Total CPU usage time since boot = Total CPU time since boot - Total CPU Idle time since boot
   
4. Total CPU percentage = Total CPU usage time since boot/Total CPU time since boot * 100%

复制代码

有了上面的计算公式，计算某一CPU使用率或者系统总的CPU占用率也就是不难了。
示例：计算系统整体CPU占用情况
首先从/proc/stat中获取 t1时刻系统总体的user、nice、system、idle、iowait、irq、softirq、steal、guest、guest_nice的值，得到此时Total CPU time since boot（记为total1）和 Total CPU idle time since boot(记为idle1)。
其次，从/proc/stat中获取t2时刻系统总的Total CPU time since boot（记为total2）和Total CPU idle time since boot（记为idle2）。（方法同上一步）
最后，计算t2与t1之间系统总的CPU使用情况。也就是：
CPU percentage between t1 and t2 = (（total2-total1）-（idle2-idle1））/（total2-total1）* 100%
其中， (（total2-total1）-（idle2-idle1））实际上就是t1与t2时刻之间系统CPU被占用的时间（总时间 - 空闲时间）。
下面是一段计算时间段内CPU被占用情况的脚本：

1. #!/bin/bash
   
2. # by Paul Colby (http://colby.id.au), no rights reserved ;)
   
3. 
   
4. PREV_TOTAL=0
   
5. PREV_IDLE=0
   
6. 
   
7. while true; do
   
8.   # Get the total CPU statistics, discarding the 'cpu ' prefix.
   
9.   CPU=(`sed -n 's/^cpu\s//p' /proc/stat`)
   
10.   IDLE=${CPU[3]} # Just the idle CPU time.
    
11. 
    
12.   # Calculate the total CPU time.
    
13.   TOTAL=0
    
14.   for VALUE in "${CPU[@]}"; do
    
15.     let "TOTAL=$TOTAL+$VALUE"
    
16.   done
    
17. 
    
18.   # Calculate the CPU usage since we last checked.
    
19.   let "DIFF_IDLE=$IDLE-$PREV_IDLE"
    
20.   let "DIFF_TOTAL=$TOTAL-$PREV_TOTAL"
    
21.   let "DIFF_USAGE=(1000*($DIFF_TOTAL-$DIFF_IDLE)/$DIFF_TOTAL+5)/10"
    
22.   echo -en "\rCPU: $DIFF_USAGE%  \b\b"
    
23. 
    
24.   # Remember the total and idle CPU times for the next check.
    
25.   PREV_TOTAL="$TOTAL"
    
26.   PREV_IDLE="$IDLE"
    
27. 
    
28.   # Wait before checking again.
    
29.   sleep 1
    
30. done

复制代码

拓展

在内核中，关于/proc/stat中文件的实现函数如下：

1. 附注：内核版本3.14.69，文件为 /fs/proc/stat.c
   
2. 
   
3. #include <linux/cpumask.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/init.h>
   
6. #include <linux/interrupt.h>
   
7. #include <linux/kernel_stat.h>
   
8. #include <linux/proc_fs.h>
   
9. #include <linux/sched.h>
   
10. #include <linux/seq_file.h>
    
11. #include <linux/slab.h>
    
12. #include <linux/time.h>
    
13. #include <linux/irqnr.h>
    
14. #include <asm/cputime.h>
    
15. #include <linux/tick.h>
    
16. 
    
17. #ifndef arch_irq_stat_cpu
    
18. #define arch_irq_stat_cpu(cpu) 0
    
19. #endif
    
20. #ifndef arch_irq_stat
    
21. #define arch_irq_stat() 0
    
22. #endif
    
23. 
    
24. #ifdef arch_idle_time
    
25. 
    
26. static cputime64_t get_idle_time(int cpu)
    
27. {
    
28.         cputime64_t idle;
    
29. 
    
30.         idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE];
    
31.         if (cpu_online(cpu) && !nr_iowait_cpu(cpu))
    
32.                 idle += arch_idle_time(cpu);
    
33.         return idle;
    
34. }
    
35. 
    
36. static cputime64_t get_iowait_time(int cpu)
    
37. {
    
38.         cputime64_t iowait;
    
39. 
    
40.         iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT];
    
41.         if (cpu_online(cpu) && nr_iowait_cpu(cpu))
    
42.                 iowait += arch_idle_time(cpu);
    
43.         return iowait;
    
44. }
    
45. 
    
46. #else
    
47. 
    
48. static u64 get_idle_time(int cpu)
    
49. {
    
50.         u64 idle, idle_time = -1ULL;
    
51. 
    
52.         if (cpu_online(cpu))
    
53.                 idle_time = get_cpu_idle_time_us(cpu, NULL);
    
54. 
    
55.         if (idle_time == -1ULL)
    
56.                 /* !NO_HZ or cpu offline so we can rely on cpustat.idle */
    
57.                 idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE];
    
58.         else
    
59.                 idle = usecs_to_cputime64(idle_time);
    
60. 
    
61.         return idle;
    
62. }
    
63. 
    
64. static u64 get_iowait_time(int cpu)
    
65. {
    
66.         u64 iowait, iowait_time = -1ULL;
    
67. 
    
68.         if (cpu_online(cpu))
    
69.                 iowait_time = get_cpu_iowait_time_us(cpu, NULL);
    
70. 
    
71.         if (iowait_time == -1ULL)
    
72.                 /* !NO_HZ or cpu offline so we can rely on cpustat.iowait */
    
73.                 iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT];
    
74.         else
    
75.                 iowait = usecs_to_cputime64(iowait_time);
    
76. 
    
77.         return iowait;
    
78. }
    
79. 
    
80. #endif
    
81. 
    
82. static int show_stat(struct seq_file *p, void *v)
    
83. {
    
84.         int i, j;
    
85.         unsigned long jif;
    
86.         u64 user, nice, system, idle, iowait, irq, softirq, steal;
    
87.         u64 guest, guest_nice;
    
88.         u64 sum = 0;
    
89.         u64 sum_softirq = 0;
    
90.         unsigned int per_softirq_sums[NR_SOFTIRQS] = {0};
    
91.         struct timespec boottime;
    
92. 
    
93.         user = nice = system = idle = iowait =
    
94.                 irq = softirq = steal = 0;
    
95.         guest = guest_nice = 0;
    
96.         getboottime(&boottime);
    
97.         jif = boottime.tv_sec;
    
98. 
    
99.         for_each_possible_cpu(i) {
    
100.                 user += kcpustat_cpu(i).cpustat[CPUTIME_USER];
     
101.                 nice += kcpustat_cpu(i).cpustat[CPUTIME_NICE];
     
102.                 system += kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM];
     
103.                 idle += get_idle_time(i);
     
104.                 iowait += get_iowait_time(i);
     
105.                 irq += kcpustat_cpu(i).cpustat[CPUTIME_IRQ];
     
106.                 softirq += kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ];
     
107.                 steal += kcpustat_cpu(i).cpustat[CPUTIME_STEAL];
     
108.                 guest += kcpustat_cpu(i).cpustat[CPUTIME_GUEST];
     
109.                 guest_nice += kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE];
     
110.                 sum += kstat_cpu_irqs_sum(i);
     
111.                 sum += arch_irq_stat_cpu(i);
     
112. 
     
113.                 for (j = 0; j < NR_SOFTIRQS; j++) {
     
114.                         unsigned int softirq_stat = kstat_softirqs_cpu(j, i);
     
115. 
     
116.                         per_softirq_sums[j] += softirq_stat;
     
117.                         sum_softirq += softirq_stat;
     
118.                 }
     
119.         }
     
120.         sum += arch_irq_stat();
     
121. 
     
122.         seq_puts(p, "cpu ");
     
123.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(user));
     
124.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(nice));
     
125.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(system));
     
126.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(idle));
     
127.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(iowait));
     
128.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(irq));
     
129.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(softirq));
     
130.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(steal));
     
131.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest));
     
132.         seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest_nice));
     
133.         seq_putc(p, '\n');
     
134. 
     
135.         for_each_online_cpu(i) {
     
136.                 /* Copy values here to work around gcc-2.95.3, gcc-2.96 */
     
137.                 user = kcpustat_cpu(i).cpustat[CPUTIME_USER];
     
138.                 nice = kcpustat_cpu(i).cpustat[CPUTIME_NICE];
     
139.                 system = kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM];
     
140.                 idle = get_idle_time(i);
     
141.                 iowait = get_iowait_time(i);
     
142.                 irq = kcpustat_cpu(i).cpustat[CPUTIME_IRQ];
     
143.                 softirq = kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ];
     
144.                 steal = kcpustat_cpu(i).cpustat[CPUTIME_STEAL];
     
145.                 guest = kcpustat_cpu(i).cpustat[CPUTIME_GUEST];
     
146.                 guest_nice = kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE];
     
147.                 seq_printf(p, "cpu%d", i);
     
148.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(user));
     
149.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(nice));
     
150.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(system));
     
151.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(idle));
     
152.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(iowait));
     
153.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(irq));
     
154.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(softirq));
     
155.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(steal));
     
156.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest));
     
157.                 seq_put_decimal_ull(p, ' ', cputime64_to_clock_t(guest_nice));
     
158.                 seq_putc(p, '\n');
     
159.         }
     
160.         seq_printf(p, "intr %llu", (unsigned long long)sum);
     
161. 
     
162.         /* sum again ? it could be updated? */
     
163.         for_each_irq_nr(j)
     
164.                 seq_put_decimal_ull(p, ' ', kstat_irqs_usr(j));
     
165. 
     
166.         seq_printf(p,
     
167.                 "\nctxt %llu\n"
     
168.                 "btime %lu\n"
     
169.                 "processes %lu\n"
     
170.                 "procs_running %lu\n"
     
171.                 "procs_blocked %lu\n",
     
172.                 nr_context_switches(),
     
173.                 (unsigned long)jif,
     
174.                 total_forks,
     
175.                 nr_running(),
     
176.                 nr_iowait());
     
177. 
     
178.         seq_printf(p, "softirq %llu", (unsigned long long)sum_softirq);
     
179. 
     
180.         for (i = 0; i < NR_SOFTIRQS; i++)
     
181.                 seq_put_decimal_ull(p, ' ', per_softirq_sums[i]);
     
182.         seq_putc(p, '\n');
     
183. 
     
184.         return 0;
     
185. }
     
186. 
     
187. static int stat_open(struct inode *inode, struct file *file)
     
188. {
     
189.         size_t size = 1024 + 128 * num_possible_cpus();
     
190.         char *buf;
     
191.         struct seq_file *m;
     
192.         int res;
     
193. 
     
194.         /* minimum size to display an interrupt count : 2 bytes */
     
195.         size += 2 * nr_irqs;
     
196. 
     
197.         /* don't ask for more than the kmalloc() max size */
     
198.         if (size > KMALLOC_MAX_SIZE)
     
199.                 size = KMALLOC_MAX_SIZE;
     
200.         buf = kmalloc(size, GFP_KERNEL);
     
201.         if (!buf)
     
202.                 return -ENOMEM;
     
203. 
     
204.         res = single_open(file, show_stat, NULL);
     
205.         if (!res) {
     
206.                 m = file->private_data;
     
207.                 m->buf = buf;
     
208.                 m->size = ksize(buf);
     
209.         } else
     
210.                 kfree(buf);
     
211.         return res;
     
212. }
     
213. 
     
214. static const struct file_operations proc_stat_operations = {
     
215.         .open                = stat_open,
     
216.         .read                = seq_read,
     
217.         .llseek                = seq_lseek,
     
218.         .release        = single_release,
     
219. };
     
220. 
     
221. static int __init proc_stat_init(void)
     
222. {
     
223.         proc_create("stat", 0, NULL, &proc_stat_operations);
     
224.         return 0;
     
225. }
     
226. fs_initcall(proc_stat_init);

复制代码

参考

http://man7.org/linux/man-pages/man5/proc.5.html
https://github.com/pcolby/scripts/blob/master/cpu.sh
https://elixir.bootlin.com/linux/v3.14.69/source/fs/proc/stat.c
到此这篇关于Linux中计算特定CPU使用率案例详解的文章就介绍到这了,更多相关Linux中计算特定CPU使用率内容请搜索脚本之家以前的文章或继续浏览下面的相关文章，希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/LINUXjishu/788452.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！