Clientes y servidores

01 · Punto de partida

Demanda que llega, capacidad que atiende

Todo sistema de colas tiene dos elencos: los clientes, que traen trabajo (personas, requests, piezas), y los servidores, que lo hacen (cajas, workers, máquinas). Los clientes fluyen; los servidores permanecen y se ocupan.

La obra entera es el encuentro entre ambos: si hay servidor libre, hay servicio inmediato; si no, hay espera. Dimensionar es poner los servidores justos para los clientes que vienen.

• ¿Quién es cliente y quién servidor en mi sistema?
• ¿Cuántos servidores hay y son iguales?
• ¿De dónde vienen los clientes: población infinita o grupo cerrado?
• ¿Qué pasa si un servidor se libera y nadie espera?

02 · Definición

Tres caras de cada rol

03 · Roles y encuentros

Cuatro encuentros posibles

1. 1
   Libre + llega.

   Servicio inmediato, Wq=0. El servidor pasa a ocupado y agenda su fin.

2. 2
   Ocupado + llega.

   A la cola con su hora. Su Wq nacerá cuando se libere uno.

3. 3
   Fin + hay cola.

   El servidor encadena al siguiente sin descansar: el encuentro es instantáneo.

4. 4
   Fin + sin cola.

   El servidor queda libre (ocio). El próximo cliente no esperará.

Población infinita

Los que llegan no vuelven (o son tantos que da igual): λ constante. Supuesto base de M/M/1 y M/M/c.

Población finita / cerrada

N fijo que circula (10 máquinas que fallan y se reparan): al haber menos afuera, λ efectiva cae. (Notación N, Tema 30)

Servidores idénticos vs. heterogéneos

Idénticos: cuenta el nº ocupado. Distintos (caja rápida/lenta): importa cuál toca, y el tipo del cliente elige.

Throughput

Salidas por unidad en régimen: igual a λ si es estable (todo lo que entra sale). Con pérdidas o abandono, menor.

04 · Ejemplos

Quién atiende a quién

1. 1
   Banco 2 cajas, 6 clientes juntos.

   2 entran ya, 4 esperan. Cada fin encadena al siguiente: el laboratorio mide cuánto se tarda en vaciar (makespan).

2. 2
   Web 8 workers.

   Requests que caen al primero libre: el reparto es automático y justo con fila única.

3. 3
   Taller 10 máquinas, 1 técnico.

   Población cerrada: cada reparación devuelve una máquina afuera, que volverá a fallar. λ depende de cuántas estén sanas.

05 · Representación en Python

Lista de clientes, lista de servidores

Clientes como dicts en una cola; servidores como lista de libre_en. Asignar es tomar el servidor con menor libre_en.

# 6 clientes juntos (t=0), S=3, c=2: ¿cuándo sale el último?
S, c, N = 3.0, 2, 6
libres = [0.0] * c
for i in range(N):
    k = min(range(c), key=lambda j: libres[j])  # primero libre
    inicio = max(0.0, libres[k])
    libres[k] = inicio + S
    print(f"C{i+1} -> srv {k} [{inicio}, {libres[k]}]")
print("makespan:", max(libres))  # 9.0

# Con llegadas en 0, 2, 4 y c=1, S=3: ¿quién espera?
libre, S = 0.0, 3.0
for i, t in enumerate([0.0, 2.0, 4.0]):
    inicio = max(t, libre)
    libre = inicio + S
    print(f"C{i+1} llegó {t} esperó {round(inicio - t, 1)}")

06 · Exploración

Laboratorio: repartir N entre c

N clientes caen juntos en t=0 (pico brutal) con atención S y c servidores idénticos en fila única. Cada fila del Gantt es un servidor; cada bloque un cliente. Subí c y mirá cómo el makespan se parte y la espera media se desploma — con retornos decrecientes.

Filas = servidores, bloques = clientes con su ID. Todos llegan en 0: la espera es pura consecuencia de c y S.

Preguntas para explorar

1. Con N=6, S=3 y c=1, ¿makespan y espera media? ¿Y con c=2? ¿Y con c=3?
2. ¿El paso de 2→3 ahorra lo mismo que el de 1→2? ¿Qué son retornos decrecientes?
3. Con c=3 y N=3, ¿espera alguien? ¿Qué utilización da?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: makespan de un pico

N=6 juntos, S=3, c=2: ¿cuándo sale el último?

import math
N, S, c = 6, 3.0, 2
print("makespan:", math.ceil(N / c) * S)  # 9.0

Ejercicio 2: espera del tercero

Con c=1 y S=3, los 3 llegan en 0: ¿cuánto espera C3?

S = 3.0
print("C3 espera:", 2 * S)  # 6.0: dos servicios antes

Ejercicio 3: utilización del pico

N=6, S=3, c=2, makespan 9: ¿U media?

N, S, c, makespan = 6, 3.0, 2, 9.0
print("U =", (N * S) / (c * makespan))  # 1.0: pico 100%

09 · Síntesis

Ideas para recordar

En el próximo tema mediremos el ritmo de la demanda: el proceso de llegada.