Curso de Perf

Instalar Perf en distribuciones Debian, Ubuntu, RHEL, Rocky Linux, Fedora y entornos equivalentes.

Verificar compatibilidad entre versión de kernel y paquete de herramientas Perf instalado.

Comprobar disponibilidad de eventos hardware y software con `perf list`.

Preparar usuarios, permisos, sudo controlado y entorno de pruebas sin datos sensibles.

Instalar paquetes de símbolos, debug symbols y herramientas de compilación.

Configurar contenedores de laboratorio con cargas CPU, I/O, memoria y syscalls.

Crear repositorio de prácticas con scripts, binarios, datasets y comandos reproducibles.

Validar que `perf stat`, `perf record`, `perf report` y `perf top` funcionan correctamente.

Diagnosticar errores habituales por kernel mismatch, permisos, virtualización o ausencia de eventos PMU.

Realizar ejercicio de preparación completa del entorno Perf en Linux.

Comprender por qué Perf puede exponer información sensible del sistema y de procesos monitorizados.

Revisar el parámetro `kernel.perf_event_paranoid` y sus niveles de restricción.

Diferenciar ejecución como usuario normal, sudo, root y capacidades Linux específicas.

Controlar acceso a eventos kernel, profiling system-wide y capturas de otros usuarios.

Aplicar principio de mínimo privilegio en entornos compartidos.

Revisar riesgos de capturar stacks, símbolos, argumentos, direcciones o datos derivados.

Definir política corporativa para uso de Perf en producción y preproducción.

Documentar cuándo se permite `perf record -a` y quién puede ejecutarlo.

Crear checklist de seguridad para capturas, almacenamiento, transferencia y borrado de evidencias.

Realizar ejercicio de hardening y validación de permisos Perf.

Comprender ciclos de CPU, instrucciones retiradas, IPC, frecuencia, turbo, stalls y utilización real.

Diferenciar CPU usage observado por sistema operativo y trabajo útil medido por contadores.

Analizar el significado de `cycles`, `instructions`, `task-clock`, `context-switches` y `cpu-migrations`.

Interpretar IPC alto, IPC bajo, ciclos desperdiciados y workloads memory-bound o compute-bound.

Entender cómo hyperthreading, NUMA, scheduler y afinidad alteran la interpretación.

Relacionar contadores hardware con comportamiento de aplicación.

Evitar conclusiones simplistas basadas solo en porcentaje de CPU.

Preparar benchmarks controlados para comparar cambios.

Documentar entorno, frecuencia, afinidad, kernel y carga de fondo antes de medir.

Realizar ejercicio de interpretación de métricas CPU con `perf stat`.

Usar `perf stat` para ejecutar comandos y obtener contadores agregados.

Medir ciclos, instrucciones, cache misses, branches, branch misses y elapsed time.

Usar eventos explícitos con `-e` y grupos de eventos.

Comparar ejecuciones antes y después de un cambio de código o configuración.

Repetir mediciones para reducir ruido y variabilidad.

Usar `perf stat -a` para medir actividad system-wide cuando está justificado.

Interpretar escalado de contadores cuando los eventos no se ejecutan todo el tiempo.

Medir procesos existentes mediante PID cuando el caso lo requiere.

Guardar resultados para comparación, documentación e informes.

Realizar ejercicio de benchmark con `perf stat` sobre varios algoritmos.

Explorar eventos disponibles con `perf list`.

Diferenciar eventos hardware, software, tracepoints, cache events y PMU-specific events.

Interpretar nombres de eventos, alias, unidades y disponibilidad según CPU.

Elegir eventos adecuados para cada hipótesis de rendimiento.

Evitar medir demasiados eventos simultáneamente sin entender multiplexing.

Revisar diferencias entre microarquitecturas Intel, AMD, ARM y entornos virtualizados.

Usar eventos de caché, branches, page faults, context switches y migrations.

Crear grupos de eventos para diagnósticos repetibles.

Documentar eventos usados, objetivo y limitaciones de cada medición.

Realizar ejercicio de selección de eventos para tres problemas distintos.

Comprender qué significa muestrear ejecución frente a contar eventos agregados.

Usar `perf record` para capturar perfiles de CPU de un comando.

Perfilar procesos existentes mediante PID o TID.

Capturar perfiles system-wide con `-a` cuando la investigación lo justifica.

Elegir frecuencia de muestreo, evento base y duración de captura.

Controlar overhead de sampling y tamaño del archivo `perf.data`.

Guardar capturas con nombres, metadatos y contexto operativo.

Evitar capturas demasiado largas o sin hipótesis definida.

Revisar errores por permisos, símbolos incompletos o proceso demasiado corto.

Realizar ejercicio de captura de perfil CPU sobre una aplicación lenta.

Abrir capturas `perf.data` con `perf report`.

Interpretar columnas de overhead, command, shared object, symbol y call graph.

Navegar por funciones, librerías, binarios, kernel y usuario.

Diferenciar self time, children time y costes acumulados.

Identificar hot paths, funciones dominantes y librerías con mayor impacto.

Analizar diferencias entre perfiles con y sin call graph.

Filtrar por proceso, hilo, símbolo, DSO o evento.

Exportar información relevante para informes técnicos.

Evitar confundir símbolo frecuente con causa raíz sin contexto.

Realizar ejercicio de análisis de perfil y propuesta de optimización.

Usar `perf top` para observar hotspots en tiempo real.

Diferenciar análisis en vivo y captura reproducible con `perf record`.

Filtrar eventos, procesos y símbolos durante una incidencia controlada.

Interpretar overhead cambiante en servicios activos.

Detectar funciones calientes, librerías inesperadas y actividad kernel.

Usar `perf top` con permisos adecuados y baja intrusión.

Evitar tomar decisiones definitivas solo con observación en vivo.

Combinar `perf top` con métricas de sistema y logs de aplicación.

Documentar hallazgos rápidos antes de capturar una evidencia persistente.

Realizar ejercicio de diagnóstico en vivo de proceso con CPU alta.

Comprender qué son call graphs y por qué son clave para entender rutas de ejecución.

Diferenciar captura con frame pointers, DWARF y LBR cuando el hardware lo permite.

Revisar impacto de opciones de compilación en la calidad del stack.

Entender por qué algunos perfiles muestran stacks incompletos o símbolos `[unknown]`.

Configurar compilación con símbolos y frame pointers cuando procede.

Analizar stacks de usuario, kernel y librerías compartidas.

Elegir modo de call graph según aplicación, lenguaje, overhead y entorno.

Validar que el perfil refleja rutas reales de ejecución.

Documentar limitaciones de stack unwinding en cada informe.

Realizar ejercicio comparando perfiles con y sin call graph fiable.

Comprender cómo Perf resuelve símbolos de binarios, librerías y kernel.

Instalar paquetes de símbolos y debug info en distribuciones Linux.

Usar binarios compilados con `-g`, frame pointers y optimización controlada.

Interpretar símbolos ausentes, direcciones crudas y funciones inlined.

Revisar impacto de stripping, contenedores y rutas de binarios en la resolución.

Configurar build IDs y cache de símbolos.

Trabajar con símbolos de kernel y módulos cargados.

Preparar binarios de laboratorio para análisis con `perf annotate`.

Documentar configuración de compilación usada en perfiles.

Realizar ejercicio de recuperación de símbolos en perfil incompleto.

Usar `perf annotate` para mapear muestras a instrucciones y líneas de código.

Interpretar ensamblador, instrucciones calientes, branches y accesos a memoria.

Relacionar código fuente, símbolos y líneas con mayor coste.

Analizar impacto de optimizaciones del compilador e instrucciones inlined.

Revisar funciones C/C++ y Rust compiladas con información de depuración.

Identificar bucles costosos, operaciones repetitivas y ramas mal predichas.

Evitar microoptimizar sin medir impacto global.

Documentar hallazgos de bajo nivel de forma comprensible para desarrollo.

Validar mejoras con nueva captura después del cambio.

Realizar ejercicio de optimización guiada por `perf annotate`.

Generar salida textual con `perf script` desde capturas `perf.data`.

Preparar stacks para construir flame graphs.

Entender lectura de flame graphs: anchura, profundidad, rutas y funciones dominantes.

Diferenciar flame graphs de CPU, off-CPU, allocation y otros enfoques.

Detectar rutas de ejecución repetitivas y patrones de coste acumulado.

Comparar flame graphs antes y después de una optimización.

Usar flame graphs como herramienta de comunicación con desarrollo y dirección técnica.

Evitar interpretar colores o profundidad sin entender la semántica del gráfico.

Integrar generación de flame graphs en scripts de diagnóstico.

Realizar ejercicio de creación e interpretación de flame graph de una aplicación.

Usar `perf trace` para observar llamadas al sistema de procesos y comandos.

Diferenciar `perf trace` de `strace` en enfoque, overhead y fuentes de eventos.

Identificar syscalls frecuentes, lentas o inesperadas.

Analizar acceso a ficheros, red, sincronización, timers y memoria.

Filtrar syscalls por proceso, evento o patrón.

Relacionar syscalls con latencia y consumo CPU.

Detectar bucles de polling, errores repetidos y operaciones bloqueantes.

Evitar trazas excesivas que generan ruido operativo.

Documentar syscalls relevantes y su impacto en el problema investigado.

Realizar ejercicio de diagnóstico de servicio con syscalls anómalas.

Comprender qué son los tracepoints y por qué ofrecen puntos estables de observación.

Listar tracepoints disponibles con `perf list`.

Capturar eventos de scheduler, syscalls, bloque, red, memoria y filesystem.

Combinar tracepoints con sampling para explicar comportamiento completo.

Filtrar eventos para reducir ruido y tamaño de captura.

Interpretar campos específicos de tracepoints.

Usar tracepoints para investigar latencias, bloqueos y cambios de estado.

Evitar tracepoints demasiado amplios en producción sin control.

Documentar eventos capturados, filtros y objetivo de análisis.

Realizar ejercicio de investigación de latencia usando tracepoints.

Comprender kprobes como instrumentación dinámica de funciones del kernel.

Comprender uprobes como instrumentación dinámica de funciones de usuario.

Usar `perf probe` para crear probes sobre funciones y líneas.

Capturar argumentos y contexto cuando el símbolo lo permite.

Revisar requisitos de símbolos, debug info y permisos.

Evitar probes inestables en funciones internas que cambian entre versiones.

Usar probes para confirmar hipótesis concretas sin modificar código.

Retirar probes después de la investigación para dejar el sistema limpio.

Documentar probes creados, objetivo, filtros y riesgo.

Realizar ejercicio de uprobe sobre función de aplicación y kprobe sobre kernel.

Analizar comportamiento del scheduler Linux mediante `perf sched`.

Capturar eventos de scheduling para procesos, hilos y workloads concurrentes.

Investigar latencias de run queue, cambios de contexto y migraciones de CPU.

Relacionar scheduling con contención, afinidad, CPU pinning y cgroups.

Detectar hilos que esperan CPU pese a baja utilización aparente.

Analizar impacto de prioridades, nice, policy y aislamiento de CPU.

Interpretar reportes de latencia y timeline de ejecución.

Combinar `perf sched` con `perf stat` y métricas de sistema.

Documentar hallazgos para equipos de plataforma y desarrollo.

Realizar ejercicio de diagnóstico de latencia causada por scheduling.

Comprender eventos relacionados con caché, loads, stores, latencia de memoria y misses.

Usar `perf mem` cuando la plataforma lo soporta.

Diferenciar problemas compute-bound y memory-bound.

Analizar cache misses, LLC misses, TLB misses y comportamiento de acceso.

Relacionar estructuras de datos y patrones de memoria con rendimiento.

Detectar acceso no local en sistemas NUMA cuando procede.

Comparar implementaciones con diferentes patrones de acceso a memoria.

Evitar conclusiones si el hardware o virtualización no expone eventos adecuados.

Documentar limitaciones de medición de memoria por arquitectura.

Realizar ejercicio de análisis de patrón memory-bound.

Comprender false sharing, cache line bouncing y contención entre cores.

Usar `perf c2c` para investigar cache-to-cache cuando está disponible.

Identificar líneas de caché con alto nivel de contención.

Relacionar contención con estructuras compartidas, locks y diseño concurrente.

Analizar workloads multihilo con acceso compartido a memoria.

Interpretar reportes de HITM y eventos relacionados.

Proponer mejoras: padding, separación de datos, cambios de locking o afinidad.

Validar mejoras con nueva captura y benchmark controlado.

Documentar casos donde `perf c2c` no es aplicable por hardware o permisos.

Realizar ejercicio de false sharing provocado y optimizado.

Preparar binarios con símbolos, frame pointers y opciones de compilación adecuadas.

Perfilar aplicaciones nativas CPU-bound y memory-bound.

Analizar funciones calientes, inlining, librerías y syscalls.

Usar `perf annotate` para revisar instrucciones costosas.

Comparar compilaciones debug, release y optimizadas.

Detectar problemas de locks, asignaciones, parsing, serialización o algoritmos.

Relacionar cambios de código con diferencias medibles de perfil.

Evitar optimizar microfunciones sin impacto real en el camino crítico.

Crear informe técnico para desarrollo con evidencia y recomendación.

Realizar ejercicio de optimización de aplicación nativa con Perf.

Comprender particularidades de perfilar aplicaciones Java con JIT, safepoints y símbolos dinámicos.

Revisar necesidad de perf map, frame pointers o herramientas auxiliares según entorno.

Diferenciar tiempo en código Java, JVM, GC, librerías nativas y kernel.

Analizar consumo CPU de servicios JVM bajo carga.

Interpretar perfiles donde aparecen símbolos incompletos o código generado.

Combinar Perf con métricas JVM, logs de GC y profilers de lenguaje.

Evitar conclusiones aisladas si el JIT aún no ha estabilizado el workload.

Medir impacto de calentamiento, heap, GC y configuración runtime.

Documentar limitaciones de símbolos y metodología usada.

Realizar ejercicio de perfil JVM combinando Perf y métricas de aplicación.

Entender desafíos de perfilar runtimes con JIT, intérprete, goroutines o event loop.

Analizar procesos Go con símbolos, frame pointers y runtime scheduler.

Investigar Python diferenciando intérprete, extensiones nativas y código de usuario.

Perfilar Node.js entendiendo V8, event loop, JIT y librerías nativas.

Combinar Perf con profilers propios de cada lenguaje.

Detectar syscalls, CPU nativa, bloqueo y rutas calientes externas al código de aplicación.

Evitar interpretar stacks incompletos sin conocer runtime y símbolos.

Crear capturas bajo carga estable y reproducible.

Documentar qué parte del perfil pertenece al runtime y cuál al código propio.

Realizar ejercicio de comparación de perfiles entre varios runtimes.

Perfilar procesos PostgreSQL, MySQL, Redis, NGINX, Kafka u otros servicios Linux.

Diferenciar CPU de usuario, kernel, I/O, locks, syscalls y librerías compartidas.

Capturar perfiles por proceso, por hilo o system-wide según el caso.

Combinar Perf con métricas internas del servicio.

Evitar interferir con producción sin autorización y ventana de observación definida.

Detectar funciones de compresión, parsing, red, almacenamiento, locks o planificación costosas.

Analizar comportamiento bajo carga sintética y carga real controlada.

Crear informes que conectan perfil de sistema con métricas de servicio.

Validar mejoras tras cambios de configuración, versión o consulta.

Realizar ejercicio de profiling de servicio backend o base de datos bajo carga.

Comprender cómo namespaces, cgroups y contenedores afectan al uso de Perf.

Perfilar procesos dentro y fuera de contenedores.

Resolver problemas de permisos, capabilities y acceso a eventos en contenedores.

Analizar servicios Docker o Podman con PID, cgroup y límites de CPU.

Revisar restricciones habituales en Kubernetes gestionado.

Capturar perfiles desde nodo, pod privilegiado o entorno de diagnóstico aprobado.

Relacionar throttling de CPU, límites, requests y scheduling con perfiles Perf.

Evitar elevar privilegios en clúster sin proceso de seguridad.

Documentar procedimiento seguro para profiling de contenedores.

Realizar ejercicio de análisis de rendimiento en contenedor con límites de CPU.

Entender cómo VMs, hipervisores y cloud afectan a eventos hardware.

Detectar eventos no disponibles, multiplexados o poco fiables en entornos virtualizados.

Comparar profiling en bare metal, VM, cloud y contenedor.

Revisar impacto de CPU steal, ruido de vecinos y frecuencia variable.

Adaptar metodología cuando no se dispone de PMU completa.

Usar eventos software y tracepoints cuando los contadores hardware son limitados.

Documentar limitaciones del entorno antes de presentar conclusiones.

Diseñar pruebas comparables entre entornos con distinta visibilidad.

Evitar culpar al código cuando el cuello de botella viene del entorno.

Realizar ejercicio de comparación de mediciones en host y VM.

Crear scripts para ejecutar `perf stat` con eventos estándar del equipo.

Automatizar `perf record` con duración, PID, eventos y salida controlada.

Generar nombres de archivos con fecha, host, servicio, versión y carga.

Recopilar metadatos: kernel, CPU, versión de app, contenedor, flags y carga.

Crear runbooks para CPU alta, latencia, syscalls, scheduling, memoria y regresión.

Definir límites de tamaño, duración y permisos para capturas.

Preparar plantillas de informe técnico con hallazgos, comandos y conclusiones.

Integrar generación de flame graphs en scripts internos.

Evitar automatizaciones peligrosas que capturan datos sensibles sin control.

Realizar ejercicio de runbook automatizado para incidente de CPU alta.

Usar Perf para comparar rendimiento antes y después de cambios.

Diseñar benchmarks reproducibles con carga estable y métricas claras.

Medir ciclos, instrucciones, caché, syscalls y perfiles de función entre versiones.

Integrar Perf en pruebas de rendimiento de CI/CD cuando el entorno lo permite.

Detectar regresiones por cambios de código, compilador, librerías, kernel o configuración.

Definir umbrales de alerta razonables y evitar falsos positivos por ruido.

Guardar capturas y reportes como evidencia de release.

Comparar perfiles mediante scripts y flame graphs diferenciales.

Documentar metodología para que los resultados sean defendibles.

Realizar ejercicio de detección de regresión con Perf y benchmark controlado.

Situar Perf dentro del ecosistema de observabilidad: métricas, logs, trazas y profiling.

Combinar Perf con Prometheus, Grafana, OpenTelemetry, logs y APM corporativo.

Usar métricas para detectar síntoma y Perf para investigar causa técnica.

Crear flujo de diagnóstico desde alerta hasta perfil y recomendación.

Evitar sustituir observabilidad continua por capturas manuales aisladas.

Documentar correlación temporal entre incidencia, carga y captura Perf.

Integrar resultados de Perf en postmortems y RCA.

Definir cuándo escalar desde métricas generales a profiling avanzado.

Crear paneles o registros de evidencias para análisis recurrentes.

Realizar ejercicio de investigación de alerta usando métricas y Perf.

Identificar datos potencialmente sensibles en capturas, stacks, rutas, símbolos y comandos.

Definir reglas de almacenamiento, cifrado, acceso y retención de `perf.data`.

Anonimizar informes cuando se comparten fuera del equipo técnico.

Evitar capturas system-wide en entornos multiusuario sin autorización.

Controlar transferencia de evidencias entre servidores, portátiles y repositorios.

Revisar impacto de perfiles sobre datos regulados o clientes.

Crear política de borrado seguro de capturas temporales.

Documentar quién capturó, cuándo, dónde, por qué y durante cuánto tiempo.

Incorporar seguridad en runbooks de profiling.

Realizar ejercicio de revisión de evidencias antes de compartir un informe.

Resolver errores de permisos por `perf_event_paranoid`.

Diagnosticar ausencia de eventos hardware por virtualización, kernel o CPU.

Corregir problemas de símbolos incompletos, stacks rotos o `[unknown]`.

Resolver mismatch entre paquete Perf y versión de kernel.

Identificar capturas demasiado grandes o con overhead excesivo.

Corregir perfiles sin muestras por proceso corto, evento incorrecto o frecuencia inadecuada.

Investigar errores en contenedores por capabilities, namespaces o acceso al host.

Diagnosticar problemas con debug info, build IDs y rutas de binarios.

Crear checklist de diagnóstico antes de repetir capturas.

Realizar ejercicio de reparación de un entorno Perf con fallos provocados.

Definir quién puede usar Perf y en qué entornos.

Crear estándar de comandos permitidos, eventos, duración, permisos y tratamiento de evidencias.

Establecer proceso de aprobación para capturas en producción.

Definir owners de runbooks, scripts, informes y repositorio de evidencias.

Crear plantillas de informe con hipótesis, comandos, resultados, conclusión y acción recomendada.

Revisar periódicamente permisos, capacidades y configuración de seguridad.

Mantener catálogo de casos diagnosticados y patrones recurrentes.

Integrar Perf en cultura SRE, mejora continua y postmortems sin culpabilizar equipos.

Evitar uso improvisado de profiling durante incidentes críticos sin procedimiento.

Realizar ejercicio de política corporativa de profiling avanzado con Perf.

Evaluar uso de Perf para CPU alta, regresiones, hotspots, syscalls, scheduling y memoria.

Analizar cuándo Perf complementa a profilers específicos de lenguaje.

Revisar cuándo es mejor usar eBPF, ftrace, strace, logs, trazas distribuidas o APM.

Desaconsejar capturas sin hipótesis, duración indefinida o acceso excesivo.

Desaconsejar profiling system-wide en producción sin autorización.

Identificar casos donde la causa está en configuración, arquitectura o carga externa.

Crear matriz de decisión por síntoma, entorno, riesgo y herramienta recomendada.

Documentar casos donde Perf aporta evidencias concluyentes.

Documentar casos donde Perf solo aporta una pista parcial.

Realizar ejercicio de selección de herramienta para veinte incidentes distintos.

Recibir un entorno Linux de laboratorio con varias aplicaciones y problemas de rendimiento provocados.

Preparar Perf, símbolos, permisos, contenedores, scripts y datasets de carga reproducibles.

Ejecutar mediciones iniciales con `perf stat` para establecer línea base.

Seleccionar eventos adecuados para CPU, caché, branches, syscalls, scheduling y memoria.

Capturar perfil CPU con `perf record` sobre proceso concreto y sobre sistema completo.

Analizar resultados con `perf report`, filtros, call graphs y símbolos.

Generar salida con `perf script` y construir flame graph interpretable.

Usar `perf annotate` para localizar instrucciones o líneas de código costosas.

Diagnosticar un caso de syscalls excesivas con `perf trace`.

Investigar un problema de scheduling con `perf sched`.

Analizar una aplicación en contenedor con límites de CPU y permisos controlados.

Comparar rendimiento antes y después de una optimización o cambio de configuración.

Investigar una regresión entre dos versiones de una aplicación.

Preparar una captura con kprobe o uprobe para confirmar una hipótesis concreta.

Validar seguridad de las capturas, permisos, datos sensibles y retención de evidencias.

Automatizar un runbook de captura para CPU alta o latencia anómala.

Integrar resultados con métricas básicas de observabilidad.

Crear informe técnico con hipótesis, comandos, datos, gráficos, hallazgos y recomendaciones.

Presentar conclusiones defendiendo causa raíz, impacto, riesgo, mejora y siguiente acción.

Entregar política mínima de uso de Perf para equipos de sistemas, desarrollo y SRE.