中国领先的IT技术网站
|
|

Linux下的系统性能调优工具——Perf

很多 perf 命令都是为调试单个程序或者单个目的而设计。有些时候,性能问题并非由单个原因所引起,需要从各个角度一一查看。为此,人们常需要综合利用各种工具,比如 top,vmstat,oprofile 或者 perf。

作者:佚名来源:嵌入式Linux中文站|2017-07-04 13:02

Tech Neo技术沙龙 | 11月25号,九州云/ZStack与您一起探讨云时代网络边界管理实践


Linux下的系统性能调优工具——Perf

1. 背景知识

1.1 与性能调优相关的硬件特性

  • 硬件特性之cache

内存读写是很快的,但还是无法和处理器的指令执行速度相比。为了从内存中读取指令和数据,处理器需要等待,用处理器的时间来衡量,这种等待非常漫长。Cache 是一种 SRAM,它的读写速率非常快,能和处理器处理速度相匹配。因此将常用的数据保存在 cache 中,处理器便无须等待,从而提高性能。Cache 的尺寸一般都很小,充分利用 cache 是软件调优非常重要的部分。

  • 硬件特性之流水线,超标量体系结构,乱序执行

提高性能最有效的方式之一就是并行。处理器在硬件设计时也尽可能地并行,比如流水线,超标量体系结构以及乱序执行。

处理器处理一条指令需要分多个步骤完成,比如先取指令,然后完成运算,最后将计算结果输出到总线上。第一条指令在运算时,第二条指令已经在取指了;而第一条指令输出结果时,第二条指令则又可以运算了,而第三天指令也已经取指了。这样从长期看来,像是三条指令在同时执行。在处理器内部,这可以看作一个三级流水线。

超标量(superscalar)指一个时钟周期发射多条指令的流水线机器架构,比如 Intel 的 Pentium 处理器,内部有两个执行单元,在一个时钟周期内允许执行两条指令。

在处理器内部,不同指令所需要的处理步骤和时钟周期是不同的,如果严格按照程序的执行顺序执行,那么就无法充分利用处理器的流水线。因此指令有可能被乱序执行。

上述三种并行技术对所执行的指令有一个基本要求,即相邻的指令相互没有依赖关系。假如某条指令需要依赖前面一条指令的执行结果数据,那么 pipeline 便失去作用,因为第二条指令必须等待第一条指令完成。因此好的软件必须尽量避免这种代码的生成。

  • 硬件特性之分支预测

分支指令对软件性能有比较大的影响。尤其是当处理器采用流水线设计之后,假设流水线有三级,当前进入流水的第一条指令为分支指令。假设处理器顺序读取指令,那么如果分支的结果是跳转到其他指令,那么被处理器流水线预取的后续两条指令都将被放弃,从而影响性能。为此,很多处理器都提供了分支预测功能,根据同一条指令的历史执行记录进行预测,读取最可能的下一条指令,而并非顺序读取指令。

分支预测对软件结构有一些要求,对于重复性的分支指令序列,分支预测硬件能得到较好的预测结果,而对于类似 switch case 一类的程序结构,则往往无法得到理想的预测结果。

上面介绍的几种处理器特性对软件的性能有很大的影响,然而依赖时钟进行定期采样的 profiler 模式无法揭示程序对这些处理器硬件特性的使用情况。处理器厂商针对这种情况,在硬件中加入了 PMU 单元,即 performance monitor unit。PMU 允许软件针对某种硬件事件设置 counter,此后处理器便开始统计该事件的发生次数,当发生的次数超过 counter 内设置的值后,便产生中断。比如 cache miss 达到某个值后,PMU 便能产生相应的中断。

捕获这些中断,便可以考察程序对这些硬件特性的利用效率了。

1.2 Tracepoints

Tracepoint 是散落在内核源代码中的一些 hook,一旦使能,它们便可以在特定的代码被运行到时被触发,这一特性可以被各种 trace/debug 工具所使用。Perf 就是该特性的用户之一。

假如您想知道在应用程序运行期间,内核内存管理模块的行为,便可以利用潜伏在 slab 分配器中的 tracepoint。当内核运行到这些 tracepoint 时,便会通知 perf。Perf 将 tracepoint 产生的事件记录下来,生成报告,通过分析这些报告,调优人员便可以了解程序运行时期内核的种种细节,对性能症状作出更准确的诊断。

2.Perf简介

  • Perf是Linux内核自带的系统性能优化工具,原理是:

CPU的PMU registers中Get/Set performance counters来获得诸如instructions executed, cache-missed suffered, branches mispredicted等信息。linux kernel对这些registers进行了一系列抽象,所以你可以按进程,按CPU或者按counter group等不同类别来查看Sample信息。

  • 通过Perf,应用程序可以利用 PMU,tracepoint 和内核中的特殊计数器来进行性能统计。它不但可以分析指定应用程序的性能问题 (per thread),也可以用来分析内核的性能问题,当然也可以同时分析应用代码和内核,从而全面理解应用程序中的性能瓶颈。
  • Perf 不仅可以用于应用程序的性能统计分析,也可以应用于内核代码的性能统计和分析。得益于其优秀的体系结构设计,越来越多的新功能被加入 Perf,使其已经成为一个多功能的性能统计工具集 。

3.perf 的基本使用

性能调优工具如 perf,Oprofile 等的基本原理都是对被监测对象进行采样,最简单的情形是根据 tick 中断进行采样,即在 tick 中断内触发采样点,在采样点里判断程序当时的上下文。假如一个程序 90% 的时间都花费在函数 foo() 上,那么 90% 的采样点都应该落在函数 foo() 的上下文中。运气不可捉摸,但我想只要采样频率足够高,采样时间足够长,那么以上推论就比较可靠。因此,通过 tick 触发采样,我们便可以了解程序中哪些地方最耗时间,从而重点分析。稍微扩展一下思路,就可以发现改变采样的触发条件使得我们可以获得不同的统计数据:以时间点 ( 如 tick) 作为事件触发采样便可以获知程序运行时间的分布。以 cache miss 事件触发采样便可以知道 cache miss 的分布,即 cache 失效经常发生在哪些程序代码中。如此等等。

因此让我们先来了解一下 perf 中能够触发采样的事件有哪些。

3.1 Perf list,perf 事件

使用 perf list 命令可以列出所有能够触发 perf 采样点的事件。比如

  1. # perf list  
  2.   List of pre-defined events (to be used in -e):  
  3.   cpu-cycles OR cycles [Hardware event]  
  4.   instructions [Hardware event]  
  5.   … 
  6.   cpu-clock [Software event]  
  7.   task-clock [Software event]  
  8.   context-switches OR cs [Software event]  
  9.   … 
  10.   ext4:ext4_allocate_inode [Tracepoint event]  
  11.   kmem:kmalloc [Tracepoint event]  
  12.   module:module_load [Tracepoint event]  
  13.   workqueue:workqueue_execution [Tracepoint event]  
  14.   sched:sched_{wakeup,switch} [Tracepoint event]  
  15.   syscalls:sys_{enter,exit}_epoll_wait [Tracepoint event]  
  16.   …  

不同的系统会列出不同的结果,在 2.6.35 版本的内核中,该列表已经相当的长,但无论有多少,我们可以将它们划分为三类:

  • Hardware Event 是由 PMU 硬件产生的事件,比如 cache 命中,当您需要了解程序对硬件特性的使用情况时,便需要对这些事件进行采样;
  • Software Event 是内核软件产生的事件,比如进程切换,tick 数等 ;
  • Tracepoint event 是内核中的静态 tracepoint 所触发的事件,这些 tracepoint 用来判断程序运行期间内核的行为细节,比如 slab 分配器的分配次数等。

上述每一个事件都可以用于采样,并生成一项统计数据,时至今日,尚没有文档对每一个 event 的含义进行详细解释。

3.2 Perf stat

面对一个问题程序,最好采用自顶向下的策略。先整体看看该程序运行时各种统计事件的大概,再针对某些方向深入细节。而不要一下子扎进琐碎细节,会一叶障目的。

有些程序慢是因为计算量太大,其多数时间都应该在使用 CPU 进行计算,这叫做 CPU bound 型;有些程序慢是因为过多的 IO,这种时候其 CPU 利用率应该不高,这叫做 IO bound 型;对于 CPU bound 程序的调优和 IO bound 的调优是不同的。

如果您认同这些说法的话,Perf stat 应该是您最先使用的一个工具。它通过概括精简的方式提供被调试程序运行的整体情况和汇总数据。

下面演示了 perf stat 针对程序 t1 的输出:

$perf stat ./t1 Performance counter stats for './t1':

  1. 262.738415 task-clock-msecs # 0.991 CPUs  
  2.    2 context-switches # 0.000 M/sec  
  3.    1 CPU-migrations # 0.000 M/sec  
  4.    81 page-faults # 0.000 M/sec  
  5.    9478851 cycles # 36.077 M/sec (scaled from 98.24%)  
  6.    6771 instructions # 0.001 IPC (scaled from 98.99%)  
  7.    111114049 branches # 422.908 M/sec (scaled from 99.37%)  
  8.    8495 branch-misses # 0.008 % (scaled from 95.91%)  
  9.    12152161 cache-references # 46.252 M/sec (scaled from 96.16%)  
  10.    7245338 cache-misses # 27.576 M/sec (scaled from 95.49%) 
  11.  
  12.    0.265238069 seconds time elapsed  

上面告诉我们,程序 t1 是一个 CPU bound 型,因为 task-clock-msecs 接近 1。

对 t1 进行调优应该要找到热点 ( 即最耗时的代码片段 ),再看看是否能够提高热点代码的效率。

缺省情况下,除了 task-clock-msecs 之外,perf stat 还给出了其他几个最常用的统计信息:

  1. Task-clock-msecs:CPU 利用率,该值高,说明程序的多数时间花费在 CPU 计算上而非 IO。 
  2.     Context-switches:进程切换次数,记录了程序运行过程中发生了多少次进程切换,频繁的进程切换是应该避免的。 
  3.     Cache-misses:程序运行过程中总体的 cache 利用情况,如果该值过高,说明程序的 cache 利用不好 
  4.     CPU-migrations:表示进程 t1 运行过程中发生了多少次 CPU 迁移,即被调度器从一个 CPU 转移到另外一个 CPU 上运行。 
  5.     Cycles:处理器时钟,一条机器指令可能需要多个 cycles, 
  6.     Instructions: 机器指令数目。 
  7.     IPC:是 Instructions/Cycles 的比值,该值越大越好,说明程序充分利用了处理器的特性。 
  8.     Cache-references: cache 命中的次数 
  9.     Cache-misses: cache 失效的次数。  

通过指定 -e 选项,您可以改变 perf stat 的缺省事件 ( 关于事件,在上一小节已经说明,可以通过 perf list 来查看 )。假如您已经有很多的调优经验,可能会使用 -e 选项来查看您所感兴趣的特殊的事件。

3.3perf Top

Perf top 用于实时显示当前系统的性能统计信息。该命令主要用来观察整个系统当前的状态,比如可以通过查看该命令的输出来查看当前系统最耗时的内核函数或某个用户进程。

下面是 perf top 的可能输出:

  1. PerfTop: 705 irqs/sec kernel:60.4% [1000Hz cycles]  
  2.    --------------------------------------------------  
  3.    sampl pcnt function DSO  
  4.    1503.00 49.2% t2  
  5.    72.00 2.2% pthread_mutex_lock /lib/libpthread-2.12.so  
  6.    68.00 2.1% delay_tsc [kernel.kallsyms]  
  7.    55.00 1.7% aes_dec_blk [aes_i586]  
  8.    55.00 1.7% drm_clflush_pages [drm]  
  9.    52.00 1.6% system_call [kernel.kallsyms]  
  10.    49.00 1.5% __memcpy_ssse3 /lib/libc-2.12.so  
  11.    48.00 1.4% __strstr_ia32 /lib/libc-2.12.so  
  12.    46.00 1.4% unix_poll [kernel.kallsyms]  
  13.    42.00 1.3% __ieee754_pow /lib/libm-2.12.so  
  14.    41.00 1.2% do_select [kernel.kallsyms]  
  15.    40.00 1.2% pixman_rasterize_edges libpixman-1.so.0.18.0  
  16.    37.00 1.1% _raw_spin_lock_irqsave [kernel.kallsyms]  
  17.    36.00 1.1% _int_malloc /lib/libc-2.12.so  
  18.    ^C  

很容易便发现 t2 是需要关注的可疑程序。不过其作案手法太简单:肆无忌惮地浪费着 CPU。所以我们不用再做什么其他的事情便可以找到问题所在。但现实生活中,影响性能的程序一般都不会如此愚蠢,所以我们往往还需要使用其他的 perf 工具进一步分析。

通过添加 -e 选项,您可以列出造成其他事件的 TopN 个进程 / 函数。比如 -e cache-miss,用来看看谁造成的 cache miss 最多。

3.4 使用 perf record, 解读 report

  1. lenny@hbt:~/test$ perf record ./a.out  
  2.    [ perf record: Woken up 1 times to write data ] 
  3.    [ perf record: Captured and wrote 0.015 MB perf.data (~656 samples) ] 
  4.    lenny@hbt:~/test$ perf report 
  5.    Events: 12  cycles                                                                                                                      
  6.     62.29%  a.out  a.out              [.] longa 
  7.     35.17%  a.out  [kernel.kallsyms]  [k] unmap_vmas 
  8.      1.76%  a.out  [kernel.kallsyms]  [k] __schedule 
  9.      0.75%  a.out  [kernel.kallsyms]  [k] ____cache_alloc 
  10.      0.03%  a.out  [kernel.kallsyms]  [k] native_write_msr_safe  

perf record时加上-g选项,可以记录函数的调用关系,显示类似下面这样:

  1. lenny@hbt:~/test$ perf record -g ./a.out  
  2.     [ perf record: Woken up 1 times to write data ] 
  3.     [ perf record: Captured and wrote 0.016 MB perf.data (~701 samples) ] 
  4.     lenny@hbt:~/test$ perf report 
  5.     Events: 14  cycles                                                                                                                      
  6.     -  87.12%  a.out  a.out              [.] longa                                                                                         
  7.        - longa                                                                                                                             
  8.           - 52.91% fun1                                                                                                                    
  9.                main                                                                                                                        
  10.                __libc_start_main                                                                                                           
  11.           - 47.09% fun2                                                                                                                    
  12.                main                                                                                                                        
  13.                __libc_start_main                                                                                                           
  14.     +   9.12%  a.out  [kernel.kallsyms]  [k] vm_normal_page                                                                                
  15.     +   3.48%  a.out  [kernel.kallsyms]  [k] _cond_resched                                                                                 
  16.     +   0.28%  a.out  [kernel.kallsyms]  [k] native_write_msr_safe  

***使用 PMU 的例子下面这个例子 t3 参考了文章“Branch and Loop Reorganization to Prevent Mispredicts”该例子考察程序对奔腾处理器分支预测的利用率,如前所述,分支预测能够显著提高处理器的性能,而分支预测失败则显著降低处理器的性能。首先给出一个存在 BTB 失效的例子:

清单 3. 存在 BTB 失效的例子程序

  1. //test.c  
  2.    #include <stdio.h>  
  3.    #include <stdlib.h> 
  4.  
  5.    void foo()  
  6.    {  
  7.     int i,j;  
  8.     for(i=0; i< 10; i++)  
  9.     j+=2;  
  10.    }  
  11.    int main(void)  
  12.    {  
  13.     int i;  
  14.     for(i = 0; i< 100000000; i++)  
  15.     foo();  
  16.     return 0;  
  17.    }  

用 gcc 编译生成测试程序 t3: gcc – o t3 – O0 test.c

用 perf stat 考察分支预测的使用情况: [lm@ovispoly perf]$ ./perf stat ./t3

  1. Performance counter stats for './t3'
  2.  
  3.    6240.758394 task-clock-msecs # 0.995 CPUs  
  4.    126 context-switches # 0.000 M/sec  
  5.    12 CPU-migrations # 0.000 M/sec  
  6.    80 page-faults # 0.000 M/sec  
  7.    17683221 cycles # 2.834 M/sec (scaled from 99.78%)  
  8.    10218147 instructions # 0.578 IPC (scaled from 99.83%)  
  9.    2491317951 branches # 399.201 M/sec (scaled from 99.88%)  
  10.    636140932 branch-misses # 25.534 % (scaled from 99.63%)  
  11.    126383570 cache-references # 20.251 M/sec (scaled from 99.68%)  
  12.    942937348 cache-misses # 151.093 M/sec (scaled from 99.58%) 
  13.  
  14.     6.271917679 seconds time elapsed  

可以看到 branche-misses 的情况比较严重,25% 左右。我测试使用的机器的处理器为 Pentium4,其 BTB 的大小为 16。而 test.c 中的循环迭代为 20 次,BTB 溢出,所以处理器的分支预测将不准确。对于上面这句话我将简要说明一下,但关于 BTB 的细节,请阅读参考文献 [6]。for 循环编译成为 IA 汇编后如下:

清单 4. 循环的汇编

  1. // C code  
  2.     for ( i=0; i < 20; i++ )  
  3.     { … } 
  4.  
  5.     //Assembly code;  
  6.     mov    esi, data  
  7.     mov    ecx, 0  
  8.     ForLoop:  
  9.     cmp    ecx, 20  
  10.     jge     
  11.     EndForLoop  
  12.     … 
  13.     add    ecx, 1  
  14.     jmp    ForLoop  
  15.     EndForLoop:  

可以看到,每次循环迭代中都有一个分支语句 jge,因此在运行过程中将有 20 次分支判断。每次分支判断都将写入 BTB,但 BTB 是一个 ring buffer,16 个 slot 写满后便开始覆盖。假如迭代次数正好为 16,或者小于 16,则完整的循环将全部写入 BTB。

清单 5. 没有 BTB 失效的代码

  1. #include <stdio.h>  
  2.     #include <stdlib.h> 
  3.  
  4.     void foo()  
  5.     {  
  6.      int i,j;  
  7.      for(i=0; i< 10; i++)  
  8.      j+=2;  
  9.     }  
  10.     int main(void)  
  11.     {  
  12.      int i;  
  13.      for(i = 0; i< 100000000; i++)  
  14.      foo();  
  15.      return 0;  
  16.     }  

此时再次用 perf stat 采样得到如下结果: [lm@ovispoly perf]$ ./perf stat ./t3

  1. Performance counter stats for './t3: 
  2.  
  3.    2784.004851 task-clock-msecs # 0.927 CPUs  
  4.    90 context-switches # 0.000 M/sec  
  5.    8 CPU-migrations # 0.000 M/sec  
  6.    81 page-faults # 0.000 M/sec  
  7.    33632545 cycles # 12.081 M/sec (scaled from 99.63%)  
  8.    42996 instructions # 0.001 IPC (scaled from 99.71%)  
  9.    1474321780 branches # 529.569 M/sec (scaled from 99.78%)  
  10.    49733 branch-misses # 0.003 % (scaled from 99.35%)  
  11.    7073107 cache-references # 2.541 M/sec (scaled from 99.42%)  
  12.    47958540 cache-misses # 17.226 M/sec (scaled from 99.33%) 
  13.  
  14.     3.002673524 seconds time elapsed  

Branch-misses 减少了。本例只是为了演示 perf 对 PMU 的使用,本身并无意义,关于充分利用 processor 进行调优可以参考 Intel 公司出品的调优手册,其他的处理器可能有不同的方法,还希望读者明鉴。

3.5 使用 tracepoint

当 perf 根据 tick 时间点进行采样后,人们便能够得到内核代码中的 hot spot。那什么时候需要使用 tracepoint 来采样呢?我想人们使用 tracepoint 的基本需求是对内核的运行时行为的关心,如前所述,有些内核开发人员需要专注于特定的子系统,比如内存管理模块。这便需要统计相关内核函数的运行情况。另外,内核行为对应用程序性能的影响也是不容忽视的:以之前的遗憾为例,假如时光倒流,我想我要做的是统计该应用程序运行期间究竟发生了多少次系统调用。在哪里发生的?下面我用 ls 命令来演示 sys_enter 这个 tracepoint 的使用:

  1. [root@ovispoly /]# perf stat -e raw_syscalls:sys_enter ls bin dbg etc lib media opt root selinux sys usr boot dev home lost+found mnt proc sbin srv tmp var 
  2.  
  3. Performance counter stats for 'ls'
  4.  
  5. 101 raw_syscalls:sys_enter 
  6.  
  7. 0.003434730 seconds time elapsed 
  8.  
  9. [root@ovispoly /]# perf record -e raw_syscalls:sys_enter ls 
  10.  
  11. [root@ovispoly /]# perf report Failed to open .lib/ld-2.12.so, continuing without symbols # Samples: 70 # # Overhead Command Shared Object Symbol # ........ ............... ............... ...... # 97.14% ls ld-2.12.so [.] 0x0000000001629d 2.86% ls [vdso] [.] 0x00000000421424 # # (For a higher level overview, try: perf report --sort comm,dso) # 

这个报告详细说明了在 ls 运行期间发生了多少次系统调用 ( 上例中有 101 次 ),多数系统调用都发生在哪些地方 (97% 都发生在 ld-2.12.so 中 )。有了这个报告,或许我能够发现更多可以调优的地方。比如函数 foo() 中发生了过多的系统调用,那么我就可以思考是否有办法减少其中有些不必要的系统调用。您可能会说 strace 也可以做同样事情啊,的确,统计系统调用这件事完全可以用 strace 完成,但 perf 还可以干些别的,您所需要的就是修改 -e 选项后的字符串。罗列 tracepoint 实在是不太地道,本文当然不会这么做。但学习每一个 tracepoint 是有意义的,类似背单词之于学习英语一样,是一项缓慢痛苦却不得不做的事情。

3.6 perf probe

tracepoint 是静态检查点,意思是一旦它在哪里,便一直在那里了,您想让它移动一步也是不可能的。内核代码有多少行?我不知道,100 万行是至少的吧,但目前 tracepoint 有多少呢?我最大胆的想象是不超过 1000 个。所以能够动态地在想查看的地方插入动态监测点的意义是不言而喻的。

Perf 并不是第一个提供这个功能的软件,systemTap 早就实现了。但假若您不选择 RedHat 的发行版的话,安装 systemTap 并不是件轻松愉快的事情。perf 是内核代码包的一部分,所以使用和维护都非常方便。

我使用的 Linux 版本为 2.6.33。因此您自己做实验时命令参数有可能不同。

  1. [root@ovispoly perftest]# perf probe schedule:12 cpu  
  2.     Added new event:  
  3.     probe:schedule (on schedule+52 with cpu) 
  4.  
  5.     You can now use it on all perf tools, such as
  6.  
  7.                  perf record -e probe:schedule -a sleep 1 
  8.  
  9.     [root@ovispoly perftest]# perf record -e probe:schedule -a sleep 1  
  10.     Error, output file perf.data exists, use -A to append or -f to overwrite. 
  11.  
  12.     [root@ovispoly perftest]# perf record -f -e probe:schedule -a sleep 1  
  13.     [ perf record: Woken up 1 times to write data ]  
  14.     [ perf record: Captured and wrote 0.270 MB perf.data (~11811 samples) ]  
  15.     [root@ovispoly perftest]# perf report  
  16.     # Samples: 40  
  17.     #  
  18.     # Overhead Command Shared Object Symbol  
  19.     # ........ ............... ................. ......  
  20.     #  
  21.     57.50% init 0 [k] 0000000000000000  
  22.     30.00% firefox [vdso] [.] 0x0000000029c424  
  23.     5.00% sleep [vdso] [.] 0x00000000ca7424  
  24.     5.00% perf.2.6.33.3-8 [vdso] [.] 0x00000000ca7424  
  25.     2.50% ksoftirqd/0 [kernel] [k] 0000000000000000  
  26.     #  
  27.     # (For a higher level overview, try: perf report --sort comm,dso)  
  28.     #  

上例利用 probe 命令在内核函数 schedule() 的第 12 行处加入了一个动态 probe 点,和 tracepoint 的功能一样,内核一旦运行到该 probe 点时,便会通知 perf。可以理解为动态增加了一个新的 tracepoint。此后便可以用 record 命令的 -e 选项选择该 probe 点,最后用 perf report 查看报表。如何解读该报表便是见仁见智了,既然您在 shcedule() 的第 12 行加入了 probe 点,想必您知道自己为什么要统计它吧?

3.7 Perf sched

调度器的好坏直接影响一个系统的整体运行效率。在这个领域,内核黑客们常会发生争执,一个重要原因是对于不同的调度器,每个人给出的评测报告都各不相同,甚至常常有相反的结论。因此一个权威的统一的评测工具将对结束这种争论有益。Perf sched 便是这种尝试。

Perf sched 有五个子命令:

  1. perf sched record            # low-overhead recording of arbitrary workloads  
  2.    perf sched latency           # output per task latency metrics  
  3.    perf sched map               # show summary/map of context-switching  
  4.    perf sched trace             # output finegrained trace  
  5.    perf sched replay            # replay a captured workload using simlated threads  

用户一般使用’ perf sched record ’收集调度相关的数据,然后就可以用’ perf sched latency ’查看诸如调度延迟等和调度器相关的统计数据。其他三个命令也同样读取 record 收集到的数据并从其他不同的角度来展示这些数据。下面一一进行演示。

  1. perf sched record sleep 10     # record full system activity for 10 seconds  
  2.     perf sched latency --sort max  # report latencies sorted by max  
  3.     ------------------------------------------------------------------------------------- 
  4.      Task               |   Runtime ms  | Switches | Average delay ms | Maximum delay ms |  
  5.     ------------------------------------------------------------------------------------- 
  6.      :14086:14086        |      0.095 ms |        2 | avg:    3.445 ms | max:    6.891 ms |  
  7.      gnome-session:13792   |   31.713 ms |      102 | avg:    0.160 ms | max:    5.992 ms |  
  8.      metacity:14038      |     49.220 ms |      637 | avg:    0.066 ms | max:    5.942 ms |  
  9.      gconfd-2:13971     | 48.587 ms |      777 | avg:    0.047 ms | max:    5.793 ms |  
  10.      gnome-power-man:14050 |  140.601 ms | 434 | avg:  0.097 ms | max:    5.367 ms |  
  11.      python:14049        |  114.694 ms |      125 | avg:    0.120 ms | max:    5.343 ms |  
  12.      kblockd/1:236       |   3.458 ms |      498 | avg:    0.179 ms | max:    5.271 ms |  
  13.      Xorg:3122         |   1073.107 ms |     2920 | avg:    0.030 ms | max:    5.265 ms |  
  14.      dbus-daemon:2063   |   64.593 ms |      665 | avg:    0.103 ms | max:    4.730 ms |  
  15.      :14040:14040       |   30.786 ms |      255 | avg:    0.095 ms | max:    4.155 ms |  
  16.      events/1:8         |    0.105 ms |       13 | avg:    0.598 ms | max:    3.775 ms |  
  17.      console-kit-dae:2080  | 14.867 ms |   152 | avg:    0.142 ms | max:    3.760 ms |  
  18.      gnome-settings-:14023 |  572.653 ms |  979 | avg:    0.056 ms | max:    3.627 ms |  
  19.     ...  
  20.     ----------------------------------------------------------------------------------- 
  21.      TOTAL:                |   3144.817 ms |    11654 |  
  22.     ---------------------------------------------------  

上面的例子展示了一个 Gnome 启动时的统计信息。

各个 column 的含义如下: Task: 进程的名字和 pid Runtime: 实际运行时间 Switches: 进程切换的次数 Average delay: 平均的调度延迟 Maximum delay: 最大延迟

这里最值得人们关注的是 Maximum delay,一般从这里可以看到对交互性影响最大的特性:调度延迟,如果调度延迟比较大,那么用户就会感受到视频或者音频断断续续的。

其他的三个子命令提供了不同的视图,一般是由调度器的开发人员或者对调度器内部实现感兴趣的人们所使用。

首先是 map:

  1. N1  O1  .   .   .   S1  .   .   .   B0  .  *I0  C1  .   M1  .    23002.773423 secs  
  2.     N1  O1  .  *Q0  .   S1  .   .   .   B0  .   I0  C1  .   M1  .    23002.773423 secs  
  3.     N1  O1  .   Q0  .   S1  .   .   .   B0  .  *R1  C1  .   M1  .    23002.773485 secs  
  4.     N1  O1  .   Q0  .   S1  .  *S0  .   B0  .   R1  C1  .   M1  .    23002.773478 secs  
  5.    *L0  O1  .   Q0  .   S1  .   S0  .   B0  .   R1  C1  .   M1  .    23002.773523 secs  
  6.     L0  O1  .  *.   .   S1  .   S0  .   B0  .   R1  C1  .   M1  .    23002.773531 secs  
  7.     L0  O1  .   .   .   S1  .   S0  .   B0  .   R1  C1 *T1  M1  .    23002.773547 secs  
  8.                         T1 => irqbalance:2089  
  9.     L0  O1  .   .   .   S1  .   S0  .  *P0  .   R1  C1  T1  M1  .    23002.773549 secs  
  10.    *N1  O1  .   .   .   S1  .   S0  .   P0  .   R1  C1  T1  M1  .    23002.773566 secs  
  11.     N1  O1  .   .   .  *J0  .   S0  .   P0  .   R1  C1  T1  M1  .    23002.773571 secs  
  12.     N1  O1  .   .   .   J0  .   S0 *B0  P0  .   R1  C1  T1  M1  .    23002.773592 secs  
  13.     N1  O1  .   .   .   J0  .  *U0  B0  P0  .   R1  C1  T1  M1  .    23002.773582 secs  
  14.     N1  O1  .   .   .  *S1  .   U0  B0  P0  .   R1  C1  T1  M1  .    23002.773604 secs 

星号表示调度事件发生所在的 CPU。

点号表示该 CPU 正在 IDLE。

Map 的好处在于提供了一个的总的视图,将成百上千的调度事件进行总结,显示了系统任务在 CPU 之间的分布,假如有不好的调度迁移,比如一个任务没有被及时迁移到 idle 的 CPU 却被迁移到其他忙碌的 CPU,类似这种调度器的问题可以从 map 的报告中一眼看出来。如果说 map 提供了高度概括的总体的报告,那么 trace 就提供了最详细,最底层的细节报告。

Perf replay 这个工具更是专门为调度器开发人员所设计,它试图重放 perf.data 文件中所记录的调度场景。很多情况下,一般用户假如发现调度器的奇怪行为,他们也无法准确说明发生该情形的场景,或者一些测试场景不容易再次重现,或者仅仅是出于“偷懒”的目的,使用 perf replay,perf 将模拟 perf.data 中的场景,无需开发人员花费很多的时间去重现过去,这尤其利于调试过程,因为需要一而再,再而三地重复新的修改是否能改善原始的调度场景所发现的问题。

下面是 replay 执行的示例:

  1. $ perf sched replay run measurement overhead: 3771 nsecs sleep measurement overhead: 66617 nsecs the run test took 999708 nsecs the sleep test took 1097207 nsecs 
  2. nr_run_events: 200221 nr_sleep_events: 200235 nr_wakeup_events: 100130 task 0 ( perf: 13519), 
  3. nr_events: 148 task 1 ( perf: 13520), nr_events: 200037 task 2 ( pipe-test-100k: 13521), nr_events: 300090 task 3 ( ksoftirqd/0: 4), 
  4. nr_events: 8 task 4 ( swapper: 0), nr_events: 170 task 5 ( gnome-power-man: 3192), nr_events: 3 task 6 ( gdm-simple-gree: 3234), 
  5. nr_events: 3 task 7 ( Xorg: 3122), nr_events: 5 task 8 ( hald-addon-stor: 2234), nr_events: 27 task 9 ( ata/0: 321), 
  6. nr_events: 29 task 10 ( scsi_eh_4: 704), nr_events: 37 task 11 ( events/1: 8), nr_events: 3 task 12 ( events/0: 7), 
  7. nr_events: 6 task 13 ( flush-8:0: 6980), nr_events: 20 
  8. ------------------------------------------------------------ #1 : 2038.157, ravg: 2038.16, cpu: 0.09 / 0.09 #2 : 2042.153, ravg: 2038.56, cpu: 0.11 / 0.09 ^C 

3.8 perf bench

除了调度器之外,很多时候人们都需要衡量自己的工作对系统性能的影响。benchmark 是衡量性能的标准方法,对于同一个目标,如果能够有一个大家都承认的 benchmark,将非常有助于”提高内核性能”这项工作。

目前,就我所知,perf bench 提供了 3 个 benchmark:

1.Sched message

sched message 是从经典的测试程序 hackbench 移植而来,用来衡量调度器的性能,overhead 以及可扩展性。该 benchmark 启动 N 个 reader/sender 进程或线程对,通过 IPC(socket 或者 pipe) 进行并发的读写。一般人们将 N 不断加大来衡量调度器的可扩展性。Sched message 的用法及用途和 hackbench 一样。

2.Sched Pipe

Sched pipe 从 Ingo Molnar 的 pipe-test-1m.c 移植而来。当初 Ingo 的原始程序是为了测试不同的调度器的性能和公平性的。其工作原理很简单,两个进程互相通过 pipe 拼命地发 1000000 个整数,进程 A 发给 B,同时 B 发给 A。。。因为 A 和 B 互相依赖,因此假如调度器不公平,对 A 比 B 好,那么 A 和 B 整体所需要的时间就会更长。

3.Mem memcpy

这个是 perf bench 的作者 Hitoshi Mitake 自己写的一个执行 memcpy 的 benchmark。该测试衡量一个拷贝 1M 数据的 memcpy() 函数所花费的时间。我尚不明白该 benchmark 的使用场景。。。或许是一个例子,告诉人们如何利用 perf bench 框架开发更多的 benchmark 吧。

这三个 benchmark 给我们展示了一个可能的未来:不同语言,不同肤色,来自不同背景的人们将来会采用同样的 benchmark,只要有一份 Linux 内核代码即可。

3.9 perf lock

锁是内核同步的方法,一旦加了锁,其他准备加锁的内核执行路径就必须等待,降低了并行。因此对于锁进行专门分析应该是调优的一项重要工作。

3.10 perf Kmem

Perf Kmem 专门收集内核 slab 分配器的相关事件。比如内存分配,释放等。可以用来研究程序在哪里分配了大量内存,或者在什么地方产生碎片之类的和内存管理相关的问题。

Perf kmem 和 perf lock 实际上都是 perf tracepoint 的特例,您也完全可以用 Perf record – e kmem: 或者 perf record – e lock: 来完成同样的功能。但重要的是,这些工具在内部对原始数据进行了汇总和分析,因而能够产生信息更加明确更加有用的统计报表。

3.11 Perf timechart

很多 perf 命令都是为调试单个程序或者单个目的而设计。有些时候,性能问题并非由单个原因所引起,需要从各个角度一一查看。为此,人们常需要综合利用各种工具,比如 top,vmstat,oprofile 或者 perf。这非常麻烦。

此外,前面介绍的所有工具都是基于命令行的,报告不够直观。更令人气馁的是,一些报告中的参数令人费解。所以人们更愿意拥有一个“傻瓜式”的工具。

以上种种就是 perf timechart 的梦想,其灵感来源于 bootchart。采用“简单”的图形“一目了然”地揭示问题所在。

Timechart 可以显示更详细的信息,实际上是一个矢量图形 SVG 格式,用 SVG viewer 的放大功能,我们可以将该图的细节部分放大,timechart 的设计理念叫做”infinitely zoomable”。放大之后便可以看到一些更详细的信息,类似网上的 google 地图,找到国家之后,可以放大,看城市的分布,再放大,可以看到某个城市的街道分布,还可以放大以便得到更加详细的信息。完整的 timechart 图形和颜色解读超出了本文的范围,感兴趣的读者可以到作者 Arjan 的博客上查看。

【编辑推荐】

  1. pass:一款简单的基于Linux命令行的密码管理工具
  2. Linux连接投影仪(ubuntu)失败或显示不正常
  3. uCareSystem:Ubuntu/Linux Mint的一体化系统更新和维护工具
  4. 在Linux中使用shell脚本自动创建/移除并挂载交换文件
  5. 基于Linux的物联网操作系统知多少
【责任编辑:枯木 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

系统分析师技术指南

本书对前沿而又成熟的系统分析技术和方法进行了讨论,包括CMM与过程改进、J2EE与NET平台、中间件及相关技术、应用服务器、Web 服务、数据...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× CTO训练营(深圳站)