La trampa de la CPU

Hasta aquí asyncio parece magia: pones async delante de todo y las cosas van más rápido. En este paso vas a descubrir dónde deja de funcionar, y es un descubrimiento que te va a ahorrar días de depuración en el futuro.

Un latido para vigilar el bucle

Necesitamos una forma de saber si el event loop está sano. La técnica es sencilla: una tarea que imprime la hora cada 100 milisegundos. Si el bucle va bien, los intervalos serán de 100 milisegundos clavados. Si alguien lo bloquea, veremos el hueco.

Primero necesitas algo que queme CPU de verdad. Crea heavy.py:

import numpy as np


def detect_in_process(jpeg: bytes):
    """Pure CPU work, standing in for a model running inside this process."""
    total = 0.0
    for _ in range(3):
        a = np.random.rand(700, 700)
        b = np.random.rand(700, 700)
        total += float((a @ b).sum())
    return total

Multiplicar matrices de 700 por 700 tarda unos cientos de milisegundos y no hace nada de I/O: es cálculo puro, igual que un modelo corriendo dentro de tu proceso.

Ahora crea block_loop.py:

async def heartbeat():
    last = time.perf_counter()
    while True:
        now = time.perf_counter()
        print(f"tick   gap {(now - last) * 1000:6.0f} ms")
        last = now
        await asyncio.sleep(0.1)

async def infer_badly():
    for _ in range(4):
        detect_in_process(b"")       # <- pure CPU, inside the loop
        await asyncio.sleep(0)       # too late, the blocking already happened

async def main():
    asyncio.create_task(heartbeat())
    await asyncio.sleep(0.35)
    await infer_badly()
    await asyncio.sleep(0.35)

asyncio.run(main())

Fíjate en main, porque introduce algo nuevo: asyncio.create_task. A diferencia de await, que espera a que la corrutina termine, create_task la lanza a correr en segundo plano y sigue con la línea siguiente. Por eso el latido late mientras el resto del programa hace lo suyo.

Y detect_in_process es una detección hecha dentro de tu proceso: puro cálculo con NumPy, sin red de por medio.

Qué significa esto en un pipeline

Traduce ese hueco a tu proyecto real. Durante ese segundo y medio:

• Ninguna cámara se leyó. Los frames que llegaron por la red se quedaron en el buffer del sistema operativo, o se perdieron.
• Ninguna cola se vació.
• Ningún evento se publicó.

Una sola función pesada, mal colocada, paraliza el sistema entero. Y lo peor es que no falla: no hay excepción ni error. Simplemente todo va a tirones y no sabes por qué.

Arriba, tareas de I/O: cada una trabaja un instante y suelta el control, y el bucle salta entre ellas. Abajo, una tarea de cálculo puro ocupa toda la línea de tiempo y nadie más avanza.