Como no vi nada acerca de perfcuál es una herramienta relativamente nueva para perfilar el núcleo y las aplicaciones de usuario en Linux, decidí agregar esta información.
En primer lugar, este es un tutorial sobre el perfil de Linux conperf
Puede usarlo perfsi su kernel de Linux es mayor que 2.6.32 o oprofilesi es anterior. Ambos programas no requieren que usted instrumente su programa (como gprofrequiere). Sin embargo, para obtener el gráfico de llamadas correctamente perf, necesita construir su programa con -fno-omit-frame-pointer. Por ejemplo: g++ -fno-omit-frame-pointer -O2 main.cpp.
Puede ver el análisis "en vivo" de su aplicación con perf top:
sudo perf top -p `pidof a.out` -K
O puede registrar datos de rendimiento de una aplicación en ejecución y analizarlos después de eso:
1) Para registrar datos de rendimiento:
perf record -p `pidof a.out`
o para grabar durante 10 segundos:
perf record -p `pidof a.out` sleep 10
o para grabar con el gráfico de llamadas ()
perf record -g -p `pidof a.out`
2) Para analizar los datos grabados
perf report --stdio
perf report --stdio --sort=dso -g none
perf report --stdio -g none
perf report --stdio -g
O puede grabar los datos de rendimiento de una aplicación y analizarlos después de eso simplemente iniciando la aplicación de esta manera y esperando a que salga:
perf record ./a.out
Este es un ejemplo de perfilado de un programa de prueba
El programa de prueba está en el archivo main.cpp (pondré main.cpp en la parte inferior del mensaje):
Lo compilo de esta manera:
g++ -m64 -fno-omit-frame-pointer -g main.cpp -L. -ltcmalloc_minimal -o my_test
Lo uso libmalloc_minimial.soya que está compilado -fno-omit-frame-pointermientras que libc malloc parece estar compilado sin esta opción. Entonces ejecuto mi programa de prueba
./my_test 100000000
Luego grabo datos de rendimiento de un proceso en ejecución:
perf record -g -p `pidof my_test` -o ./my_test.perf.data sleep 30
Luego analizo la carga por módulo:
informe de rendimiento --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]
Luego se analiza la carga por función:
informe de rendimiento --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 ...
Luego se analizan las cadenas de llamadas:
informe de rendimiento --stdio -g gráfico -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 ...
Entonces, en este punto, ya sabe dónde pasa el tiempo su programa.
Y esto es main.cpp para la prueba:
#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;
}