1. Por qué un simulador de CFS
CFS es más difícil de entender a mano que los algoritmos clásicos porque el vruntime se acumula continuamente y el reparto es proporcional. Un simulador permite ver cómo el vruntime crece a diferente velocidad según el nice, y cómo el reparto resultante es proporcional a los pesos.
Este simulador es el último del bloque 10 y cierra el estudio del planificador de Linux. A partir del bloque 11, se integran todos los algoritmos.
2. El modelo de CFS
El simulador simplifica CFS a sus elementos esenciales:
- Procesos: cada uno con un nice (prioridad) y una ráfaga.
- Pesos: tabla de pesos según el nice.
- vruntime: se acumula a velocidad inversamente proporcional al peso.
- Selección: el proceso con menor vruntime se ejecuta.
- Tiempo de ejecución: fijo (simplificación) o dinámico.
3. El algoritmo simplificado
El simulador ejecuta CFS de forma simplificada: en cada paso, elige el proceso con menor vruntime y lo ejecuta durante un quantum fijo. El vruntime se actualiza según el peso:
function cfs(procesos, quantum) {
var p = procesos.map(function (x) {
return { pid: x.pid, nice: x.nice, peso: peso(x.nice),
rafaga: x.rafaga, restante: x.rafaga,
vruntime: 0, inicio: 0, fin: 0, primera: true };
});
var t = 0;
var terminados = 0;
var n = p.length;
while (terminados < n) {
/* Elegir el de menor vruntime entre los listos. */
var elegido = null;
for (var i = 0; i < p.length; i++) {
if (p[i].restante > 0) {
if (elegido === null || p[i].vruntime < elegido.vruntime) {
elegido = p[i];
}
}
}
if (elegido === null) break;
if (elegido.primera) { elegido.inicio = t; elegido.primera = false; }
var duracion = Math.min(quantum, elegido.restante);
t += duracion;
elegido.restante -= duracion;
/* Actualizar vruntime: tiempo_real * (1024 / peso). */
elegido.vruntime += duracion * (1024 / elegido.peso);
if (elegido.restante <= 0) {
elegido.fin = t;
terminados++;
}
}
return p;
}4. Gantt del reparto
El Gantt muestra los turnos de cada proceso. Con nice distintos, los procesos con nice más bajo (mayor peso) reciben turnos más largos (o más frecuentes).
5. La tabla de vruntime
La tabla muestra, para cada proceso, su nice, peso, vruntime acumulado, tiempo de CPU y fracción recibida:
6. Los controles
- Procesos: número de procesos (2 a 6).
- Ráfaga: ráfaga de CPU de cada proceso.
- Nice de P1, P2, ...: nice de cada proceso (-20 a +19).
- Quantum: duración de cada turno.
- Semilla: semilla del generador (para generar ráfagas distintas).
7. Simulador interactivo
Este simulador reproduce el reparto de CFS. Ajusta los nice y observa cómo cambia el vruntime y el reparto:
Simulador · CFS
| Proceso | Nice | Peso | vruntime | Tiempo CPU | Fracción | Inicio | Fin |
|---|
8. Verificación y casos de prueba
| Caso | Entrada | Resultado esperado |
|---|---|---|
| Nice iguales | P1(0,10), P2(0,10), nice 0 y 0 | Reparto 50/50. vruntime iguales. |
| Nice distintos | P1(0,10), P2(0,10), nice 0 y 5 | P1 recibe más CPU. vruntime de P2 crece más rápido. |
| Un proceso | P1(0,5), nice 0 | Un bloque 0-5. vruntime = 5. |
| Quantum 1 | P1(0,5), P2(0,5), nice 0 y 0, q=1 | 10 bloques alternados. |
9. Resumen
- El simulador reproduce CFS con distintos valores de nice.
- El vruntime se acumula a velocidad inversamente proporcional al peso.
- El proceso con menor vruntime se ejecuta primero.
- El reparto es proporcional a los pesos.
- El simulador es la culminación del bloque 10 (planificador de Linux).
10. Preguntas de repaso
Intenta responder cada una antes de abrir la respuesta.
1. ¿Qué muestra el simulador?
El reparto de CPU de CFS con distintos valores de nice.
2. ¿Cómo se calcula el vruntime?
vruntime += tiempo_real × (1024 / peso).
3. ¿Qué proceso se ejecuta primero?
El que tiene menor vruntime.
4. ¿Cómo afecta el nice al vruntime?
Nice más bajo = mayor peso = acumulación más lenta = más CPU.
5. ¿Qué es el quantum en el simulador?
La duración de cada turno de CPU.
6. ¿Qué muestra la tabla?
Nice, peso, vruntime, tiempo de CPU, fracción, inicio y fin de cada proceso.
7. ¿Qué ocurre con nice iguales?
Reparto equitativo (50/50 para dos procesos).
8. ¿Qué bloque del curso cierra este simulador?
El bloque 10 (el planificador de Linux).
9. ¿Por qué el vruntime de un proceso con nice +5 crece más rápido?
Porque su peso es menor (335), así que el factor 1024/335 = 3,06 es mayor.
10. ¿Qué es la fracción de CPU?
El porcentaje de tiempo de CPU que recibe cada proceso.
Para practicar
- Ejecuta el simulador con nice 0 y 0, y verifica el reparto 50/50.
- Cambia el nice de P2 a +10 y observa cómo cambia el reparto.
- Modifica el simulador para añadir un cuarto proceso con nice distinto.
- Calcula el vruntime final de cada proceso.
- Compara el simulador con el comportamiento real de Linux (nice y top).
- Investiga cómo se implementa el árbol rojinegro en CFS.