Como não vi aqui nada sobre o perfque é uma ferramenta relativamente nova para criar um perfil dos aplicativos do kernel e do usuário no Linux, decidi adicionar essas informações.
Primeiro de tudo - este é um tutorial sobre criação de perfil do Linux comperf
Você pode usar perfse o seu Kernel Linux for maior que 2.6.32 ou oprofilese for mais antigo. Ambos os programas não exigem que você instrumente seu programa (como gprofexige). No entanto, para obter o gráfico de chamadas corretamente, perfvocê precisa criar seu programa -fno-omit-frame-pointer. Por exemplo: g++ -fno-omit-frame-pointer -O2 main.cpp.
Você pode ver a análise "ao vivo" do seu aplicativo com perf top:
sudo perf top -p `pidof a.out` -K
Ou você pode gravar dados de desempenho de um aplicativo em execução e analisá-los depois:
1) Para registrar dados de desempenho:
perf record -p `pidof a.out`
ou para gravar por 10 segundos:
perf record -p `pidof a.out` sleep 10
ou gravar com gráfico de chamadas ()
perf record -g -p `pidof a.out`
2) Analisar os dados gravados
perf report --stdio
perf report --stdio --sort=dso -g none
perf report --stdio -g none
perf report --stdio -g
Ou você pode gravar dados de desempenho de um aplicativo e analisá-los depois disso, iniciando o aplicativo dessa maneira e esperando que ele saia:
perf record ./a.out
Este é um exemplo de criação de perfil de um programa de teste
O programa de teste está no arquivo main.cpp (colocarei main.cpp na parte inferior da mensagem):
Eu compilo desta maneira:
g++ -m64 -fno-omit-frame-pointer -g main.cpp -L. -ltcmalloc_minimal -o my_test
Eu uso libmalloc_minimial.sodesde que ele é compilado -fno-omit-frame-pointerenquanto o libc malloc parece ser compilado sem essa opção. Então eu executo meu programa de teste
./my_test 100000000
Depois, registro os dados de desempenho de um processo em execução:
perf record -g -p `pidof my_test` -o ./my_test.perf.data sleep 30
Então analiso a carga por módulo:
relatório perf --stdio -g none --ort 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]
A carga por função é analisada:
relatório perf --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 ...
Em seguida, as cadeias de chamadas são analisadas:
relatório perf --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 ...
Então, neste ponto, você sabe onde seu programa gasta tempo.
E este é main.cpp para o teste:
#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;
}