Planificación de la CPU — práctica con problemas guiados paso a paso: FCFS frente a SJF, una expulsión en SRTF, la cola de Round Robin y un ejercicio con el formato del examen (y el cuanto que le regalé a quien no tocaba)

En el simulacro que hicimos en clase antes del parcial me tocó un Round Robin con cuanto 2. Dibujé el Gantt, saqué las medias y me quedé tan tranquilo. Al corregir, mi respuesta media era 3 y la buena, 1,75. El fallo estaba en un solo instante: en t = 2 un proceso agotó su cuanto justo cuando llegaba otro, y yo puse primero en la cola al que salía de la CPU. Con ese cambio, todo lo que venía después se descolocó. Desde entonces, cada vez que un cuanto acaba en el mismo instante en que llega alguien, me paro y escribo la cola entera antes de seguir.

Esta es la práctica guiada de planificación de la CPU. En la teoría de planificación de la CPU viste las métricas y los cuatro algoritmos que caen en el examen (FCFS, SJF, SRTF y Round Robin), siempre con los procesos de la noche antes de entregar. Aquí resolvemos cuatro problemas paso a paso, como se hacen en la parte escrita del examen: no basta con el Gantt, hay que saber por qué cada proceso entra cuando entra y sacar bien las cuentas. Para cada uno verás el método, el porqué de cada decisión, cómo comprobarlo y los errores que más se repiten. Después, en los ejercicios de planificación de la CPU, te toca a ti con cinco Gantt que se corrigen solos.

Antes de empezar

Conviene tener claro:

• Qué son la llegada, la ráfaga y el instante de fin de un proceso.
• Las tres fórmulas: retorno = fin − llegada, espera = retorno − ráfaga y respuesta = primer instante en CPU − llegada.
• Qué algoritmos expulsan (SRTF y Round Robin) y cuáles no (FCFS y SJF).
• Los criterios de desempate de la teoría: por orden de llegada y, si llegan a la vez, por el orden de la tabla; SRTF solo expulsa si el nuevo es estrictamente más corto; en Round Robin, el recién llegado entra en la cola antes que el que acaba de agotar su cuanto.

Si alguno te suena dudoso, repasa la teoría antes de seguir.

Cómo se resuelve un ejercicio de planificación

Los cuatro problemas siguen el mismo método de cuatro pasos. Te lo dejo aquí una vez para no repetirlo:

1. Apunta los datos (proceso, llegada y ráfaga) y el algoritmo, con su cuanto si es Round Robin. Escribe el criterio de desempate antes de empezar.
2. Decide en los instantes que importan: en los no expulsivos, cada vez que la CPU queda libre; en SRTF, además, en cada llegada; en Round Robin, cada vez que se agota un cuanto. Entre esos instantes no pasa nada.
3. Dibuja el Gantt y apunta los fines de cada proceso (el último tramo de cada uno).
4. Resta y comprueba: retorno, espera y respuesta con las fórmulas, medias y dos comprobaciones rápidas (que el último fin sea la suma de ráfagas si la CPU nunca para, y que cada espera sea el tiempo que el proceso está «fuera» del Gantt desde que llega).

Problema 1: FCFS frente a SJF

Enunciado. La mañana de la entrega tienes en el portátil cuatro procesos (tiempos en milisegundos). Dibuja el Gantt con FCFS y con SJF no expulsivo y calcula en los dos la espera media y el retorno medio. ¿Cuál es mejor?

Proceso	Qué es	Llegada	Ráfaga
zoom	la videollamada del grupo	0	7
git	el git push de la práctica	2	3
gcc	compilando la última versión	3	5
latex	la memoria en PDF	5	1

La idea

Los dos algoritmos son no expulsivos: el que entra en la CPU sale cuando termina. Así que solo hay que decidir cada vez que la CPU queda libre. FCFS elige al que llegó antes; SJF, al que tiene la ráfaga más corta entre los que ya han llegado. Esa coletilla es la clave: SJF no puede elegir a un proceso que todavía no ha llegado, aunque sea más corto.

Paso a paso

FCFS. El orden de llegada es zoom, git, gcc, latex, y cada uno empieza cuando acaba el anterior:

Instante	CPU libre, esperan…	Entra	Hasta
0	zoom	zoom	7
7	git, gcc, latex	git (llegó antes)	10
10	gcc, latex	gcc	15
15	latex	latex	16

SJF. En t = 0 solo está zoom, que entra y ya no sale hasta t = 7. En t = 7 esperan git (3), gcc (5) y latex (1): el más corto es latex, aunque haya llegado el último. Después git (3) y por último gcc (5).

Instante	CPU libre, esperan… (ráfaga)	Entra	Hasta
0	zoom (7)	zoom	7
7	git (3), gcc (5), latex (1)	latex	8
8	git (3), gcc (5)	git	11
11	gcc (5)	gcc	16

Ahora las cuentas, con retorno = fin − llegada y espera = retorno − ráfaga:

Proceso	Llegada	Ráfaga	Fin FCFS	Retorno	Espera	Fin SJF	Retorno	Espera
zoom	0	7	7	7	0	7	7	0
git	2	3	10	8	5	11	9	6
gcc	3	5	15	12	7	16	13	8
latex	5	1	16	11	10	8	3	2
Media				9,5	5,5		8	4

Medias: FCFS, retorno $(7 + 8 + 12 + 11) / 4 = 38 / 4 = 9{,}5$ ms y espera $(0 + 5 + 7 + 10) / 4 = 22 / 4 = 5{,}5$ ms. SJF, retorno $32 / 4 = 8$ ms y espera $16 / 4 = 4$ ms. SJF es mejor en las dos.

Comprobación

• La CPU nunca se queda parada (siempre hay alguien esperando), así que los dos Gantt tienen que acabar en $7 + 3 + 5 + 1 = 16$: así es.
• Cada espera es el tiempo que el proceso pasa sin CPU desde que llega. latex en FCFS llega en 5 y empieza en 15: 10 ms, como dice la tabla.
• En los no expulsivos, la espera coincide con la respuesta (cada proceso entra una sola vez).

Preguntas que te puedes hacer

¿Por qué SJF no elige latex en t = 0 si es el más corto? Porque en t = 0 latex no ha llegado. SJF solo compara a los que están en la cola de preparados en el momento de decidir.

¿Por qué SJF gana en espera media? Porque al poner primero al corto, sus pocos milisegundos se suman a la espera de pocos procesos y los largos esperan solo un poco más. Es el algoritmo óptimo en espera media cuando todos están disponibles a la vez, y por eso sirve de referencia.

¿Hay algún proceso que salga perdiendo con SJF? Sí: git espera 6 en lugar de 5 y gcc 8 en lugar de 7. La media mejora porque latex gana mucho (de 10 a 2). Si siguieran llegando procesos cortos, gcc podría esperar indefinidamente: es la inanición de SJF.

¿Y si dos procesos tuvieran la misma ráfaga en t = 7? Se aplica el criterio de desempate: el que llegó antes (y, si llegaron a la vez, el que va antes en la tabla). En el examen, escríbelo en una línea: así se ve que no ha sido casualidad.

Pruébalo tú

• Cambia la llegada de latex a t = 8. ¿Cambia algo en SJF? ¿Por qué?
• Calcula el retorno medio de FCFS si el orden de llegada fuera latex, git, gcc, zoom, todos en t = 0. ¿Cuánto mejora?

Problema 2: SRTF con una expulsión

Enunciado. Ahora hay una descarga grande en marcha y van llegando otros procesos. Dibuja el Gantt con SRTF (SJF expulsivo) y calcula el retorno, la espera y la respuesta de cada proceso y sus medias.

Proceso	Llegada	Ráfaga
descarga	0	6
gcc	1	3
antivirus	2	7
spotify	4	1

La idea

SRTF siempre ejecuta al proceso al que le queda menos. Por eso hay que decidir en dos tipos de instante: cada vez que llega alguien (puede expulsar al que corre si le queda menos que a él) y cada vez que termina alguien. Para no perderte, lleva una columna con lo que le queda a cada proceso en cada instante de decisión.

Paso a paso

Instante	Qué pasa	Le queda a…	Decisión
0	llega descarga	descarga 6	entra descarga
1	llega gcc	descarga 5, gcc 3	3 < 5: gcc expulsa a descarga
2	llega antivirus	gcc 2, descarga 5, antivirus 7	7 no es menor que 2: sigue gcc
4	acaba gcc; llega spotify	descarga 5, antivirus 7, spotify 1	entra spotify
5	acaba spotify	descarga 5, antivirus 7	entra descarga
10	acaba descarga	antivirus 7	entra antivirus
17	acaba antivirus	—	fin

Proceso	Llegada	Ráfaga	Primer instante en CPU	Fin	Retorno	Espera	Respuesta
descarga	0	6	0	10	10	4	0
gcc	1	3	1	4	3	0	0
antivirus	2	7	10	17	15	8	8
spotify	4	1	4	5	1	0	0
Media					7,25	3	2

Retorno medio $29 / 4 = 7{,}25$ ms, espera media $12 / 4 = 3$ ms y respuesta media $8 / 4 = 2$ ms.

Comprobación

• La suma de ráfagas es $6 + 3 + 7 + 1 = 17$ y el Gantt acaba en 17, sin huecos.
• descarga aparece en dos tramos (0-1 y 5-10): $1 + 5 = 6$ ms, su ráfaga entera. Su espera, 4, es justo el hueco entre los dos tramos (de 1 a 5).
• En un expulsivo, espera y respuesta pueden ser distintas: descarga tiene respuesta 0 (entró nada más llegar) pero espera 4.

Preguntas que te puedes hacer

¿Por qué en t = 2 antivirus no expulsa a gcc? Porque a gcc le quedan 2 ms y antivirus necesita 7. SRTF compara siempre con lo que le queda al que corre, no con su ráfaga inicial.

¿Y si en t = 4 a descarga le quedara 1, lo mismo que a spotify? Sería un empate entre dos procesos que esperan (la CPU acaba de quedar libre): con el criterio de la teoría desempata la llegada y entraría descarga, que llegó antes. La regla de «estrictamente más corto» es para otra cosa: decidir si alguien que llega expulsa al que ya está en la CPU. Si tu profesor usa otro criterio, escríbelo y aplícalo igual en todo el ejercicio.

¿Por qué antivirus espera tanto? Porque es el más largo y cada proceso corto que llega se le cuela. Es la misma inanición de SJF, pero más acusada, porque SRTF reacciona también a las llegadas.

¿Cuántos cambios de contexto hay? Cada cambio de proceso en el Gantt es uno: descarga → gcc → spotify → descarga → antivirus, cuatro. En la teoría se suponía que eran gratis; en un sistema real cada uno cuesta un poco de CPU, y por eso expulsar demasiado no sale gratis.

Pruébalo tú

• Repite el problema con SJF no expulsivo. ¿Cuánto empeora la espera media?
• Cambia la ráfaga de gcc a 5. ¿Expulsa ahora a descarga en t = 1? ¿Por qué?

Problema 3: la cola de Round Robin

Enunciado. Con Round Robin y cuanto q = 2, dibuja el Gantt de estos procesos, escribe la cola de preparados en cada cambio y calcula retorno, espera y respuesta medios.

Proceso	Llegada	Ráfaga
zoom	0	5
gcc	1	3
spotify	2	1
latex	3	4

La idea

Round Robin es FCFS con turnos: el primero de la cola usa la CPU como mucho un cuanto. Si termina antes, sale; si no, vuelve al final de la cola. Todo el problema es llevar bien la cola. Y el único momento delicado es cuando un cuanto se agota en el mismo instante en que llega otro proceso: según el criterio de la teoría, el recién llegado entra en la cola antes que el que sale de la CPU.

Paso a paso

Instante	En CPU (tramo)	Llegan	Cola después del tramo
0	zoom (0-2), le quedan 3	gcc (1), spotify (2)	gcc, spotify, zoom
2	gcc (2-4), le queda 1	latex (3)	spotify, zoom, latex, gcc
4	spotify (4-5), termina	—	zoom, latex, gcc
5	zoom (5-7), le queda 1	—	latex, gcc, zoom
7	latex (7-9), le quedan 2	—	gcc, zoom, latex
9	gcc (9-10), termina	—	zoom, latex
10	zoom (10-11), termina	—	latex
11	latex (11-13), termina	—	—

La fila de t = 0 es la de la anécdota del principio: zoom agota su cuanto en t = 2, que es justo cuando llega spotify. spotify entra en la cola antes que zoom.

Proceso	Llegada	Ráfaga	Primer instante en CPU	Fin	Retorno	Espera	Respuesta
zoom	0	5	0	11	11	6	0
gcc	1	3	2	10	9	6	1
spotify	2	1	4	5	3	2	2
latex	3	4	7	13	10	6	4
Media					8,25	5	1,75

Retorno medio $33 / 4 = 8{,}25$ ms, espera media $20 / 4 = 5$ ms y respuesta media $7 / 4 = 1{,}75$ ms.

Comprobación

• Suma de ráfagas $5 + 3 + 1 + 4 = 13$ y el Gantt acaba en 13.
• Ningún tramo dura más de q = 2, y los de 1 ms son siempre el final de un proceso (spotify, gcc y zoom).
• zoom tiene tres tramos (0-2, 5-7 y 10-11) que suman 5, su ráfaga. Su espera, 6, son los huecos: de 2 a 5 (3) y de 7 a 10 (3).

Preguntas que te puedes hacer

¿Por qué Round Robin gana en respuesta y no en espera? Porque reparte la CPU enseguida entre todos: nadie espera más de unos pocos cuantos para empezar (respuesta media 1,75). Pero, al trocear, los procesos largos acaban más tarde, y la espera total sube.

¿Qué pasa si el cuanto es muy grande? Si q es mayor que todas las ráfagas, nadie agota el cuanto y Round Robin se convierte en FCFS. Si es muy pequeño, hay tantos cambios de contexto que el sistema pasa más tiempo cambiando que trabajando.

¿Y si el cuanto se agota y la cola está vacía? El proceso vuelve a entrar en la CPU enseguida. En el Gantt se ven dos tramos seguidos del mismo proceso, que puedes dibujar como uno solo.

¿Por qué el orden de la cola cambia la respuesta y no siempre la espera? Porque la respuesta depende de cuándo empieza cada uno por primera vez, y eso lo decide el orden de la cola en los primeros instantes. En la anécdota del principio, con la cola mal ordenada, la espera media salía igual, 5, pero la respuesta media pasaba de 1,75 a 3.

Pruébalo tú

• Repite el problema con q = 3. ¿Cuántos tramos tiene ahora el Gantt?
• ¿Con qué cuanto saldría el mismo Gantt que con FCFS?

Problema 4: un ejercicio con el formato del examen

En la parte escrita del examen de IC2 suele caer un ejercicio rápido de procesos: unos procesos con su llegada y su ráfaga, uno o dos algoritmos (FCFS, SJF, SRTF o Round Robin) y los tiempos medios. Se valora el Gantt, la tabla con las cuentas y que el resultado sea coherente. Este ejercicio es original y está escrito con ese formato, para que practiques responder rápido y bien.

Ejercicio. Dados los procesos de la tabla (tiempos en ms), a) dibuja el diagrama de Gantt con SJF no expulsivo y con Round Robin con q = 3; b) calcula en los dos el tiempo medio de retorno, de espera y de respuesta; c) indica cuál es mejor en espera media y cuál en respuesta media.

Proceso	Llegada	Ráfaga
P1	0	6
P2	1	4
P3	2	2
P4	4	5
P5	6	1

Resultado	SJF	RR (q = 3)
Retorno medio	___	___
Espera media	___	___
Respuesta media	___	___

La idea

Dos algoritmos con los mismos datos: el truco es no mezclarlos. Haz uno entero (Gantt, tabla y medias) y después el otro. En SJF, la primera decisión con candidatos es en t = 6, cuando P1 termina y ya han llegado todos. En Round Robin, el instante delicado es t = 6: P2 agota su cuanto justo cuando llega P5.

Paso a paso

SJF. P1 entra en t = 0 y no sale hasta t = 6. En t = 6 esperan P2 (4), P3 (2), P4 (5) y P5 (1, acaba de llegar): por ráfaga, P5, P3, P2 y P4.

Round Robin, q = 3.

Instante	En CPU (tramo)	Llegan	Cola después del tramo
0	P1 (0-3), le quedan 3	P2 (1), P3 (2)	P2, P3, P1
3	P2 (3-6), le queda 1	P4 (4), P5 (6)	P3, P1, P4, P5, P2
6	P3 (6-8), termina	—	P1, P4, P5, P2
8	P1 (8-11), termina	—	P4, P5, P2
11	P4 (11-14), le quedan 2	—	P5, P2, P4
14	P5 (14-15), termina	—	P2, P4
15	P2 (15-16), termina	—	P4
16	P4 (16-18), termina	—	—

Proceso	Llegada	Ráfaga	SJF: fin	Retorno	Espera	Resp.	RR: fin	Retorno	Espera	Resp.
P1	0	6	6	6	0	0	11	11	5	0
P2	1	4	13	12	8	8	16	15	11	2
P3	2	2	9	7	5	5	8	6	4	4
P4	4	5	18	14	9	9	18	14	9	7
P5	6	1	7	1	0	0	15	9	8	8
Media				8	4,4	4,4		11	7,4	4,2

Resultado	SJF	RR (q = 3)
Retorno medio	40 / 5 = 8	55 / 5 = 11
Espera media	22 / 5 = 4,4	37 / 5 = 7,4
Respuesta media	22 / 5 = 4,4	21 / 5 = 4,2

c) SJF es mejor en espera media (4,4 frente a 7,4) y Round Robin, por poco, en respuesta media (4,2 frente a 4,4).

Comprobación y cómo se corrige

• Los dos Gantt acaban en $6 + 4 + 2 + 5 + 1 = 18$, y cada proceso suma su ráfaga entre todos sus tramos.
• En SJF, espera = respuesta en todos los procesos (es no expulsivo): si te saliera distinta, algo estaría mal.
• Una comprobación de la media: la suma de esperas es la suma de retornos menos la suma de ráfagas, $40 – 18 = 22$ en SJF y $55 – 18 = 37$ en RR. Si no cuadra, revisa los fines.

En la corrección pesan el Gantt (con los instantes escritos en el eje), la tabla con cada resta y las medias. Un error al principio del Gantt arrastra todas las cuentas, así que compensa repasar los dos primeros instantes de decisión antes de seguir. Y la respuesta del apartado c) tiene que salir de tus números, no de lo que «suele pasar»: aquí Round Robin gana en respuesta, pero por muy poco.

Pruébalo tú

• Resuelve el mismo ejercicio con SRTF. ¿Mejora la espera media de SJF?
• Con Round Robin, ¿con qué cuanto mínimo se obtiene el mismo Gantt que con FCFS?

Errores típicos en esta práctica

• Olvidar restar la llegada. Espera = fin − llegada − ráfaga; sin la llegada solo vale para los que llegan en t = 0.
• Elegir a un proceso que aún no ha llegado. SJF y SRTF solo comparan a los que están en la cola en ese instante.
• En SRTF, comparar con la ráfaga original. Se compara con lo que le queda al que corre.
• En Round Robin, desordenar la cola en los empates entre un cuanto agotado y una llegada.
• No escribir el criterio de desempate. Si el ejercicio no lo dice, escríbelo y aplícalo siempre igual.
• No comprobar. El último fin, la suma de esperas y los tramos de cada proceso detectan casi todos los errores.

Compruébalo con Python

Este planificador de papel resuelve los cuatro problemas con los mismos criterios de la teoría y escribe el Gantt y la tabla de cada uno. Ejecútalo después de hacer los problemas a mano, no antes.

# Planificador de la CPU de papel: FCFS, SJF, SRTF y Round Robin con los procesos de la práctica.
# Criterios (los de la teoría): empates por llegada y, si no, por orden de la tabla; SRTF solo expulsa
# si el nuevo es ESTRICTAMENTE más corto; en Round Robin el recién llegado entra en la cola antes
# que el proceso que acaba de agotar su cuanto.
def planifica(procs, alg, q=None):
    rest = {p: r for p, _, r in procs}; lleg = {p: l for p, l, _ in procs}
    orden = [p for p, _, _ in procs]; t, gantt, fin, cola, vistos = 0, [], {}, [], set()
    def llegan(hasta):   # mete en la cola, en orden, los que han llegado hasta ese instante
        for p in orden:
            if p not in vistos and lleg[p] <= hasta: cola.append(p); vistos.add(p)
    llegan(0)
    while len(fin) < len(procs):
        if not cola: t = min(lleg[p] for p in orden if p not in vistos); llegan(t); continue
        if alg in ("SJF", "SRTF"):
            p = min(cola, key=lambda x: (rest[x], lleg[x], orden.index(x)))
        else:
            p = cola[0]                      # FCFS y RR: el primero de la cola
        cola.remove(p)
        if alg == "RR": dur = min(q, rest[p])
        elif alg == "SRTF":                  # corre hasta acabar o hasta que llegue alguien más corto
            dur = rest[p]
            for o in orden:
                if o not in vistos and t < lleg[o] < t + dur and rest[o] < rest[p] - (lleg[o] - t):
                    dur = lleg[o] - t; break
        else: dur = rest[p]
        gantt.append((p, t, t + dur)); t += dur; rest[p] -= dur
        llegan(t)                            # primero los recién llegados...
        if rest[p]: cola.append(p)           # ...y después el que no ha terminado
        else: fin[p] = t
    return gantt, fin

def informe(nombre, procs, alg, q=None):
    g, fin = planifica(procs, alg, q)
    junta = []                               # une tramos seguidos del mismo proceso
    for p, a, b in g:
        if junta and junta[-1][0] == p and junta[-1][2] == a: junta[-1] = (p, junta[-1][1], b)
        else: junta.append((p, a, b))
    print(f"== {nombre}: {alg}" + (f" q={q}" if q else ""))
    print("   Gantt:", " | ".join(f"{p} {a}-{b}" for p, a, b in junta))
    tot = {"ret": 0, "esp": 0, "resp": 0}
    for p, l, r in procs:
        ret = fin[p] - l; esp = ret - r; resp = min(a for x, a, _ in g if x == p) - l
        tot["ret"] += ret; tot["esp"] += esp; tot["resp"] += resp
        print(f"   {p:<9} llega {l:>2}  ráfaga {r:>2}  fin {fin[p]:>2}  retorno {ret:>2}  espera {esp:>2}  respuesta {resp:>2}")
    n = len(procs)
    print(f"   medias: retorno {tot['ret']}/{n} = {tot['ret']/n:.2f}  espera {tot['esp']}/{n} = {tot['esp']/n:.2f}  respuesta {tot['resp']}/{n} = {tot['resp']/n:.2f}")

A = [("zoom", 0, 7), ("git", 2, 3), ("gcc", 3, 5), ("latex", 5, 1)]
B = [("descarga", 0, 6), ("gcc", 1, 3), ("antivirus", 2, 7), ("spotify", 4, 1)]
C = [("zoom", 0, 5), ("gcc", 1, 3), ("spotify", 2, 1), ("latex", 3, 4)]
D = [("P1", 0, 6), ("P2", 1, 4), ("P3", 2, 2), ("P4", 4, 5), ("P5", 6, 1)]
informe("Problema 1", A, "FCFS"); informe("Problema 1", A, "SJF")
informe("Problema 2", B, "SRTF")
informe("Problema 3", C, "RR", 2)
informe("Problema 4", D, "SJF"); informe("Problema 4", D, "RR", 3)

Salida (ejecutado una vez):

== Problema 1: FCFS
   Gantt: zoom 0-7 | git 7-10 | gcc 10-15 | latex 15-16
   zoom      llega  0  ráfaga  7  fin  7  retorno  7  espera  0  respuesta  0
   git       llega  2  ráfaga  3  fin 10  retorno  8  espera  5  respuesta  5
   gcc       llega  3  ráfaga  5  fin 15  retorno 12  espera  7  respuesta  7
   latex     llega  5  ráfaga  1  fin 16  retorno 11  espera 10  respuesta 10
   medias: retorno 38/4 = 9.50  espera 22/4 = 5.50  respuesta 22/4 = 5.50
== Problema 1: SJF
   Gantt: zoom 0-7 | latex 7-8 | git 8-11 | gcc 11-16
   zoom      llega  0  ráfaga  7  fin  7  retorno  7  espera  0  respuesta  0
   git       llega  2  ráfaga  3  fin 11  retorno  9  espera  6  respuesta  6
   gcc       llega  3  ráfaga  5  fin 16  retorno 13  espera  8  respuesta  8
   latex     llega  5  ráfaga  1  fin  8  retorno  3  espera  2  respuesta  2
   medias: retorno 32/4 = 8.00  espera 16/4 = 4.00  respuesta 16/4 = 4.00
== Problema 2: SRTF
   Gantt: descarga 0-1 | gcc 1-4 | spotify 4-5 | descarga 5-10 | antivirus 10-17
   descarga  llega  0  ráfaga  6  fin 10  retorno 10  espera  4  respuesta  0
   gcc       llega  1  ráfaga  3  fin  4  retorno  3  espera  0  respuesta  0
   antivirus llega  2  ráfaga  7  fin 17  retorno 15  espera  8  respuesta  8
   spotify   llega  4  ráfaga  1  fin  5  retorno  1  espera  0  respuesta  0
   medias: retorno 29/4 = 7.25  espera 12/4 = 3.00  respuesta 8/4 = 2.00
== Problema 3: RR q=2
   Gantt: zoom 0-2 | gcc 2-4 | spotify 4-5 | zoom 5-7 | latex 7-9 | gcc 9-10 | zoom 10-11 | latex 11-13
   zoom      llega  0  ráfaga  5  fin 11  retorno 11  espera  6  respuesta  0
   gcc       llega  1  ráfaga  3  fin 10  retorno  9  espera  6  respuesta  1
   spotify   llega  2  ráfaga  1  fin  5  retorno  3  espera  2  respuesta  2
   latex     llega  3  ráfaga  4  fin 13  retorno 10  espera  6  respuesta  4
   medias: retorno 33/4 = 8.25  espera 20/4 = 5.00  respuesta 7/4 = 1.75
== Problema 4: SJF
   Gantt: P1 0-6 | P5 6-7 | P3 7-9 | P2 9-13 | P4 13-18
   P1        llega  0  ráfaga  6  fin  6  retorno  6  espera  0  respuesta  0
   P2        llega  1  ráfaga  4  fin 13  retorno 12  espera  8  respuesta  8
   P3        llega  2  ráfaga  2  fin  9  retorno  7  espera  5  respuesta  5
   P4        llega  4  ráfaga  5  fin 18  retorno 14  espera  9  respuesta  9
   P5        llega  6  ráfaga  1  fin  7  retorno  1  espera  0  respuesta  0
   medias: retorno 40/5 = 8.00  espera 22/5 = 4.40  respuesta 22/5 = 4.40
== Problema 4: RR q=3
   Gantt: P1 0-3 | P2 3-6 | P3 6-8 | P1 8-11 | P4 11-14 | P5 14-15 | P2 15-16 | P4 16-18
   P1        llega  0  ráfaga  6  fin 11  retorno 11  espera  5  respuesta  0
   P2        llega  1  ráfaga  4  fin 16  retorno 15  espera 11  respuesta  2
   P3        llega  2  ráfaga  2  fin  8  retorno  6  espera  4  respuesta  4
   P4        llega  4  ráfaga  5  fin 18  retorno 14  espera  9  respuesta  7
   P5        llega  6  ráfaga  1  fin 15  retorno  9  espera  8  respuesta  8
   medias: retorno 55/5 = 11.00  espera 37/5 = 7.40  respuesta 21/5 = 4.20

Cosas que observar:

1. En el Problema 2, el Gantt tiene dos tramos de descarga (0-1 y 5-10): la expulsión de t = 1 sale sola de la condición rest[o] < rest[p] - (lleg[o] - t), que compara con lo que le queda en el instante de la llegada.
2. En el Problema 3, el orden de las dos líneas llegan(t) y cola.append(p) es el criterio de la teoría: primero los recién llegados. Si las cambias de orden, la respuesta media pasa de 1,75 a 3, como en la anécdota.
3. En SJF y SRTF, min(cola, key=…) desempata por llegada y orden de la tabla; con otros criterios, solo habría que cambiar esa clave.
4. informe() junta los tramos seguidos del mismo proceso para dibujar el Gantt como en el papel, pero la respuesta la calcula con el primer tramo de cada uno.

Si quieres verlo animado, paso a paso y con tus propios datos, tienes el simulador de planificación de CPU del Laboratorio: usa los mismos criterios de desempate.

Resumen

• Decide solo en los instantes que importan: CPU libre (todos), llegadas (SRTF) y cuantos agotados (Round Robin).
• SJF y SRTF eligen entre los que ya han llegado; SRTF compara con lo que le queda al que corre.
• En Round Robin, lleva la cola escrita; el recién llegado va antes que el que agota su cuanto.
• Retorno = fin − llegada; espera = retorno − ráfaga; respuesta = primer instante en CPU − llegada.
• SJF y SRTF suelen ganar en espera media; Round Robin, en respuesta. Pero la conclusión sale de tus números.
• Comprueba siempre: el último fin, los tramos de cada proceso y que la suma de esperas sea la de retornos menos la de ráfagas.

Checklist: ¿lo has practicado?

• ¿Has hecho los cuatro problemas en papel antes de leer el paso a paso?
• ¿Sabes en qué instantes se decide con cada algoritmo?
• ¿Puedes escribir la cola de Round Robin en cada cambio sin equivocarte en los empates?
• ¿Sabes calcular la respuesta y por qué en los no expulsivos coincide con la espera?
• ¿Has comprobado los cuatro problemas con el programa de Python o con el simulador?
• ¿Has intentado los «Pruébalo tú» sin mirar la teoría?

Si has respondido que sí a casi todo, estás listo para los ejercicios de planificación de la CPU, con un test de todo el tema y cinco Gantt con casillas que se corrigen solas. ¡Nos vemos allí!

Siguiente paso: ejerciciosPlanificación de la CPU — ejercicios tipo examen con test, cinco diagramas de Gantt que se corrigen solos y preguntas de desarrollo (y la llegada que ya no se me olvida restar)

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →