Sistemas informáticos

01 · Punto de partida

Pedidos que llegan, workers que atienden

Cada slot llega un pedido con a y se sirve uno con s (si hay). Con buffer K = 4, la cola Xₙ es Markov: si a > s crece y pierde; si a < s se vacía y sobra capacidad.

Los indicadores son latencia (cola media), throughput (servidos/slot) y pérdida (P(llena) con arribo).

• ¿Qué carga a y qué capacidad s por slot?
• ¿Qué cola media (latencia) resulta?
• ¿Cuánto throughput real sale?
• ¿Qué fracción se pierde por buffer lleno?

02 · Definición

Carga, capacidad y sus tres números

Todo sistema de cola-slots se resume en:

Con K = 4, a = 0,4 y s = 0,5: ρ = 0,8, cola media ≈ 1,6 y pérdida ≈ 5 % (laboratorio).

03 · Anatomía

Throughput, latencia y buffer

Cuatro lecturas del mismo π:

Throughput

Servidos por slot: mín(a, s·(1−π₀)). Con ρ < 1 es a (todo lo que llega sale).

Latencia

Cola media E[X]: a más cola, más espera (Little en espíritu).

Pérdida

Con buffer lleno y arribo: π_K·a. Más K, menos pérdida pero más latencia.

Buffer K

Amortigua ráfagas pero no crea capacidad: con ρ > 1 solo retrasa la pérdida.

04 · Ejemplos

Sistemas que son colas con otro nombre

Todo «llegan y se atienden» cabe en (a, s, K):

1. 1
   API con workers.

   a = 0,8/slot, s = 1: ρ = 0,8 con latencia media.

2. 2
   Cola de impresión.

   K grande: casi no pierde, pero espera.

3. 3
   Reintentos.

   Lo perdido vuelve: carga efectiva mayor que a.

4. 4
   Cache.

   Hit = servicio instantáneo: s alta con K chico.

5. 5
   Videojuego.

   Tick 60 Hz: a y s por frame, K = backlog tolerado.

05 · Representación en Python

Cola (a, s, K) en diez líneas

En Python, el paso es arribo menos servicio con topes: A ~ Bernoulli(a), S ~ Bernoulli(s) si hay. Con eso se simula y se mide.

import random

def paso(x, a=0.4, s=0.5, K=4):
    A = 1 if random.random() < a else 0
    S = 1 if (x + A > 0 and random.random() < s) else 0
    return min(K, max(0, x + A - S))

random.seed(7)
x = 0
for _ in range(10):
    x = paso(x)
    print(x, end=" ")

Con a < s la cola vuelve a 0 seguido; con a > s se pega al 4.

Throughput y pérdida simulados

Contando servidos y perdidos en N slots:

import random

def simular(a=0.4, s=0.5, K=4, N=5000, semilla=3):
    random.seed(semilla)
    x, serv, perd = 0, 0, 0
    for _ in range(N):
        A = 1 if random.random() < a else 0
        if x == K and A:
            perd += 1
            A = 0  # no entra
        S = 1 if (x + A > 0 and random.random() < s) else 0
        x = min(K, max(0, x + A - S))
        serv += S
    return serv / N, perd / N

print([round(v, 3) for v in simular()])

06 · Exploración

Laboratorio: carga vs capacidad

Cola 0…4 con llegadas a y servicio s (6 réplicas de 40 slots). La línea gris es ρ = 1 (a = s). Pasala: la cola se pega arriba y la pérdida se dispara. Métricas: cola media, pérdida y ρ.

Cada línea es una cola; la blanca, el promedio. En saturación todas viven en 4: el buffer deja de amortiguar.

Preguntas para explorar

1. Con a = 0,4 y s = 0,8 (ρ = 0,5), ¿la cola toca el 4? ¿La pérdida?
2. Con a = 0,7 y s = 0,5 (ρ = 1,4), ¿dónde viven las líneas? ¿Throughput ≈ s?
3. ¿Subir K a 8 salvaría con ρ = 1,4? ¿Latencia o pérdida?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: leer ρ

Con a = 0,6 y s = 0,5, calculá ρ y anticipá el régimen.

a, s = 0.6, 0.5
print("rho:", a / s, "| régimen:", "saturada" if a > s else "estable")

Ejercicio 2: throughput en saturación

Sin ejecutar primero: con ρ > 1 y s = 0,5, ¿throughput cerca de qué? Comprobalo simulando.

import random

def thr(a=0.7, s=0.5, K=4, N=4000):
    random.seed(2)
    x, serv = 0, 0
    for _ in range(N):
        A = 1 if random.random() < a else 0
        if x == K and A:
            A = 0
        S = 1 if (x + A > 0 and random.random() < s) else 0
        x = min(K, max(0, x + A - S))
        serv += S
    return round(serv / N, 3)

print(thr())

Ejercicio 3: dimensionar workers

Si a = 0,8 y cada worker aporta s = 0,3, ¿cuántos workers para ρ ≤ 0,8?

import math
print(math.ceil(0.8 / (0.8 * 0.3)))

09 · Síntesis

Ideas para recordar

Cerramos aplicaciones. En el final integrarás todo: proyecto de simulación.