Saltearse al contenido

Medir

Optimizar sin medir es cambiar código y esperar que mejore. A veces mejora. El problema es que nunca sabes qué cambió. Este capítulo trata las tres preguntas que se hacen antes de tocar nada: ¿cuánto cuesta esta operación?, ¿qué función domina?, ¿quién ocupa la memoria?

Cada herramienta responde una pregunta distinta; usar la equivocada da números ciertos e inútiles.

Pregunta Herramienta Salida
¿Cuánto tarda esta operación? timeit Nanosegundos por llamada
¿Qué función consume el tiempo? cProfile Tiempo por función y llamadas
¿Quién ocupa la memoria? tracemalloc Bytes por línea de código
import timeit
timeit.timeit("sorted(datos)", globals=globals(), number=1000)
timeit.repeat("sorted(datos)", globals=globals(), number=1000, repeat=5)

Tres reglas:

  • repeat y quedarse con el mínimo, no con la media. El mínimo es el que menos ruido tiene del sistema operativo.
  • number alto para operaciones rápidas: medir una suma con number=1 es medir el reloj.
  • La misma máquina y el mismo proceso para comparar dos versiones.
import cProfile, pstats
cProfile.run("main()", "salida.prof")
pstats.Stats("salida.prof").sort_stats("cumtime").print_stats(10)

Dos columnas que hay que saber leer:

  • tottime: el tiempo dentro de la función, sin sus llamadas.
  • cumtime: el tiempo total, incluyendo lo que llamó.

Una función con cumtime alto y tottime bajo no es el problema: es el que llama al problema. Hay que bajar hasta la que tiene tottime alto.

import tracemalloc
tracemalloc.start()
main()
snapshot = tracemalloc.take_snapshot()
for stat in snapshot.statistics("lineno")[:10]:
print(stat)

Devuelve las líneas que más memoria asignaron, con el tamaño y el número de bloques. Es la única herramienta de la biblioteca estándar que responde «quién».

Instrumentar cambia el programa
Instrumento Coste relativo
Sin instrumentar 1.0×
cProfile 1.1×
tracemalloc 6.6×

python mediciones/05-01-04-memoria.py

El 1,1 de cProfile es engañoso: su coste es por llamada, no por operación. En un bucle dentro de una sola función casi no se nota; en un programa con millones de llamadas pequeñas, multiplica el tiempo por cinco o más.

tracemalloc cuesta 6,6 veces porque intercepta cada asignación. Sirve para diagnosticar, nunca para dejar activado en producción.

  1. Reproducir el problema con un caso medible. Un script que corre en segundos y falla igual que producción.
  2. Medir sin instrumentar para tener la línea base.
  3. Perfilar con la herramienta que corresponda a la pregunta.
  4. Cambiar una cosa. Una.
  5. Volver a medir con el mismo caso y comparar.

El paso 4 es donde se rompe el método: cambiar tres cosas a la vez y ver que mejora no dice cuál funcionó, y una de las tres puede estar empeorando.

cProfile y tracemalloc exigen ejecutar el programa con ellos. En producción eso no siempre es posible, y ahí entra el perfilado por muestreo: py-spy toma muestras de la pila cada pocos milisegundos desde fuera del proceso.

Ventana de terminal
py-spy top --pid 12345
py-spy record -o perfil.svg --pid 12345

Su ventaja no es la precisión: es que no modifica el proceso, no necesita reiniciarlo y funciona con el binario compilado. Su límite es el mismo: da porcentajes de tiempo, no números exactos de una operación.

Para memoria en un entorno que no puedes modificar, tracemalloc con PYTHONTRACEMALLOC=25 activa el rastreo desde el arranque sin tocar el código, a cambio del coste del capítulo (6,6×). Úsalo en una réplica o durante una ventana de diagnóstico, no como configuración permanente de producción.

  • Antes de tener un problema. Optimizar lo que no duele es la forma más eficiente de complicar el código.
  • Si el cuello es la red o el disco. py-spy o el profiler del sistema, no cProfile.
  • En código que va a cambiar. Un microbenchmark de una función que se reescribe la semana que viene no aporta.

Una función tarda 2 segundos procesando 100 000 filas. cProfile muestra que el 80 % del tottime está en validar_email, llamada 100 000 veces. Propón el orden de intervención y qué medirías después de cada cambio.

Solución
  1. Medir la línea base con el caso reproducible: 2 s, 100 000 llamadas → 20 µs por llamada.
  2. Comprobar si hay que validar todas. Si el 90 % de los emails se repiten, una caché con lru_cache reduce las llamadas reales a 10 000. Medir de nuevo: debería bajar a unos 0,56 s (1,6 s por el 10 % de cálculo restante más 0,4 s de caché).
  3. Si no se repiten, optimizar la función. Un regex precompilado en el módulo, en lugar de compilarlo en cada llamada, es la mejora típica.
  4. Volver a perfilar para confirmar que validar_email ya no domina y ver cuál es el nuevo cuello.

El orden importa: primero se elimina trabajo (no validar lo repetido), después se acelera el trabajo restante. Al revés se optimiza una función que quizá no había que llamar.

Y en cada paso, el mismo cProfile sobre el mismo caso: si el tottime de la función no baja, el cambio no sirvió.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 17 y 22.
  • CPython 3.13: Lib/timeit.py, Lib/cProfile.py, Modules/tracemalloc.c.
  • Mediciones: mediciones/05-01-04-memoria.py.
  • 05 · Optimizar sin mentir: qué hacer con lo que la medición revela.
  • 02 · Fugas: el diagnóstico con dos snapshots.
  • 06 · Vectorizar: cuando el cuello es un bucle de Python.