Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Solución de los ejercicios de memoria virtual

2011-12-22T01:41:15Z

Josazcrom: /* NRU */

= NRU =

En caso de empate, se emplea LRU.
accesos a páginas

| r | r | w | r | r | r | r | w | w | w | r | r |
-------------------------------------------------------------------------------------------------
| 1 | 3 | 3 | 3 | 4 | 5 | 1 | 2 | 5 | 1 | 3 | 4 |
---------------------------------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | = | = | = | = | = | = |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | 1 | 0 | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = |
---------------------------------------------------------------------------------------------------------
marcos | 2 | | 3 | 3 | = | = | = | = | = | = | = | = | = |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | | | 1 | 0 | 1 | 1 | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = |
---------------------------------------------------------------------------------------------------------
| 3 | | | | | 4 | = | = | 2 | = | = | = | 4 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | | | | | | | | | 1 | 0 | = | = | = | = | 1 | 1 | = | = | = | = | = | = | 1 | 0 |
---------------------------------------------------------------------------------------------------------
| 4 | | | | | | 5 | = | = | 5 | = | = | = |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | | | | | | | | | | | 1 | 0 | = | = | = | = | 1 | 1 | = | = | = | = | = | = |
---------------------------------------------------------------------------------------------------------
fallo | X | X | | | X | X | | X | | | | X |
página -------------------------------------------------------------------------------------------------

tiempo ->

6
talla de fallos de página = ------ = 0,5
12

CORRECCIÓN: En el acceso a 1 de escritura (antepenúltimo acceso), en el marco 1 debería de ser R=1 y M=1 ya que se accede en modo escritura y ello hace que M cambie de 0 a 1. --[[Usuario:Josazcrom|Josazcrom]] 01:41 22 dic 2011 (UTC)

= Sustitución por envejecimiento =
Periodo de 4, registro R de 3 bits, desempate: LRU

_________________accesos a página__________________
|_2_|_3_|_3_|_1_||_4_|_5_|_4_|_1_||_5_|_2_|_3_|_4_|
======================================================
1 | 2 | = | = | = || 2 | 5 | = | = || 5 | = | = | = |
|100| = | = | = ||010|100| = | = ||110| = | = | = |
m---|---|---|---|---||---|---|---|---||---|---|---|---|
a 2 | | 3 | = | = || 3 | = | = | = || 3 | 2 | = | = |
r | |100| = | = ||010| = | = | = ||001|100| = | = |
c---|---|---|---|---||---|---|---|---||---|---|---|---|
o 3 | | | | 1 || 1 | = | = | 1 || 1 | = | = | 4 |
s | | | |100||010| = | = |110||011| = | = |100|
---|---|---|---|---||---|---|---|---||---|---|---|---|
4 | | | | || 4 | = | = | = || 4 | = | 3 | = |
| | | | ||100| = | = | = ||010| = |100| = |
--------------------------------------------------------> t
x x x x x x x x

8
tasa fallos pág = ----
12

Ejercicios administración de memoria contigua

2011-12-21T12:33:41Z

Josazcrom: /* Ejercicio 2 */

=Ejercicios Clase=

==Ejercicio 1==
Ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_____
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[Solución Ejercicio clase Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

==Ejercicio 2==
Segundo ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 2 |
P2 | 0 | 4 | 1 |
P3 | 0 | 5 | 3 |
P4 | 0 | 2 | 8 |
P5 | 0 | 1 | 7 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

Calcula los cronogramas tal y como se hizo en el ejercicio anterior.

PD: Ejercicio NO resuelto en clase.

a) Determina el cronograma del Mejor Ajuste Estático [[solución ejercicio2 Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[solución ejercicio2 Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución ejercicio2Mejor Ajuste Dinámico|Ver solución]]

No me deja editar soluciones asi que edito aquí, a mi me ha dado lo mismo en los 3 apartados --[[Usuario:Josazcrom|Josazcrom]] 12:33 21 dic 2011 (UTC)

Monitores

2011-12-14T10:39:13Z

Josazcrom: /* Ejemplo del funcionamiento de una clase monitor */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret; #1
down(s); #2
ret = recursoCompartido; #3
up(s); #4
return ret; #5
}

public void set(int valor){
down(s); #1
recursoCompartido = valor; #2
up(s); #3
}
}
</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

== Ejemplo del funcionamiento de una clase monitor ==

Dado un cierto recurso compartido protegido por una clase monitor denominada ''RecursoCompartido'' con los siguientes métodos:

* '''get''', permite obtener el valor del recurso compartido, devuelve un entero.
* '''set''', permite establecer el valor del recurso compartido.

Suponga ya creada un objeto RecursoCompartido para dos hilos h1 y h2:

<source lang="java">
RecursoCompartido r = new RecursoCompartido();
</source>

Dichos hilos tienen el siguiente código:

* Lector (h1):

<source lang="java">
int valor;
for(int j=0; j<2; j++) { #1
valor=r.get(); #2
print(valor); #3
}
</source>

* Escritor (h2):

<source lang="java">
int i=0;
for(int j=0; j<2; j++) { #1
r.set(i); #2
i++; #3
}
</source>

Suponiendo turno rotatorio estricto con quantum de 4 unidades de tiempo y que el planificador da paso en primer lugar al hilo h1. El cronograma con la representación de la ejecución sería el siguiente:

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.
B = el proceso pasa a estado bloqueado
P = el proceso pasa a estado preparado

Asignación del recurso procesador

| 1 |2.1|2.2|2.3| | |2.4|2.5| 3 | 1 | | | | |2.1|2.2|2.3|2.4| | | | |2.5| 3 | 1 | |
h1 <---|---|---|---P | |---|---|---|---P | | | |---|---|---|---| | | | |---|---|---> |
| | | | | 1 |2.1| | | | |2.2|2.3| 3 | 1 | | | | |2.1|2.2|2.3| 3 | | | | 1 |
h2 | | | | <---|---B P | | |---|---|---|---P | | | |---|---|---|---| | | |--->
----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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

Nota: Los números de la parte superior a los guiones, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor (Ver la implementación de la clase monitor de RecursoCompartido vista en clase).

[[Usuario:Migoligon|Migoligon]] 16:51 4 dic 2011 (UTC)Porqué h1 no tiene la P de preparado en el 2.4 ni h2 en el último 3, y porqué h2 no se bloquea en el 2º down??

H1 y H2 si pasan a preparado en 2.4 y 3 respectivamente, si no está la P será por olvido. Por otro lado, H2 no bloquea en el segundo down porque el semáforo en ese instante es s=1. El h1 en el instante 2.4 lo pone a 1, y pasa a preparado por consumir todo el quantum. Cuando h2 hace el down, el contador sigue a 1, lo decrementa y sigue ejecutando código.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

Creo que una solución mas correcta es la siguiente:
Asignación del recurso procesador

| 1 | 2 |2.1|2.2| | | |2.3|2.4|2.5| 3 | | | | | 1 | 2 |2.1|2.2| | |2.3|2.4|2.5| 3 | | | | | 1 | |
h1 <---|---|---|---P | | |---|---|---|---P | | | |---|---|---|---P | |---|---|---|---P | | | |---> |
| | | | | 1 | 2 |2.1| | | | |2.2|2.3| 3 | 1 | | | | | 2 |2.1| | | | |2.2|2.3|2.4| 3 | | 1 |
h2 | | | | <---|---|---B | P | |---|---|---|---P | | | |---|---B | P | |---|---|---|---| |--->
----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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

Creo que esta solución sería más correcta puesto que la línea 2 del código de cada hilo(en el hilo 1 el get() y en el hilo 2 el set(i)) hay que tratarla como una unidad de ejecución más. (Pendiente de que Pablo le de el visto bueno)

Esta solución es incorrecta (creo que lo comentó también Pablo en clase) ya que las llamadas a las funciones son en realidad un puntero apuntando a una dirección de la memoria en la que se encuentra esa función (apuntará a la primera línea de ejecución de la función). Para verlo con un ejemplo más de "andar por casa", digamos que sería el equivalente a sustituir en el código del hilo1 la linea #2 por todas las líneas de la función en si, #2.1 #2.2 #2.3 #2.4 y #2.5, la llamada a la función no cuenta como una ejecución más.--[[Usuario:Josazcrom|Josazcrom]] 10:39 14 dic 2011 (UTC)

== Fuentes ==
<references/>

Sol-ejer6-planif-procesos

2011-11-23T13:21:28Z

Josazcrom: /* Apartado c */

= Apartado a =

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_2__|_3__|_5__|
problema _t__|_3__|_1__|_4__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que ha consumido su cuanto
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | p---> | | | | | | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# |---& p---# |---> | | | | | | | | | |
PD | | | | | < |---# | | |---|---|---|---|---> | | | | |
Planificador X X X X X X X X X X X | | | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

-Respuesta: debido a que el quantum tiene un tamaño muy pequeño el planificador de tareas se ejecuta continuamente (tiempo del sistema alto) con lo que el rendimiento se verá afectado.

DUDA: En t=5 ¿por qué se inicia PC en vez de PD? Si entra PD en t=5 se debería ejecutar porque en RR estricto los procesos recién lanzados deben ejecutarse, similar a lo de orden de llegada. He pensado que puede ser por la prioridad pero esque aquí en la tabla no viene las prioridades, solo H0 y t. --Luisa Mª.

- En t=4 se han ejecutado Pa,Pb y Pc, entonces le tocaría el turno a Pd pero como en ese momento no está preparado se le pasa el turno a Pa otra vez, después de ejecutarse este se le pasa el turno a Pb pero como ya ha terminado de ejecutarse se salta al proceso siguiente: Pc. ¡Aunque también es posible que me haya equivocado! --[[Usuario:jesgonbel|jesgonbel]].

- Creo que como dice Luisa se debería ejecutar PD, porque los recien llegados tienen prioridad frente a los que ya se han iniciado.--[[Usuario:Josmorsot|Josmorsot]] 12:39 11 nov 2011 (UTC)

- Mirad el enunciado, el proceso C tiene una prioridad superior a D, imagino que será por eso. --Juan Ignacio.

OTRA DUDA: En t=8 porqué se ejecuta A en lugar de D (que sería el siguiente en el turno después de C. --[[Usuario:Danjurfer|Danjurfer]]

Mi propuesta de solución, creo que es la correcta, a ver que os parece (por --[[Usuario:Josazcrom|Josazcrom]] 10:34 23 nov 2011 (UTC))

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | p---> | | | | | | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# | |---& p |---| |---> | | | | | | | |
PD | | | | | <---# |---# | |---| |---|---|---> | | | | |
Planificador X X X X X X X X X X X X X | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Hitos importantes:

- en t=4, lo que ha dicho --[[Usuario:jesgonbel|jesgonbel]] arriba. 
- en t=5, como bien dice Luisa María, se le dá oportunidad de ejecución al proceso recién lanzado que en este caso es Pd, el cual llegaría a la cola de preparados por delante de Pc que en ese momento sería el único preparado de la cola. 
- en t=8 es donde llega mi DUDA, puesto que pasan a estado preparado Pa y Pc a la vez y el enunciado del problema debería de especificar un orden de prioridad para estos casos. En mi solución le he dado mayor prioridad a Pa respecto a Pc, de ahí que se ejecute primero.

= Apartado b =

En ambos casos la solución es la misma.

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_2__|_3__|_5__|
problema _t__|_3__|_1__|_4__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que ha consumido su cuanto
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | | |---> | | | | | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# |---& p---|---> | | | | | | | | | | |
PD | | | | | < |---# | | |---|---|---|---|---> | | | | |
Planificador X X X X | | X X | X X | | | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

DUDA: No entiendo que eso de que bloquea cuando su quantum es 1 si en uno de SJF no hay quantum además dudo que ambas soluciones sean iguales ya que en uno apropiativo se le puede retirar el proceso, en cuanto haya uno mas corto en estado preparado, que alguien me corrija si me equivoco, gracias.

Resp: Estoy contigo, esta solucion seria para el Apropiativo y sin contar con el quantum ni la prioridad, ya que se mira al que le quede menos. Para el No Apropiativo yo tengo otra solución totalmente diferente, la pongo y me decis si tengo algo mal:

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p <---& | | p | | | | |---> | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <-------& p-------> | | | | | | | | | | | |
PD | | | | | < | | |---|---|---|---|---|---> | | | | | |
| | | | | | | | | | | | | | | | | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Si yo creo que es correcto, hemos hecho el ejercicio dos personas y nos ha dado el mismo resultado.

A mi también me ha dado lo mismo la solución No Apropiativa (--[[Usuario:Josazcrom|Josazcrom]] 10:58 23 nov 2011 (UTC))

= Apartado c =

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_2__|_3__|_5__|
problema _t__|_3__|_1__|_4__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que el planificador le retira el procesador
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | p | |---& | | > | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# |---& p---|---& > | | | | | | | | | |
PD | | | | | < |---# | |---| |---|---|---|---> | | | | |
Planificador X X X X X X X X X X X | | | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Indices de penalizacion: PA=9 PB=1 PC=7/4 PD=9/6

Duda: ¿porqué en el instante t=8 no se le asigna el recurso procesador al proceso A, siendo su penalizacion mayor que C?
Yo diría que este ejercicio esta mal.A ver si el profesor nos da su opinión.

Resp: Yo opino igual que tu, en el enunciado pone que es APROPIATIVO, en el t=8 se deberia revaluar la situación, los indices de penalización son: Pa=3, Pc=1'5 y Pd=1'33, por tanto entraria el Pa, luego iria Pc de t9 a t10 que termina y por ultimo Pd de t10 a t15.

Resp: En el enunciado actualmente pone NO apropiativo, por lo que este ejercicio no estaría correcto. En t=4 debería seguir el proceso C ¿no?

Efectivamente, este ejercicio creo que no está bien, pongo mi solución para ver si os dá lo mismo

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p |---& | | p | | | | |---x | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---|---& p---|---> | | | | | | | | | | | |
PD | | | | | < | | |---|---|---|---|---|---> | | | | | |
Planificador X X X X X X X | X X | | | | X X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Hitos importantes: 
- en t=5 se comparan los índices de Pa y Pd, ya que Pb ha terminado y Pc está bloqueado (el mayor índice lo dá Pa) 
- en t=6 se comparan los índices de Pc y Pd, dándo Pc el mayor índice 
- en t=8 se ejecuta el proceso Pc al no haber ningún otro proceso preparado que se pueda evaluar su índice

Espero que a alguien más le de el mismo resultado :) (por --[[Usuario:Josazcrom|Josazcrom]] 13:21 23 nov 2011 (UTC))

Sol-ejer6-planif-procesos

2011-11-23T10:58:13Z

Josazcrom: /* Apartado b */

Sol-ejer6-planif-procesos

2011-11-23T10:34:01Z

Josazcrom: /* Apartado a */

= Apartado a =

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_2__|_3__|_5__|
problema _t__|_3__|_1__|_4__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que ha consumido su cuanto
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | p---> | | | | | | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# |---& p---# |---> | | | | | | | | | |
PD | | | | | < |---# | | |---|---|---|---|---> | | | | |
Planificador X X X X X X X X X X X | | | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

-Respuesta: debido a que el quantum tiene un tamaño muy pequeño el planificador de tareas se ejecuta continuamente (tiempo del sistema alto) con lo que el rendimiento se verá afectado.

DUDA: En t=5 ¿por qué se inicia PC en vez de PD? Si entra PD en t=5 se debería ejecutar porque en RR estricto los procesos recién lanzados deben ejecutarse, similar a lo de orden de llegada. He pensado que puede ser por la prioridad pero esque aquí en la tabla no viene las prioridades, solo H0 y t. --Luisa Mª.

- En t=4 se han ejecutado Pa,Pb y Pc, entonces le tocaría el turno a Pd pero como en ese momento no está preparado se le pasa el turno a Pa otra vez, después de ejecutarse este se le pasa el turno a Pb pero como ya ha terminado de ejecutarse se salta al proceso siguiente: Pc. ¡Aunque también es posible que me haya equivocado! --[[Usuario:jesgonbel|jesgonbel]].

- Creo que como dice Luisa se debería ejecutar PD, porque los recien llegados tienen prioridad frente a los que ya se han iniciado.--[[Usuario:Josmorsot|Josmorsot]] 12:39 11 nov 2011 (UTC)

- Mirad el enunciado, el proceso C tiene una prioridad superior a D, imagino que será por eso. --Juan Ignacio.

OTRA DUDA: En t=8 porqué se ejecuta A en lugar de D (que sería el siguiente en el turno después de C. --[[Usuario:Danjurfer|Danjurfer]]

Mi propuesta de solución, creo que es la correcta, a ver que os parece (por --[[Usuario:Josazcrom|Josazcrom]] 10:34 23 nov 2011 (UTC))

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | p---> | | | | | | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# | |---& p |---| |---> | | | | | | | |
PD | | | | | <---# |---# | |---| |---|---|---> | | | | |
Planificador X X X X X X X X X X X X X | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Hitos importantes:

- en t=4, lo que ha dicho --[[Usuario:jesgonbel|jesgonbel]] arriba. 
- en t=5, como bien dice Luisa María, se le dá oportunidad de ejecución al proceso recién lanzado que en este caso es Pd, el cual llegaría a la cola de preparados por delante de Pc que en ese momento sería el único preparado de la cola. 
- en t=8 es donde llega mi DUDA, puesto que pasan a estado preparado Pa y Pc a la vez y el enunciado del problema debería de especificar un orden de prioridad para estos casos. En mi solución le he dado mayor prioridad a Pa respecto a Pc, de ahí que se ejecute primero.

= Apartado b =

En ambos casos la solución es la misma.

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_2__|_3__|_5__|
problema _t__|_3__|_1__|_4__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que ha consumido su cuanto
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | | |---> | | | | | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# |---& p---|---> | | | | | | | | | | |
PD | | | | | < |---# | | |---|---|---|---|---> | | | | |
Planificador X X X X | | X X | X X | | | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

DUDA: No entiendo que eso de que bloquea cuando su quantum es 1 si en uno de SJF no hay quantum además dudo que ambas soluciones sean iguales ya que en uno apropiativo se le puede retirar el proceso, en cuanto haya uno mas corto en estado preparado, que alguien me corrija si me equivoco, gracias.

Resp: Estoy contigo, esta solucion seria para el Apropiativo y sin contar con el quantum ni la prioridad, ya que se mira al que le quede menos. Para el No Apropiativo yo tengo otra solución totalmente diferente, la pongo y me decis si tengo algo mal:

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p <---& | | p | | | | |---> | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <-------& p-------> | | | | | | | | | | | |
PD | | | | | < | | |---|---|---|---|---|---> | | | | | |
| | | | | | | | | | | | | | | | | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Si yo creo que es correcto, hemos hecho el ejercicio dos personas y nos ha dado el mismo resultado.

= Apartado c =

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_2__|_3__|_5__|
problema _t__|_3__|_1__|_4__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que el planificador le retira el procesador
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

| | | | | | | | | | | | | | | | | | | | |
PA <---& | | p---& | | p | |---& | | > | | | | | |
PB | | <---> | | | | | | | | | | | | | | | | |
PC | | | <---# |---& p---|---& > | | | | | | | | | |
PD | | | | | < |---# | |---| |---|---|---|---> | | | | |
Planificador X X X X X X X X X X X | | | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Indices de penalizacion: PA=9 PB=1 PC=7/4 PD=9/6

Duda: ¿porqué en el instante t=8 no se le asigna el recurso procesador al proceso A, siendo su penalizacion mayor que C?
Yo diría que este ejercicio esta mal.A ver si el profesor nos da su opinión.

Resp: Yo opino igual que tu, en el enunciado pone que es APROPIATIVO, en el t=8 se deberia revaluar la situación, los indices de penalización son: Pa=3, Pc=1'5 y Pd=1'33, por tanto entraria el Pa, luego iria Pc de t9 a t10 que termina y por ultimo Pd de t10 a t15.

Resp: En el enunciado actualmente pone NO apropiativo, por lo que este ejercicio no estaría correcto. En t=4 debería seguir el proceso C ¿no?

Sol-ejer3-planif-procesos

2011-11-22T18:55:19Z

Josazcrom: /* Nueva Duda: */

= Ejercicio 3 =

Datos del problema:
| Pa | Pb | Pc | Pd |
--------------------------
H0 | 0 | 1 | 2 | 3 |
--------------------------
t | 4 | 4 | 12 | 12 |
--------------------------

Pa y Pb bloquean por operación de E/S tras 1 unidad de ejecución

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

| | | | | | | | | | | | | | | | | | | | |
Pa <---| | | | | |---| | | | | | | | | |---| |---> |
Pb | <---| | | | | |---| | | | | | | | | |---| |--->
Pc | | <---|---| | | | |---|---|---|---| | | | | | | | |
Pd | | | < |---|---| | | | | | |---|---|---|---| | | | |
Plnf X X X | X | X X X | | | X | | | X | | | X
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

... continuación ...

| | | | | | | | | | | | |
Pa | | | | | | | | | | | | |
Pb | | | | | | | | | | | | |
Pc |---|---|---|---| | | | |---|---> | |
Pd | | | | |---|---|---|---| | |---|--->
Plnf | | | | X | | | X | X | |
|___|___|___|___|___|___|___|___|___|___|___|___|
20 21 22 23 24 25 26 27 28 29 30 31 32

Cálculo de índices:

| Pa | Pb | Pc | Pd |
--------------------------
t | 4 | 4 | 12 | 12 |
--------------------------
T | 19 | 20 | 30 | 32 |
--------------------------
T/t |4.75| 5 | 2.5 |2.66|
--------------------------

Explicación:

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)

= Dudas =

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]]:

| | | | | | | | | | | | |
Pa | | | | | | | | |---> | | |
Pb | | | | | | | | | |---> | |
Pc |---|---|---|---| | | | | | |------->
Pd | | | | |---|---|---|---| | | | |------>
Plnf | | | | X | | | X | X | X
|___|___|___|___|___|___|___|___|___|___|___|___|
18 19 20 21 22 23 24 25 26 27 28 29 30

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.

¿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]]

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]]

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)

Vaya caos! Podemos poner ambos ejercicios --[[Usuario:PCamino|PCamino]]

Con respecto a la prioridad de las colas multinivel realimentadas, creo que carecen de prioridad, simplemente basta con saber cuantas veces se ejecutan cada una y en cual de ellas se meten los procesos que van llegando.--[[Usuario:Jmf bsk|Jmf bsk]] 23:10 22 mar 2011 (UTC)

DUDA: Creo que este ejercicio está hecho para tiempos de bloqueo de 2 unidades, mientras que en el enunciado los tiempos de bloqueo es de 1 t. Si fuera para tiempos de bloqueo = 1 en el instante 2 Pa regresa a la cola 2 de preparados, luego pasaría a estado activo antes que Pd , por lo que en t=4 Pa pasaría a estado activo,después iría Pd y después la segunda ejecución de Pb. Lo escribo para aclararlo:

Pa y Pb bloquean cada unidad de tiempo, durante una unidad de tiempo de bloqueo.

| | | | | | | | | | | | | | | | | | | | |
Pa <---| | | |---| | | | | | | | | | | |---| |---> |
Pb | <---| | | | | |---| | | | | | | | | |---| |--->
Pc | | <---|---| | | | |---|---|---|---| | | | | | | | |
Pd | | | < | |---|---| | | | | |---|---|---|---| | | | |
Plnf X X X | X X | X X | | | X | | | X | | | X
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

¿es correcta la solución que planteo para una unidad de tiempo de bloqueo?

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

==='''Nueva Duda:'''===

Si sobre la cola 2 se itera dos veces, porque no se vuelve al Pa y Pb en el instante de tiempo 8? Como sucede en el instante 18.

R:
Fijate que en el instante de tiempo t=6 ya es la 2ª vez que se itera sobre Pa y Pb, la diferencia radica en que en la cola 2 inicialmente existian cuatro procesos que había que atenderlos en RR, añadiendo que Pa y Pb bloquean cada 1 UT, a diferencia del intante t=18 solo existen Pa y Pb y como dice el enunciado se les da dos oportunidades de ejecucion si no consumen su quantum.
--[[Usuario:Albsolnog|Albsolnog]] 11:53 13 nov 2011 (UTC)

R1:
Añado para mayor comprensión del ejercicio que en el instante t=6 empieza la segunda iteración de la cola 2, lo que pasa es que en esta iteración nada más que entran Pa y Pb, ya que los procesos Pc y Pd han consumido su quantum entero y han promocionado a la cola 1. --[[Usuario:Josazcrom|Josazcrom]] 18:55 22 nov 2011 (UTC)

Sol-ejer2-planif-procesos

2011-11-22T17:28:58Z

Josazcrom: /* Turno rotatorio proporcional al número de procesos */

= Turno rotatorio estricto =

____|_PA_|_PB_|_PC_|
Datos del _H0_|_0__|_1__|_2__|
problema _t__|_3__|_5__|_6__|

PA bloquea por E/S cada 1 unidad de tiempo
PB bloquea por E/S cada 3 unidades de tiempo
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

| | | | | | | | | | | | | | | | | | | |
Pa <---| | | | |---| | | |---> | | | | | | | | |
Pb | <---|---| | | |---| | | |---|---> | | | | | | |
Pc | | < |---|---| | |---|---| | | |---|---> | | | | |
Planificador X X | X | X X X | X X | X | X | | | | |
____|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

_____|_Pa_|_Pb_|_Pc_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_10_|_11_|_12_|
_T/t_|3.3_|2.2_|_2__|

Notése que el proceso A no llega a emplear el ''quantum'' que tiene asignado, en ese caso, como indica la [[Criterios_de_planificación|teoría]], se le retira el procesador y el planificador selecciona a otro proceso. Dejar el procesador sin proceso asignado, es decir, ocioso, va contra la lógica del máximo aprovechamiento del procesador. Por ello, he retirado una solución incorrecta que aparecía en esta sección. --[[Usuario:Pneira|Pneira]] 21:15 21 mar 2011 (UTC)

Tengo una duda en este ejercicio, en la unidad de tiempo 6 cuando el planificador activa el proceso Pb, porque motivo solo le asigna una unidad de tiempo?, podria asignarle 2 no? teniendo en cuenta que el quantum = 2. Ademas el proceso B bloquea cada 3 unidades de tiempo, no entiendo porque solo le asigna una unidad y luego activa en la unidad de tiempo 7 el proceso C. LFE (Luis Fernandez Esteban)

Pues yo diría que es porque se bloquea cada 3, al igual que el A se bloquea a cada unidad. Ya llevaba 1, y con esa actividad, +2 --[[Usuario:PCamino|PCamino]]

Gracias, tienes razon ya lo entendi. LFE (Luis Fernandez Esteban)

DUDA
En t=3 llegaría el proceso Pa y el proceso Pb a la cola de estado preparado. Como dice en teroía, un proceso que se bloquea sin llegar a agotar su quantum, pasaría al final de la cola de estados preparados. Por tanto, el siguiente en ejecutarse sería Pb, puesto que Pa viene de estar bloqueado sin agotar su quantum luego pasaría al final de la cola de preparados. ¿Estoy en lo cierto?
--[[Usuario:josvaldia|josvaldia]]

-esto es estricto no por compensación por tanto no estas en lo cierto. --[[Usuario:juacordia|juacordia]]

DUDA: ¿En t=10 el proceso A no bloquearia y terminaria de ejecutarse cuando vuelva del bloqueo? --[[Usuario:jesgonbel|jesgonbel]]

RESP: En t=10, el proceso A no entra en bloqueo, sino que directamente finaliza su ejecución.
--[[Usuario:framorexp|framorexp]]

RESP2: jesgonbel, el proceso terminaría cuando vuelve del bloqueo, no finaliza en el 10, lo haría en el 12 lo dijo pablo en clase creo recordar --[[Usuario:fercarort|fercarort]]

RESP3: Vale, puede ser, pero a efectos prácticos es como si finalizara en el 10, porque tras el bloqueo no necesita ningún tipo de procesamiento. No se si este caso merece algún trato especial, pero creo que no. --[[Usuario:framorexp|framorexp]]

= Por prioridades =

Suponiendo que la prioridad de los procesos es la siguiente: A<B<C

____|_PA_|_PB_|_PC_|
Datos del _H0_|_0__|_1__|_2__|
problema _t__|_3__|_5__|_6__|

PA bloquea por E/S cada 1 unidad de tiempo
PB bloquea por E/S cada 3 unidades de tiempo
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

| | | | | | | | | | | | | | | | | | | |
PA <---| | | | | | | | | |---| | | |---> | | | |
PB | <---| | | | | | |---|---| | |---|---> | | | | |
PC | | <---|---|---|---|---|---> | | | | | | | | | | |
Planificador X X X | | | | | X | X X X | X | | | | |
____|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_15_|_13_|_6_|
_T/t_|__5_|_2.6|_1__|

Nota: Del 11 al 12 no se procesa nada porque sólo quedan los procesos A y B, pero en esa unidad de tiempo ambos están bloqueados (los bloqueos de A y B duran 2 uds. de tiempo) --[[Usuario:Pneira|Pneira]] 19:23 8 nov 2011 (UTC)

= Turno rotatorio proporcional al número de procesos =

____|_PA _|_PB_|_PC _|
Datos del _H0_|_0__|_1__|_2__|
problema _t__|_3__|_5__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
B = bloquea
P = preparado

q=2 q=2 q=1 q=1 q=1 q=2 q=1 q=1 q=1 q=1 q=2
| | | | | | | | | | | | | | | | | | | | |
Pa <---B | P |---B | P |---> | | | | | | | | | | |
Pb | <---|---P | |---B | P |---P |---> | | | | | | | |
Pc | | < |---P | |---|---P | |---P |---|---> | | | | | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_12_|_15_|_17_|
_T/t_|_4__|2.80|_2.5|

Nota: Fíjese en que el quantum se calcula en base al número de procesos que están en estado preparado cada vez que hay que tomar una decisión de planificación --[[Usuario:Pneira|Pneira]] 19:34 8 nov 2011 (UTC)

Los índices de penalización de este ejercicio son erróneos, la solución correcta creo que sería la siguiente:

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5___|_6__|
de tiempos __T__|_9__|_11__|_12_|
_T/t_|_3__|_2.2_|__2_|--[[Usuario:Josazcrom|Josazcrom]] 17:28 22 nov 2011 (UTC)

Sol-ejer2-planif-procesos

2011-11-22T17:27:40Z

Josazcrom: /* Turno rotatorio proporcional al número de procesos */

Sol-ejer1-planif-procesos

2011-11-22T13:27:26Z

Josazcrom: /* indice de penalizacion (no apropiativo) */

= FIFO (no apropiativo) =

____|_PA_|_PB_|_PC_|_PD_|_PE__|
Datos del _H0_|_0__|_1__|_2__|_3__|_4__|
problema _t__|_5__|_3__|_1__|_6__|_2__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

 | | | | | | | | | | | | | | | | | | | | |
PA <___|___|___|___|___> | | | | | | | | | | | | | | |
PB | < | | | |___|___|___> | | | | | | | | | | | |
PC | | < | | | | | |___> | | | | | | | | | | |
PD | | | < | | | | | |___|___|___|___|___|___> | | | | |
PE | | | | < | | | | | | | | | | |___|___|> | | |
 Planificador X | | | | X | | X X | | | | | X | | | | |
 -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|_PD_|_PE__|
Cálculos __t__|_5__|_3__|_1__|_6__|_2__|
de tiempos __T__|_5__|_7__|_7__|_12_|_13_|
_T/t_|_1__|_7/3|_7__|__2_|13/2|
|
|_> Indice de penalización

= SJF (no apropiativo) =

____|_PA_|_PB_|_PC_|_PD_|_PE__|
Datos del _H0_|_0__|_1__|_2__|_3__|_4__|
problema _t__|_5__|_3__|_1__|_6__|_2__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

 | | | | | | | | | | | | | | | | | | | | |
PA <___|___|___|___|___> | | | | | | | | | | | | | | |
PB | < | | | | | | |___|___|___> | | | | | | | | |
PC | | < | | |___> | | | | | | | | | | | | | |
PD | | | < | | | | | | | |___|___|___|___|___|___> | | |
PE | | | | < | |___|___> | | | | | | | | | | | |
 Planificador X | | | | X X | X | | X | | | | | X | | |
 -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|_PD_|_PE_|
Cálculos __t__|_5__|_3__|_1__|_6__|_2__|
de tiempos __T__|_5__|_10_|_4__|_14_|_4__|
_T/t_|_1__|10/3|_4__|_7/3|_2__|
|
|_> Indice de penalización

= SJF (apropiativo) =

____|_PA_|_PB_|_PC_|_PD_|_PE__|
Datos del _H0_|_0__|_1__|_2__|_3__|_4__|
problema _t__|_5__|_3__|_1__|_6__|_2__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

 | | | | | | | | | | | | | | | | | | | | |
PA <___| | | | | | |___|___|___|___> | | | | | | | | |
PB | <___| |___|___> | | | | | | | | | | | | | | |
PC | | <___> | | | | | | | | | | | | | | | | |
PD | | | < | | | | | | | |___|___|___|___|___|___> | | |
PE | | | | < |___|___> | | | | | | | | | | | | |
 Planificador X X X X X X | X | | | X | | | | | X | | |
 -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|_PD_|_PE_|
Cálculos __t__|_5__|_3__|_1__|_6__|_2__|
de tiempos __T__|_11__|_4__|_1__|_14_|_3_|
_T/t_|11/5|_4/3|_1__|_7/3|_3/2|
|
|_> Indice de penalización

= indice de penalizacion (no apropiativo) =

____|_PA_|_PB_|_PC_|_PD_|_PE__|
Datos del _H0_|_0__|_1__|_2__|_3__|_4__|
problema _t__|_5__|_3__|_1__|_6__|_2__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

 | | | | | | | | | | | | | | | | | | | | |
PA <___|___|___|___|___> | | | | | | | | | | | | | | |
PB | < | | | | |___|___|___> | | | | | | | | | | |
PC | | < | | |___> | | | | | | | | | | | | | |
PD | | | < | | | | | | | |___|___|___|___|___|___> | | |
PE | | | | < | | | | |___|___> | | | | | | | | |
 Planificador X | | | | X X | | X | X | | | | | | | | |
 -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|_PD_|_PE_|
Cálculos __t__|_5__|_3__|_1__|_6__|_2__|
de tiempos __T__|_5__|_7__|_7__|_14_|_13_|
_z___|_1__|_8/3|_4__|_7/3|_7/2|
|
|_> Indice de penalización

Criterios de planificación

2011-11-18T18:42:24Z

Josazcrom: /* El siguiente, el más corto (Shortest Job First: SJF) */

=4.3.1 Métodos no apropiativos =

El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.
En los métodos no apropiativos, si el proceso se bloquea o entra en estado bloqueado, el procesador quedará sin uso durante todo ese tiempo, pues estaba dedicado/reservado para ése proceso.

== Estocástico ==

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 repetitividad 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.

No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.

== Con conocimiento del futuro ==

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.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|
problema _t__|_3__|_5__|_2__|_3__|_1__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización
_z__|_1__|_9/5|_1__|_8/3|_4/1|

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.

== Por orden de llegada (First In, First Out: FIFO) ==

Se selecciona el proceso por orden de llegada al sistema, cuando un proceso está preparado se añade al final de la cola y se ejecuta según el orden de incorporacion. Su principales ventajas son su facilidad de implementación, consume muy poco tiempo de procesador (casi ninguno) y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración pueden quedar a la espera de procesos muy prolongados, así que presentarán un alto índice de penalización.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|
problema _t__|_3__|_5__|_2__|_5__|_5__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx>
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| t = tiempo de ejecución
Cálculos _t__|_3__|_5__|_2__|_5__|_5__| T = tiempo de terminación (Instante de
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| terminación - Instante de lanzamiento)
_z__|_1__|_7/5|_7/2|_6/5|_8/5| z = índice de penalización

== El siguiente, el más corto (Shortest Job First: SJF) ==

Se selecciona el proceso que requiera menos tiempo de ejecución de entre todos los que están listos para ejecutarse. Se necesita conocer con antelación el tiempo de ejecucion de cada proceso, algo que es muy dificil en muchas ocasiones.
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. Otro inconveniente es que todo trabajo corto que llegue cuando ya ha comenzado un trabajo largo tiene un gran retraso. Su orden de complejidad es O(n).

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|
problema _t__|_3__|_5__|_2__|_5__|_5__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
& = se ejecuta el planficador
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx>
planif. &---|---|---&---|---&---|---|---|---|---&---|---|---|---|---&---|---|---|---|---&
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización
_z__|_1__|_9/5|_1__|_6/5|_8/5|

== Basado en índice de penalización ==

Se selecciona el proceso que tendrá el índice de penalización <math>I_p=\frac{T}{t}=\frac{H_f-H_0}{t}</math> de mayor valor. Este método puede producir aplazamientos de ejecución de procesos,pero no son indefinidos. Su orden de complejidad es <math>O(n)</math>.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_7__|_6__|
problema _t__|_3__|_5__|_4__|_3__|_5__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
& = se ejecuta el planficador

|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|
Pe |---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>
planif.&---|---|---&---|---|---|---|---&---|---|---|---&---|---|---&---|---|---|---|---&
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|
z(3)|_1__|_'''7/5'''|_1__|____|____|
z(8)|_1__|_7/5|_'''9/4'''|_4/3|_7/5|
z(12)|_1__|_7/5|_9/4|_'''8/3'''|11/5| z = índice de penalización
z(15)|_1__|_7/5|_9/4|_8/3|'''14/5'''|
z(20)|_1__|_7/5|_9/4|_8/3|14/5|

=4.3.2 Métodos apropiativos =

El planificador puede retirar el procesador en cualquier momento al proceso activo. Se emplea fundamentalmente en sistemas operativos [[Multiprogramación|multiprogramables]].

Con métodos apropiativos, la decisión de planificación tiene lugar si:

* El proceso activo pasa a estado bloqueado.
* El proceso activo termina su ejecución.
* Se lanza un nuevo proceso.
* El proceso activo agota el tiempo máximo de asignación del procesador (veáse ''Turno Rotatorio'').

== El siguiente, el más corto (Shortest Job First: SJF) ==

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 del que le falta al actual, se le retira el procesador al actual proceso y se le asigna al nuevo. 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.Con este método los procesos más largos se ven perjudicados, pues se puede retrasar tanto su tiempo de inicio, como el de finalización.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|
problema _t__|_3__|_5__|_1__|_8__|_3__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
& = se ejecuta el código del planificador
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx>
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|
Planif.|---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---&
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|
de tiempos _T__|_3__|_8__|_1__|_11_|_3__| z = índice de penalización
_z__|_1__|_8/5|_1__|11/8|_1__|

== Por prioridades ==

Se establecen índices de prioridad a cada proceso:

* '''Í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).
* '''Í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, aumentándola cuando un proceso está a la espera o disminuyéndola cuando tiene adjudicado el procesador.

El método funciona de la siguiente manera: El planificador mantiene ordenada la cola de procesos preparados, según prioridades decrecientes. Si el proceso en ejecución se bloquea, el planificador selecciona el primero de la lista. Cuando un proceso pasa a la situación de preparado, comprueba si su prioridad es mayor que la del proceso activo. En tal caso, suspende la ejecución de éste, colocándolo al principio de la cola de preparados, y elige al recién llegado; si no, lo inserta en la cola según su prioridad.
Cuando hay varios procesos con la misma prioridad se pueden aplicar diversos criterios, como seguir el orden de llegada a la cola de preparados, o el que necesite menos tiempo para acabar entre otros.

El orden es siempre O(n).

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática
_p__|_0__|-20_|_4__|_10_|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
& = se ejecuta el código del planificador
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|
Planif. |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---&---|---|---|---|---|
-------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización
_z__|_3__|_1__|_3__|12/7|

== Turno rotatorio ==

=== Turno rotatorio estricto (Round Robin: RR) ===

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.

El tamaño del ''quantum'' es fundamental para determinar el comportamiento de este criterio de planificación.
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 ''quantum'' 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 .

Si un proceso bloquea antes de consumir su ''quantum'' '''se le retira el procesador''' y se añade al final de la cola. Esto beneficia a los procesos por lotes, cuyo comportamiento está limitado por el procesador, pues se pasan más tiempo asignados al procesador.

Puesto que el reparto del procesador es estricto, los procesos recién lanzados deben acceder al procesador lo antes posible, por tanto, se les da oportunidad de ejecución por orden de llegada por delante de los procesos en la cola de procesos preparados. De esta manera, se evita que los procesos recién lanzados queden postergados indefinidamente.

Este criterio se puede implementar con una cola, de manera que el orden de complejidad en la selección del proceso que pasa a estado activo es <math>O(1)</math>. Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|
$ $---$---$---$---$---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización
_z__|_5/2|10/4|_5/2|12/7|

=== Turno rotatorio con compensación ===

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 (dispondrá de otro quantum completo).
Este tipo de criterio tiene un problema y es que se pueden posponer indefinidamente algunos procesos si hay varios procesos que bloqueen.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_| Pa y Pc bloquean cada 1 unidad de tiempo
Datos del _H0_|_0__|_1__|_2__|_3__| El bloqueo se resuelve tras 2 unidades de tiempo
problema _t__|_2__|_4__|_2__|_7__| quantum = 2 unidad de tiempo

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxxxxxx|---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---<---|xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<---|xxx|xxx|---|---|---|---|xxxxxxxxxxxxxxxxxxx>---|---|---|---|---|
$ $---$---|---$---$---$---|---$---$---|---$---|---$---|---$---$---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_7__|_9__|_6__|_12_| z = índice de penalización
_z__|_7/2|_9/4|_6/2|12/7|

=== Turno rotatorio con quantum dependiente del número de procesos ===

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.

== Colas multinivel ==

En este tipo de criterio se mantienen múltiples colas con los procesos en estado preparado. Los procesos se clasifican en las colas según sus características, cada cola recibe un tratamiento distinto.

Un ejemplo sería el siguiente, compuesto de cuatro colas:

# Esta primera cola es para procesos que poseen menor tiempo de ejecución, son los gestores de interrupción y los gestores de dispositivos (drivers). Hay que tomar los datos y almacenarlos en memoria lo antes posible para poder recoger más, aunque se posponga el procesamiento de dichos datos.
# En esta cola se almacenan los procesos del servidor, tales como : proceso administrador de memoria, administrador de ficheros, administrador de red, etc.
# Esta cola esta reservada a los procesos de usuario (procesos útiles para el usuario). Esta se divide a su vez en dos colas:
## Cola de procesos interactivos, limitados por E/S.
## Cola de procesos por lotes, limitados por el procesador.

Las colas tienen prioridad según su número, por ejemplo mientras que haya procesos preparados en la primera cola, no se mira la segunda. Esto puede dar lugar a que si hay muchos procesos de gestión de dispositivos se degrade la eficiencia del sistema.

La primera cola esta implementada con una FIFO(no apropiativo), mientras que las colas 2 y 3 se basan en un sistema de RR (turno rotatorio).

=== Colas multinivel con realimentación (feedback)===

Es una variante de las colas multinivel en las que los procesos pasan de una cola a otra según su comportamiento, de manera que:

* Los procesos interactivos tienen más oportunidades de emplear el procesador.
* Los procesos por lotes disponen del procesador durante más tiempo.

Los procesos se asignan al procesador por turnos rotatorios, empleando un ''quantum'' dependiente de la cola en la que se encuentren. Los procesos que consumen el ''quantum'' asignado completamente un número determinado de veces pasan a colas en las que se asignan ''quantum'' mayores. Nótese que los procesos que no consumen su ''quantum'' muestran un comportamiento interactivo. Para no discriminar a los procesos que se encuentran en las colas con ''quantum'' menores, se les dan más oportunidades de ejecución.

Por ejemplo, en un sencillo planificador de colas multinivel con realimentación compuesto por dos colas:

* En la primera cola se le asignan un ''quantum'' de 2 unidades de tiempo a los procesos.
* En la segunda cola se le asignan un ''quantum'' de 1 unidad de tiempo a los procesos.

Si un proceso no consume el ''quantum'' asignado dos veces, pasa a la cola en la que en la se le asignan ''quantum'' de 1 unidad de tiempo.

Para que los procesos interactivos no salgan perjudicados, en aras de hacer un reparto del procesador más equitativo, se le dan dos oportunidades de ejecución a los procesos situados en la cola con ''quantum'' de 1 unidad de tiempo. De esta manera, los procesos de la primera cola reciben una oportunidad de ejecución con un ''quantum'' de 2 unidades de tiempo y los de la segunda reciben dos oportunidades de ejecución con un ''quantum'' de 1 unidad de tiempo.

Ejemplo:

Pa y Pc bloquean cada 1 unidad de tiempo
El bloqueo se resuelve tras 2 unidades de tiempo
Colas multinivel: 1. Procesos interactivos (quantum = 1 unidad de tiempo)
2. Procesos por lotes (quantum = 2 unidad de tiempo)
Inicialmente todos los procesos van a la cola 2
Los procesos que no consuman su quantum al menos una vez pasan a la cola 1
Las colas implementan turno rotatorio estricto.
Siempre que haya procesos en la cola 1, debe ser atendidos de manera preferente frente a la cola 2.

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxxxxxx|---|---|---|---|---|xxxxxxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---<---|---|xxx|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<---|---|xxxxxxx|---|---|---|xxxxxxxxxxxxxxxxxxx>---|---|---|---|---|
$ $---$---|---$---$---$---|---$---$---|---$---|---$---|---$---$---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_4__|_9__|_6__|_12_| z = índice de penalización
_z__|_4/2|_9/4|_6/2|12/7|