【发布时间】：2011-01-14 19:40:21
【问题描述】：
我需要一些方法来记录 Linux 机器上应用程序的性能。我不会有 IDE。
理想情况下，我需要一个可以附加到进程并记录定期快照的应用程序： 内存使用情况 线程数 CPU使用率
有什么想法吗？
【问题讨论】：
【发布时间】：2011-01-14 19:40:21
【问题描述】：
你研究过 gprof 吗？您需要使用 -pg 选项编译代码，该选项会检测代码。之后，您可以运行程序并使用 gprof 来查看结果。
【讨论】：
你也可以试试cpuprofiler.com。它获取您通常从 top 命令获取的信息，甚至可以从 Web 浏览器远程查看 cpu 使用数据。
【讨论】：
-
链接断开。域不再有效。
理想情况下，我需要一个可以附加到进程并记录以下定期快照的应用程序：内存使用情况线程数 CPU 使用情况
好吧，为了收集有关您的进程的此类信息，您实际上并不需要 Linux 上的分析器。
1）您可以在批处理模式下使用top。它以批处理模式运行，直到它被杀死或完成 N 次迭代：
top -b -p `pidof a.out`
或
top -b -p `pidof a.out` -n 100
你会得到这个：
$ top -b -p `pidof a.out`
top - 10:31:50 up 12 days, 19:08, 5 users, load average: 0.02, 0.01, 0.02
Tasks: 1 total, 0 running, 1 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 16330584k total, 2335024k used, 13995560k free, 241348k buffers
Swap: 4194296k total, 0k used, 4194296k free, 1631880k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
24402 SK 20 0 98.7m 1056 860 S 43.9 0.0 0:11.87 a.out
top - 10:31:53 up 12 days, 19:08, 5 users, load average: 0.02, 0.01, 0.02
Tasks: 1 total, 0 running, 1 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.9%us, 3.7%sy, 0.0%ni, 95.5%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 16330584k total, 2335148k used, 13995436k free, 241348k buffers
Swap: 4194296k total, 0k used, 4194296k free, 1631880k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
24402 SK 20 0 98.7m 1072 860 S 19.0 0.0 0:12.44 a.out
2) 您可以使用 ps（例如在 shell 脚本中）
ps --format pid,pcpu,cputime,etime,size,vsz,cmd -p `pidof a.out`
我需要一些方法来记录 Linux 机器上应用程序的性能
为了做到这一点，如果你的 Linux 内核大于 2.6.32，你需要使用perf，如果它更旧，你需要使用 Oprofile。这两个程序都不需要你来指导你的程序（比如gporf 需要）。但是，为了在perf 中正确生成调用图，您需要使用-fno-omit-frame-pointer 构建您的程序。例如：g++ -fno-omit-frame-pointer -O2 main.cpp。
至于 Linux perf:
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
在 RHEL 6.3 上允许读取 /boot/System.map-2.6.32-279.el6.x86_64，所以我通常添加 --kallsyms=/boot/System.map-2.6.32-279.el6。 x86_64 什么时候做性能报告：
perf report --stdio -g --kallsyms=/boot/System.map-2.6.32-279.el6.x86_64
在这里，我写了一些关于使用 Linux perf 的更多信息：
首先 - 这是tutorial about Linux profiling with perf
如果您的 Linux 内核大于 2.6.32，您可以使用 perf；如果它较旧，您可以使用 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;
}
【讨论】：
-
perf record -p $(ps aux | grep '[H]elloWord' | awk '{print $2}')注意你的应用程序的第一个字母周围的方括号，这样 grep 只会返回应用程序 pid 而不是 grep 本身的 pid
如果您正在寻找可以加快程序速度的事情，您需要stackshots。一个简单的方法是使用 pstack 实用程序，如果可以的话，使用 lsstack。
You can do better than gprof.如果您想使用官方分析工具，您需要在挂钟时间对调用堆栈进行采样并显示行级成本的东西，例如 Oprofile 或 RotateRight/Zoom。
【讨论】：
您可以使用valgrind。它将数据记录在一个文件中，您可以稍后使用适当的 gui 进行分析，例如 KCacheGrind
一个用法示例是：
valgrind --tool=callgrind --dump-instr=yes --simulate-cache=yes your_program
它会生成一个名为 callgrind.out.xxx 的文件，其中 xxx 是程序的 pid
编辑：与 gprof 不同，valgrind 可以使用多种不同的语言，包括 java with some limitations。
【讨论】：
引用 Linus Torvalds 本人的话：
"Don't use gprof. You're _much_ better off using the newish Linux 'perf' tool."
以后...
"I can pretty much guarantee that once you start using it, you'll never use gprof or oprofile again."
见：http://marc.info/?l=git&m=126262088816902&w=2
祝你好运！
【讨论】：