Simulaciones paralelas y semillas

01 · Punto de partida

Ocho workers, un solo ciclo

Partís tu Monte Carlo en 8 workers y cada uno siembra con la hora: los que arrancan en el mismo milisegundo quedan gemelos y tu “×8 réplicas” son ×4 duplicadas. O siembran 1…8 en un LCG y sus streams se solapan (Tema 37). El paralelismo multiplica la velocidad pero también multiplica las formas de pisarse.

La regla de oro: el stream del worker w es función determinista de (madre, w), nunca del reloj ni del azar del momento.

• ¿Por qué la hora por worker genera gemelos?
• ¿Qué tres repartos garantizan disjunción?
• ¿Cómo agrego resultados parciales sin sesgo?
• ¿Qué cambia en GPU con miles de hilos?

02 · Definición

Tres repartos honestos

03 · Agregación correcta

Promediar parciales sin mentir

Cada worker estima con su stream (media, proporción, percentil) y el coordinador promedia ponderado por N: con igual N por worker, promedio simple. La varianza entre workers estima el error: si dos workers dan idéntico, son gemelos, no precisión.

Gemelos por reloj

Workers nacidos en el mismo ms comparten semilla y stream: sus “réplicas independientes” son copias. Síntoma: varianza entre workers ≈ 0.

Orden no determinista

Los workers terminan en cualquier orden: agregar por índice w (no por llegada) mantiene la trazabilidad semilla→resultado.

Reproducibilidad paralela

Misma madre + mismo W + mismo reparto por índice = mismos parciales aunque cambie el hardware o el orden de llegada (Tema 36).

04 · Ejemplos

Tres repartos reales

1. 1
   π con 8 workers.

   Cada uno estima con su stream; el promedio de los 8 es el π final con error ÷√8.

2. 2
   Búsqueda de bug en worker 5.

   Se re-corre solo w = 5 con su stream: el resto ni se toca.

3. 3
   GPU con 10⁵ hilos.

   Hilo t = Philox(llave = t): sin solape posible por construcción, sin memoria compartida.

05 · Implementación en Python

Emular workers con índice

Sin NumPy ni procesos: cada “worker” es un Random(hash(madre, w)) que estima π en su cuarto de círculo. El promedio de parciales converge; con reloj colapsaría.

import hashlib
import random

def worker_pi(w, madre=38, n=2000):
    h = hashlib.sha256(f"{madre}:{w}".encode()).digest()
    rng = random.Random(int.from_bytes(h[:8], "big"))
    dentro = sum(1 for _ in range(n) if rng.random() ** 2 + rng.random() ** 2 < 1)
    return 4 * dentro / n


W = 8
parciales = [worker_pi(w) for w in range(W)]
print([round(p, 4) for p in parciales])
print("pi global:", round(sum(parciales) / W, 4))

Ocho parciales ≈ 3,14 ± 0,03 y un global más cerca de π que cualquiera: ÷√8 en acción.

Gemelos por reloj, en cámara lenta

import random

def worker_reloj(w, n=500):
    rng = random.Random(1718440000)  # mismo segundo para todos
    return [rng.random() for _ in range(n)][0]


print([round(worker_reloj(w), 6) for w in range(4)])

06 · Exploración

Laboratorio: gemelos al acecho

W workers con L valores cada uno sobre LCG m = 256: con semillas 1…W (vecinas) los streams se pisan; con bloques de 256/W se separan. El panel cuenta pares de workers con solape.

Cada fila es un worker, cada punto un valor: columnas violeta = el mismo valor en varios workers a la vez.

Preguntas para explorar

1. Con vecinas, W = 16 y L = 40: ¿qué % de valores son únicos? ¿De qué sirve paralelizar así?
2. Con bloques y L = 120, W = 16: ¿hay solape? ¿Por qué el bloque debe ser ≥ L?
3. Si los parciales de 8 workers dan idéntico hasta el 4º decimal, ¿precisión o gemelos?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: π en 8 workers

Repetí la estimación del bloque anterior con W = 4 y W = 16: ¿cómo escala el error del global?

import hashlib
import random

def worker_pi(w, madre=38, n=2000):
    h = hashlib.sha256(f"{madre}:{w}".encode()).digest()
    rng = random.Random(int.from_bytes(h[:8], "big"))
    dentro = sum(1 for _ in range(n) if rng.random() ** 2 + rng.random() ** 2 < 1)
    return 4 * dentro / n


for w in [4, 16]:
    ps = [worker_pi(i) for i in range(w)]
    print(w, round(sum(ps) / w, 4))

Ejercicio 2: contar gemelos

Con el juguete m = 256 y semillas 1…8 con L = 40, contá pares de workers con algún valor en común.

def run(semilla, n, a=13, c=7, m=256):
    x = semilla % m
    sal = []
    for _ in range(n):
        x = (a * x + c) % m
        sal.append(x)
    return set(sal)


streams = [run(s, 40) for s in range(1, 9)]
pares = sum(1 for i in range(8) for j in range(i + 1, 8) if streams[i] & streams[j])
print(pares, "de 28")

Ejercicio 3: re-correr al worker 5

Mostrá que el parcial del worker 5 se reproduce solo, sin tocar a los demás.

import hashlib
import random

def parcial(w, madre=38, n=2000):
    h = hashlib.sha256(f"{madre}:{w}".encode()).digest()
    rng = random.Random(int.from_bytes(h[:8], "big"))
    return sum(rng.random() for _ in range(n))


print(parcial(5) == parcial(5))

09 · Síntesis

Ideas para recordar

En el próximo bloque entra el mundo físico del cómputo: precisión de punto flotante, cómo guarda decimales tu máquina.