系统相关
首页 > 系统相关> > 转载 Linux性能优化gprof使用

转载 Linux性能优化gprof使用

作者：互联网

  1. gcc -pg 编译程序
  2. 运行程序，程序退出时生成 gmon.out
  3. gprof ./prog gmon.out -b 查看输出

要想产生gmon.out文件，必须在编译和链接时，都加上-pg  -g选项。

 

1 简介

改进应用程序的性能是一项非常耗时耗力的工作，但是究竟程序中是哪些函数消耗掉了大部分执行时间，这通常都不是非常明显的。GNU 编译器工具包所提供了一种剖析工具 GNU profiler（gprof）。gprof 可以为 Linux平台上的程序精确分析性能瓶颈。gprof精确地给出函数被调用的时间和次数，给出函数调用关系。

 

gprof 用户手册网站 http://sourceware.org/binutils/docs-2.17/gprof/index.html

 

2 功能

Gprof 是GNU gnu binutils工具之一，默认情况下linux系统当中都带有这个工具。

1. 可以显示“flat profile”，包括每个函数的调用次数，每个函数消耗的处理器时间，

2. 可以显示“Call graph”，包括函数的调用关系，每个函数调用花费了多少时间。

3. 可以显示“注释的源代码”－－是程序源代码的一个复本，标记有程序中每行代码的执行次数。

 

3 原理

通过在编译和链接程序的时候（使用 -pg 编译和链接选项），gcc 在你应用程序的每个函数中都加入了一个名为mcount ( or  “_mcount”  , or  “__mcount” , 依赖于编译器或操作系统)的函数，也就是说你的应用程序里的每一个函数都会调用mcount, 而mcount 会在内存中保存一张函数调用图，并通过函数调用堆栈的形式查找子函数和父函数的地址。这张调用图也保存了所有与函数相关的调用时间，调用次数等等的所有信息。

 

4 使用流程

1. 在编译和链接时 加上-pg选项。一般我们可以加在 makefile 中。

2. 执行编译的二进制程序。执行参数和方式同以前。

3. 在程序运行目录下 生成 gmon.out 文件。如果原来有gmon.out 文件，将会被重写。

4. 结束进程。这时 gmon.out 会再次被刷新。

5. 用 gprof 工具分析 gmon.out 文件。

 

5 参数说明

l -b 不再输出统计图表中每个字段的详细描述。

l -p 只输出函数的调用图（Call graph的那部分信息）。

l -q 只输出函数的时间消耗列表。

l -e Name 不再输出函数Name 及其子函数的调用图（除非它们有未被限制的其它父函数）。可以给定多个 -e 标志。一个 -e 标志只能指定一个函数。

l -E Name 不再输出函数Name 及其子函数的调用图，此标志类似于 -e 标志，但它在总时间和百分比时间的计算中排除了由函数Name 及其子函数所用的时间。

l -f Name 输出函数Name 及其子函数的调用图。可以指定多个 -f 标志。一个 -f 标志只能指定一个函数。

l -F Name 输出函数Name 及其子函数的调用图，它类似于 -f 标志，但它在总时间和百分比时间计算中仅使用所打印的例程的时间。可以指定多个 -F 标志。一个 -F 标志只能指定一个函数。-F 标志覆盖 -E 标志。

l -z 显示使用次数为零的例程（按照调用计数和累积时间计算）。

 

一般用法： gprof –b 二进制程序 gmon.out >report.txt

 

6 报告说明

Gprof 产生的信息解释：

  %time

Cumulative

seconds

Self 

Seconds

Calls

Self

TS/call

Total

TS/call

name

该函数消耗时间占程序所有时间百分比

程序的累积执行时间

（只是包括gprof能够监控到的函数）

该函数本身执行时间

（所有被调用次数的合共时间）

函数被调用次数

函数平均执行时间

（不包括被调用时间）

（函数的单次执行时间）

函数平均执行时间

（包括被调用时间）

 

（函数的单次执行时间）

函数名

 

Call Graph 的字段含义：

Index

%time

Self

Children

Called

Name

索引值

函数消耗时间占所有时间百分比

函数本身执行时间

执行子函数所用时间

被调用次数

函数名

 

注意：

程序的累积执行时间只是包括gprof能够监控到的函数。工作在内核态的函数和没有加-pg编译的第三方库函数是无法被gprof能够监控到的，（如sleep（）等）

Gprof 的具体参数可以 通过 man gprof 查询。

 

7 共享库的支持

对于代码剖析的支持是由编译器增加的，因此如果希望从共享库中获得剖析信息，就需要使用 -pg 来编译这些库。提供已经启用代码剖析支持而编译的 C 库版本（libc_p.a）。

如果需要分析系统函数（如libc库），可以用 –lc_p替换-lc。这样程序会链接libc_p.so或libc_p.a。这非常重要，因为只有这样才能监控到底层的c库函数的执行时间，（例如memcpy()，memset()，sprintf()等）。

gcc example1.c –pg -lc_p -o example1

注意要用ldd ./example | grep libc来查看程序链接的是libc.so还是libc_p.so

 

8 用户时间与内核时间

gprof 的最大缺陷：它只能分析应用程序在运行过程中所消耗掉的用户时间，无法得到程序内核空间的运行时间。通常来说，应用程序在运行时既要花费一些时间来运行用户代码，也要花费一些时间来运行 “系统代码”，例如内核系统调用sleep()。

有一个方法可以查看应用程序的运行时间组成，在 time 命令下面执行程序。这个命令会显示一个应用程序的实际运行时间、用户空间运行时间、内核空间运行时间。

如 time ./program

输出：

real    2m30.295s

user    0m0.000s

sys     0m0.004s

 

9 注意事项

1. g++在编译和链接两个过程，都要使用-pg选项。

2. 只能使用静态连接libc库，否则在初始化*.so之前就调用profile代码会引起“segmentation fault”，解决办法是编译时加上-static-libgcc或-static。

3. 如果不用g++而使用ld直接链接程序，要加上链接文件/lib/gcrt0.o，如ld -o myprog /lib/gcrt0.o myprog.o utils.o -lc_p。也可能是gcrt1.o

4. 要监控到第三方库函数的执行时间，第三方库也必须是添加 –pg 选项编译的。

5. gprof只能分析应用程序所消耗掉的用户时间.

6. 程序不能以demon方式运行。否则采集不到时间。（可采集到调用次数）

7. 首先使用 time 来运行程序从而判断 gprof 是否能产生有用信息是个好方法。

8. 如果 gprof 不适合您的剖析需要，那么还有其他一些工具可以克服 gprof 部分缺陷，包括 OProfile 和 Sysprof。

9. gprof对于代码大部分是用户空间的CPU密集型的程序用处明显。对于大部分时间运行在内核空间或者由于外部因素（例如操作系统的 I/O 子系统过载）而运行得非常慢的程序难以进行优化。

10. gprof 不支持多线程应用，多线程下只能采集主线程性能数据。原因是gprof采用ITIMER_PROF信号，在多线程内只有主线程才能响应该信号。但是有一个简单的方法可以解决这一问题：http://sam.zoy.org/writings/programming/gprof.html

11. gprof只能在程序正常结束退出之后才能生成报告（gmon.out）。

a) 原因： gprof通过在atexit()里注册了一个函数来产生结果信息，任何非正常退出都不会执行atexit()的动作，所以不会产生gmon.out文件。

b) 程序可从main函数中正常退出，或者通过系统调用exit()函数退出。

 

 

10 多线程应用

gprof 不支持多线程应用，多线程下只能采集主线程性能数据。原因是gprof采用ITIMER_PROF信号，在多线程内只有主线程才能响应该信号。

采用什么方法才能够分析所有线程呢？关键是能够让各个线程都响应ITIMER_PROF信号。可以通过桩子函数来实现，重写pthread_create函数。

  1.  gprof-helper.c
  2.  
  3. #define _GNU_SOURCE
  4.  
  5. #include <sys/time.h>
  6.  
  7. #include <stdio.h>
  8.  
  9. #include <stdlib.h>
  10.  
  11. #include <dlfcn.h>
  12.  
  13. #include <pthread.h>
  14.  
  15.  
  16.  
  17. static void * wrapper_routine(void *);
  18.  
  19.  
  20.  
  21. /* Original pthread function */
  22.  
  23. static int (*pthread_create_orig)(pthread_t *__restrict,
  25.                                   __const pthread_attr_t *__restrict,
  27.                                   void *(*)(void *),
  29.                                   void *__restrict) = NULL;
  30.  
  31.  
  32.  
  33. /* Library initialization function */
  34.  
  35. void wooinit(void) __attribute__((constructor));
  36.  
  37.  
  38.  
  39. void wooinit(void)
  40.  
  41. {
  42.  
  43.     pthread_create_orig = dlsym(RTLD_NEXT, "pthread_create");
  44.  
  45.     fprintf(stderr, "pthreads: using profiling hooks for gprof/n");
  46.  
  47.     if(pthread_create_orig == NULL)
  48.  
  49.     {
  50.  
  51.         char *error = dlerror();
  52.  
  53.         if(error == NULL)
  54.  
  55.         {
  56.  
  57.             error = "pthread_create is NULL";
  58.  
  59.         }
  60.  
  61.         fprintf(stderr, "%s/n", error);
  62.  
  63.         exit(EXIT_FAILURE);
  64.  
  65.     }
  66.  
  67. }
  68.  
  69.  
  70.  
  71. /* Our data structure passed to the wrapper */
  72.  
  73. typedef struct wrapper_s
  74.  
  75. {
  76.  
  77.     void * (*start_routine)(void *);
  78.  
  79.     void * arg;
  80.  
  81.     pthread_mutex_t lock;
  82.  
  83.     pthread_cond_t  wait;
  84.  
  85.     struct itimerval itimer;
  86.  
  87. } wrapper_t;
  88.  
  89.  
  90.  
  91. /* The wrapper function in charge for setting the itimer value */
  92.  
  93. static void * wrapper_routine(void * data)
  94.  
  95. {
  96.  
  97.     /* Put user data in thread-local variables */
  98.  
  99.     void * (*start_routine)(void *) = ((wrapper_t*)data)->;start_routine;
  100.  
  101.     void * arg = ((wrapper_t*)data)->;arg;
  102.  
  103.  
  104.  
  105.     /* Set the profile timer value */
  106.  
  107.     setitimer(ITIMER_PROF, &((wrapper_t*)data)->;itimer, NULL);
  108.  
  109.  
  110.  
  111.     /* Tell the calling thread that we don't need its data anymore */
  112.  
  113.     pthread_mutex_lock(&((wrapper_t*)data)->;lock);
  114.  
  115.     pthread_cond_signal(&((wrapper_t*)data)->;wait);
  116.  
  117.     pthread_mutex_unlock(&((wrapper_t*)data)->;lock);
  118.  
  119.  
  120.  
  121.     /* Call the real function */
  122.  
  123.     return start_routine(arg);
  124.  
  125. }
  126.  
  127.  
  128.  
  129. /* Our wrapper function for the real pthread_create() */
  130.  
  131. int pthread_create(pthread_t *__restrict thread,
  133.                    __const pthread_attr_t *__restrict attr,
  135.                    void * (*start_routine)(void *),
  137.                    void *__restrict arg)
  138.  
  139. {
  140.  
  141.     wrapper_t wrapper_data;
  142.  
  143.     int i_return;
  144.  
  145.  
  146.  
  147.     /* Initialize the wrapper structure */
  148.  
  149.     wrapper_data.start_routine = start_routine;
  150.  
  151.     wrapper_data.arg = arg;
  152.  
  153.     getitimer(ITIMER_PROF, &wrapper_data.itimer);
  154.  
  155.     pthread_cond_init(&wrapper_data.wait, NULL);
  156.  
  157.     pthread_mutex_init(&wrapper_data.lock, NULL);
  158.  
  159.     pthread_mutex_lock(&wrapper_data.lock);
  160.  
  161.  
  162.  
  163.     /* The real pthread_create call */
  164.  
  165.     i_return = pthread_create_orig(thread,
  166.  
  167.                                    attr,
  168.  
  169.                                    &wrapper_routine,
  170.  
  171.                                    &wrapper_data);
  172.  
  173.  
  174.  
  175.     /* If the thread was successfully spawned, wait for the data
  177.      * to be released */
  178.  
  179.     if(i_return == 0)
  180.  
  181.     {
  182.  
  183.         pthread_cond_wait(&wrapper_data.wait, &wrapper_data.lock);
  184.  
  185.     }
  186.  
  187.  
  188.  
  189.     pthread_mutex_unlock(&wrapper_data.lock);
  190.  
  191.     pthread_mutex_destroy(&wrapper_data.lock);
  192.  
  193.     pthread_cond_destroy(&wrapper_data.wait);
  194.  
  195.  
  196.  
  197.     return i_return;
  198.  
  199. }
  200.  
  201.  
  202.  
  203. ///
  204.  
  205. 然后编译成动态库 gcc -shared -fPIC gprof-helper.c -o gprof-helper.so -lpthread -ldl 
  206.  
  207.  
  208.  
  209. 使用例子：
  210.  
  211. /a.c/
  212.  
  213. #include <stdio.h>;
  214.  
  215. #include <stdlib.h>;
  216.  
  217. #include <unistd.h>;
  218.  
  219. #include <pthread.h>;
  220.  
  221. #include <string.h>;
  222.  
  223. void fun1();
  224.  
  225. void fun2();
  226.  
  227. void* fun(void * argv);
  228.  
  229. int main()
  230.  
  231. {
  232.  
  233.         int i =0;
  234.  
  235.         int id;
  236.  
  237.         pthread_t    thread[100];
  238.  
  239.         for(i =0 ;i< 100; i++)
  240.  
  241.         {
  242.  
  243.                 id = pthread_create(&thread[i], NULL, fun, NULL);
  244.  
  245.                 printf("thread =%d/n",i);
  246.  
  247.         }
  248.  
  249.         printf("dsfsd/n");
  250.  
  251.         return 0;
  252.  
  253. }
  254.  
  255. void*  fun(void * argv)
  256.  
  257. {
  258.  
  259.         fun1();
  260.  
  261.         fun2();
  262.  
  263.         return NULL;
  264.  
  265. }
  266.  
  267.  
  268.  
  269. void fun1()
  270.  
  271. {
  272.  
  273.         int i = 0;
  274.  
  275.         while(i<100)
  276.  
  277.         {
  278.  
  279.                 i++;        
  280.  
  281.                 printf("fun1/n");
  282.  
  283.         }        
  284.  
  285. }
  286.  
  287.  
  288.  
  289. void fun2()
  290.  
  291. {
  292.  
  293.         int i = 0;
  294.  
  295.         int b;
  296.  
  297.         while(i<50)
  298.  
  299.         {
  300.  
  301.                 i++;
  302.  
  303.                 printf("fun2/n");
  304.  
  305.                 //b+=i;        
  306.  
  307.         }        
  308.  
  309. }
  310.  
  311. ///
  312.  
  313.  
  314.  
  315. gcc -pg a.c  gprof-helper.so
  316.  
  317.  
  318.  
  319. 运行程序:
  320.  
  321. ./a.out
  322.  
  323.  
  324.  
  325. 分析gmon.out:
  326.  
  327. gprof -b a.out gmon.out

 

标签：函数,Linux,void,gprof,wrapper,pthread,转载,data
来源： https://www.cnblogs.com/ooouliwa/p/16348666.html