Rendimiento con multitudes

01 · Punto de partida

El tick que tarda un café

En el Tema 46 la rejilla bajaba los chequeos en papel. Ahora el reloj habla: ms por tick y KB por agente en tu máquina. El rendimiento une escalabilidad (Tema 46), memoria y vectores en un perfil que dice dónde duele.

Por eso optimizar sin medir es apostar: el cuello casi nunca está donde parece. Primero cronómetro, después bisturí.

• ¿Cuántos ms tarda cada tick?
• ¿Cuánta memoria ocupa cada agente?
• ¿Qué parte come el tiempo: mover o vecinos?
• ¿Qué se sacrifica para ir más rápido?

02 · Definición

Tiempo, memoria y cuello

Todo rendimiento combina cuánto tarda, cuánto ocupa y dónde se atasca:

03 · Perfil

Adivinar frente a medir

La intuición apunta al dibujo; el perfil delata a los vecinos. Creerle al reloj ahorra semanas.

Rendimiento

Ms por tick y KB totales con N y ticks dados. Se mide con cronómetro, no con feeling.

Perfil

Tiempo por parte: mover, vecinos, dibujar. Lo que dice dónde duele antes de operar.

Vectorización

Operar de a bloques y no de a uno: arreglos que vuelan. Velocidad a cambio de simpleza.

Compromiso

Lo que se entrega por ir rápido: detalle, precisión o memoria. Sin costo no hay magia.

04 · Ciclo

La ronda que afina con reloj

Cada mejora perfila, ataca el cuello y repite, en este orden:

1. 1
   Perfilar el tick.

   Cronometrar mover y vecinos por separado: el parte que manda.

2. 2
   Atacar el cuello.

   Rejilla, menos dibujo o resumir datos: una sola cirugía por vez.

3. 3
   Repetir la medida.

   Mismo N y ticks con reloj: si no baja, se revierte.

05 · Representación en Python

Reloj que no miente

Medir es restar tiempos y estimar memoria por agente. Lo demás es operar el cuello.

import time
def tick(n):
    t0 = time.perf_counter()
    s = sum(i * i for i in range(n))
    return round((time.perf_counter() - t0) * 1000, 2)

print(tick(10000))

Mide ms de un trabajo con N: el reloj pone número a la sospecha.

Memoria que se estima

Cada agente pesa: contar antes de cargar millones.

def memoria_kb(n, bytes_por_agente=64):
    return round(n * bytes_por_agente / 1024, 1)

print(memoria_kb(60000), memoria_kb(1000000))

06 · Exploración

Laboratorio: reloj en mano

Nube que camina ticks con agentes y cuenta vecinos en radio con rejilla. Se cronometra en tu navegador y se estima memoria a 64 bytes por agente. Verde camina, líneas vecinas. ¿A qué N el tick deja de ser interactivo?

Cada punto camina con paso fijo y cuenta vecinos por rejilla: el tiempo es real de tu equipo. Más radio es más vecinos por tick. Pulsá Nueva réplica para otra nube con los mismos parámetros.

Preguntas para explorar

1. Con pocos agentes y ticks, ¿los ms importan? ¿Por qué con N chico el perfil sobra?
2. Subí N al máximo con radio grande. ¿Los ms suben lineal o más? ¿Qué parte los empuja?
3. Repetí 3 veces iguales. ¿Los ms son idénticos? ¿Qué parte es modelo y qué parte es máquina?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: reloj que habla

Ejecutá y compará N chico contra grande. Luego duplicá otra vez.

import time
def trabajo(n):
    t0 = time.perf_counter()
    s = sum(i for i in range(n))
    return round((time.perf_counter() - t0) * 1000, 2)

print(trabajo(10000), trabajo(100000))

Ejercicio 2: predecir la memoria

Sin ejecutar primero: 200 mil agentes a 64 bytes. ¿KB y MB?

print(200000 * 64 / 1024, 200000 * 64 / 1024 / 1024)

Ejercicio 3: cuello que manda

Si mover tarda 2 ms y vecinos 18 ms, ¿qué atacás? Escribilo.

print("vecinos: 90 % del tick")

09 · Síntesis

Ideas para recordar

En el próximo tema veremos la visualización de agentes: ver rejillas, redes y movimientos.