Herramientas de profiling en Linux¶
Lo que se vio en la sesión: cómo mirar un programa desde afuera cuando ya está corriendo, qué parte de su tiempo se va dentro del núcleo, cuántos fallos de caché cuesta un recorrido mal puesto y cuál de esas dos cosas explica el tiempo que se pierde. Las diapositivas están en el Campus Virtual; aquí quedan las órdenes, las trazas que devolvieron y las mediciones.
Dos programas que hacen la misma cuenta¶
Dos versiones suman los 10.000 por 10.000 enteros de una matriz. Las dos
imprimen 999900000000 y la única diferencia son tres caracteres en un índice:
// bueno.cpp, por filas
for (int i = 0; i < SIZE; i++)
for (int j = 0; j < SIZE; j++)
suma += matriz[i][j];
// malo.cpp, por columnas
for (int i = 0; i < SIZE; i++)
for (int j = 0; j < SIZE; j++)
suma += matriz[j][i];
| Medición | ./bueno |
./malo |
|---|---|---|
| Instrucciones ejecutadas | 3.504.983.954 | 3.504.984.293 |
| Ciclos de CPU | 1.177.787.894 | 2.796.626.915 |
| Tiempo transcurrido | 0,43538 s | 0,79385 s |
El procesador ejecuta el mismo trabajo y gasta casi el doble de ciclos en hacerlo. Un cronómetro dice cuánto tardó, no por qué, y responder esa pregunta obliga a mirar dentro del sistema operativo y dentro del procesador.
Las cuatro familias de perfiladores¶
Es la misma clasificación de la sesión de profiling en Python, con las herramientas equivalentes del lado de C++ y del sistema operativo:
| Categoría | En Python | En C++ y Linux | Cómo trabaja |
|---|---|---|---|
| Temporizadores | time, timeit |
chrono |
Miden tiempo transcurrido |
| Deterministas | cProfile |
callgrind |
Instrumentan el código y registran cada evento |
| Estadísticos | pyinstrument |
perf |
Muestreo periódico |
| Monitores del sistema | no aplica | top, htop, ps |
Observan el proceso desde afuera |
La cuarta fila es la que no tenía equivalente en Python: no mide código, mide procesos. Ahí está la diferencia de fondo de la sesión. En Python el instrumento vive dentro del programa, que se lanza desde el perfilador; las tres herramientas de esta sesión se aplican sobre un PID o sobre un ejecutable, así que sirven en producción, sobre un servidor que lleva tres días corriendo y sobre un binario que compiló alguien más.
Alrededor del 20 % del código produce el 80 % de los problemas de rendimiento, y el ciclo es siempre el mismo: medir, localizar el cuello de botella, optimizar y volver a medir, porque al quitar uno aparece el siguiente.
El proceso visto desde afuera: top, htop y ps¶
top muestra en tiempo real los procesos activos y su consumo. Las cinco
primeras líneas son el estado de la máquina completa:
top
top - 10:35:35 up 3:18, 1 user, load average: 1,19, 1,28, 1,17
Tasks: 349 total, 1 running, 347 sleep, 0 d-sleep, 0 stopped, 1 zombie
%Cpu(s): 8,9 us, 1,3 sy, 0,0 ni, 88,8 id, 0,1 wa, 0,6 hi, 0,3 si, 0,0 st
MiB Mem : 15800,0 total, 2953,6 free, 4322,3 used, 9047,1 buff/cache
MiB Swap: 12000,7 total, 12000,7 free, 0,0 used. 11477,7 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
30576 cardel 20 0 1409,7g 861704 198936 S 103,7 5,3 17:04.11 vivaldi-bin
3090 cardel 20 0 49,2g 681644 430060 S 15,0 4,2 22:45.41 vivaldi-bin
10046 cardel 20 0 7613408 621756 404188 S 11,3 3,8 17:38.47 obs
1721 cardel 9 -11 199548 43500 12336 S 2,7 0,3 5:02.19 pipewire-pulse
El promedio de carga a 1, 5 y 15 minutos se lee contra el número de núcleos:
igual al número de núcleos es uso pleno, por encima hay procesos esperando
turno, y las tres cifras juntas dan la tendencia. 1,19 1,28 1,17 es carga
estable; 5,00 2,00 1,00 es carga que acaba de dispararse. En %Cpu(s), un
wa grande con us pequeño dice que la CPU espera al disco, y agregar hilos
ahí no mueve nada.
De las columnas de la lista, tres se confunden entre sí. VIRT es todo el
espacio de direcciones que el proceso puede tocar, incluidas las librerías
compartidas y la memoria reservada y nunca usada; RES es la RAM que ocupa de
verdad; SHR es la parte de RES que comparte con otros. Ese vivaldi-bin con
1409,7g de VIRT usa 861 MB reales, y diagnosticar consumo de memoria por
VIRT lleva siempre a la conclusión equivocada.
Los estados que aparecen en la columna S:
| Estado | Código | Significado |
|---|---|---|
| Running | R |
Ejecutándose en una CPU |
| Sleep | S |
Esperando un evento o una operación de entrada y salida |
| D-sleep | D |
Sueño profundo, no interrumpible, casi siempre por disco |
| Stopped | T |
Pausado por una señal SIGSTOP |
| Zombie | Z |
Terminó, y su entrada sigue en la tabla de procesos |
El zombie ya liberó su memoria: lo que queda es su código de salida esperando a que el padre lo recoja. Uno solo ocupa una entrada de la tabla; miles la agotan y el sistema deja de poder crear procesos nuevos.
PR es la prioridad con que el planificador atiende al proceso y NI el ajuste
que el usuario pide sobre ella, entre -20 y 19, con 0 por omisión. En la salida
anterior pipewire-pulse tiene NI = -11 y PR = 9, porque es audio y una
interrupción se oye. Pedir más prioridad requiere privilegios; pedir menos, no.
Para mirar un proceso concreto, top -p 27847; para los de un usuario,
top -u cardel. Y en modo batch imprime una captura y termina, con lo que se
deja llamar desde un script:
top -b -p 1668 -n 1
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1668 cardel 20 0 234944 10180 8812 S 0,0 0,1 1:46.69 xdg-desktop-por
htop da la misma información con colores, barras por núcleo, navegación con
teclas y árbol de procesos, que es lo que top no trae: un programa con
multiprocessing aparece como un padre con sus hijos colgando y se ve de una
vez cuántos trabajadores se crearon. btop, glances y nmon agregan red,
disco y temperaturas; glances expone las métricas por una API web.
ps captura una instantánea en vez de refrescar, y por eso es la que sirve en
scripts:
ps a | head -n 5
PID TTY STAT TIME COMMAND
1420 tty2 Ssl+ 0:00 /usr/bin/start-hyprland
1474 tty2 Sl+ 13:02 Hyprland --watchdog-fd 4
1510 tty2 S+ 0:00 /bin/sh -c /usr/bin/lxqt-policykit-agent >/dev/null
1514 tty2 Sl+ 0:00 /usr/bin/lxqt-policykit-agent
La columna STAT es el estado más una serie de banderas: l es proceso
multihilo, s líder de sesión y + en primer plano de su terminal. Hyprland
aparece como Sl+, y esa l es el primer dato antes de ir a contar los hilos.
El programa paralelo visto desde afuera¶
Para observar un programa paralelo hace falta uno que dure. El de la sesión reserva la matriz de 10.000 por 10.000 y la suma tantas veces como se le pida, repartiendo las filas entre los hilos de OpenMP. Se lanza en una terminal y se mira desde otra:
# Terminal 1: el programa trabajando
./paralelo 900
# Terminal 2: -b modo batch, -n1 una captura, -o %CPU ordena por uso de CPU
top -b -n1 -o %CPU | head -n 11
top - 20:12:20 up 45 min, 1 user, load average: 3,48, 3,41, 3,28
Tasks: 475 total, 3 running, 471 sleep, 0 d-sleep, 0 stopped, 1 zombie
%Cpu(s): 91,9 us, 5,1 sy, 0,0 ni, 1,7 id, 0,0 wa, 1,0 hi, 0,3 si, 0,0 st
MiB Mem : 31992,5 total, 7793,2 free, 10810,8 used, 14960,1 buff/cache
MiB Swap: 12288,0 total, 12288,0 free, 0,0 used. 21181,7 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
102237 cardel 20 0 488792 395268 4084 R 919,1 1,2 1:21.05 paralelo
893 root 20 0 2301316 124004 61384 S 51,8 0,4 0:31.82 dockerd
El 919,1 de la columna %CPU se cuenta sobre un núcleo, no sobre la máquina.
Esta tiene doce núcleos lógicos, así que el techo es 1200 y paralelo ocupa el
equivalente a 9,2 de ellos; un programa secuencial no pasa de 100. El
encabezado lo confirma por otro lado, con 91,9 us y apenas 1,7 id. La RES
de 395 MB es la matriz: cien millones de enteros de cuatro bytes.
ps responde en una línea cuántos hilos tiene y cuánta CPU acumula:
ps -o user,pid,thcount,pcpu,pmem,cputime,cmd -p 102237
USER PID THCNT %CPU %MEM TIME CMD
cardel 102237 12 981 1.2 00:01:21 ./paralelo 900
Doce hilos y 981 % de CPU. Un THCNT de 1 en este punto diría que la directiva
omp parallel for no se aplicó y que el binario se compiló sin -fopenmp, por
más que el código diga lo contrario. Esa comprobación va antes de perfilar
cualquier programa paralelo.
La bandera -T abre el proceso y da una fila por hilo:
ps -o pid,tid,psr,pcpu,comm -T -p 102237
PID TID PSR %CPU COMMAND
102237 102237 5 86.4 paralelo
102237 102239 5 79.6 paralelo
102237 102240 6 83.4 paralelo
102237 102241 11 84.8 paralelo
102237 102242 4 81.2 paralelo
102237 102243 2 85.2 paralelo
102237 102244 1 84.8 paralelo
102237 102245 8 82.2 paralelo
102237 102246 10 84.5 paralelo
102237 102247 0 82.3 paralelo
102237 102248 10 83.8 paralelo
102237 102249 3 83.8 paralelo
TID es el identificador del hilo, y el primero coincide con el PID porque es
el hilo principal: los otros once los creó OpenMP. PSR es el núcleo donde el
planificador tenía ese hilo en el instante de la consulta. Los doce van entre
79,6 % y 86,4 %, que es el reparto que se espera de un parallel for sobre
filas del mismo tamaño; uno en 100 % y once en 10 % diría que el trabajo quedó
mal repartido.
Los PSR de esa captura son 5, 5, 6, 11, 4, 2, 1, 8, 10, 0, 10 y 3: los núcleos
7 y 9 están libres mientras otros dos cargan con dos hilos cada uno. El
planificador mueve los hilos y la consulta es la foto de un instante, así que
repetirla da otro reparto. Fijar un hilo a un núcleo es cosa de taskset o de
las variables de afinidad de OpenMP.
El costo completo del proceso: /usr/bin/time -v¶
El time que responde al escribirlo suelto es una palabra reservada del
intérprete y da tres tiempos. El programa /usr/bin/time, escrito con la ruta
completa, es otro: con -v imprime las veintitrés líneas que el núcleo lleva
contabilizadas del proceso, repartidas en tiempos, tamaño en memoria, fallos de
página, cambios de contexto y actividad de entrada y salida. Nada de eso exige
recompilar.
/usr/bin/time -v ./bueno
999900000000
Command being timed: "./bueno"
User time (seconds): 0.59
System time (seconds): 0.19
Percent of CPU this job got: 98%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.79
Maximum resident set size (kbytes): 394368
Major (requiring I/O) page faults: 0
Minor (reclaiming a frame) page faults: 97870
Voluntary context switches: 1
Involuntary context switches: 84
Page size (bytes): 4096
Exit status: 0
El mismo reporte sobre las dos versiones, línea por línea:
| Línea del reporte | ./bueno |
./malo |
|---|---|---|
User time |
0,59 s | 0,81 s |
System time |
0,19 s | 0,19 s |
Maximum resident set size |
394.368 kB | 394.780 kB |
Minor page faults |
97.870 | 97.870 |
Major page faults |
0 | 0 |
Los dos procesos ocupan 394 MB, provocan exactamente 97.870 fallos de página
menores y ninguno mayor, y gastan el mismo tiempo de sistema. Lo único que se
mueve es el tiempo de usuario, y ahí time ya no alcanza.
Un fallo de página menor se resuelve dentro de la memoria física: la página ya está en RAM y al núcleo le falta anotarla en la tabla del proceso, que es lo que pasa la primera vez que se escribe en memoria recién reservada. Los 97.870 son la matriz apareciendo: 394 MB en páginas de 4 kB dan unas 96.000 páginas. Un fallo mayor obliga a leer del disco y cuesta cinco órdenes de magnitud más; un programa con fallos mayores distintos de cero está yendo a swap, y eso es un problema de otra naturaleza.
Contar llamadas al sistema con strace -c¶
strace sigue las llamadas que el proceso le hace al núcleo: abrir un archivo,
escribir, reservar memoria, crear un hilo. Con -c no imprime la traza completa
sino un resumen contado y ordenado por tiempo. Mide en la frontera entre el
programa y el núcleo, que es un sitio distinto del que miran perf y Valgrind.
strace -c ./bueno
999900000000
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
98,35 0,008408 3 2503 brk
1,01 0,000086 14 6 mprotect
0,16 0,000014 0 22 mmap
0,11 0,000009 1 5 close
0,08 0,000007 3 2 getrandom
------ ----------- ----------- --------- --------- ----------------
100,00 0,008549 3 2567 1 total
El programa tarda 0,79 segundos y de esos solo 8,5 milisegundos ocurren dentro
del núcleo: todo el tiempo se va en espacio de usuario. strace descarta una
causa y manda la investigación a otra herramienta, y descartar también es un
resultado. Las 2.503 llamadas a brk, que mueve el límite superior del heap,
salen de las 10.000 llamadas a new int[SIZE]: la librería de reserva agrupa
esas peticiones de 40 kB y pide al núcleo un bloque grande cada cierto número.
Cuando sí encuentra el cuello de botella¶
Dos programas escriben las mismas 200.000 líneas en el mismo archivo. El primero
llama a write por cada línea; el segundo deja que la librería acumule en un
búfer:
// lento.cpp
int fd = open("salida.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
char linea[32];
for (int i = 0; i < 200000; i++) {
int n = snprintf(linea, sizeof(linea), "%d\n", i);
write(fd, linea, n);
}
// rapido.cpp
FILE *f = fopen("salida.txt", "w");
for (int i = 0; i < 200000; i++) {
fprintf(f, "%d\n", i);
}
strace -c ./lento
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
99,94 0,855684 4 200000 write
0,03 0,000231 10 22 mmap
0,01 0,000066 11 6 mprotect
------ ----------- ----------- --------- --------- ----------------
100,00 0,792353 3 200067 1 total
strace -c ./rapido
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
100,00 0,000526 1 315 write
0,00 0,000000 0 22 mmap
0,00 0,000000 0 6 mprotect
------ ----------- ----------- --------- --------- ----------------
100,00 0,000822 2 383 1 total
| Medición | ./lento |
./rapido |
Razón |
|---|---|---|---|
Llamadas a write |
200.000 | 315 | 635 × |
Tiempo dentro del núcleo que cuenta strace |
0,792 s | 0,000822 s | 964 × |
Tiempo de reloj sin strace |
0,12 s | 0,01 s | 12 × |
Cada write cruza la frontera, y escribir 32 bytes cuesta lo mismo que escribir
8.192: el precio no está en los datos sino en el cambio de modo y en la vuelta
al planificador. fprintf llena un búfer de 4 kB y solo entonces llama al
núcleo, y por eso 200.000 líneas caben en 315 llamadas. El mismo patrón aparece
cuando varios hilos escriben resultados a disco o a red línea por línea: los
hilos quedan serializados en la llamada al sistema y la aceleración se estanca
sin que la CPU aparezca ocupada.
Esto puede aparecer en el parcial, en la forma en que se planteó en clase: hay un programa que tarda demasiado y hay que mostrar que el cuello de botella es la escritura a disco. La respuesta es contar las llamadas al sistema.
La caché simulada: Valgrind¶
Antes de leer un contador de fallos conviene tener presente contra qué se mide. La caché no es una sola: L1 es la más pequeña y rápida y le pertenece a cada hilo de hardware, L2 es por núcleo y L3 la comparten todos los núcleos del procesador. Un fallo de L1 no llega a memoria si el dato está en L2 o en L3, y además el procesador trae por adelantado lo que supone que sigue, de modo que un recorrido ordenado encuentra en los niveles intermedios lo que todavía no pidió. Por eso los contadores se leen en pareja: los fallos del primer nivel dicen cuántas veces no estaba donde se buscó primero, y los del último, cuántas veces hubo que ir hasta la RAM.
Valgrind es una herramienta de análisis dinámico para C y C++, y su componente
callgrind analiza las llamadas a funciones y el comportamiento de la caché. El
código instrumentado corre hasta diez veces más lento, así que no sirve para
medir tiempos absolutos sino para comparar patrones de acceso. Se compila
siempre con -g, que es lo que permite atribuir cada fallo a una función y a una
línea:
g++ -g -o bueno -Wall -Wextra Bueno.cpp
valgrind --tool=callgrind --dump-instr=yes \
--simulate-cache=yes --collect-jumps=yes ./bueno
==54691== Callgrind, a call-graph generating cache profiler
==54691== Command: ./bueno
[...]
999900000000
==54691== Events : Ir Dr Dw I1mr D1mr D1mw ILmr DLmr DLmw
==54691== I refs: 3,504,816,314
==54691== D refs: 1,901,594,260 (1,501,108,221 rd + 400,486,039 wr)
==54691== D1 misses: 12,653,756 ( 6,366,206 rd + 6,287,550 wr)
==54691== LLd misses: 12,518,925 ( 6,262,120 rd + 6,256,805 wr)
==54691== D1 miss rate: 0.7% ( 0.4% + 1.6% )
==54691== LLd miss rate: 0.7% ( 0.4% + 1.6% )
| Opción | Función |
|---|---|
--tool=callgrind |
Usar el perfilador de llamadas |
--dump-instr=yes |
Volcar información de instrucciones |
--simulate-cache=yes |
Simular el comportamiento de la caché |
--collect-jumps=yes |
Evaluar los saltos del código |
Cada corrida deja un callgrind.out.<pid>, con lo que dos corridas dejan dos
archivos y no se pisan. Las métricas se nombran por nivel y por tipo de acceso:
D1mr y D1mw son los fallos de la caché L1 de datos en lectura y en
escritura, DLmr y DLmw los del último nivel, y la I delante señala la
caché de instrucciones. Esa separación entre lectura y escritura es la que
delata el problema.
El resumen que deja cada corrida en la terminal, puesto en una tabla:
| Contador | ./bueno |
./malo |
Razón |
|---|---|---|---|
I refs (instrucciones) |
3.504.816.314 | 3.504.816.328 | 1,0 × |
D refs (accesos a datos) |
1.901.594.260 | 1.901.594.268 | 1,0 × |
D1 misses |
12.653.756 | 118.909.812 | 9,4 × |
de lectura (rd) |
6.366.206 | 112.622.262 | 17,7 × |
de escritura (wr) |
6.287.550 | 6.287.550 | 1,0 × |
LLd misses |
12.518.925 | 104.365.640 | 8,3 × |
D1 miss rate |
0,7 % | 6,3 % | 9,0 × |
Los fallos de escritura coinciden hasta el último dígito porque las dos
versiones inicializan la matriz igual: el main recorre por filas en los dos
archivos. La única diferencia está en sumaMatriz, que solo lee, y por eso el
desastre aparece completo en la columna de lectura. Una tasa de 6,3 % suena baja
hasta que se multiplica: 112 millones de fallos, cada uno esperando a la memoria
principal unos 200 ciclos. Las tasas de caché se leen siempre junto al número
absoluto de accesos.
La tabla sin interfaz: callgrind_annotate¶
callgrind_annotate lee el mismo archivo que abre KCachegrind y escribe el
reporte en la terminal, que es lo que sirve en un servidor por SSH, en un
contenedor o en la máquina de la sala:
callgrind_annotate --threshold=95 callgrind.out.57031
I1 cache: 32768 B, 64 B, 8-way associative
D1 cache: 32768 B, 64 B, 8-way associative
LL cache: 33554432 B, 64 B, direct-mapped
Events recorded: Ir Dr Dw I1mr D1mr D1mw ILmr DLmr DLmw
Ir Dr D1mr file:function
1,800,240,044 (51.36%) 800,080,014 (53.30%) 3 ( 0.00%) Malo.cpp:main
1,700,090,012 (48.51%) 700,040,005 (46.63%) 112,509,996 (99.90%) Malo.cpp:sumaMatriz(int**)
El 99,90 % de los fallos de lectura ocurre dentro de sumaMatriz, aunque esa
función aporta el 48,51 % de las instrucciones. Y el reporte baja un nivel más,
hasta anotar el fuente línea por línea:
-- Auto-annotated source: Malo.cpp
Ir Dr D1mr DLmr
3 ( 0.00%) 0 . . long sumaMatriz(int **matriz) {
1 ( 0.00%) 0 . . long suma = 0;
40,005 ( 0.00%) 20,002 ( 0.00%) 0 . for (int i = 0; i < SIZE; i++) {
400,050,000 (11.41%) 200,020,000 (13.32%) . . for (int j = 0; j < SIZE; j++) {
1,300,000,000 (37.09%) 500,000,000 (33.31%) 112,509,996 (99.90%) 98,099,653 (99.99%) suma += matriz[j][i];
| Función | D1mr en ./bueno |
D1mr en ./malo |
|---|---|---|
main (inicializa) |
3 | 3 |
sumaMatriz (recorre) |
6.253.939 | 112.509.996 |
El reporte señala suma += matriz[j][i]; y no el ciclo que la rodea. Ese nivel
de detalle es lo que justifica pagar el sobrecosto de la instrumentación: con
perf se sabe qué función cuesta, y con esta anotación cuál de sus líneas.
KCachegrind y cachegrind¶
KCachegrind abre el mismo archivo con interfaz: a la izquierda el perfil plano,
con una fila por función, y a la derecha los eventos de la función seleccionada
con sus llamadores y llamados. Reporta Incl., el costo de la función más el de
sus llamadas hijas; Self, el costo exclusivo; Called, cuántas veces se
invocó; y una columna por cada evento de caché. En la pestaña de eventos, cada
porcentaje es la parte de ese evento que le corresponde a la función
seleccionada, no la tasa de fallo del programa: un 99,90 en D1mr quiere decir
que casi todos los fallos de lectura del programa ocurren dentro de esa función.
cachegrind hace la mitad del trabajo de callgrind: simula la caché sin
reconstruir el grafo de llamadas, cuesta menos y entrega la cuenta global de
accesos y fallos por nivel. En Valgrind 3.25 la simulación viene apagada, y sin
la bandera la corrida imprime una sola línea con el conteo de instrucciones:
valgrind --tool=cachegrind --cache-sim=yes ./bueno
==53035== Cachegrind, a high-precision tracing profiler
==53035== Command: ./bueno
--53035-- warning: L3 cache found, using its data for the LL simulation.
999900000000
==53035== I refs: 3,504,827,550
==53035== I1 misses: 2,044
==53035== LLi misses: 1,985
==53035== D refs: 1,901,594,260 (1,801,137,907 rd + 100,456,353 wr)
==53035== D1 misses: 12,653,756 ( 6,366,974 rd + 6,286,782 wr)
==53035== LLd misses: 12,518,925 ( 6,262,871 rd + 6,256,054 wr)
==53035== D1 miss rate: 0.7% ( 0.4% + 6.3% )
==53035== LL misses: 12,520,910 ( 6,264,856 rd + 6,256,054 wr)
==53035== LL miss rate: 0.2% ( 0.1% + 6.2% )
| Línea del resumen | ./bueno |
./malo |
|---|---|---|
I refs |
3.504.827.550 | 3.504.827.564 |
I1 miss rate |
0,00 % | 0,00 % |
D refs |
1.901.594.260 | 1.901.594.268 |
D1 misses |
12.653.756 | 118.909.812 |
D1 miss rate |
0,7 % | 6,3 % |
LL misses |
12.520.910 | 104.367.625 |
LL miss rate |
0,2 % | 1,9 % |
I1 misses vale 2.044 en las dos corridas y la tasa redondea a 0,00 %: el ciclo
interno cabe de sobra en la caché de instrucciones, así que el código no es el
problema, lo son los datos que ese código pide. En ./malo, de los 118,9
millones de fallos de L1 hay 104,3 millones que tampoco encuentran el dato en el
último nivel y terminan en memoria principal, el 88 % de los fallos: la matriz
de 400 MB no cabe en los 32 MB del último nivel, y recorrerla por columnas hace
que ninguna línea siga viva cuando vuelva a hacer falta.
El encabezado del reporte anota la jerarquía que simuló: D1 de 32 kB con
líneas de 64 bytes y ocho vías, LL de 32 MB con líneas de 64 bytes. Valgrind
la lee de la CPU de la máquina, así que los números cambian al correr el mismo
binario en otro procesador.
Perfilar una porción¶
Perfilar un programa grande entero cuesta tiempo y casi nunca hace falta. Las
macros de callgrind.h delimitan qué se instrumenta:
#include <valgrind/callgrind.h>
int main() {
inicializar_datos(); // no se perfila
CALLGRIND_START_INSTRUMENTATION;
CALLGRIND_TOGGLE_COLLECT;
funcion_sospechosa(); // se perfila
CALLGRIND_TOGGLE_COLLECT;
CALLGRIND_STOP_INSTRUMENTATION;
procesar_resultados(); // no se perfila
}
valgrind --tool=callgrind --dump-instr=yes --simulate-cache=yes \
--collect-jumps=yes --collect-atstart=no --instr-atstart=no ./programa
==25467== I refs: 1,700,090,015
==25467== D refs: 900,060,011 (700,040,006 rd + 200,020,005 wr)
==25467== D1 misses: 6,253,943 ( 6,253,942 rd + 1 wr)
==25467== LLd misses: 6,253,943 ( 6,253,942 rd + 1 wr)
==25467== D1 miss rate: 0.7% ( 0.9% + 0.0% )
La cuenta cae a 1.700.090.015 instrucciones, las de la función acotada, y los fallos quedan en 6.253.942 de lectura y uno de escritura: la reserva y la inicialización de la matriz ya no entran en la medición. Así se aísla la función sospechosa y se comparan versiones sin pagar el sobrecosto de instrumentar la carga de datos.
Los contadores del procesador: perf¶
perf es una herramienta del núcleo de Linux que lee los contadores de
rendimiento del hardware: registros de la CPU que cuentan ciclos, instrucciones,
fallos de caché y predicciones erróneas de salto. Valgrind simula la caché en
software, instrumenta cada acceso y produce una traza completa a cambio de diez
veces el tiempo; perf lee los contadores reales y trabaja por muestreo,
interrumpiendo el programa cada cierto número de eventos para anotar dónde
estaba. El sobrecosto es despreciable, así que sirve incluso en producción.
Leer esos contadores pide privilegios, y es la razón por la que la herramienta falla en la sala:
sysctl kernel.perf_event_paranoid
kernel.perf_event_paranoid = 2
Con el parámetro en 2 o menos se mide un programa propio, que es el caso de toda la sesión. Pedir los contadores de la máquina entera responde otra cosa:
perf stat -a -e cycles,instructions sleep 1
perf_event_paranoid setting is 2:
-1: Allow use of (almost) all events by all users
Ignore mlock limit after perf_event_mlock_kb without CAP_IPC_LOCK
>= 0: Disallow raw and ftrace function tracepoint access
>= 1: Disallow CPU event access
>= 2: Disallow kernel profiling
La propia salida lista qué habilita cada valor: la máquina entera pide 1 o menos.
Se baja con sudo sysctl -w kernel.perf_event_paranoid=1, y el cambio se pierde
al reiniciar salvo que quede escrito en /etc/sysctl.conf.
El catálogo de eventos depende del modelo de CPU. El de la máquina de las mediciones trae 614 eventos y solo tres tocan la caché L1 de datos con nombre genérico:
perf list | grep -A1 dcache
l1-dcache-load-misses
[Level 1 data cache read misses. Unit: cpu]
l1-dcache-loads
[Level 1 data cache read accesses. Unit: cpu]
l1-dcache-prefetches
[Level 1 data cache prefetch accesses. Unit: cpu]
El tercero cuenta las líneas que el procesador trajo antes de que nadie las
pidiera. Ese captador anticipado es el que hace funcionar el recorrido por
filas. El resto de la lista son los eventos propios del modelo, con nombres que
no viajan a otra máquina, y un script de medición escrito contra ellos queda
amarrado al procesador donde se escribió. El sufijo :u, como en cycles:u,
filtra los eventos de espacio de usuario y deja fuera el tiempo dentro del
núcleo, el planificador y los manejadores de interrupción.
perf stat sobre un proceso que ya está corriendo¶
El programa paralelo sigue trabajando en la otra terminal, y perf se engancha
a su PID:
perf stat -p 102237 sleep 5
Performance counter stats for process id '102237':
0 context-switches:u # 0,0 cs/sec cs_per_second
0 cpu-migrations:u # 0,0 migrations/sec migrations_per_second
0 page-faults:u # 0,0 faults/sec page_faults_per_second
51.361,10 msec task-clock:u # 10,2 CPUs CPUs_utilized
3.688.576 branch-misses:u # 0,0 % branch_miss_rate (50,03%)
36.032.967.962 branches:u # 701,6 M/sec branch_frequency (66,71%)
197.325.259.436 cpu-cycles:u # 3,8 GHz cycles_frequency (66,71%)
175.840.655.774 instructions:u # 0,9 instructions insn_per_cycle (66,70%)
5.079.247.275 stalled-cycles-frontend:u # 0,03 frontend_cycles_idle (66,68%)
5,006738898 seconds time elapsed
El sleep 5 no se está midiendo: perf necesita un comando que marque el final
de la medición, y con -p los contadores se leen del proceso indicado. Cinco
segundos y lo suelta, con el proceso siguiendo su marcha.
Los 51.361 milisegundos de task-clock en 5,006 segundos de reloj dan las
10,2 CPUs: el proceso consumió diez veces más tiempo de CPU que tiempo
transcurrido porque estaba en diez núcleos a la vez. Medido desde afuera y sin
tocar el fuente, ese número comprueba que la paralelización funciona.
| Métrica | Qué indica |
|---|---|
task-clock |
Tiempo que la CPU ejecutó instrucciones del proceso |
instructions entre cycles |
IPC: por encima de 1 va bien, por debajo el procesador espera |
context-switches |
Cambios de contexto; muchos señalan contención |
cpu-migrations |
Proceso movido entre núcleos, con la caché caliente invalidada |
branch-misses |
Predicciones de salto fallidas; por encima del 5 % se revisa la lógica |
El IPC es el primer número que se mira. Aquí vale 0,9 en un ciclo que solo acumula enteros: la aritmética no es lo que cuesta, el procesador pasa la mayor parte de los ciclos esperando datos. Optimizar las operaciones de ese programa no cambiaría nada; lo que hay que arreglar es el acceso a memoria.
Los porcentajes entre paréntesis miden otra cosa: el tiempo que ese contador estuvo activo. La CPU tiene menos registros de contadores que eventos pedidos, así que el núcleo los rota y después escala las cifras, y con nueve eventos y seis registros cada uno alcanza dos tercios del tiempo. Pedir pocos eventos a la vez evita el reparto.
Los fallos de caché, en el hardware¶
De vuelta a los dos programas del comienzo, con --repeat 10 para que promedie
diez corridas y reporte la desviación:
perf stat --repeat 10 -e cycles:u -e instructions:u \
-e l1-dcache-loads:u -e l1-dcache-load-misses:u ./bueno
Performance counter stats for './bueno' (10 runs):
1.177.787.894 cycles:u ( +- 0,15% )
3.504.983.954 instructions:u ( +- 0,00% )
1.108.892.990 l1-dcache-loads:u ( +- 0,00% )
13.219.995 l1-dcache-load-misses:u ( +- 0,14% )
0,43538 +- 0,00164 seconds time elapsed ( +- 0,38% )
| Evento | ./bueno |
./malo |
Razón |
|---|---|---|---|
instructions:u |
3.504.983.954 | 3.504.984.293 | 1,0 × |
l1-dcache-loads:u |
1.108.892.990 | 1.111.367.503 | 1,0 × |
l1-dcache-load-misses:u |
13.219.995 | 120.227.697 | 9,1 × |
cycles:u |
1.177.787.894 | 2.796.626.915 | 2,4 × |
| Tiempo transcurrido | 0,43538 s | 0,79385 s | 1,8 × |
Trece millones de fallos sobre mil cien millones de lecturas es una tasa cercana al 1,2 %: la caché sirve casi todo. El recorrido por columnas pide las mismas lecturas y falla en casi el 11 % de ellas. Las dos primeras filas son idénticas, la tercera explica las dos últimas, y el patrón de acceso a memoria es lo que duplica el tiempo.
Los eventos genéricos cache-references y cache-misses miran el último nivel:
cuántos accesos llegaron hasta allí y cuántos siguieron de largo hacia la
memoria principal.
perf stat --repeat 10 -e cache-references,cache-misses,instructions,cycles ./malo
Performance counter stats for './malo' (10 runs):
397.645.281 cache-references:u ( +- 0,17% )
108.341.596 cache-misses:u ( +- 0,02% )
3.504.981.715 instructions:u ( +- 0,00% )
3.211.385.373 cycles:u ( +- 1,10% )
1,044781297 +- 0,013348942 seconds time elapsed ( +- 1,28% )
| Evento | ./bueno |
./malo |
Razón |
|---|---|---|---|
instructions |
3.504.981.209 | 3.504.981.715 | 1,0 × |
cache-references |
20.315.439 | 397.645.281 | 19,6 × |
cache-misses |
260.870 | 108.341.596 | 415 × |
cycles |
2.001.530.252 | 3.211.385.373 | 1,6 × |
| Tiempo transcurrido | 0,7301 s | 1,0448 s | 1,4 × |
Cuatrocientas quince veces. La cuenta de instrucciones coincide en las siete
primeras cifras, así que el procesador ejecuta el mismo trabajo. Lo que cambia
es que en ./bueno el captador anticipado acierta y casi nada llega al último
nivel, mientras en ./malo cada salto de columna pide una línea que nadie
predijo y que ya no está en ningún nivel de caché.
Grabar y analizar: perf record y perf report¶
perf stat da totales. perf record guarda muestras en un archivo perf.data
y perf report las analiza después, función por función. La opción -F 99 fija
la frecuencia de muestreo en 99 Hz, y -g captura la pila de llamadas en cada
muestra:
perf record -g -e cycles:u -e instructions:u \
-e l1-dcache-loads:u -e l1-dcache-load-misses:u -F 99 ./bueno
999900000000
[ perf record: Woken up 2 times to write data ]
[ perf record: Captured and wrote 0,031 MB perf.data (276 samples) ]
Sobre ./malo el mismo comando captura 397 muestras. A 99 Hz, más muestras es
más tiempo vivo, y el tamaño del archivo ya contrasta antes de abrir el reporte.
Subir la frecuencia da más resolución a cambio de un archivo mayor y de más
sobrecosto; 1.000 Hz es lo que se usa cuando hace falta ver una función que dura
milisegundos. El perf.data es binario: abrirlo con cat o con head muestra
basura, y lo que lo lee es perf report o perf script.
Sin -g se sabe qué función es costosa; con -g se sabe además por qué camino
de llamadas se llegó a ella, lo que importa cuando una función de librería se
llama desde cinco sitios distintos y solo uno la está llamando un millón de
veces. Esa pila es también la base de los flame graphs.
perf report --stdio # sin interfaz interactiva
perf report --sort=dso # agrupado por librería compartida
# Samples: 202 of event 'cpu/cycles/Pu'
# Event count (approx.): 2006790974
#
# Children Self Command Shared Object Symbol
# ........ ........ ....... .................... ...............................
#
99.97% 0.00% malo malo [.] _start
|
---_start
__libc_start_main
| Columna | Significado |
|---|---|
Overhead, Self |
Porcentaje de muestras dentro de esa función |
Children |
Porcentaje incluyendo las funciones hijas |
Shared Object |
Binario o librería donde vive el símbolo |
[.] y [k] |
Código de usuario y código del núcleo |
Si el binario se compiló sin -g o se le quitaron los símbolos, el reporte queda
en hexadecimal: perf report necesita símbolos para traducir una dirección a un
nombre de función. Compilar con -g, no aplicar strip e instalar los paquetes
de símbolos de las librerías del sistema resuelve la mayoría de los casos.
El perfil en el navegador¶
El Firefox Profiler visualiza los datos de perf en el navegador usando el
formato Gecko, con flame graphs interactivos, zoom sobre un intervalo y
filtrado por proceso y por hilo:
perf record -g -F 99 ./malo
perf script report gecko
Staring Firefox Profiler on your default browser...
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
Opening in existing browser session.
127.0.0.1 - - [26/Mar/2026 12:05:22] "GET /gecko_profile.json HTTP/1.1" 200 -
[ perf gecko: Captured and wrote into gecko_profile.json ]
Quedan dos cosas: el servidor en el puerto 8000, que sirve el perfil mientras la
terminal siga abierta, y el archivo gecko_profile.json, que se guarda y se
carga después en https://profiler.firefox.com desde otra máquina. El ancho de
cada barra del flame graph es la proporción de muestras en esa función y el
apilamiento vertical es la cadena de llamadas, así que una meseta ancha en la
mitad del gráfico señala dónde se va el tiempo sin leer una tabla de cien filas.
En clase la demostración se hizo dos veces. La primera grabación salió sin -g
y sin pedir evento, y el visor abrió el árbol de llamadas con main y
sumaMatriz pero sin el detalle que se buscaba. La segunda, con
perf record -e cache-misses, se leyó con perf report, que atribuyó cerca del
94 % de los fallos a sumaMatriz y alrededor del 5 % a main. Dos cosas quedan
de ahí: las banderas de la grabación deciden qué se puede preguntar después, y el
reporte en texto contesta preguntas que el visor no.
Grabar la máquina entera vuelve al asunto de los permisos:
perf record -a -g -F 99 sleep 60
Error:
Failure to open event 'cpu/cycles/Pu' on PMU 'cpu' which will be removed.
Access to performance monitoring and observability operations is limited.
Consider adjusting /proc/sys/kernel/perf_event_paranoid setting to open
access to performance monitoring and observability operations for processes
without CAP_PERFMON, CAP_SYS_PTRACE or CAP_SYS_ADMIN Linux capability.
El mensaje dice dónde se ajusta. Sobre un proceso propio, con
perf record -g -p <pid> sleep 10, no hace falta tocar nada.
La misma diferencia, medida de cuatro formas¶
El mismo par de programas, los mismos tres caracteres de diferencia, cuatro instrumentos:
| Herramienta | Lo que compara | malo sobre bueno |
|---|---|---|
/usr/bin/time -v |
Tiempo de usuario | 1,4 × |
cachegrind |
D1 misses simulados |
9,4 × |
callgrind |
D1mr de sumaMatriz |
18,0 × |
perf |
cache-misses reales |
415 × |
Ninguna de las cuatro es la medida verdadera. El perfilador estadístico tiene
el margen de su muestreo, y el determinista cuenta cada evento pero mete
sobrecosto, que a su vez cambia lo que mide: un cocinero trabaja distinto con
alguien anotándole cada movimiento. Dentro de una máquina virtual o de un
contenedor, además, perf depende de que el anfitrión exponga los contadores
del procesador, y lo corriente es que no lo haga.
Las razones no coinciden porque no miden lo mismo. Valgrind simula un modelo de
caché sin captador anticipado y cuenta accesos de primer nivel; perf lee el
hardware, donde el captador ya escondió casi todos los fallos de ./bueno y
ninguno de los de ./malo. Cuanto más abajo se mide, más grande se ve la
diferencia, y el tiempo de reloj, arriba del todo, es el que menos se mueve. Al
reportar una mejora conviene decir con qué se midió.
El orden de trabajo¶
| Paso | Herramienta | Qué se pregunta |
|---|---|---|
| 1. Visión general | top, htop, ps |
Quién consume CPU y memoria, cuántos hilos hay |
| 2. Patrón de caché | Valgrind | Localidad, tasa de fallo, qué línea del fuente |
| 3. Contadores | perf |
IPC real, ciclos, fallos en el hardware |
- Perfilar antes de optimizar, sin suponer dónde está el cuello de botella.
- Ejecutar varias veces y mirar la desviación que reporta
perf stat --repeat N. - Compilar con
-gen los dos casos: Valgrind lo necesita para atribuir el fallo a una línea yperf reportpara mostrar nombres en vez de direcciones. Paraperf, medir además sobre código optimizado con-O2y sinstrip. - Valgrind para diagnosticar el patrón de caché,
perfpara medir el impacto real en tiempo. - Mirar la separación entre lectura y escritura: una tasa alta de fallo de escritura apunta al orden de los índices, no al algoritmo.
- Verificar el número de hilos con
ps -o thcountantes de perfilar un programa paralelo.
| Característica | top y ps |
Valgrind | perf |
|---|---|---|---|
| Lenguajes | cualquiera | C y C++ | cualquiera |
| Sobrecosto | nulo | alto, diez veces | mínimo |
| Caché | no | simulada | real, contadores |
| Lectura y escritura por separado | no | sí | según el evento |
| Nivel de detalle | proceso | función y línea | función |
| Sobre un proceso vivo | sí | no | sí |
| Visualización | terminal | KCachegrind | Firefox Profiler |
Lecturas¶
- Manual de callgrind: https://valgrind.org/docs/manual/cl-manual.html
- Wiki de
perf: https://perfwiki.github.io/main/ - Documentación del Firefox Profiler: https://profiler.firefox.com/docs/
- En la propia máquina:
man top,man ps,man perf-stat,man perf-record.
Lo que quedó pendiente¶
El ejercicio del Campus Virtual quedó para la casa: el campus no abrió al final
de la sesión. Son cuatro pasos sobre el código de la sesión: habilitar la bandera
de paralelismo, perfilar con perf, revisar la caché con cachegrind y escribir
una versión rápida explicando por qué lo es. No hay que programar nada nuevo: se
ejecuta, se observa lo que devuelve cada herramienta y se escribe la conclusión. La documentación del ejercicio
cubre ps, top, htop, Valgrind y perf, y las herramientas están
instaladas en los computadores de la sala.
Las corridas de callgrind, cachegrind y KCachegrind se mostraron sobre
trazas preparadas, porque instrumentar la matriz entera en vivo se lleva la
clase. Correrlas con el código de la sesión es la forma de ver la diferencia
entre el reporte que sale en segundos y el que tarda minutos. La instrumentación
por porciones quedó nombrada en el mismo punto, con las macros a la vista y sin
corrida. Grafana y Prometheus quedaron mencionados al pasar, como las
herramientas con que se monitorea un clúster.
Las actividades del navegador siguen el orden de los temas de la sesión: los dos programas que hacen la misma cuenta, el programa paralelo visto desde afuera, las llamadas al sistema contadas una por una, los fallos de caché de Valgrind, los contadores del procesador y la misma diferencia medida de cuatro formas.
El código de la sesión está completo, con el Makefile,
las órdenes de perfilado de cada programa y lo que imprimió cada una.