Simulación de Eventos Discretos · Tema 33

Utilización del servidor

ρ y la frontera de la estabilidad — cuánto trabaja, cuándo respira y cuándo la cola deja de volver.

01 · Punto de partida

El número más citado y más mal leído

“Estamos al 95%, somos eficientes”, festeja el jefe. La fila, mientras tanto, no baja nunca: L ≈ 19 en M/M/1, Wq de 9× la de ρ = 0.5. Al 95% no hay eficiencia: hay saturación. Y del otro lado, ρ = 1.2 no es “trabajar al 120%”: es avalancha, backlog que crece sin cota.

ρ es la frontera entre régimen y deriva: trabajo que llega sobre capacidad. Este tema la define, la mide y la usa para decidir.

  • ¿Cómo se calcula ρ con (λ, S, c) y cómo se mide con cronómetro?
  • ¿Qué ρ es sana, cuál tensa y cuál avalancha?
  • ¿Por qué la utilización medida se clava en 1 aunque ρ ofrecida sea 1.5?
  • ¿Qué margen dejo según variabilidad y SLA?

02 · Definición

Oferta, capacidad y fracción ocupada

a

Oferta

a = λE[S] (erlangs): trabajo que llega por unidad. Pide ⌊a⌋+1 servidores como piso.

ρ

Utilización

ρ = a/c: fracción ocupada por servidor en régimen. También P(servidor ocupado) y 1 − P0 en M/M/1.

U

Medición

U = tiempo ocupado/T (cronómetro o log). En régimen U ≈ ρ; saturada, U ≈ 1 aunque ρ > 1.

ρ y su lectura operativa (M/M/1, L = ρ/(1−ρ)).
ρLecturaL (M/M/1)Decisión
0.50Ágil: la mitad ocioso1.0Sobra; el 2º sería lujo
0.70Zona sana con azar2.3Margen para rachas
0.85Tenso: cada décima duele5.7Preparar el siguiente c
0.95Pared19Sumar capacidad o perder SLA
1.20Avalancha (sin régimen)∞Cola o fuga: no hay equilibrio

03 · El corazón: por qué 1 es pared

Debajo deriva cero, arriba deriva positiva

oferta a = λE[S]vscapacidad c→ρ decide

Si llega más trabajo del que sale (a > c), el backlog crece a tasa λ − cμ por unidad: la cola no “se estabiliza alta”, se va. Si a < c, el sistema vuelve una y otra vez al vacío y los promedios convergen. ρ = 1 es el filo: deriva nula, retornos infinitos, varianza que pide horizonte eterno.

  1. 1
    Estimar oferta.

    a = λ × E[S] (mismas unidades). Es lo que pediría c = a servidores al 100%.

  2. 2
    Dividir por c.

    ρ = a/c. Con heterogéneos o turnos, ρ por servidor (el quemado manda).

  3. 3
    Comparar con 1 + margen.

    ρ < 0.7 ágil, < 0.85 sano, > 0.9 pared (con azar; con D se estira).

  4. 4
    Medir U para auditar.

    U = ocupado/T por servidor. Si U ≈ 1 y hay cola siempre, estás saturado aunque tu planilla diga ρ = 0.8 (λ mal medida).

ρ ofrecida vs U medida
ρ se calcula con λ de puerta; U se mide con cronómetro. Con pérdidas, U usa λef: ρ “de puerta” > U real.
Saturación
U ≈ 1 con cola permanente: el servidor no descansa y el backlog crece a λ − cμ. La firma de ρ > 1.
Pico transitorio
ρ > 1 un rato (pico) con K que absorbe: backlog temporal que luego se drena. Se dimensiona por peor pico, no por media.
Margen por variabilidad
A igual ρ media, más Cs² pide ρ objetivo menor: el margen paga rachas, no ociosidad “vaga”.

ρ < 1

Régimen

Vuelve al vacío, U ≈ ρ, Little vale, Erlang predice. Se diseña aquí, con margen según SLA.

ρ ≥ 1

Deriva

U ≈ 1 clavada, backlog a λ − cμ, sin L de equilibrio. O se suma c, o se pierde (K), o se raciona (prioridades).

04 · Ejemplos

Cuatro ρ con historia

  1. 1
    Banco ρ = 0.67.

    λ = 20/h, S = 2 min, c = 1: tenso viable, U ≈ 0.67 medida en caja.

  2. 2
    Call center ρ = 0.86.

    a = 6, c = 7: estable pero al límite; el 8º lo lleva a 0.75 y salva el SLA.

  3. 3
    Router en pico ρ = 1.2.

    Buffer absorbe 30 s de avalancha y luego drena: U = 1 medida, ρ ofrecida 1.2.

  4. 4
    Taller cerrado.

    Con 8 de 10 máquinas caídas, la oferta efectiva cae sola: ρ se autorregula (N finita).

05 · Representación en Python

Calcular ρ y medir U

ρ se calcula en una línea; U se mide acumulando ocupado += fin − ini por servidor.

Python en tu navegador. El primero semaforiza ρ; el segundo mide U en una tanda c = 1. Compará cálculo con cronómetro.

# rho() con semáforo operativo
def rho(lam, E, c=1):
    r = lam * E / c
    sem = "estable" if r < 0.85 else ("tenso" if r < 1 else "AVALANCHA")
    return r, sem

for lam, E, c in [(0.25, 2, 1), (0.45, 2, 1), (0.9, 2, 3)]:
    print((lam, E, c), rho(lam, E, c))
# Medir U = ocupado/T en c=1 con arribos fijos
S, c, T = 2.0, 1, 20.0
libre, ocupado = 0.0, 0.0
for t in [0, 1, 2, 3, 15]:
    ini = max(t, libre)
    libre = ini + S
    ocupado += S
print(f"U={ocupado/T:.2f} (rho ofrecida={(5/T)*S/c:.2f})")

06 · Exploración

Laboratorio: cruzar la frontera

Elegí la oferta a (S = 2 fijo, λ = a/2) y c. El medidor muestra ρ con semáforo; la escalera es N(t) simulada (M/M/c, T = 120, réplica). Debajo de 1, U ≈ ρ y la escalera vuelve; arriba de 1, U se clava en 1 y el backlog no vuelve.

EXPERIMENTO 33

ρ ofrecida vs U medida

ρ = a/c · U = ocupado/T ≤ 1

Los resultados numéricos aparecen debajo.
ρ ofrecida0
U medida0
N final (backlog)0
Estado—

Cruzá ρ = 1 para ver la deriva.

Barra superior = ρ con semáforo (verde/amarillo/rojo); escalera = N(t); línea punteada = c. En avalancha la escalera no vuelve y U ≈ 1.

Preguntas para explorar

  1. Con a=1.8, c=2 (ρ=0.9): ¿U ≈ 0.9? ¿N final vuelve a chico?
  2. Pasá a c=1 (ρ=1.8): ¿U? ¿N final? ¿Por qué U no dice 1.8?
  3. Con a=1.8, c=3 (ρ=0.6): ¿qué margen compraste respecto a c=2 y a qué precio?
Ver respuestas sugeridas
  1. Sí: U ~0.85–0.95 y N final chico (régimen tenso, vuelve).
  2. U ≈ 1 clavada y N final grande (10–30): la medida satura; ρ ofrecida 1.8 solo vive en la planilla.
  3. Margen 0.3 de ρ y Wq de ~8 a ~1: un salario contra impaciencia y SLA.

07 · Comprensión

Confusiones frecuentes

«U = ρ siempre»

Solo en régimen sin pérdidas. Saturado, U = 1 aunque ρ = 1.5; con bloqueo, U usa λef y queda bajo ρ de puerta.

«ρ = 1.1 es estar muy ocupado»

Es avalancha con backlog a λ − cμ por unidad. “Muy ocupado” es ρ = 0.85; ρ > 1 es “no dar abasto”.

«ρ baja es desperdicio»

Con alta variabilidad o SLA duro, ρ = 0.6 es diseño, no despilfarro: compra espera baja y aire para picos.

«ρ global alcanza»

Con heterogéneos o mala asignación, un servidor quema al 0.95 y otros pasean: el ρ global 0.6 miente. Medí por servidor.

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: semáforo

λ=6/min, S=1, c=7 y c=8. ¿ρ y estado?

for c in [7, 8]:
    r = 6*1/c
    print(f"c={c} rho={r:.2f}", "tenso" if r >= 0.85 else "sano")
Ver solución razonada

c=7: ρ≈0.86 tenso; c=8: ρ=0.75 sano. El octavo compra el SLA.

Ejercicio 2: backlog de avalancha

λ=0.9, μ=0.5, c=1 (ρ=1.8). ¿Backlog por hora?

lam, mu, c = 0.9, 0.5, 1
print(f"deriva={(lam - c*mu)*60:.0f} clientes/hora")
Ver solución

24/hora: cada hora la fila crece 24 aunque nadie se vaya. O sumás c o perdés (K).

Ejercicio 3: U que delata λ

Medís U=0.95 con c=2, S=2 en T=60. ¿λ implícita en régimen? ¿Y si hay cola permanente?

Ver una posible respuesta
U, c, S = 0.95, 2, 2.0
print(f"lambda≈{U*c/S:.2f}/min en régimen; con cola permanente, lambda>= {c/S} (saturado)")

En régimen λ ≈ 0.95/min; con cola que no vuelve, λ ≥ 1.0 y U ya no dice cuánto más.

09 · Síntesis

Ideas para recordar

  • ρ = λE[S]/c: oferta sobre capacidad; <1 régimen, ≥1 deriva.
  • U = ocupado/T ≈ ρ en régimen, = 1 saturada: la medida delata la frontera.
  • ρ < 0.7 ágil, < 0.85 sano, > 0.9 pared (con azar).
  • En Python: rho() para decidir, cronómetro por servidor para auditar.
  • Dimensioná por pico con margen, no por media justa.

En el próximo tema mediremos la congestión: la longitud media de la cola.