https://1984.lsi.us.es/wiki-ssoo/api.php?action=feedcontributions&feedformat=atom&user=Josmorgav1Wiki de Sistemas Operativos - Contribuciones del usuario [es]2026-05-15T00:00:03ZContribuciones del usuarioMediaWiki 1.29.0https://1984.lsi.us.es/wiki-ssoo/index.php?title=Soluci%C3%B3n_ejercicio_5&diff=798Solución ejercicio 52011-05-10T10:13:34Z<p>Josmorgav1: solución ejercicio 5</p>
<hr />
<div>--[[Usuario:Josmorgav1|Josmorgav1]] 10:13 10 may 2011 (UTC) Posible solución al ejercicio 5<br />
<br />
X = El proceso pasa a estado bloqueado.<br />
/ = El proceso pasa a estado preparado.<br />
> = Fin de su ejecución<br />
<br />
| | | #1| #2| #3| #4| #1| #2| | | | | #3| #4| #1| | | | | |<br />
P1| | |---|---|---|---|---|---X | / | |---|---|--->FIN| | | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
| #1| #2| | | | | | | #3| #4| #1| #2| | | | #3| #4| #1| | |<br />
P2|---|---X | | | / | |---|---|---|---X | / |---|---|--->FIN| |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Soluci%C3%B3n_ejercicio_2&diff=772Solución ejercicio 22011-05-09T16:57:14Z<p>Josmorgav1: respuesta a la duda</p>
<hr />
<div> X = El proceso pasa a estado bloqueado.<br />
/ = El proceso pasa a estado preparado.<br />
> = Fin de su ejecucion<br />
<br />
<br />
| #1| #2| #3| | | #4| #1| #2| | | | #3| #4| | | | | | | |<br />
p1|---|---|---| | |---|---|---X | / |---|---> | | | | | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
| | | | #1| #2| | | | #3| #4| #1| | | #2| #3| #4| | | | |<br />
p2| | | |---|---X / | |---|---|---| | |---|---|---> | | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
El proceso P1 comienza su ejecucion hasta agotar su ventana de tiempo , luego el proceso P2 bloquea al hacer el down(s2) ya que el semaforo s2 tiene el valor 0 , y como sabemos de los semaforos el proceso se bloquea hasta que no se vuelva a hacer un up(s2). P1 comienza y al hacer un up(s2) pasa p2 a estado preparado , luego al final de la ventana bloquea al hacer down(s1) ya que el contador en ese momento vale 0. Comienza la ejecucion p2 que estaba en estado preparado en el instante T = 10 hace un up(s1) por lo tanto p1 pasa a esta preparado. P1 se ejecuta y finaliza su ejecucion , y luego P2 se ejecuta y finaliza su ejecucion.<br />
<br />
--[[Usuario:DvS 013|DvS 013]] 15:30 9 may 2011 (UTC) : las ultimas instrucciones #1 de ambos programas deben ejecutarse para poder ver que i==2 y finalizar el bucle for, no?¿<br />
<br />
/ : bloqueado, @: preparado, >: fin del programa, X : se ejecuta el planificador<br />
<br />
|i1=0 |i2=0 | i1=1 | i2=1| i1=2| i2=2|<br />
| #1| #2| #3| | | #4| #1| #2| | | | #3| #4| #1| | | | |<br />
P1 |---|---|---| | |---|---|---/ | @ |---|---|---> | | | |<br />
s1 | 1 | 0 | 0 | 1 |<br />
| | | | #1| #2| | | | #3| #4| #1| | | | #2| #3| #4| #1|<br />
P2 | | | |---|---/ @ | |---|---|---| | | |---|---|---|---><br />
s2 | 0 | 0 | 1 | 0 |<br />
planif X | | X | X | | X | | X | | X | | X |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18<br />
<br />
<br />
--[[Usuario:Josmorgav1|Josmorgav1]] 15:38 9 may 2011 (UTC)<br />
Es correcto, la instrucción #1 si no la ejecuta, no hace la comprobación para continuar o salir del bucle, yo también he hecho el ejercicio en papel, y me da la misma solución que a David Martin.<br />
<br />
<br />
<br />
--[[Usuario:Jorcalmar|Jorcalmar]] 16:33 9 may 2011 (UTC)<br />
<br />
Duda acerca de semáforos:<br />
<br />
La operación down(s) verifica si el valor del semáforo es 0, si es así, añade el proceso a la lista de procesos bloqueados que tiene el semáforo y si no, contador--. Ahora bien:<br />
<br />
¿No sería necesario verificar esta condición por ejemplo en el instante 8? Para verificar si hemos hecho un up que nos permita volver a poner el proceso en preparado. Con verificar me refiero volver a realizar la llamada.<br />
<br />
<br />
--[[Usuario:Josmorgav1|Josmorgav1]] 16:57 9 may 2011 (UTC)<br />
No entiendo bien tu pregunta, pero como aclaración te digo, que respecto al down(s) es correcta la definición que has dado.<br />
Para el caso del instante 8, realizas un up(s) que por definición, si no tiene procesos en la lista de semáforo, incrementa la variable (s++), en caso de tener algún proceso en esa lista, implica que estaría bloqueado, por lo cual, al hacer el up(s), se pone el proceso en modo preparado, y no se incrementa el contador, ya que al hacer up(s) permitimos que entre otro proceso en la sección crítica, pero a la vez, si está en la lista de semáforo, ya estamos "preparando" el proceso que entrará en la sección crítica, por eso se mantiene el semáforo con el valor que tenía antes del up(s).<br />
Espero que haya servido de aclaración, aunque el up(s) es un poco enredoso.</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Soluci%C3%B3n_ejercicio_2&diff=754Solución ejercicio 22011-05-09T15:38:33Z<p>Josmorgav1: Aclaración compañeros</p>
<hr />
<div> X = El proceso pasa a estado bloqueado.<br />
/ = El proceso pasa a estado preparado.<br />
> = Fin de su ejecucion<br />
<br />
<br />
| #1| #2| #3| | | #4| #1| #2| | | | #3| #4| | | | | | | |<br />
p1|---|---|---| | |---|---|---X | / |---|---> | | | | | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
| | | | #1| #2| | | | #3| #4| #1| | | #2| #3| #4| | | | |<br />
p2| | | |---|---X / | |---|---|---| | |---|---|---> | | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
El proceso P1 comienza su ejecucion hasta agotar su ventana de tiempo , luego el proceso P2 bloquea al hacer el down(s2) ya que el semaforo s2 tiene el valor 0 , y como sabemos de los semaforos el proceso se bloquea hasta que no se vuelva a hacer un up(s2). P1 comienza y al hacer un up(s2) pasa p2 a estado preparado , luego al final de la ventana bloquea al hacer down(s1) ya que el contador en ese momento vale 0. Comienza la ejecucion p2 que estaba en estado preparado en el instante T = 10 hace un up(s1) por lo tanto p1 pasa a esta preparado. P1 se ejecuta y finaliza su ejecucion , y luego P2 se ejecuta y finaliza su ejecucion.<br />
<br />
--[[Usuario:DvS 013|DvS 013]] 15:30 9 may 2011 (UTC) : las ultimas instrucciones #1 de ambos programas deben ejecutarse para poder ver que i==2 y finalizar el bucle for, no?¿<br />
<br />
/ : bloqueado, @: preparado, >: fin del programa, X : se ejecuta el planificador<br />
<br />
|i1=0 |i2=0 | i1=1 | i2=1| i1=2| i2=2|<br />
| #1| #2| #3| | | #4| #1| #2| | | | #3| #4| #1| | | | |<br />
P1 |---|---|---| | |---|---|---/ | @ |---|---|---> | | | |<br />
s1 | 1 | 0 | 0 | 1 |<br />
| | | | #1| #2| | | | #3| #4| #1| | | | #2| #3| #4| #1|<br />
P2 | | | |---|---/ @ | |---|---|---| | | |---|---|---|---><br />
s2 | 0 | 0 | 1 | 0 |<br />
planif X | | X | X | | X | | X | | X | | X |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18<br />
<br />
<br />
--[[Usuario:Josmorgav1|Josmorgav1]] 15:38 9 may 2011 (UTC)<br />
Es correcto, la instrucción #1 si no la ejecuta, no hace la comprobación para continuar o salir del bucle, yo también he hecho el ejercicio en papel, y me da la misma solución que a David Martin.</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Soluci%C3%B3n_ejercicio_1&diff=751Solución ejercicio 12011-05-09T15:32:30Z<p>Josmorgav1: Aclaración compañeros</p>
<hr />
<div> <br />
X = El proceso pasa a estado bloqueado.<br />
/ = El proceso pasa a estado preparado.<br />
<br />
<br />
<br />
| | | #1| #2| #3| #4| #5| #1| | | | #2| #3| #4| | | | #5| fin de ejecucion<br />
p1| | |---|---|---|---|---|---| | | |---|---|---| | | |---| | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
| #1| #2| | | | | | | #3| #4| #1| | | | #2| #3| #4| fin de ejecucion<br />
p2|---|---X | | | | / |---|---|---| | | |---|---|---| | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
El proceso P2 comienza su ejecucion y al hacer el down al semaforo s2 que vale 0 bloquea , ya que los semaforo es un sincronizacion bloqueante, p1 comienza su ejecucion hasta que se hace up(s2) y agota su ventana de tiempo y p2 puede comenzar su ejecucion.<br />
<br />
--[[Usuario:DvS 013|DvS 013]] 15:09 9 may 2011 (UTC) : había conflicto cuando le he dado a subir así que pongo debajo lo que yo estaba editando antes de que se subiera nada<br />
p1: <source lang="c"><br />
for (int i=0; i<2; i++) { #1<br />
down(s1); #2<br />
f1(); #3<br />
if (get(s1) == 0) #4<br />
up(s2); #5<br />
} </source> <br />
P2: <source lang="c"><br />
for (int i=0; i<2; i++) { #1<br />
down(s2); #2<br />
f2(); #3<br />
up(s1); #4<br />
} </source> <br />
<br />
X : se ejecuta el planificador<br />
> : fin del proceso<br />
#nº : número de insturcción<br />
<br />
|i2=0 |i1=0 | i2=1 | i1=1 | | i2=2|i1=2 |<br />
| | | | #1| #2| #3| | | | #4| #1| #2| #3| #4| #5| | | | #1| |<br />
P1 | | | |---|---|---| | | |---|---|---|---|---|---| | | |---> |<br />
s1 | 1 | 0 | 1 | 0 | 1 | |<br />
| #1| #2| #3| | | | #4| #1| #2| | | | | | | #3| #4| #1| | |<br />
P2 |---|---|---| | | |---|---|---| | | | | | |---|---|---> | |<br />
s2 | 1 | 0 | 0 | | | | | |<br />
planif X | | X | | X | | X | | X | | X | | X X |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
Nueva solución:<br />
Con respecto a la primera, una simple aclaración --[[Usuario:David|David]] 15:26 9 may 2011 (UTC)<br />
X = El proceso pasa a estado bloqueado.<br />
/ = El proceso pasa a estado preparado.<br />
<br />
<br />
<br />
| | | #1| #2| #3| #4| #5| #1| | | | #2| #3| #4| | #5| #1| | <br />
p1| | |---|---|---|---|---|---| | | |---|---|---| |---|---| | | |<br />
| | | | | | | | | | | | | | | | | | | | |<br />
| #1| #2| | | | | | | #3| #4| #1| | | | #2| | | #3| #4| #1|<br />
p2|---|---X | | | | / |---|---|---| | | |---X / |---|---|---|<br />
| | | | | | | | | | | | | | | | | | | | |<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Como aclaración: cuando se realiza el up de un semáforo que vale 0, si hay procesos en su lista de semáforos, se coge el primero y se pasa a estado preparado, valiendo el contador del semáforo 0, por eso en el instante 15 al hacer el down de s2 vuelve a bloquear.<br />
<br />
--[[Usuario:Josmorgav1|Josmorgav1]] 15:32 9 may 2011 (UTC)<br />
Una aclaración al compañero David Martin, el contador de semáforo s2, en un principio vale 0, y como el primer proceso en ejecutar es P2, al hacer el down(s2); bloquea, creo que en tu solución consideras que s2 vale 1.<br />
Desde mi punto de vista, la solución por ahora más correcta, es la del compañero David Suárez.</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sol-ejer3-planif-procesos&diff=488Sol-ejer3-planif-procesos2011-03-22T21:42:21Z<p>Josmorgav1: Aclaración de enunciado</p>
<hr />
<div>= Ejercicio 3 =<br />
<br />
Datos del problema:<br />
| Pa | Pb | Pc | Pd |<br />
--------------------------<br />
H0 | 0 | 1 | 2 | 3 |<br />
--------------------------<br />
t | 4 | 4 | 12 | 12 |<br />
--------------------------<br />
<br />
Pa y Pb bloquean por operación de E/S tras 1 unidad de ejecución<br />
<br />
< = indica el instante de lanzamiento del proceso<br />
> = indica el instante de finalización del proceso<br />
X = se ejecuta el código del planificador<br />
<br />
| | | | | | | | | | | | | | | | | | | | |<br />
Pa <---| | | | | |---| | | | | | | | | |---| |---| |<br />
Pb | <---| | | | | |---| | | | | | | | | |---| |---|<br />
Pc | | <---|---| | | | |---|---|---|---| | | | | | | | |<br />
Pd | | | < |---|---| | | | | | |---|---|---|---| | | | |<br />
Plnf X X X | X | X X X | | | X | | | X | | | X<br />
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
... continuación ...<br />
<br />
| | | | | | | | | | | | |<br />
Pa | | | | | | | | | | | | |<br />
Pb | | | | | | | | | | | | |<br />
Pc |---|---|---|---| | | | |---|---| | |<br />
Pd | | | | |---|---|---|---| | |---|---|<br />
Plnf | | | | X | | | X | X | | <br />
|___|___|___|___|___|___|___|___|___|___|___|___|<br />
20 21 22 23 24 25 26 27 28 29 30 31 32<br />
<br />
Cálculo de índices:<br />
<br />
| Pa | Pb | Pc | Pd |<br />
--------------------------<br />
t | 4 | 4 | 12 | 12 |<br />
--------------------------<br />
T | 19 | 20 | 30 | 32 |<br />
--------------------------<br />
T/t |4.75| 5 | 2.5 |2.66|<br />
--------------------------<br />
<br />
Explicación:<br />
<br />
Todos los procesos empiezan inicialmente en la segunda cola. Pa y Pb reciben una oportunidad de ejecución sin consumir su quantum debido a bloqueo, por tanto, permanecen en la segunda cola. Pc y Pd consumen todo su quantum, por tanto, promocionan a la primera cola. Los procesos Pa y Pb se ejecutan otra vez, pues los procesos que se encuentran en la segunda cola reciben dos oportunidades de ejecución. Tras esto, los procesos recién ascendidos a la primera cola, que son Pc y Pd, reciben su oportunidad de ejecución, en este caso con quantum de 4 unidades. De nuevo, se le da oportunidad de ejecución a los procesos de la segunda cola, que terminan su ejecución. Como no hay más procesos en la segunda cola, se le da una oportunidad de ejecución a los de la primera. --[[Usuario:Pneira|Pneira]] 18:36 22 mar 2011 (UTC)<br />
<br />
= Dudas =<br />
<br />
No entiendo por qué en la unidad de tiempo 18 no aparece el proceso c y d y posteriormente a b c y d.Esto es a lo que me refiero --[[Usuario:Jherrera|Jherrera]]:<br />
<br />
<br />
| | | | | | | | | | | | |<br />
Pa | | | | | | | | |---> | | |<br />
Pb | | | | | | | | | |---> | |<br />
Pc |---|---|---|---| | | | | | |-------><br />
Pd | | | | |---|---|---|---| | | | |------><br />
Plnf | | | | X | | | X | X | X <br />
|___|___|___|___|___|___|___|___|___|___|___|___|<br />
18 19 20 21 22 23 24 25 26 27 28 29 30<br />
<br />
<br />
<br />
Solucion: Por que en la 2ª cola estan los procesos A y B, por que nunca consumen los quantums, y la 2ª cola siempre se itera 2 veces.<br />
<br />
<br />
¿No se supone que la cola 1 posee mayor prioridad que la 2? siendo asi, mientras C y D esten en la 1ª cola no se le debería volver a dar oportunidad a la cola 2 no?¿--[[Usuario:DvS 013|DvS 013]]<br />
<br />
Creo que se lo que dices. Aunque C y D esten en la primera cola, se pasa a la segunda. Esto es porque la primera cola no tiene mas prioridad, sino solo un quantum más ancho. Entonces se mira la primera cola, luego 2 veces la segunda, y vuelta a empezar --[[Usuario:PCamino|PCamino]]<br />
<br />
El problema creo yo es que el enunciado ha sido modificado de esta mañana para acá, porque yo también hice el ejercicio para subirlo a la wiki, pero se me adelantaron, y esta mañana en el enunciado ponia que la cola 1 tenia más prioridad que la 2, y ademas no ponia el tiempo que estaban en estado bloqueado los procesos, ahora si lo pone, y no pone lo de la prioridad. Yo estoy de acuerdo con la solucion propuesta arriba. --[[Usuario:Josmorgav1|Josmorgav1]] 21:42 22 mar 2011 (UTC)</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sol-ejer3-planif-procesos&diff=428Sol-ejer3-planif-procesos2011-03-22T12:45:29Z<p>Josmorgav1: Aclaración/explicación de la discusión</p>
<hr />
<div>= Ejercicio 3 =<br />
<br />
____|_P<sub>A</sub>_|_P<sub>B</sub>_|_P<sub>C</sub>_|_P<sub>D</sub>_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_4__|_4__|_12_|_12_|<br />
<br />
P<sub>A</sub> y P<sub>B</sub> bloquean por operación de E/S tras 1 unidad de ejecución<br />
< = indica el instante de lanzamiento del proceso<br />
> = indica el instante de finalización del proceso<br />
X = se ejecuta el código del planificador<br />
<br />
<sub> </sub> | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |<br />
P<sub>A</sub> <---| | | | | |---| | | | | | | | | | | | | | | | | | | | | |---| |---> |<br />
P<sub>B</sub> | <---| | | | | |---| | | | | | | | | | | | | | | | | | | | | |---| |---><br />
P<sub>C</sub> | | <---|---| | | | |---|---|---|---| | | | |---|---|---|---| | | | |---|---> | | | | | |<br />
P<sub>D</sub> | | | < |---|---| | | | | | |---|---|---|---| | | | |---|---|---|---| | |---|---> | | | |<br />
PlnfX X X | X | X X X | | | X | | | X | | | X | | | X | X | X X X X X <br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|_> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32<br />
<br />
_____|_P<sub>A</sub>_|_P<sub>B</sub>_|_P<sub>C</sub>_|_P<sub>D</sub>_|<br />
Cálculos __t__|_4__|_4__|_12_|_12_|<br />
de tiempos __T__|_31_|_31_|_24_|_25_|<br />
_T/t_|7.75|7.75|_2__|2.08|<br />
<br />
-Observaciones<br />
<br />
Por que ejecutas seguidamente los procesos C y D seguidamente, ¿la cola 1 solo se ejecuta 1 vez y pasa a la 2ª o varias veces hasta que se agotan los procesos? ¿qué opináis? <br />
<br />
Yo creo que la cola 1 tiene mas prioridad que la cola 2 y por eso se ejecutan los procesos de la cola 1 hasta que no queden más pero no estoy totalmente seguro de que sea así. No se si cuando se ejecutan los procesos de la cola 1 al pasar a preparados otra vez entran en la 2 o se quedan en la 1 yo supongo lo segundo<br />
<br />
Yo también estoy de acuerdo con la repetitividad de C y D debido a la prioridad superior de la cola 1.<br />
En respuesta a ¿dónde se quedan los procesos de la cola 1?, en el enunciado te comentan:<br />
-Si el proceso está en la cola 2 y agota el quantum, pasa a la cola 1, en caso contrario, sigue en la cola 2.<br />
-Si el proceso está en la cola 1 y agota el quantum, se mantiene en ella, pero si no lo agota completamente vuelve a la cola 2.</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=243Criterios de planificación2011-03-16T12:25:05Z<p>Josmorgav1: aclaración de lanzamiento de proceso + centrado de grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planif.|---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planif. |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=242Criterios de planificación2011-03-16T12:23:24Z<p>Josmorgav1: aclaración de lanzamiento de proceso + centrado de grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planif.|---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planif. |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=241Criterios de planificación2011-03-16T12:20:43Z<p>Josmorgav1: aclaración de lanzamiento de proceso + centrado de grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planif.|---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=240Criterios de planificación2011-03-16T12:16:34Z<p>Josmorgav1: aclaración de lanzamiento de proceso + centrado de grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planificador |---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=239Criterios de planificación2011-03-16T12:14:54Z<p>Josmorgav1: aclaración de lanzamiento de proceso + centrado de grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planificador |---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=238Criterios de planificación2011-03-16T12:13:10Z<p>Josmorgav1: centrado de la grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planificador |---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=237Criterios de planificación2011-03-16T12:11:59Z<p>Josmorgav1: centrado de la grafica</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planificador |---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=236Criterios de planificación2011-03-16T12:08:07Z<p>Josmorgav1: aclaración de lanzamiento de proceso</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planificador |---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=235Criterios de planificación2011-03-16T12:07:24Z<p>Josmorgav1: aclaración de lanzamiento de proceso</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = lanzamiento del proceso<br />
> = finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el proceso por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
Planificador |---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
El orden es siempre O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
& = se ejecuta el código del planificador<br />
<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
Planificador |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=222Criterios de planificación2011-03-15T09:28:50Z<p>Josmorgav1: introducción del ejemplo</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
$ $---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización<br />
_z__|_5/2|10/4|_5/2|12/7|<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=221Criterios de planificación2011-03-15T09:15:42Z<p>Josmorgav1: introducción del ejemplo</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Datos del _H0_|_0__|_1__|_2__|_3__|<br />
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática<br />
_p__|_0__|-20_|_4__|_10_|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|<br />
Cálculos _t__|_2__|_4__|_2__|_7__|<br />
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización<br />
_z__|_3__|_1__|_3__|12/7|<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=220Criterios de planificación2011-03-15T09:03:32Z<p>Josmorgav1: correcciones</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__| z = índice de penalización<br />
_z__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=219Criterios de planificación2011-03-15T09:01:53Z<p>Josmorgav1: correcciones</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
z(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización<br />
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
z(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__|<br />
_x__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=218Criterios de planificación2011-03-15T09:00:13Z<p>Josmorgav1: correcciones</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
x(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
x(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
x(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''|<br />
x(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
x(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__|<br />
_x__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=217Criterios de planificación2011-03-15T08:57:44Z<p>Josmorgav1: correcciones</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__|<br />
_x__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
x = indica que el proceso está asignado al procesador en ese momento <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
x(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
x(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
x(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''|<br />
x(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
x(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__|<br />
_x__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=216Criterios de planificación2011-03-15T08:52:56Z<p>Josmorgav1: correcciones</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que se trata de un buen criterio de planificación.<br />
<br />
No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
x = indica que el proceso está asignado al procesador en ese momento<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización<br />
_z__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_7__|_7__|_6__|_8__|<br />
_x__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
de tiempos _T__|_3__|_9__|_2__|_6__|_8__|<br />
_x__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
x(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
x(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
x(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''|<br />
x(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
x(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__|<br />
<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
de tiempos _T__|_3__|_8__|_1__|_14_|_3__|<br />
_x__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos.<br />
<br />
== Turno rotatorio estricto (Round Robin: RR) ==<br />
<br />
En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado '''quantum''', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.<br />
<br />
El tamaño del '''quantum''' es fundamental para determinar el comportamiento de este criterio de planificación. <br />
Si el '''quantum''' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, Si el '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .<br />
<br />
Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.<br />
<br />
Este criterio se puede implementar con una cola, de manera que la complejidad de la selección de un proceso es O(1). Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.<br />
<br />
== Turno rotatorio con compensación ==<br />
<br />
Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio.<br />
<br />
== Turno rotatorio con quantum dependiente del número de procesos ==<br />
<br />
Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Usuario:Josmorgav1&diff=150Usuario:Josmorgav12011-03-08T15:14:31Z<p>Josmorgav1: </p>
<hr />
<div>José Manuel Moreno Gavira<br />
Grupo 1 Ingeniero en Informática<br />
correo: seelnova@hotmail.com</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=149Criterios de planificación2011-03-08T15:13:32Z<p>Josmorgav1: Introducción de ejemplo</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__| Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__| de tiempos _T__|_3__|_9__|_2__|_8__|_4__|<br />
_x__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_7__|_7__|_6__|_8__|<br />
_x__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_9__|_2__|_6__|_8__|<br />
_x__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
x(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
x(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
x(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''|<br />
x(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
x(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
$ = indica la ejecución del planificador para retirar un<br />
proceso y establecer otro según el criterio<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_4__|_6__|_12_| Cálculos _t__|_3__|_5__|_1__|_8__|_3__|<br />
problema _t__|_3__|_5__|_1__|_8__|_3__| de tiempos _T__|_3__|_8__|_1__|_14_|_3__|<br />
_x__|_1__|_8/5|_1__|14/8|_1__|<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=148Criterios de planificación2011-03-08T14:53:40Z<p>Josmorgav1: Introducción de ejemplo</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__| Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__| de tiempos _T__|_3__|_9__|_2__|_8__|_4__|<br />
_x__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_7__|_7__|_6__|_8__|<br />
_x__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_9__|_2__|_6__|_8__|<br />
_x__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx><br />
Pe |---|---|---|---|---|---<---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_7__|_6__| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_7__|_9__|_13_|_11_|<br />
x(3)|_1__|_'''2/5'''|_0/4|____|____|<br />
x(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|<br />
x(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''|<br />
x(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|<br />
x(20)|_1__|_7/5|_9/4|13/3|11/5|<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=147Criterios de planificación2011-03-08T14:16:37Z<p>Josmorgav1: Introducción de ejemplo</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__| Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__| de tiempos _T__|_3__|_9__|_2__|_8__|_4__|<br />
_x__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_7__|_7__|_6__|_8__|<br />
_x__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_9__|_2__|_6__|_8__|<br />
_x__|_1__|_9/5|_1__|_6/5|_8/5|<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=146Criterios de planificación2011-03-08T13:47:24Z<p>Josmorgav1: Añadir ejemplo FIFO</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__| Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__| de tiempos _T__|_3__|_9__|_2__|_8__|_4__|<br />
_x__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx><br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_9__|_12_| Cálculos _t__|_3__|_5__|_2__|_5__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_5__| de tiempos _T__|_3__|_7__|_7__|_6__|_8__|<br />
_x__|_1__|_7/5|_7/2|_6/5|_8/5|<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=145Criterios de planificación2011-03-08T13:14:32Z<p>Josmorgav1: Corrección de las tablas</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_3__|_6__|_7__| Cálculos _t__|_3__|_5__|_2__|_3__|_1__|<br />
problema _t__|_3__|_5__|_2__|_3__|_1__| de tiempos _T__|_3__|_9__|_2__|_8__|_4__|<br />
_x__|_1__|_9/5|_1__|_8/3|_4/1|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=144Criterios de planificación2011-03-08T10:59:22Z<p>Josmorgav1: /* Con conocimiento del futuro */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_7__| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_2__|_5__|_1__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=143Criterios de planificación2011-03-08T10:48:08Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso <br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
-------------------------------------------------------------------------------------------------------------------------<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=142Criterios de planificación2011-03-08T10:46:05Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t<br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=141Criterios de planificación2011-03-08T10:43:52Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pb |---<---|---|---|---|---|---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx><br />
Pc |---|---|---<xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pd |---|---|---|---|---|---<---|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|<br />
Pe |---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|<br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___<br />
| | | | | | | | | | | | | | | | | | | | | t--><br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|<br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=140Criterios de planificación2011-03-08T10:34:47Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
Pa <xxx|xxx|xxx> | | | | | | | | | | | | | | | | |<br />
Pb | < | | | | | | | | | | | | | |---|---|---|---|---><br />
Pc | | < |---|---|---|---> | | | | | | | | | | | | |<br />
Pd | | | | | | < |---|---|---> | | | | | | | | | |<br />
Pe | | | | | | | | | | <---|---|---|---|---> | | | | |<br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___<br />
| | | | | | | | | | | | | | | | | | | | | t--><br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| <br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=139Criterios de planificación2011-03-08T10:33:35Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
<br />
<nowiki> | | | | | | | | | | | | | | | | | | | | |<br />
Pa <---|---|---> | | | | | | | | | | | | | | | | |<br />
Pb | < | | | | | | | | | | | | | |---|---|---|---|---><br />
Pc | | < |---|---|---|---> | | | | | | | | | | | | |<br />
Pd | | | | | | < |---|---|---> | | | | | | | | | |<br />
Pe | | | | | | | | | | <---|---|---|---|---> | | | | |<br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___<br />
| | | | | | | | | | | | | | | | | | | | | t--><br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20</nowiki><br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| <br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=138Criterios de planificación2011-03-08T10:32:38Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
<br />
| | | | | | | | | | | | | | | | | | | | |<br />
Pa <---|---|---> | | | | | | | | | | | | | | | | |<br />
Pb | < | | | | | | | | | | | | | |---|---|---|---|---><br />
Pc | | < |---|---|---|---> | | | | | | | | | | | | |<br />
Pd | | | | | | < |---|---|---> | | | | | | | | | |<br />
Pe | | | | | | | | | | <---|---|---|---|---> | | | | |<br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___<br />
| | | | | | | | | | | | | | | | | | | | | t--><br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| <br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=137Criterios de planificación2011-03-08T10:31:24Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<nowiki><br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
| | | | | | | | | | | | | | | | | | | | |<br />
Pa <---|---|---> | | | | | | | | | | | | | | | | |<br />
Pb | < | | | | | | | | | | | | | |---|---|---|---|---><br />
Pc | | < |---|---|---|---> | | | | | | | | | | | | |<br />
Pd | | | | | | < |---|---|---> | | | | | | | | | |<br />
Pe | | | | | | | | | | <---|---|---|---|---> | | | | |<br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___<br />
| | | | | | | | | | | | | | | | | | | | | t--><br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| <br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
</nowiki><br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_planificaci%C3%B3n&diff=136Criterios de planificación2011-03-08T10:30:10Z<p>Josmorgav1: /* Estocástico */</p>
<hr />
<div>= Métodos no apropiativos =<br />
<br />
El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.<br />
<br />
== Estocástico ==<br />
<br />
Se selecciona aleatoriamente un procesos. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitibilidad o predecibilidad. Su uso es establecer una cota inferior a la hora de diseñar un planificador: Si éste presenta peores resultados que el método estocástico, significa que estará mal diseñado.<br />
<br />
Ejemplo:<br />
< = indica que el proceso se encuentra en modo preparado<br />
> = indica la finalización del proceso<br />
<br />
| | | | | | | | | | | | | | | | | | | | |<br />
Pa <---|---|---> | | | | | | | | | | | | | | | | |<br />
Pb | < | | | | | | | | | | | | | |---|---|---|---|---><br />
Pc | | < |---|---|---|---> | | | | | | | | | | | | |<br />
Pd | | | | | | < |---|---|---> | | | | | | | | | |<br />
Pe | | | | | | | | | | <---|---|---|---|---> | | | | |<br />
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___<br />
| | | | | | | | | | | | | | | | | | | | | t--><br />
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20<br />
<br />
____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| ____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| <br />
Datos del _H0_|_0__|_1__|_2__|_6__|_10_| Cálculos _t__|_3__|_5__|_4__|_3__|_5__|<br />
problema _t__|_3__|_5__|_4__|_3__|_5__| de tiempos _T__|_3__|_19_|_5__|_4__|_5__|<br />
_x__|_1__|19/5|_5/4|_4/3|_1__|<br />
<br />
Como podemos observar, este método puede provocar grandes retrasos en algunos procesos debido a su carácter aleatorio.<br />
<br />
== Con conocimiento del futuro ==<br />
<br />
En base al conocimiento del futuro se asignan los procesos. Representa una cota superior, es decir, mientras un planificador tenga un comportamiento más parecido a este método, mejor diseñado estará.<br />
<br />
== Por orden de llegada (First In, First Out: FIFO) ==<br />
<br />
Se selecciona el procesa por orden de lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).<br />
<br />
== Basado en índice de penalización ==<br />
<br />
Se selecciona el proceso que lleva más tiempo sin estar en estado activo. Estima los índices de penalización y elige el de mayor valor.<br />
<br />
= Métodos apropiativos =<br />
<br />
El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]].<br />
<br />
== El siguiente, el más corto (Shortest Job First: SJF) ==<br />
<br />
Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución, se le asigna el procesador.<br />
<br />
== Por prioridades ==<br />
<br />
Se establecen índices de prioridad a cada proceso:<br />
<br />
* Índice estático: Establecido por el usuario.<br />
* Índice dinámico: Establecido por el planificador, inicialmente basado en el índice estático.<br />
<br />
En el caso de Linux, como sucede con otros sistemas tipo-Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).<br />
<br />
== Turno rotatorio (Round Robin: RR) ==<br />
<br />
== Colas multinivel ==</div>Josmorgav1https://1984.lsi.us.es/wiki-ssoo/index.php?title=Usuario:Josmorgav1&diff=135Usuario:Josmorgav12011-03-08T10:01:52Z<p>Josmorgav1: Página nueva: José Manuel Moreno Gavira Grupo 1 Ingeniero en Informática</p>
<hr />
<div>José Manuel Moreno Gavira<br />
Grupo 1 Ingeniero en Informática</div>Josmorgav1