Capacidad de una cola

01 · Punto de partida

Mismo arribo, distinto “lleno”

Un bar deja entrar hasta 30 personas; el que llega 31 se va a otro lado. Un estacionamiento con 20 boxes hace circular al 21. Un router con buffer de 50 paquetes tira el 51. La demanda λ era la misma; el cupo K decidió cuántos entraron y cuántos se perdieron.

Esa es la capacidad de la cola: el tope de clientes en el sistema. Infinita es una idealización cómoda (nadie se pierde, pero la espera puede explotar); finita es lo real (espera acotada, pero hay pérdida que hay que medir).

• ¿Cuántos caben en total (K) y cuántos en espera (K − c)?
• ¿Qué hace el que llega con el sistema lleno: se pierde, reintenta, ve la fila y ni entra?
• ¿Cómo mido perdidos, bloqueo Pb y throughput real?
• ¿Cuándo puedo suponer K = ∞ sin mentir?

02 · Definición

Cupo, espera y pérdida

03 · El corazón: perder acota, no regala

Bloqueo, throughput y Little efectiva

El simulador pregunta en cada llegada: si N < K admite (a servicio o a espera); si no, cuenta un perdido y sigue. El sistema pierde trabajo pero gana previsibilidad: la espera queda acotada por K − c lugares. El precio se paga en throughput: salen λ_ef, no λ.

1. 1
   Fijar K total.

   Incluye a los en servicio: con c = 1 y 3 sillas, K = 4. Confundir sillas con K es el error clásico.

2. 2
   Preguntar al llegar.

   si N < K: admitir; si no: perdidos += 1. La llegada que cae justo en un fin entra (la salida libera primero).

3. 3
   Contar tres flujos.

   Llegadas, admitidas y perdidas. Pb = perdidas/llegadas; λ_ef = admitidas/T.

4. 4
   Auditar con λ_ef.

   Little finita: L ≈ λefW (solo los que entraron viven W). Con λ cruda, la auditoría falla.

Erlang B (M/M/c/c)

Pérdida pura sin espera: Pb = ErlangB(c, λ/μ). La referencia para dimensionar líneas con Pb objetivo (1–2%).

Balking

Ve la fila y ni entra (bar lleno). El arribo “potencial” supera al que golpea la puerta: λ medida ya trae el descuento.

Reneging / abandono

Entra pero se cansa y se va (call center). Parecido a pérdida, pero ocupó espera un rato: Tema 39.

Reintento (retrial)

El perdido vuelve a llamar. Ojo: λ efectiva a la puerta supera a λ fresca y Pb se realimenta.

04 · Ejemplos

Cuatro llenos cotidianos

1. 1
   Bar K = 30.

   El 31 ve la fila y se va (balking). Pb alta un sábado no es fracaso: es puerta girando.

2. 2
   Parking K = 20, c = 20.

   Pérdida pura: o hay box o seguís de largo. Sin espera posible.

3. 3
   Router buffer 50.

   El paquete 51 se descarta (drop-tail). TCP lo reintentará: pérdida con reintento.

4. 4
   Call center 5 agentes + 3 en espera (K = 8).

   El noveno escucha “ocupado”. Tres esperan, cinco hablan, el resto pierde.

05 · Representación en Python

El cupo es un if a la entrada

Todo lo demás (reloj, FEL, FIFO) sigue igual. La única línea nueva es preguntar N < K antes de admitir y contar al que se va.

# Cupo K=3, c=1, S=2: ¿quién entra y quién se pierde?
K, S = 3, 2.0
fines, perd = [], 0  # fines = salidas programadas (largo = N en sistema)
for t in [0, 0.5, 1.0, 1.5, 5.0]:
    fines = [f for f in fines if f > t]  # salen los terminados (libera antes)
    if len(fines) < K:
        ini = max(t, fines[-1]) if fines else t
        fines.append(ini + S)
        print(f"t={t} N={len(fines)-1} -> entra, sale en {fines[-1]}")
    else:
        perd += 1
        print(f"t={t} N={K} -> PIERDE (perdidos={perd})")

# De conteos a Pb, lambda efectiva y Little
lleg, perd, T = 100, 12, 20.0
Pb = perd / lleg
lam_ef = (lleg - perd) / T
L, W = 2.2, 0.5  # medidos solo con admitidos
print(f"Pb={Pb:.0%} lam_ef={lam_ef:.2f} lam_ef*W={lam_ef*W:.2f} vs L={L}")

06 · Exploración

Laboratorio: achicar K, ver la fuga

Arribos Poisson de tasa λ, servicio fijo S, un servidor y cupo total K (T = 20 min). La escalera es N(t) en el sistema; la línea punteada es K; cada ✕ roja es un cliente perdido. Achicá K y subí λ: la espera se aplasta contra el techo y la fuga se dispara.

Escalera lima = N(t); techo punteado = K; ✕ rojas = arribos perdidos. Con K = 1 no hay escalón 2: o hay uno en servicio o se pierde.

Preguntas para explorar

1. Con λ=0.5, S=2 (ρ=1.0) y K=4, ¿hay perdidos? ¿Y con K=1? ¿Qué cupo “salva” la ρ=1?
2. Subí λ a 1.0 con K=4: ¿Pb? ¿Throughput crece igual que λ o se aplasta?
3. ¿Por qué Little se audita con λ_ef y no con λ? ¿Qué error da usar λ cruda con Pb=20%?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: K con c=1

Un servidor y 3 sillas de espera. ¿K? ¿Cuántos esperan como máximo?

c, sillas = 1, 3
K = sillas + c
print(f"K={K}, esperan hasta {K - c}")  # K=4, 3 en espera

Ejercicio 2: de perdidos a Pb

Llegaron 200, se perdieron 10 en T=10 h. ¿Pb y λ_ef?

lleg, perd, T = 200, 10, 10.0
print(f"Pb={perd/lleg:.0%} lam_ef={(lleg-perd)/T:.1f}/h")

Ejercicio 3: pérdida pura K=c

5 líneas sin espera (M/M/5/5), λ=4/h, μ=1/h. Estimá Pb con Erlang B.

import math
a, c = 4.0, 5
num = a**c / math.factorial(c)
den = sum(a**k / math.factorial(k) for k in range(c + 1))
print(f"ErlangB={num/den:.1%}")  # ~8%: el laboratorio con K=5 replica el orden

09 · Síntesis

Ideas para recordar

En el próximo tema juntaremos λ, μ y c en el caso base: los sistemas de un servidor.