Chinaunix首页 | 论坛 | 博客

在线笔记

首页　| 　博文目录　| 　关于我

ckelsel

  • 博客访问： 1570067
  • 博文数量： 596
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 173
  • 用 户 组： 普通用户
  • 注册时间： 2016-07-06 15:50
个人简介

在线笔记

文章分类

全部博文（596）

文章存档

2016年（1）

2015年（104）

2014年（228）

2013年（226）

2012年（26）

2011年（11）

推荐博文
相关博文
Linux应用程序性能优化教程

分类： 架构设计与优化

2013-06-04 16:13:32

1.1   参考资料

《嵌入式Linux性能详解》，史子旺

主页

，Linux 的系统级性能剖析工具-perf （一） - 淘宝内核组

http://www.ibm.com/developerworks/cn/linux/l-cn-perf1/，Perf -- Linux下的系统性能调优工具，第 1 部分

2       测试优化概述

2.1   性能指标

性能指标最好以数值的形式来体现，如下表所示

场景

理想(ms)

下限(ms)

优化前(ms)

优化后(ms)

提升（倍）

移动窗口延迟

0

1000

 

 

 

2.2   测试工具

测试工具是十分重要，影响到测试结果的准确性以及性能瓶颈定位。

测试工具要符合以下几点：

l  支持输出函数调用关系图

l  支持输出函数被调用的次数

l  支持输出调用函数的时间占所有时间的百分比

l  支持统计库函数

下面这些是可选的，有这些功能更好。

l  支持分析cache命中率

l  支持源码级分析

l  支持汇编级分析

2.3   测试优化基本流程


2.4   测试优化基础知识

程序性能的问题，有很多原因，总结如下三点：

1、 程序的运算量很大，导致 CPU过于繁忙，CPU是瓶颈。

2、 程序需要做大量的 I/O，读写文件、内存操作等等，CPU 更多的是处于等待，I/O部分称为程序性能的瓶颈。

3、 程序之间相互等待，结果 CPU 利用率很低，但运行速度依然很慢，事务间的共享与死锁制约了程序的性能。

3       perf测试工具简介

Perf是内置于Linux内核源码树中的性能剖析工具。它基于事件采样原理，以性能事件为基础，支持针对处理器相关性能指标与操作系统相关性能指标的性能剖析。可用于性能瓶颈的查找与热点代码的定位。

通过它，应用程序可以利用 PMU，tracepoint 和内核中的特殊计数器来进行性能统计。它不但可以分析指定应用程序的性能问题 (per thread)，也可以用来分析内核的性能问题，当然也可以同时分析应用代码和内核，从而全面理解应用程序中的性能瓶颈。

最初的时候，它叫做 Performance counter，在 2.6.31 中第一次亮相。此后他成为内核开发最为活跃的一个领域。在 2.6.32 中它正式改名为 Performance Event，因为 perf 已不再仅仅作为 PMU 的抽象，而是能够处理所有的性能相关的事件。

使用 perf，您可以分析程序运行期间发生的硬件事件，比如 instructions retired ，processor clock cycles 等；您也可以分析软件事件，比如 Page Fault 和进程切换。这使得 Perf 拥有了众多的性能分析能力，举例来说，使用 Perf 可以计算每个时钟周期内的指令数，称为 IPC，IPC 偏低表明代码没有很好地利用 CPU。Perf 还可以对程序进行函数级别的采样，从而了解程序的性能瓶颈究竟在哪里等等。

3.1   移植安装perf

1.         内核支持perf，配置内核支持如下选项

CONFIG_HAVE_PERF_EVENTS=y
CONFIG_PERF_USE_VMALLOC=y
#
# Kernel Performance Events And Counters
#
CONFIG_PERF_EVENTS=y
CONFIG_PERF_COUNTERS=y

2.         编译perf

进入内核源码根目录

$cd tools/perf

$make

生成perf可执行文件，拷贝该文件即可。

3.2   优化示例


  1. //test.c
  2.  void longa(int a[])
  3.  {
  4.    int i,j;
  5.    for(i = 0; i < 1000000; i++)
  6.    j=i;
  7.    *a = j;
  8.  }
  9.  
  10.  void foo2(int a[])
  11.  {
  12.    int i;
  13.    for(i=0 ; i < 10; i++)
  14.         longa(&a[i]);
  15.  }
  16.  
  17.  void foo1(int a[])
  18.  {
  19.    int i;
  20.    for(i = 0; i< 100; i++)
  21.       longa(&a[i]);
  22.  }
  23.  
  24.  int main(void)
  25.  {
  26. int a[100];
  27.    foo1(a);
  28.    foo2(a);
  29. }
$ gcc test.c –g –o t1

3.2.1   定义性能指标

性能指标最好以数值的形式来体现，如下表所示

场景

理想(ms)

下限(ms)

优化前(ms)

优化后(ms)

提升（倍）

程序运行总时间

10

100

 

 

 

3.2.2   判断程序是CPU繁忙型还是IO等待型

$ perf stat ./t1


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

 

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

  • 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 失效的次数。

3.2.3   找出占用时间最多的函数

l  使用perf record对程序采样，

$ perf record –r0 –F100000 –g –f ./t1

-r 0实时采样

-F 100000 每秒采样100000次

-g 记录函数调用流程图

-f 覆盖以前的采样记录

l  输入采样结果，并打印函数调用流程图

$perf report –g

 


  1. # Samples: 867913977
  2. #
  3. # Overhead Command Shared Object Symbol
  4. # ........ ....... ............................................... ....
  5. #
  6.     93.32% a.out a.out [.] longa
  7.         |
  8.         --- longa
  9.             |
  10.             |--93.01%-- foo1
  11.             | main
  12.             | __libc_start_main
  13.             | _start
  14.             |
  15.             |--6.99%-- foo2
  16.             | main
  17.             | __libc_start_main
  18.             | _start
  19.             --0.00%-- [...]
  20.  
  21.      0.41% a.out [kernel.kallsyms] [k] perf_pending_interrupt
  22.         |
  23.         --- perf_pending_interrupt
  24.             |
  25.             |--91.40%-- longa
  26.             | |
  27.             | |--97.01%-- foo1
  28.             | | main
  29.             | | __libc_start_main
  30.             | | _start
  31.             | |
  32.             | --2.99%-- foo2
  33.             | main
  34.             | __libc_start_main
  35.             | _start
  36.             |
  37.             |--3.57%-- do_softirq
  38.             | irq_exit
  39.             | smp_apic_timer_interrupt
  40.             | apic_timer_interrupt
  41.             | |
  42.             | |--95.45%-- longa
  43.             | | foo1
  44.             | | main
  45.             | | __libc_start_main
  46.             | | _start
  47.             | |
  48.             | --4.55%-- do_filp_open
  49.             | do_sys_open
  50.             | sys_open
  51.             | syscall_call
  52.             | 0xb77ad994
  53.             | 0xb779d62b

从函数调用流程图可以看出，占用CPU时间最多的函数是longa（），占用程序运行时间的93.32%。 [.]表示用户态程序

93.32%    a.out  a.out                                            [.] longa

3.2.4   定位修改代码

   

  1. 93.32% a.out a.out [.] longa
  2.         |
  3.         --- longa
  4.             |
  5.             |--93.01%-- foo1
  6.             | main
  7.             | __libc_start_main
  8.             | _start

可以看出，foo1()函数最终调用longa()函数，占用了大部份时间。因此着手分析main()函数，foo1()函数，longa()函数。

分析代码，得出foo1（）调用了100次longa(),而longa()中的for循环没有做什么有意义的事情，因此删除该循环。


  1. void longa(int a[])
  2.  {
  3.    int i,j;
  4.    for(i = 0; i < 1000000; i++)
  5.    j=i;
  6.    *a = j;
  7.  }

修改后的代码如下


  1. void longa(int a[])
  2.  {
  3.    *a = 999999;
  4.  }

3.2.5   重新测试验证

l  程序运行时间对比

bash-4.0# perf stat ./a.out


  1. Performance counter stats for './a.out':
  2.  
  3.        1.698595 task-clock-msecs # 0.580 CPUs
  4.              22 context-switches # 0.013 M/sec
  5.               0 CPU-migrations # 0.000 M/sec
  6.              82 page-faults # 0.048 M/sec
  7.         2339630 cycles # 1377.391 M/sec
  8.          607298 instructions # 0.260 IPC
  9.          107550 branches # 63.317 M/sec
  10.           12025 branch-misses # 11.181 %
  11.   <not counted> cache-references
  12.   <not counted> cache-misses
  13.  
  14. 0.002929202 seconds time elapse

现在总的运行时间是0.002929202s， 对比优化前的运行时间0.265238069s，运行速度提升了100倍。

l  占用时间最多的函数

bash-4.0# perf report -g | head -n 100


  1. # Samples: 217690
  2. #
  3. # Overhead Command Shared Object Symbol
  4. # ........ ....... ....................................... ......
  5. #
  6.      5.51% a.out [kernel.kallsyms] [k] intel_pmu_enable_all
  7.               |
  8.               --- intel_pmu_enable_all
  9.                   hw_perf_enable
  10.                   perf_enable
  11.                  |
  12.                  |--62.88%-- ctx_sched_in
  13.                  | perf_event_task_sched_in
  14.                  | |
  15.                  | |--99.88%-- finish_task_switch
  16.                  | | schedule
  17.                  | | |
  18.                  | | |--50.00%-- work_resched
  19.                  | | | 0xffffe430
  20.                  | | | run_builtin
  21.                  | | | main
  22.                  | | | __libc_start_main
  23.                  | | | _start
  24.                  | | |
  25.                  | | --50.00%-- __cond_resched
  26.                  | | _cond_resched
  27.                  | | wait_for_common
  28.                  | | wait_for_completion
  29.                  | | sched_exec
  30.                  | | do_execve
  31.                  | | sys_execve
  32.                  | | ptregs_execve
  33.                  | | 0xffffe430
  34.                  | | __cmd_record
  35.                  | | run_builtin
  36.                  | | main
  37.                  | | __libc_start_main
  38.                  | | _start
  39.                  | --0.12%-- [...]
  40.                  |
  41.                  |--37.04%-- perf_ctx_adjust_freq
  42.                  | perf_event_task_tick
  43.                  | scheduler_tick
  44.                  | update_process_times
  45.                  | tick_sched_timer
  46.                  | __run_hrtimer
  47.                  | hrtimer_interrupt
  48.                  | smp_apic_timer_interrupt
  49.                  | apic_timer_interrupt
  50.                  | |
  51.                  | |--84.78%-- search_binary_handler
  52.                  | | do_execve
  53.                  | | sys_execve
  54.                  | | ptregs_execve
  55.                  | | 0xffffe430

最耗时的函数是内核态程序intel_pmu_enable_all（），而是其运行时间只占程序总运行时间的5%,优化可以结束。

3.2.6   总结

场景

理想(ms)

下限(ms)

优化前(ms)

优化后(ms)

提升（倍）

程序运行总时间

10

100

265.238069

2.929202

91

 


阅读(5048) | 评论(0) | 转发(1) |
1

上一篇：三元光栅操作

下一篇：注释代码定位bug

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6