Redes de colas

01 · Punto de partida

Ninguna cola vive sola

El banco es informes → caja; la guardia triage → médico → farmacia; la web front → app → DB. Cada salida es una llegada aguas abajo (más arribos externos). Dimensionar el nodo 1 sin mirar el 2 es regalar el cuello: el sistema anda a la velocidad del más cargado.

La red de colas conecta nodos con ruteo y resuelve el tráfico λ_i de cada uno: con eso, cada nodo se analiza (o simula) con su λ y el total se suma por visitas.

• ¿Cómo se conectan los nodos y qué fracción va a cada uno?
• ¿Cómo calculo λ en cada nodo (externo + interno)?
• ¿Cuál es el cuello y qué W total sufre el cliente?
• ¿Cuándo puedo analizar nodo por nodo y cuándo simulo la red?

02 · Definición

Nodos, ruteo y tráfico

03 · El corazón: resolver, hallar el cuello, sumar

Tráfico primero, colas después

Sin λ_i no hay ρ_i ni Wq_i: el tráfico manda. En tándem es multiplicar (λ₂ = λ₁P₁₂); con ciclos (rework) es sistema lineal; con Jackson M/M/c abierto, cada nodo se comporta como si fuera M/M/c aislado con su λ_i (forma producto).

1. 1
   Dibujar nodos y flechas.

   γ externas por nodo, P_ij entre nodos y P_i0 de salida. Todo suma 1 por fila.

2. 2
   Resolver λ_i.

   Tándem: en cadena. Con ciclos: sistema lineal (2×2 a mano, más con Python).

3. 3
   Hallar el cuello.

   ρ_i = λ_i/(c_iμ_i): el máximo decide estabilidad y SLA. Refuerzo va ahí.

4. 4
   Sumar visitas.

   W total = Σ (visitas medias al i × W_i). El que recorre dos nodos paga dos esperas.

Tándem

Fila en serie: λ₂ = λ₁P₁₂. El caso del laboratorio y de front→app→DB.

Split / merge

Una salida se parte (70/30) o varias se juntan: λ_j suma aportes. El merge correlaciona arribos (ojo PASTA).

Jackson (red abierta)

Con M/M/c por nodo y ruteo markoviano, P(n₁,n₂…) = ΠP_i(n_i): cada nodo como aislado. Aproximación de trabajo diaria.

Burke

La salida de un M/M/c estable es Poisson: el tándem markoviano se encadena limpio. Con G o K finita, ya no.

04 · Ejemplos

Cuatro redes de todos los días

1. 1
   Banco: informes → caja (70%).

   λ₁ = 0.4, λ₂ = 0.28: el cuello suele ser informes (ρ₁ = 0.8).

2. 2
   Guardia: triage → médico → farmacia.

   Tres tándem con prioridades solo en el primero: red + clases combinadas.

3. 3
   Web: front → app (80%) → DB (60%).

   λ_DB = λ·0.48: DB pequeña con todo el tráfico es el cuello clásico.

4. 4
   Taller con rework 10%.

   P₂₁ = 0.1 de vuelta a corte: ciclo que infla λ₁ = γ/(1−0.1·…). Se resuelve, no se adivina.

05 · Representación en Python

Tráfico con álgebra, red con traza

Resolver λ_i es lineal; simular el tándem es pasarle las salidas del 1 como arribos del 2.

# Tráfico del tándem: γ1=0.4, P12=0.7, S1=S2=2
gamma1, p = 0.4, 0.7
lam1, lam2 = gamma1, gamma1 * p
for i, lam in [(1, lam1), (2, lam2)]:
    print(f"nodo{i}: lam={lam:.2f} rho={lam*2:.2f}")

# Tándem M/M/1 -> M/M/1: salidas del 1 alimentan al 2 (p=0.7)
import random
random.seed(40)
lam, mu, p, T = 0.4, 0.5, 0.7, 200.0
t, libre1, libre2, Wtot, n = 0.0, 0.0, 0.0, [], 0
while t < T:
    t += random.expovariate(lam)
    ini1 = max(t, libre1)
    fin1 = ini1 + random.expovariate(mu)
    libre1 = fin1
    if random.random() < p:
        ini2 = max(fin1, libre2)
        fin2 = ini2 + random.expovariate(mu)
        libre2 = fin2
        Wtot.append(fin2 - t)
    else:
        Wtot.append(fin1 - t)
    n += 1
print(f"W total={sum(Wtot)/len(Wtot):.1f} (N={n})")

06 · Exploración

Laboratorio: el tándem y su cuello

Tándem puerta (S₁ = 2 fijo) → fondo con prob. p (S₂ ajustable), c = 1 en ambos, T = 150, semilla fija. El esquema muestra los flujos λ₁ → λ₂; las barras comparan Wq₁ vs Wq₂. Subí p o S₂ y mirá cómo el cuello se muda del nodo 1 al 2.

Flechas con tasas; barras = Wq por nodo (naranja el cuello). W total = puerta + p·fondo para el que sigue.

Preguntas para explorar

1. Con λ₁=0.4, p=70%, S iguales: ¿ρ₁ vs ρ₂? ¿Dónde está el cuello?
2. Subí S₂=4: ¿ρ₂? ¿W total para el que sigue?
3. Con p=30%: ¿λ₂? ¿El fondo respira aunque S₂=4?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: tráfico en cadena

γ₁=0.5, P₁₂=0.8, P₂₃=0.5. ¿λ₁, λ₂, λ₃?

g1, p12, p23 = 0.5, 0.8, 0.5
lam1, lam2, lam3 = g1, g1*p12, g1*p12*p23
print(f"{lam1:.2f} {lam2:.2f} {lam3:.2f}")  # 0.50 0.40 0.20

Ejercicio 2: W del que sigue

W₁=10, W₂=4.5, p=0.7. ¿W total medio (todos) y del que sigue?

W1, W2, p = 10.0, 4.5, 0.7
print(f"todos={W1+p*W2:.2f} sigue={W1+W2:.1f}")

Ejercicio 3: rework que infla

γ=0.4 al nodo 1, P₁₂=1, P₂₁=0.1 (10% vuelve). Resolvé λ₁, λ₂.

# lam1 = g + 0.1*lam2; lam2 = lam1 -> lam1 = g/0.9
g = 0.4
lam1 = g/0.9
print(f"lam1={lam1:.2f} lam2={lam1:.2f}")  # 0.44: el rework infla 11%

09 · Síntesis

Ideas para recordar

En el próximo tema mediremos bien el arranque: el período de calentamiento.