1. Por qué un simulador de Round Robin
Round Robin tiene un parámetro (el quantum) que afecta drásticamente al comportamiento del algoritmo. Un simulador con un control deslizante permite ver el efecto del quantum en tiempo real: al mover el deslizador, el Gantt y las métricas se actualizan al instante, mostrando cómo cambia el número de bloques, el tiempo de respuesta y el overhead.
Este simulador es la culminación del bloque 6: reúne Round Robin (tema 20), la elección del quantum (tema 21) y el costo del cambio de contexto (tema 22) en una sola herramienta interactiva.
Mover el deslizador del quantum de 1 a 20 muestra cómo los bloques del Gantt se fusionan (quantum grande) o se fragmentan (quantum pequeño), y cómo cambian las métricas. Es la forma más intuitiva de entender el trade-off del quantum.
2. Arquitectura
El simulador tiene las mismas cinco partes que los anteriores:
| Parte | Responsabilidad | Funciones |
|---|---|---|
| Modelo | Representar un proceso. | crearProceso, copiar |
| Generador | Producir cargas reproducibles. | crearGenerador, generarCarga |
| Algoritmo | Ejecutar Round Robin con quantum. | roundRobin |
| Vista | Dibujar Gantt multi-bloque y tabla. | reconstruirTrace, dibujarGantt, renderTabla |
| Controlador | Leer controles (incluyendo el slider), ejecutar, actualizar. | dibujar, listeners |
3. La función roundRobin
La función ejecuta Round Robin con un quantum dado y devuelve el arreglo de procesos con las métricas rellenas. Incluye el manejo de llegadas distintas y CPU ociosa:
function roundRobin(procesos, quantum) {
var p = procesos.map(function (x) {
return { pid: x.pid, llegada: x.llegada, rafaga: x.rafaga,
restante: x.rafaga, inicio: 0, fin: 0, respuesta: 0,
espera: 0, retorno: 0, primera: true };
});
p.sort(function (a, b) {
if (a.llegada !== b.llegada) return a.llegada - b.llegada;
return a.pid - b.pid;
});
var cola = [];
var t = 0;
var idx = 0;
var terminados = 0;
var n = p.length;
while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
while (terminados < n) {
if (cola.length === 0) {
t = p[idx].llegada;
while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
continue;
}
var proc = cola.shift();
if (proc.primera) { proc.inicio = t; proc.primera = false; }
var duracion = Math.min(quantum, proc.restante);
t += duracion;
proc.restante -= duracion;
while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
if (proc.restante <= 0) {
proc.fin = t;
proc.respuesta = proc.inicio - proc.llegada;
proc.retorno = proc.fin - proc.llegada;
proc.espera = proc.retorno - proc.rafaga;
terminados++;
} else {
cola.push(proc);
}
}
return p;
}4. Gantt multi-bloque
Round Robin interrumpe procesos, así que un proceso puede tener varios bloques en el Gantt. Hay que reconstruir el trace de ejecución:
function reconstruirTrace(procesos, quantum) {
var p = procesos.map(function (x) {
return { pid: x.pid, llegada: x.llegada, rafaga: x.rafaga, restante: x.rafaga };
});
p.sort(function (a, b) {
if (a.llegada !== b.llegada) return a.llegada - b.llegada;
return a.pid - b.pid;
});
var cola = [];
var t = 0;
var idx = 0;
var terminados = 0;
var n = p.length;
var bloques = [];
while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
while (terminados < n) {
if (cola.length === 0) {
t = p[idx].llegada;
while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
continue;
}
var proc = cola.shift();
var duracion = Math.min(quantum, proc.restante);
bloques.push({ pid: proc.pid, inicio: t, fin: t + duracion });
t += duracion;
proc.restante -= duracion;
while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
if (proc.restante <= 0) {
terminados++;
} else {
cola.push(proc);
}
}
return { bloques: bloques, total: t };
}Los bloques se dibujan como spans con flex proporcional a la duración. Los huecos de CPU ociosa se insertan como spans «ociosa».
5. La tabla de métricas
La tabla muestra los resultados ordenados por pid, con las tres métricas:
function renderTabla(procesos, filasEl, promEl) {
var ordenado = procesos.slice().sort(function (a, b) { return a.pid - b.pid; });
filasEl.innerHTML = '';
var sr = 0, se = 0, st = 0;
ordenado.forEach(function (p) {
var tr = document.createElement('tr');
[ 'P' + p.pid, p.llegada, p.rafaga, p.inicio, p.fin,
p.respuesta, p.espera, p.retorno ].forEach(function (v) {
var td = document.createElement('td');
td.textContent = v;
tr.appendChild(td);
});
filasEl.appendChild(tr);
sr += p.respuesta; se += p.espera; st += p.retorno;
});
var n = ordenado.length;
if (n === 0) { promEl.textContent = ''; return; }
promEl.textContent = 'Promedio: respuesta=' + (sr/n).toFixed(2) +
' espera=' + (se/n).toFixed(2) + ' retorno=' + (st/n).toFixed(2);
}6. El control deslizante del quantum
El control deslizante (slider) es un <input type="range"> que permite ajustar el quantum de forma continua. Al moverlo, el evento input se dispara y el simulador recalcula:
<input type="range" id="quantum" min="1" max="20" value="3" />
<span id="quantum-valor">3</span>
<script>
var slider = document.getElementById('quantum');
var valor = document.getElementById('quantum-valor');
slider.addEventListener('input', function () {
valor.textContent = slider.value;
dibujar();
});
</script>El slider es más intuitivo que un campo de texto: el usuario ve el efecto del quantum en tiempo real mientras lo ajusta. Los valores extremos (1 y 20) muestran los dos límites: quantum mínimo (muchos bloques, alta respuesta, alto overhead) y quantum máximo (pocos bloques, baja respuesta, bajo overhead).
Mover el slider de 1 a 20 muestra cómo los bloques del Gantt se fusionan y cómo cambian las métricas. Es la forma más directa de entender el compromiso entre respuesta y overhead.
7. Incluir el costo de contexto
El simulador puede incluir el costo del cambio de contexto, añadiendo un tiempo c en cada transición. Esto se hace en la función roundRobin añadiendo c al tiempo total cuando se cambia de proceso:
function roundRobinConCosto(procesos, quantum, costoCambio) {
/* ... misma estructura que roundRobin, pero: */
if (t > 0) t += costoCambio; /* costo de cambio */
var duracion = Math.min(quantum, proc.restante);
t += duracion;
/* ... */
}El costo se añade al tiempo total, lo que aumenta las métricas de todos los procesos. El impacto es mayor cuanto más corto sea el quantum.
8. Los demás controles
Además del slider del quantum, el simulador tiene los controles habituales:
- Procesos: número de procesos (2 a 8).
- Llegada máxima: llegada máxima posible.
- Ráfaga máxima: ráfaga máxima posible.
- Semilla: semilla del generador pseudoaleatorio.
- Costo de cambio: costo del cambio de contexto (0 a 5).
9. Simulador interactivo
Este simulador ejecuta Round Robin con un quantum ajustable mediante un slider. Cambia el quantum y observa cómo cambian el Gantt y las métricas en tiempo real:
Simulador · Round Robin (quantum con slider)
| Proceso | Llegada | Ráfaga | Inicio | Fin | Respuesta | Espera | Retorno |
|---|---|---|---|---|---|---|---|
10. Verificación y casos de prueba
| Caso | Entrada | Resultado esperado |
|---|---|---|
| Quantum ≥ ráfaga | P1(0,3), P2(0,5), q=5 | Un bloque por proceso (equivale a FCFS). |
| Quantum = 1 | P1(0,3), P2(0,3), q=1 | 6 bloques alternados: P1, P2, P1, P2, P1, P2. |
| Un proceso | P1(0,5), q=3 | Un bloque 0-5. |
| Hueco de CPU | P1(0,3), P2(5,2), q=2 | P1 0-3 (2 bloques), ociosa 3-5, P2 5-7. |
| Con costo | P1(0,4), P2(0,4), q=2, costo=1 | Los bloques se separan por el costo de cambio. |
11. Extensiones posibles
- Gráfico de métricas vs quantum: un gráfico que muestra cómo cambian las métricas al variar el quantum.
- Comparación con FCFS y SJF: mostrar los tres Gantt uno encima del otro para la misma carga.
- Modo paso a paso: avanzar un quantum a la vez.
- Animación: reproducir el Gantt bloque por bloque.
12. Resumen
- El simulador de Round Robin usa un slider para ajustar el quantum en tiempo real.
- El Gantt se reconstruye cada vez que cambia el quantum.
- La tabla de métricas se actualiza al instante.
- El costo de cambio de contexto se puede incluir como parámetro.
- Los casos de prueba verifican el simulador contra resultados conocidos.
- El slider hace visible el trade-off entre respuesta y overhead.
13. Preguntas de repaso
Intenta responder cada una antes de abrir la respuesta.
1. ¿Por qué un slider es mejor que un campo de texto para el quantum?
Porque permite ver el efecto del quantum en tiempo real mientras se ajusta.
2. ¿Qué ocurre cuando el quantum es mayor que todas las ráfagas?
Cada proceso se ejecuta de una vez. Round Robin se comporta como FCFS.
3. ¿Cómo se reconstruye el Gantt en Round Robin?
Re-ejecutando el algoritmo y guardando cada bloque (pid, inicio, fin).
4. ¿Qué efecto tiene el costo de cambio de contexto en el Gantt?
Los bloques se separan por un intervalo (el costo de cambio).
5. ¿Por qué el tiempo de respuesta mejora con un quantum corto?
Porque los procesos reciben la CPU más frecuentemente.
6. ¿Por qué la espera empeora con un quantum corto?
Porque los procesos se intercalan más, aumentando el tiempo total en la cola.
7. ¿Qué evento se usa para actualizar el simulador?
El evento input del slider y de los demás controles.
8. ¿Cómo se desempatan procesos con la misma llegada?
Por pid.
9. ¿Qué se muestra en la nota bajo el simulador?
Las métricas promedio y el overhead estimado.
10. ¿Qué extensión mostraría las métricas para varios quantums a la vez?
Un gráfico de métricas vs quantum.
Para practicar
- Implementa el simulador completo y verifica los cinco casos de prueba.
- Añade un gráfico que muestre las métricas para quantum = 1 a 20.
- Compara Round Robin con FCFS y SJF para la misma carga.
- Implementa el modo paso a paso (un quantum a la vez).
- Añade la animación del Gantt bloque por bloque.
- Modifica el simulador para incluir llegadas distintas y observa el efecto.