Reloj de simulación

01 · Punto de partida

Dos relojes en tu mesa

Mientras simulás 12 minutos de banco, en tu mesa corren dos tiempos: el de tu PC (medio segundo de CPU) y el del banco (12 minutos virtuales). El segundo es el reloj de simulación: una variable t que empieza en 0 y termina en 12, visitando solo los instantes con eventos, por ejemplo 0 → 2 → 4 → 5 → 8.

Si ese reloj avanzara de a 1 minuto parejo, sería pasos fijos. Como salta al próximo evento —2.0, 3.7, 4.2, da igual— es simulación por eventos. Todo el curso depende de esa variable.

• ¿Cuánto vale ahora y cuánto valdrá después del próximo evento?
• ¿Puede quedarse quieto o retroceder?
• ¿Cuándo termina la simulación: por tiempo o por conteo?
• ¿Qué pasa con los decimales (2.37) y los empates (dos a las 5)?

02 · Definición

Una variable con tres reglas de oro

El reloj forma parte del snapshot para reanudar (Tema 4): (t, estado, FEL). Sin t, los tiempos del FEL quedan huérfanos.

03 · Propiedades

Horizonte, saltos y empates

1. 1
   Horizonte T.

   Condición de parada por tiempo: “simular hasta t=100”. Los eventos más allá de T se ignoran (o se truncan). Alternativa: parar por conteo (“1000 clientes”, Tema 19).

2. 2
   Saltos variables.

   De 2 a 4 hay salto 2; de 4 a 5, salto 1. El salto medio y el máximo describen cuán ralos son los eventos: a saltos grandes, más ahorro vs. pasos fijos.

3. 3
   Empates (salto cero).

   Dos eventos a las 5.0: el reloj se queda en 5.0 y procesa ambos con regla explícita. Salto cero es legal; salto negativo es bug.

Monotonía

t′ ≥ t siempre. Un assert reloj_nuevo >= reloj en la rutina principal caza FEL desordenados.

Resolución

Los tiempos son floats (2.37): el reloj por eventos es exacto, no redondea a la grilla. Redondear a enteros es pasos fijos.

Reloj + FEL

El reloj dice “dónde estoy”; el FEL dice “qué viene”. Avanzar es copiar el tiempo del evento extraído, nunca t+dt.

Ocio del reloj

Saltos grandes = sistema quieto mucho tiempo (noche sin llegadas). El simulador los cruza gratis; pasos fijos los pagaría uno por uno.

04 · Ejemplos

El mismo reloj en cuatro mundos

05 · Representación en Python

Una variable y un assert guardián

El reloj es un float que solo se asigna desde el FEL, con un assert de monotonía que delata cualquier desorden.

import heapq
fel = [(2.0, "llegada"), (4.0, "llegada"), (5.0, "salida")]
heapq.heapify(fel)
reloj, visitas = 0.0, [0.0]
while fel:
    t, _ = heapq.heappop(fel)
    assert t >= reloj, "el reloj retrocedió: FEL desordenado"
    reloj = t  # ¡el salto!
    visitas.append(reloj)
print("visitas:", visitas)  # [0.0, 2.0, 4.0, 5.0]
print("saltos:", [round(b - a, 1) for a, b in zip(visitas[:-1], visitas[1:])])

# Horizonte T: lo que pase después se ignora
T = 4.5
visitas = [0.0, 2.0, 4.0, 5.0]
dentro = [t for t in visitas if t <= T]
print("dentro del horizonte:", dentro, "| truncado:", [t for t in visitas if t > T])

06 · Exploración

Laboratorio: los saltos del reloj

Llega uno cada A, atención S, 1 caja, horizonte 12. La recta numérica muestra en verde los instantes que el reloj visita (eventos ≤12) y en gris los que saltea; los arcos son los saltos. Subí A y mirá cómo los saltos se agrandan y el ahorro se dispara.

Puntos verdes: el reloj los visita. Grises: los saltea. Arcos: tamaño del salto. Más verde junto = reloj casi parejo; verde ralo = grandes saltos gratis.

Preguntas para explorar

1. Con A=2, S=3, ¿qué instantes visita el reloj? ¿Cuál es el salto máximo?
2. Con A=4, S=4, ¿cuántas visitas hay? ¿Qué ahorro lográs?
3. Con A=1, S=1, ¿el reloj se parece a pasos fijos? ¿Cuándo conviene cada uno?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: registrar visitas y saltos

Con FEL en 2, 4 y 5 desde 0, listá visitas y saltos.

visitas = [0.0, 2.0, 4.0, 5.0]
saltos = [b - a for a, b in zip(visitas[:-1], visitas[1:])]
print("visitas:", visitas, "| saltos:", saltos, "| medio:", sum(saltos) / len(saltos))

Ejercicio 2: cazar un retroceso

¿Qué hace este código con un FEL desordenado?

reloj = 5.0
t_nuevo = 4.0  # llegó desordenado
assert t_nuevo >= reloj, "retroceso"
print("avanza a", t_nuevo)

Ejercicio 3: horizonte que trunca

Con T=4.5 y visitas hasta 8, ¿qué se procesa y qué se ignora?

T, visitas = 4.5, [0.0, 2.0, 4.0, 5.0, 8.0]
print("proceso:", [t for t in visitas if t <= T])
print("ignoro:", [t for t in visitas if t > T])

09 · Síntesis

Ideas para recordar

En el próximo tema compararemos el avance del tiempo: incremento fijo frente a salto al próximo evento.