Algoritmos de Planificación:

Los algoritmos de planificación de procesos es la forma que usa el sistema operativo a través del
gestor de procesos para determinar que proceso le entrego al CPU de un conjunto de procesos
que me están solicitando entrar al CPU. Esta decisión va a variar de un sistema operativo a otro,
pero esas decisiones se toman como base usando los algoritmos de planificación, los cuales se
mencionan a continuación:

1. FIFO (First IN – First Out)

2. Primer Trabajo más Corto / Shortest Job First (SJF)
3. Tiempo Restante mas Corto / Shortest Remaining Time (SRT)
4. Prioridades
5. Round Robin

FIFO (First IN – First Out) : Este algoritmo es como la cola de un banco, supermercado entre
otros. Donde el primero en ser atendido es el primero en entrar. Son atendidos en el mismo orden
que llegan.

L A B C D
U 0 1 2 3 4 5 6 7 8 9 10
E A A A B B B B B C C

L E
U 11 12 13 14 15 16 17 18 19 20
E D D D D D E E E E E

L  Tiempo de Llegada
U  Unidad de Tiempo
E  Tiempo en que se ejecutan

Proceso Tiempo de t Tiempo T W P

Llegada Finalización
A 0 3 3 3 0 1
B 1 5 8 7 2 1,4
C 3 2 10 7 5 3,5
D 9 5 15 6 1 1,2
E 12 5 20 8 3 1,6
PROMEDIO 6,2 2,2 1,74

T = Tiempo Finalización – Tiempo de llegada

W= T–t

P=T/t
Dependiendo del algoritmo lo que se piensa hacer es una corrida en frio, en la cual vamos a
determinar el orden en que esos procesos van a pasar a ejecución emulando lo que hace el
sistema operativo en la vida Real.

Explicación Solución: Si prestamos atención en el instante “0”, me llega un proceso “A”,

supongamos que soy un cajero y atiendo esa persona que acaba de llegar (FIFO). El algoritmo
FIFO es no apropiativo, esto significa que una vez que entrego el CPU a un proceso, no se lo voy
a quitar hasta que este termine o me lo entregue voluntariamente. “B” llego aun cuando el proceso
“A” estaba siendo ejecutado, por lo tanto, ahora tengo a “A” en ejecución y a “B” en la cola.
Seguidamente “A” muere y “C” entra en la cola. Ahora tengo dos procesos en la cola “B” y “C”,
debo elegir cual proceso ejecutar, pero como es FIFO ejecutare el primero que entro a la cola que
en nuestro caso es “B”. Mientras me encuentro procesando a “B” tengo a “C” en la cola, luego “B”
muere y “C”, se pasa a ejecutar, mientras estoy ejecutando “C”, llega “D”, pero al ser un algoritmo
no apropiativo “D” se mantiene en la cola hasta que “C” muera. Seguidamente “C” muere y “D”
pasa a ejecución, le entrego las unidades de tiempo que debe ejecutarse a “D” aun y cuando “E”
entra en la cola, el proceso “E” debe esperar a que proceso “D” termine, luego “D” muere y termino
de asignarle las unidades de tiempo a “E” hasta que este muere.

Como se puede observar en este algoritmo todos los procesos fueron atendidos en el momento en
que llegaron, no es el más eficiente, pero si es equitativo. Si analizamos “A” tiene a su izquierda el
tiempo de arranque (0), pero lo que me interesa son los tiempos de finalización que sería el
número que está a la derecha de la ultima A (3), B (5), C (10), D (15), E (20).

Nota: El tiempo perfecto de “P” es de 1,0 y su promedio nos indica que tarda 1,75 en ejecutarse
por lo tanto debemos compararlo con otro algoritmo para determinar si los tiempos de ejecución
son los mejores.

FIFO casi siempre da peores resultados, la pregunta es ¿porque se utiliza? Bueno precisamente porque hay
escenarios donde si resulta conveniente usar FIFO, pero casi nunca arroja buenos resultados ya que FIFO
busca ser equitativo, no busca ser optimo, no busca optimizar el numero de procesos que entran al CPU, ni
reducir los tiempos de respuesta, solo busca ser equitativo, tal como lo es en la vida real, cuando busco
equidad estoy buscando ser justo.

Primer Trabajo más Corto / Shortest Job First (SJF)

En este algoritmo el sistema da prioridad a los procesos mas pequeños, quiere decir que si en la
configuración tengo 5 procesos que llegan yo daré mas importancia a los procesos pequeños y
dejar los grandes de ultimo (no busca ser equitativo sino mejorar los tiempos de respuesta.)

L A B C D
U 0 1 2 3 4 5 6 7 8 9 10
E A A A C C B B B B B

L E
U 11 12 13 14 15 16 17 18 19 20
E D D D D D E E E E E

Proceso Tiempo de t Tiempo T W P

Llegada
A 0
B 1
C 3
D 9
E 12
PROMEDIO
Finalización
3 3 3 0 1.0
5 10 9 4 1,8
2 5 2 0 1,0
5 15 6 1 1,2
5 20 8 3 1,6
5,6 1,6 1,32
Tiempo Restante mas Corto / Shortest Remaining Time (SRT):

Este algoritmo es una variación del anterior (SJF) con la diferencia de que si es apropiativo, lo que significa que yo entrego
a ese proceso al CPU pero no espero a que ese proceso termine, sino que en un momento dado si llega otro proceso cuyo
tiempo restante es mas corto, sea menor que el ya esta procesando, dejo de procesar el que tengo y empiezo a procesar el
que acaba de llegar.

Por Ejemplo:
Bomba 1: 00:45  Dejo el proceso
Bomba 2: 00:15  Me cambio antes de que explote la bomba 😊

L A B C D E
U 0 1 2 3 4 5 6 7 8 9 10
E A A B C C B B B B D

L
U 11 12 13 14 15 16 17 18 19 20
E E E D D D

Proceso Tiempo de t Tiempo T W P

Llegada
A 0
B 1
C 3
D 9
E 10
PROM
Finalización
2 2 2 0 1,0
5 9 8 3 1,6
2 4 2 0 1,0
4 15 6 2 1,5
2 12 2 0 1,0
4 1,2 1,22

Nota: Nos arroja datos menores, sin embargo, no podemos compararlo con los anteriores dos porque usamos datos
distintos, sin embargo, si fueran los mismos datos y diera menos que los anteriores 2, seria el mejor algoritmo.

4- Prioridades: En los sistemas operativos no todos los procesos tienen el mismo nivel de prioridad o importancia, y yo
debo de atender primero el más urgente. El algoritmo de prioridades básicamente es un numero asignado a un proceso, a
menor valor de número, mayor es su prioridad. Si tengo dos procesos A y B, donde A tiene como prioridad 6 y B – 3,
entonces el proceso que atenderé primero será B.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

Ejemplo Prioridad

L A B C D
U 0 1 2 3 4 5 6 7 8 9 10
E A B B C C B B B A A

L E
U 11 12 13 14 15 16 17 18 19 20
E D D D D D E E E E E

Proceso Tiempo de t Prioridad Tiempo T W P

Llegada
A 0
B 1
C 3
D 9
E 12
PROMEDIO
Finalización
3 4 10 10 7 2,3
5 2 8 7 2 1,4
2 0 5 2 0 1
5 4 15 6 1 1,2
5 4 20 8 3 1,6
6,6 2,6 1,5
Ahora aparece una columna llamada “Prioridad”, la cual me indica la prioridad de cada proceso. Procedemos a hacer una
corrida en frio. Primero empezamos con el proceso “A”, ya que es el único que esta en espera en este momento al cual le
asigno 1 unidad, luego “B” aparece en escena y es cuando debo preguntarme quien tiene mayor prioridad entre el Proceso
A=4 y B=2, como vimos anteriormente a menor número mayor será la prioridad por tal motivo le entrego el CPU a “B” y “A”
pasa a la cola, entrego dos unidades a “B, seguidamente aparece C y vuelvo a comparar el nivel de prioridades por lo que
en esta ocasión gana “C”, le asigno las dos unidades y posterior a eso “C” muere, “B” vuelve a tomar el control del CPU por
lo que termino asignándole las 3 unidades restantes. Ahora “A” vuelve a tomar el control del CPU por lo que le asigno las
restantes dos unidades, “A” muere y el CPU es tomado por el proceso D, por lo que le asigno 2 unidades, luego aparece
proceso E. ¿Qué pasa cuando ambos procesos tienen la misma prioridad? D = 4 y E = 4 debo aplicar FIFO en caso de
empate, por lo que continuo con proceso D y finalmente termino con proceso E.

5- Round Robbin (Ideal para sistemas de tiempo compartido)

Round Robbin es un algoritmo que se utiliza en los sistemas de tiempo compartido, los sistemas de tiempo compartido son sistemas donde tengo un mainframe y un conjunto de ordenadores, llamados terminales tontos que no tienen capacidad de
procesamiento, pero cuyo procesamiento se da porque ellos están conectados en red con ese mainframe y todas las tareas que ellos hacen en realidad s e esta procesando en ese mainframe, entonces cuando tengo un solo computador y 20
equipos conectados, debo dividir el tiempo del CPU entre todos los terminales conectados.

Round Robbin se debe a que doy una especie de vuelta atendiendo peticiones en un instante de tiempo, este sistema es apropiativo (por ejemplo, te presto el CPU por tiempos que se miden en segundos). Anteriormente era por prioridades, ahora te
quito el CPU porque se te acaba el tiempo. En sistemas compartidos a mayor cantidad de usuarios conectados, menor cantidad de tiempo o Quantun.

Ejemplo Round Robbin

Q=1

L A B C D
U 0 1 2 3 4 5 6 7 8 9 10
E A B A B C A B C B D

L E
U 11 12 13 14 15 16 17 18 19 20
E B D E D E D E D E E

Proceso Tiempo de t Tiempo T W P

Llegada Finalización
A 0 3 6 6 3 2,0
B 1 5 11 10 5 2,0
C 3 2 8 5 3 2,5
D 9 5 18 9 4 1,8
E 12 5 20 8 3 1,6
PROMEDIO 7,6 3,6 1,98

Nota: Se recomienda llevar un registro de la cola, por lo que se puede ir dibujando, ya que la interactividad es muy alta este
algoritmo es el más complejo hasta ahora.

Cola A B C A B C
Ejecución A B A B C A B

Resuelto

Cola A B C A B C B D B D E D E D E D E
Ejecución B A B C A B C B D B D E D E D E D E E

L A B C D
U 0 1 2 3 4 5 6 7 8 9 10
E A B A B C A B C B D

L E
U 11 12 13 14 15 16 17 18 19 20
E B D E D E D E D E E