教授的替代品

Valground 有一个指令计数分析器，它有一个非常好的可视化工具 KCacheGrind。正如 Mike Dunlavey 建议的那样，尽管我很遗憾地说，在存在相互递归的情况下，它似乎变得很混乱，但 Val弓还是计算了堆栈上存在过程的指令的分数。但可视化是非常好的和光年之前的 gprof。

看看 Sysprof。

你的分销商可能已经有了。

谷歌性能工具 包括一个简单的使用分析器。 CPU 和堆分析器是可用的。

如果你想要一个高性能的追踪 http://lttng.org/

因为我在这里没有看到任何关于 perf的东西，它是一个相对较新的工具，用于分析 Linux 上的内核和用户应用程序，所以我决定添加这些信息。

首先-这是一个关于 使用 perf进行 Linux 分析的教程

如果 Linux 内核大于2.6.32，可以使用 perf; 如果 Linux 内核更旧，可以使用 oprofile。这两个程序都不需要你来检测你的程序(就像 gprof要求的那样)。然而，为了在 perf中正确地获得调用图，您需要用 -fno-omit-frame-pointer构建您的程序。例如: g++ -fno-omit-frame-pointer -O2 main.cpp。

您可以使用 perf top看到对应用程序的“实时”分析:

sudo perf top -p `pidof a.out` -K

或者，您可以记录正在运行的应用程序的性能数据，然后对它们进行分析:

1)记录表现数据:

perf record -p `pidof a.out`

或记录10秒:

perf record -p `pidof a.out` sleep 10

或用呼叫图()记录

perf record -g -p `pidof a.out`

2)分析记录的数据

perf report --stdio
perf report --stdio --sort=dso -g none
perf report --stdio -g none
perf report --stdio -g

或者你可以记录应用程序的性能数据，然后通过这种方式启动应用程序并等待它退出来进行分析:

perf record ./a.out

这是分析测试程序 的示例

测试程序位于 main.cpp 文件中(我将 main.cpp 放在消息的底部) :

我是这样编译的:

g++ -m64 -fno-omit-frame-pointer -g main.cpp -L.  -ltcmalloc_minimal -o my_test

我使用 libmalloc_minimial.so，因为它是用 -fno-omit-frame-pointer编译的，而 libc malloc 似乎没有这个选项。 然后运行我的测试程序

./my_test 100000000

然后，我记录正在运行的进程的性能数据:

perf record -g  -p `pidof my_test` -o ./my_test.perf.data sleep 30

然后我分析每个模块的负载:

Perf report —— stdio-g none —— sort comm，dso-i./my _ test. Perf.data

# Overhead  Command                 Shared Object
# ........  .......  ............................
#
70.06%  my_test  my_test
28.33%  my_test  libtcmalloc_minimal.so.0.1.0
1.61%  my_test  [kernel.kallsyms]

然后分析每个函数的负载:

Perf report —— stdio-g none-i./my _ test. Perf.data | c + + filt

# Overhead  Command                 Shared Object                       Symbol
# ........  .......  ............................  ...........................
#
29.30%  my_test  my_test                       [.] f2(long)
29.14%  my_test  my_test                       [.] f1(long)
15.17%  my_test  libtcmalloc_minimal.so.0.1.0  [.] operator new(unsigned long)
13.16%  my_test  libtcmalloc_minimal.so.0.1.0  [.] operator delete(void*)
9.44%  my_test  my_test                       [.] process_request(long)
1.01%  my_test  my_test                       [.] operator delete(void*)@plt
0.97%  my_test  my_test                       [.] operator new(unsigned long)@plt
0.20%  my_test  my_test                       [.] main
0.19%  my_test  [kernel.kallsyms]             [k] apic_timer_interrupt
0.16%  my_test  [kernel.kallsyms]             [k] _spin_lock
0.13%  my_test  [kernel.kallsyms]             [k] native_write_msr_safe


and so on ...

然后对呼叫链进行分析:

Perf report —— stdio-g graph-i./my _ test. Perf.data | c + + filt

# Overhead  Command                 Shared Object                       Symbol
# ........  .......  ............................  ...........................
#
29.30%  my_test  my_test                       [.] f2(long)
|
--- f2(long)
|
--29.01%-- process_request(long)
main
__libc_start_main


29.14%  my_test  my_test                       [.] f1(long)
|
--- f1(long)
|
|--15.05%-- process_request(long)
|          main
|          __libc_start_main
|
--13.79%-- f2(long)
process_request(long)
main
__libc_start_main


15.17%  my_test  libtcmalloc_minimal.so.0.1.0  [.] operator new(unsigned long)
|
--- operator new(unsigned long)
|
|--11.44%-- f1(long)
|          |
|          |--5.75%-- process_request(long)
|          |          main
|          |          __libc_start_main
|          |
|           --5.69%-- f2(long)
|                     process_request(long)
|                     main
|                     __libc_start_main
|
--3.01%-- process_request(long)
main
__libc_start_main


13.16%  my_test  libtcmalloc_minimal.so.0.1.0  [.] operator delete(void*)
|
--- operator delete(void*)
|
|--9.13%-- f1(long)
|          |
|          |--4.63%-- f2(long)
|          |          process_request(long)
|          |          main
|          |          __libc_start_main
|          |
|           --4.51%-- process_request(long)
|                     main
|                     __libc_start_main
|
|--3.05%-- process_request(long)
|          main
|          __libc_start_main
|
--0.80%-- f2(long)
process_request(long)
main
__libc_start_main


9.44%  my_test  my_test                       [.] process_request(long)
|
--- process_request(long)
|
--9.39%-- main
__libc_start_main


1.01%  my_test  my_test                       [.] operator delete(void*)@plt
|
--- operator delete(void*)@plt


0.97%  my_test  my_test                       [.] operator new(unsigned long)@plt
|
--- operator new(unsigned long)@plt


0.20%  my_test  my_test                       [.] main
0.19%  my_test  [kernel.kallsyms]             [k] apic_timer_interrupt
0.16%  my_test  [kernel.kallsyms]             [k] _spin_lock
and so on ...

所以在这一点上，您知道您的程序在哪里花费时间。

这是用于测试的 main.cpp:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>


time_t f1(time_t time_value)
{
for (int j =0; j < 10; ++j) {
++time_value;
if (j%5 == 0) {
double *p = new double;
delete p;
}
}
return time_value;
}


time_t f2(time_t time_value)
{
for (int j =0; j < 40; ++j) {
++time_value;
}
time_value=f1(time_value);
return time_value;
}


time_t process_request(time_t time_value)
{


for (int j =0; j < 10; ++j) {
int *p = new int;
delete p;
for (int m =0; m < 10; ++m) {
++time_value;
}
}
for (int i =0; i < 10; ++i) {
time_value=f1(time_value);
time_value=f2(time_value);
}
return time_value;
}


int main(int argc, char* argv2[])
{
int number_loops = argc > 1 ? atoi(argv2[1]) : 1;
time_t time_value = time(0);
printf("number loops %d\n", number_loops);
printf("time_value: %d\n", time_value );


for (int i =0; i < number_loops; ++i) {
time_value = process_request(time_value);
}
printf("time_value: %ld\n", time_value );
return 0;
}