Sistemas de un servidor

01 · Punto de partida

Una caja explica todas las cajas

Una sucursal con una sola caja, una impresora compartida, un peaje con una cabina: todos son el mismo sistema con c = 1. Tiene el estado más simple posible —libre u ocupado más la fila— y aun así produce toda la fenomenología: espera contenida con ρ = 0.5, tensión con ρ = 0.85 y avalancha con ρ > 1.

Por eso el sistema de un servidor es el caso base: tiene fórmulas exactas (M/M/1), se simula en 20 líneas y anticipa la pregunta que decide todo dimensionamiento: ¿alcanza con uno o pido el segundo?

• ¿Cuándo alcanza un servidor y cuándo la curva se dispara?
• ¿Cómo paso de (λ, μ) a ρ, L, Wq sin simular?
• ¿Cómo valido mi simulador c=1 contra la fórmula?
• ¿Qué cambia al agregar el segundo servidor?

02 · Definición

Estado binario, fórmulas cerradas

03 · El corazón: la curva que explota

ρ manda con forma de hipérbola

Duplicar la carga de ρ = 0.4 a 0.8 no duplica la espera: la multiplica por 4. De ρ = 0.8 a 0.95 la multiplica por 4 otra vez. Esa es la hipérbola 1/(1−ρ): plana al inicio, pared al final. La regla práctica del dimensionador nace de ahí: ρ < 0.7 ágil, 0.7–0.85 tenso, > 0.85 cola permanente.

1. 1
   Estimar λ y μ.

   λ de arribos, μ = 1/E[S] de atenciones. Mismas unidades o ρ miente.

2. 2
   Calcular ρ.

   ρ = λ/μ. Si ≥ 1, no hay fórmula que valga: avalancha (o cupo con fuga, Tema 27).

3. 3
   Predecir con M/M/1.

   L, Wq y W en un renglón. Es tu hipótesis antes de simular.

4. 4
   Validar simulando.

   Corre Poisson + Exp con c=1 y compará: si difiere >10% en régimen, el bug está en tu código.

Pollaczek-Khinchine (M/G/1)

Wq = λE[S²]/(2(1−ρ)): la espera crece con el segundo momento. A igual media, gigantes ⇒ Wq mayor.

M/D/1 (piso)

Wq = ρ/(2μ(1−ρ)): la mitad que M/M/1. Si tu simulador da menos que esto, mediste mal.

Tiempo residual

El que llega con servidor ocupado espera lo que le queda al que está en curso, no un S entero: por eso E[S²] aparece.

Regla 0.7 / 0.85

Heurística de diseño: bajo 0.7 la espera es ruido; sobre 0.85 cada décima de λ se paga en minutos de Wq.

04 · Ejemplos

Tres unos que ves cada día

1. 1
   Caja única: λ=20/h, S=2 min.

   μ = 30/h, ρ ≈ 0.67. M/M/1 predice Wq ≈ 4 min, W ≈ 6. Tenso pero viable.

2. 2
   Impresora: λ=10/h, S=3 min.

   μ = 20/h, ρ = 0.5. Wq ≈ 3 min: la mitad encuentra libre, nadie protesta.

3. 3
   Peaje 1 cabina en pico: λ=60/h, S=1 min.

   μ = 60/h, ρ = 1.0: la fila no se estabiliza; o abre otra cabina o la cola llega a la ruta.

05 · Representación en Python

Del (λ, μ) a la predicción en tres líneas

La fórmula es tu hipótesis; la simulación de 20 líneas es tu experimento. Ambas con c = 1, FIFO, sin cupo.

# M/M/1 con un servidor: λ=0.25/min, S medio 2 (μ=0.5)
lam, mu = 0.25, 0.5
rho = lam / mu
L = rho / (1 - rho)
Wq = lam / (mu * (mu - lam))
print(f"ρ={rho:.2f} L={L:.2f} Wq={Wq:.1f} W={Wq + 1/mu:.1f}")

# Simular c=1 FIFO (Poisson + Exp) y comparar Wq
import random
random.seed(28)
lam, mu, T = 0.25, 0.5, 200.0
t, libre, wqs = 0.0, 0.0, []
while t < T:
    t += random.expovariate(lam)
    ini = max(t, libre)
    libre = ini + random.expovariate(mu)
    wqs.append(ini - t)
print(f"Wq sim={sum(wqs)/len(wqs):.2f} vs teoría {lam/(mu*(mu-lam)):.2f} (N={len(wqs)})")

06 · Exploración

Laboratorio: acercarse a la pared

Simulamos c = 1 con arribos Poisson y servicios exponenciales hasta T = 60 (semilla = réplica). La escalera es N(t); la línea punteada es L teórica. Subí λ con S fijo y mirá cómo la escalera se despega del piso: en ρ = 0.5 ronda L = 1, en ρ = 0.9 trepa a L = 9.

Escalera lima = N(t) simulada; punteada blanca = L = ρ/(1−ρ). Con ρ ≥ 1 no hay L teórica: la escalera no vuelve.

Preguntas para explorar

1. Con λ=0.25, S=2 (ρ=0.5), ¿Wq sim ≈ 2? Cambiá de réplica: ¿cuánto varía?
2. Subí λ a 0.45 (ρ=0.9): ¿Wq teórica? ¿La sim la alcanza en T=60 o queda corta?
3. Con λ=0.5, S=2 (ρ=1.0): ¿qué hace N(t)? ¿Por qué no hay teoría que la ate?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: predecir el caso base

λ=20/h, S=2 min, c=1. ¿ρ, L y Wq M/M/1?

lam, S = 20/60, 2.0  # por minuto
mu, rho = 1/S, lam*S
print(f"ρ={rho:.2f} L={rho/(1-rho):.2f} Wq={lam/(mu*(mu-lam)):.1f} min")

Ejercicio 2: la pared en números

Con μ=0.5/min, compará Wq con λ=0.25 y λ=0.45.

mu = 0.5
for lam in [0.25, 0.45]:
    print(f"λ={lam} ρ={lam/mu:.2f} Wq={lam/(mu*(mu-lam)):.1f}")

Ejercicio 3: ¿pido el segundo?

λ=0.45, S=2 (ρ=0.9 con c=1). ¿ρ con c=2? (Anticipa el Tema 29.)

lam, S, c = 0.45, 2.0, 2
print(f"ρ={lam*S/c:.2f}")  # 0.45: vuelve lo ágil

09 · Síntesis

Ideas para recordar

En el próximo tema sumaremos capacidad en paralelo: los sistemas con múltiples servidores.