安装Perf

安装Perf

安装 perf 非常简单, 只要内核版本高于2.6.31的, perf已经被内核支持. 首先安装内核源码:

1. apt-get install linux-source

那么在 /usr/src 目录下就已经下载好了内核源码, 我们对源码包进行解压, 然后进入 tools/perf 目录然后敲入下面两个命令即可：
 

1. make
2. make install

可能因为系统原因, 需要提前安装下面的开发包:

1. apt-get install -y binutils-dev
2. apt-get install -y libdw-dev
3. apt-get install -y python-dev
4. apt-get install -y libnewt-dev

Perf的基本使用

perf COMMAND [-e event ...] PROGRAM, perf 是采用的这么一个命令格式, COMMAND一般常用的就是 top, stat, record, report等. 然后用 -e 参数来统计需要关注的事件. 多个事件就用多个 -e 连接.

1. perf stat
说明一个工具的最佳途径是列举一个例子。
考查下面这个例子程序。其中函数 longa() 是个很长的循环，比较浪费时间。函数 foo1 和 foo2 将分别调用该函数 10 次，以及 100 次。

1. //t1.c
2.  void longa()
3.  {
4.    int i,j;
5.    for(i = 0; i < 1000000; i++)
6.    j=i; //am I silly or crazy? I feel boring and desperate.
7.  }
8.  
9.  void foo2()
10.  {
11.    int i;
12.    for(i=0 ; i < 10; i++)
13.         longa();
14.  }
15.  
16.  void foo1()
17.  {
18.    int i;
19.    for(i = 0; i< 100; i++)
20.       longa();
21.  }
22.  
23.  int main(void)
24.  {
25.    foo1();
26.    foo2();
27.  }

然后编译它:

1. gcc -o t1 -g t1.c

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

1. root@ubuntu-test:~# perf stat ./t1
2.  
3.  Performance counter stats for './t1':
4.  
5.         218.584169 task-clock # 0.997 CPUs utilized
6.                 18 context-switches # 0.000 M/sec
7.                  0 CPU-migrations # 0.000 M/sec
8.                 82 page-faults # 0.000 M/sec
9.        771,180,100 cycles # 3.528 GHz
10.      <not counted> stalled-cycles-frontend
11.      <not counted> stalled-cycles-backend
12.        550,703,114 instructions # 0.71 insns per cycle
13.        110,117,522 branches # 503.776 M/sec
14.              5,009 branch-misses # 0.00% of all branches
15.  
16.        0.219155248 seconds time elapsed
17.  
18. 程序 t1 是一个 CPU bound 型，因为 task-clock-msecs 接近 1

对 t1 进行调优应该要找到热点 ( 即最耗时的代码片段 )，再看看是否能够提高热点代码的效率。
缺省情况下，除了 task-clock-msecs 之外，perf stat 还给出了其他几个最常用的统计信息：
Task-clock-msecs：CPU 利用率，该值高，说明程序的多数时间花费在 CPU 计算上而非 IO。
Context-switches：进程切换次数，记录了程序运行过程中发生了多少次进程切换，频繁的进程切换是应该避免的。
Cache-misses：程序运行过程中总体的 cache 利用情况，如果该值过高，说明程序的 cache 利用不好
CPU-migrations：表示进程 t1 运行过程中发生了多少次 CPU 迁移，即被调度器从一个 CPU 转移到另外一个 CPU 上运行。
Cycles：处理器时钟，一条机器指令可能需要多个 cycles，
Instructions: 机器指令数目。
IPC：是 Instructions/Cycles 的比值，该值越大越好，说明程序充分利用了处理器的特性。
Cache-references: cache 命中的次数
Cache-misses: cache 失效的次数。
通过指定 -e 选项，您可以改变 perf stat 的缺省事件 ( 关于事件，在上一小节已经说明，可以通过 perf list 来查看 )。假如您已经有很多的调优经验，可能会使用 -e 选项来查看您所感兴趣的特殊的事件。
有些程序慢是因为计算量太大，其多数时间都应该在使用 CPU 进行计算，这叫做 CPU bound 型；有些程序慢是因为过多的 IO，这种时候其 CPU 利用率应该不高，这叫做 IO bound 型；对于 CPU bound 程序的调优和 IO bound 的调优是不同的。


2. perf top
使用 perf stat 的时候，往往您已经有一个调优的目标。比如我刚才写的那个无聊程序 t1。
也有些时候，您只是发现系统性能无端下降，并不清楚究竟哪个进程成为了贪吃的 hog。
此时需要一个类似 top 的命令，列出所有值得怀疑的进程，从中找到需要进一步审查的家伙。
Perf top 用于实时显示当前系统的性能统计信息。该命令主要用来观察整个系统当前的状态，比如可以通过查看该命令的输出来查看当前系统最耗时的内核函数或某个用户进程。
让我们再设计一个例子来演示吧，我很快就想到了如代码清单 2 所示的一个程序：

1. //t2.c
2. main(){
3.     int i;
4.     while(1) i++;
5. }

然后编译这个程序：

1. gcc -o t2 -g t2.c

运行这个程序后， 我们另起一个窗口，运行perf top来看看：

1. Events: 8K cycles
2.  98.67% t2 [.] main
3.   1.10% [kernel] [k] __do_softirq
4.   0.07% [kernel] [k] _raw_spin_unlock_irqrestore
5.   0.05% perf [.] kallsyms__parse
6.   0.05% libc-2.15.so [.] 0x807c7
7.   0.05% [kernel] [k] kallsyms_expand_symbol
8.   0.02% perf [.] map__process_kallsym_symbol

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



3. 使用 perf record, 解读 report
使用 top 和 stat 之后，您可能已经大致有数了。要进一步分析，便需要一些粒度更细的信息。比如说您已经断定目标程序计算量较大，也许是因为有些代码写的不够精简。那么面对长长的代码文件，究竟哪几行代码需要进一步修改呢？这便需要使用 perf record 记录单个函数级别的统计信息，并使用 perf report 来显示统计结果。
您的调优应该将注意力集中到百分比高的热点代码片段上，假如一段代码只占用整个程序运行时间的 0.1%，即使您将其优化到仅剩一条机器指令，恐怕也只能将整体的程序性能提高 0.1%。俗话说，好钢用在刀刃上，不必我多说了。

1. perf record -e cpu-clock ./t1
2. perf report

 perf report 输出结果：

1. Events: 229 cpu-clock
2.  100.00% t1 t1 [.] longa

不出所料，hot spot 是 longa( ) 函数。
但，代码是非常复杂难说的，t1 程序中的 foo1() 也是一个潜在的调优对象，为什么要调用 100 次那个无聊的 longa() 函数呢？但我们在上图中无法发现 foo1 和 foo2，更无法了解他们的区别了。
我曾发现自己写的一个程序居然有近一半的时间花费在 string 类的几个方法上，string 是 C++ 标准，我绝不可能写出比 STL 更好的代码了。因此我只有找到自己程序中过多使用 string 的地方。因此我很需要按照调用关系进行显示的统计信息。
使用 perf 的 -g 选项便可以得到需要的信息：

1. perf record -e cpu-clock -g ./t1
2. perf report

输出结果：

1. Events: 270 cpu-clock
2. - 100.00% t1 t1 [.] longa
3.    - longa
4.       + 91.85% foo1
5.       + 8.15% foo2

通过对 calling graph 的分析，能很方便地看到 91.85% 的时间都花费在 foo1() 函数中，因为它调用了 100 次 longa() 函数，因此假如 longa() 是个无法优化的函数，那么程序员就应该考虑优化 foo1，减少对 longa() 的调用次数。


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

1. root@ubuntu-test:~# perf stat -e raw_syscalls:sys_enter ls
2. bin libexec off perf.data.old t1 t3 tutong.iso
3. bwtest minicom.log perf.data pktgen t1.c t3.c
4.  
5.  Performance counter stats for 'ls':
6.  
7.                111 raw_syscalls:sys_enter
8.  
9.        0.001557549 seconds time elapsed

这个报告详细说明了在 ls 运行期间发生了多少次系统调用 ( 上例中有 111 次 )