Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Sol reloj

2011-06-07T16:09:33Z

Jmf bsk:

_________________accesos a página____________________
|_2_|_2_|_3_|_1_|_1_|_3_|_4_|_5_|_1_|_1_|_2_|_3_|_4_|
========================================================
1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 5 | 5 | 5 | 5 | 5 | 5 |
| | | | | | | | | | | | | |
m---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a 2 | | | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 2 | 2 | 2 |
r | | | | | | | | | | | | | |
c---|---|---|---|---|---|---|---|---|---|---|---|---|---|
o 3 | | | | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 4 |
s | | | | | | | | | | | | | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4 | | | | | | | 4 | 4 | 4 | 4 | 4 | 3 | 3 |
| | | | | | | | | | | | | |
------------------------------------------------------------> t

7
tasa fallos pág = ---- = 0,615
13

Creo que la tasa es de 8/13, que coincidiría con el criterio de segunda oportunidad. --[[Usuario:Lcarlosp|Lcarlosp]] 12:26 6 jun 2011 (UTC)

¿Está bien esta solución? Si el puntero señala el último marco utilizado (el 4), cuando viene el 5 habría que quitar el 4:

2(R=1)->3(R=1)->1(R=1)->4(R=1) Se implementa con una lista circular y el puntero señala el 4,
^ | luego da una vuelta cambiando todos los bits R a 0 y el primero
| | que se encuentra es de nuevo el 4, luego lo cambia por el 5.
-------------------------
--[[Usuario:Robertomartin|Robertomartin]] 08:29 7 jun 2011 (UTC)

----
_________________accesos a página____________________
|_2_|_2_|_3_|_1_|_1_|_3_|_4_|_5_|_1_|_1_|_2_|_3_|_4_|
========================================================
1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
R=| 1 | = | = | = | = | = | = | = | = | = | 1 | = | 0 |
m---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a 2 | | | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 4 |
r R=| | | 1 | = | = | = | = | 0 | = | = | = | 1 | 1 |
c---|---|---|---|---|---|---|---|---|---|---|---|---|---|
o 3 | | | | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
s R=| | | | 1 | = | = | = | 0 | 1 | = | = | = | 0 |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4 | | | | | | | 4 | 5 | 5 | 5 | 5 | 5 | 5 |
R=| | | | | | | 1 | 1 | = | = | = | = | 0 |
------------------------------------------------------------> t
creo que esta seria la solucion correcta, el puntero, en las situaciones criticas, esta apuntando a 4 que como dice Roberto se recorre la lista poniendo los bits a 0 y despues se sustituye por el 5, con bit a 1; y en la otra situación critica, cuando llega el ultimo 4, el puntero apunta a 3 y repitiendo la misma operacion de antes se sustituye por el 3.--[[Usuario:Jmf bsk|Jmf bsk]] 16:09 7 jun 2011 (UTC)

[[Criterios_de_reemplazo|Volver]]

Criterios de reemplazo

2011-06-07T15:51:30Z

Jmf bsk:

La evaluación se hace en base a la ''tasa de fallos de página'', que es el número de fallos de página entre el número de accesos totales a página, con lo que su valor oscila en el rango [0,1].
El fallo de página se produce cuando se accede a una posición de memoria que esta descargada en disco.

nº fallos pág.
tasa fallos pág = -----------------
nº accesos pág.

También hay que tener en cuenta el contexto, si estamos en arranque en frío o en caliente, así como el cumplimiento del principio de localidad espacial y temporal.

* Arranque en frío : se dan muchos fallos de página al principio, ya que los procesos se acaban de lanzar y ninguno esta cargado en memoria principal.
* Arranque en caliente : se suponen ya cargadas las páginas de los procesos en memoria principal.

==Criterios==
Ejemplo: Secuencia de acceso a página : 2,2,3,1,1,3,4,5,1,1,2,3,4
Suponiendo arranque en frío
___1____ 2_____3_____4___
memoria principal | | | | |
de 4 marcos |_____|_____|_____|_____|

;1. Criterio de página óptima: Este es un criterio teórico que viene a establecer la cota inferior de la ''tasa de fallos de página''. Consiste en escoger la página que mayor tiempo va a tardar en utilizarse. Este es el mejor caso, pero se necesita conocimiento de futuro, de ahí que sea un criterio teórico.
*[[sol_1|Solución]]
;2. Criterio de página pésima: Este también es teórico y viene a establecer la cota superior de la ''tasa de fallos de página'', para ver lo peor que podría comportarse un criterio. Consiste en seleccionar la página que menor tiempo tardará en usarse.
*[[sol_2|Solución]]
;3. Criterio MRU('''M'''ost '''R'''ecently '''U'''sed): Se selecciona la última página a la que se ha accedido. Podría implementarse con una LIFO por orden de acceso.
*[[sol_3|Solución]]
;4. Criterio de selección estocástica (aleatoria): Consiste en seleccionar una página al azar.
;5. Criterio por orden de carga FIFO: Se selecciona la página que más tiempo lleva cargada en memoria principal. Se implementa con una FIFO por orden de carga, es decir, a medida que se cargan en memoria principal las páginas son añadidas a la cola. Un problema es que suele suceder que las páginas más usadas tienden a estar mucho tiempo en memoria principal y este criterio va contra eso.

*[[sol_5|Solución]]

;6.Criterio NRU ('''N'''ot '''R'''ecently '''U'''sed): Ofrece dos bits para cada página:
* bit R : Se pone a 1 si la página ha sido usada (tanto para lectura como para escritura).
* bit M : Se pone a 1 si la página es modificada (escritura).
Para seleccionar la página victima buscamos que cumpla uno de los siguientes criterios de bits si no hay ninguno se utiliza el siguiente:

# R=0, M=0 .
# R=0, M=1 .
# R=1, M=0 .
# R=1, M=1 .

Claramente deben realizarse periodos de puesta a 0, que no tienen porque ser simultáneamente en R y M.

*[[sol_6|Solución]]

;7.Criterio de 2ª oportunidad: Se trata de la unión del dos criterios, FIFO más NRU sin el bit M. Tampoco se pone R a 0 periódicamente. Consiste en recorrer la cola hasta encontrar una página con R a 0 (si no hay ninguno, pues al que le toque de la cola) y los procesos que vaya encontrando con R a 1 se les pone R a 0 y se les da una segunda oportunidad poniéndolos al final de la cola (al final de todo, el nuevo elemento llegado).

*[[sol_7|Solución]]

;8.Criterio LRU ('''L'''east '''R'''ecently '''U'''sed): Criterio en contraposición al MRU. En MRU elegíamos aquella página que hubiéramos utilizado más recientemente (la primera de la pila de acceso) mientras que en LRU elegimos como página víctima lo contrario: La última página de la pila. Funciona como una FIFO (por orden de acceso) en la cual se actualizan los valores, poniéndose al final si llegan elementos que ya había en cola.

*[[sol_8|Solución]]

;Criterio del reloj: Igual que el de 2º oportunidad pero mantenemos un puntero a la ultima pagina examinada; se implementa con una lista circular, y un puntero a la ultima pagina examinada, que sera el 1º elemento que examinaremos para el reemplazo.

*[[sol_reloj|Solución]]

;9.Criterio LFU ('''L'''east '''F'''recuently '''U'''sed): Se incrementa un contador de uso por cada acceso. La víctima será la que tenga el contador menor.

*[[sol_9|Solución]]

;10.Aproximación discreta LRU: Consiste en LRU + LFU. Se usa el bit R. Se itera periódicamente sobre la lista de páginas si R = 1 entonces aumento el contador y pongo R a 0.

*[[sol_9.2|Solución]]

;11.Sustitución por envejecimiento: Se emplea un registro R de n bits que se va desplazando hacia la derecha periódicamente, de forma que la página victima será la que tenga el menor valor en el registro R (en caso de empate se empleao otro criterio). Por cada acceso se pone a 1 el bit más significativo del registro R. Los LSB se pierden al desplazar.

*[[sol_10|Solución]]

En el [[Algoritmos de criterios de reemplazo|Portal de la comunidad]] se encuentran implementados algunos de los anteriores criterios como ayuda para ver su funcionamiento.
Creo que los algoritmos están bien (coinciden con las soluciones), pero si alguien decide probarlos no estaría mal que los revisase por encima. --[[Usuario:Alexrdp|Alexrdp]] 16:24 6 jun 2011 (UTC)

Solución primer ajuste

2011-05-12T11:27:24Z

Jmf bsk:

Solución: P1->H1, P2->H2, P3->H3, P4->H4, P5->H4

Solución mejor ajuste estático

2011-05-12T11:26:37Z

Jmf bsk:

Solución: P1->H1, P2->H2, P3->H1/H2, P4->H4, P5->H4

P3 podrá ir a H1 o H2, la que se libere antes
P5 se pondrá esperara a que termine P4, se pondra a la cola.

Solución ejercicio 1

2011-05-09T18:14:37Z

Jmf bsk:

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.

| | | #1| #2| #3| #4| #5| #1| | | | #2| #3| #4| | | | #5| fin de ejecucion
p1| | |---|---|---|---|---|---| | | |---|---|---| | | |---| | |
| | | | | | | | | | | | | | | | | | | | |
| #1| #2| | | | | | | #3| #4| #1| | | | #2| #3| #4| fin de ejecucion
p2|---|---X | | | | / |---|---|---| | | |---|---|---| | | |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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.

--[[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
p1: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s1); #2
f1(); #3
if (get(s1) == 0) #4
up(s2); #5
} </source>
P2: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s2); #2
f2(); #3
up(s1); #4
} </source>

X : se ejecuta el planificador
> : fin del proceso
#nº : número de insturcción

|i2=0 |i1=0 | i2=1 | i1=1 | | i2=2|i1=2 |
| | | | #1| #2| #3| | | | #4| #1| #2| #3| #4| #5| | | | #1| |
P1 | | | |---|---|---| | | |---|---|---|---|---|---| | | |---> |
s1 | 1 | 0 | 1 | 0 | 1 | |
| #1| #2| #3| | | | #4| #1| #2| | | | | | | #3| #4| #1| | |
P2 |---|---|---| | | |---|---|---| | | | | | |---|---|---> | |
s2 | 1 | 0 | 0 | | | | | |
planif 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

Nueva solución:
Con respecto a la primera, una simple aclaración --[[Usuario:David|David]] 15:26 9 may 2011 (UTC)
X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.

| | | #1| #2| #3| #4| #5| #1| | | | #2| #3| #4| | #5| #1| |
p1| | |---|---|---|---|---|---| | | |---|---|---| |---|---| | | |
| | | | | | | | | | | | | | | | | | | | |
| #1| #2| | | | | | | #3| #4| #1| | | | #2| | | #3| #4| #1|
p2|---|---X | | | | / |---|---|---| | | |---X / |---|---|---|
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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.

--[[Usuario:Josmorgav1|Josmorgav1]] 15:32 9 may 2011 (UTC)
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.
Desde mi punto de vista, la solución por ahora más correcta, es la del compañero David Suárez

--[[Usuario:Jherrera|Jherrera]]
Con respecto a la solución de Dvs no es correcta a partir del instante 2, ya que interpreto que el proceso 2 ejecuta la instrucción nº3 en vez de pasar a bloqueado. He realizado el ejercicio al igual que David (última solución propuesta) y pienso que está totalmente correcto.

--[[Usuario:Jorcalmar|Jorcalmar]] 16:55 9 may 2011 (UTC)
La última solución propuesta coincide con la que me ha salido a mí, espero que esté bien.

--[[Usuario:Jmf bsk|Jmf bsk]] 18:13 9 may 2011 (UTC)
No habria que ejecutar otra vez la instruccion down, cuando ésta ha bloqueado anteriormente, por ejemplo en el tiempo 8-9 habria que volver a comprobar si el semaforo esta a 1 ¿no? y si es asi ponerlo a 0.

Solución ejercicio 1

2011-05-09T18:13:58Z

Jmf bsk:

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.

| | | #1| #2| #3| #4| #5| #1| | | | #2| #3| #4| | | | #5| fin de ejecucion
p1| | |---|---|---|---|---|---| | | |---|---|---| | | |---| | |
| | | | | | | | | | | | | | | | | | | | |
| #1| #2| | | | | | | #3| #4| #1| | | | #2| #3| #4| fin de ejecucion
p2|---|---X | | | | / |---|---|---| | | |---|---|---| | | |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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.

--[[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
p1: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s1); #2
f1(); #3
if (get(s1) == 0) #4
up(s2); #5
} </source>
P2: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s2); #2
f2(); #3
up(s1); #4
} </source>

X : se ejecuta el planificador
> : fin del proceso
#nº : número de insturcción

|i2=0 |i1=0 | i2=1 | i1=1 | | i2=2|i1=2 |
| | | | #1| #2| #3| | | | #4| #1| #2| #3| #4| #5| | | | #1| |
P1 | | | |---|---|---| | | |---|---|---|---|---|---| | | |---> |
s1 | 1 | 0 | 1 | 0 | 1 | |
| #1| #2| #3| | | | #4| #1| #2| | | | | | | #3| #4| #1| | |
P2 |---|---|---| | | |---|---|---| | | | | | |---|---|---> | |
s2 | 1 | 0 | 0 | | | | | |
planif 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

Nueva solución:
Con respecto a la primera, una simple aclaración --[[Usuario:David|David]] 15:26 9 may 2011 (UTC)
X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.

| | | #1| #2| #3| #4| #5| #1| | | | #2| #3| #4| | #5| #1| |
p1| | |---|---|---|---|---|---| | | |---|---|---| |---|---| | | |
| | | | | | | | | | | | | | | | | | | | |
| #1| #2| | | | | | | #3| #4| #1| | | | #2| | | #3| #4| #1|
p2|---|---X | | | | / |---|---|---| | | |---X / |---|---|---|
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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.

--[[Usuario:Josmorgav1|Josmorgav1]] 15:32 9 may 2011 (UTC)
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.
Desde mi punto de vista, la solución por ahora más correcta, es la del compañero David Suárez

--[[Usuario:Jherrera|Jherrera]]
Con respecto a la solución de Dvs no es correcta a partir del instante 2, ya que interpreto que el proceso 2 ejecuta la instrucción nº3 en vez de pasar a bloqueado. He realizado el ejercicio al igual que David (última solución propuesta) y pienso que está totalmente correcto.

--[[Usuario:Jorcalmar|Jorcalmar]] 16:55 9 may 2011 (UTC)
La última solución propuesta coincide con la que me ha salido a mí, espero que esté bien.

--[[Usuario:Jmf bsk|Jmf bsk]] 18:13 9 may 2011 (UTC)
No habria que ejecutar otra vez la instruccion down cuando esta ha bloqueado anteriormente, por ejemplo en el tiempo 8-9 habria que volver a comprobar si el semaforo esta a 1 ¿no? y si es asi ponerlo a 0.

Algoritmo para averiguar interbloqueo

2011-04-27T14:15:18Z

Jmf bsk: Página nueva: <source lang="csharp"> int nRecursos; int nProcesos; List<List<int>> asignados = new List<List<int>>(); List<List<int>> max...

<source lang="csharp">
int nRecursos;
int nProcesos;
List<List<int>> asignados = new List<List<int>>();
List<List<int>> maximos = new List<List<int>>();
List<int> disponibles = new List<int>();

Random r = new Random();

//Generamos las matrices aleatoriamente
for (int j1 = 0; j1 < nRecursos;j1++)
{
disponibles.Add(r.Next(0, nRecursos));
}
for (int i = 0; i < nProcesos; i++)
{
asignados.Add(new List<int>());
maximos.Add(new List<int>());
for (int j = 0; j < nRecursos; j++)
{
asignados[i].Add(r.Next(0, nRecursos));
maximos[i].Add(r.Next(0, nRecursos));
}
}

bool aux = true;
for (int proc = 0; proc < nProcesos; proc++)
{
aux = true;
for (int recur = 0; recur < nRecursos; recur++)
{
// comprobamos que haya recursos suficientes
aux = (maximos[proc][recur] - asignados[proc][recur] - disponibles[recur]) <= 0;
if (!aux)
{
break;
}
}
if (aux)
{
añadirYeliminar(ref disponibles, ref asignados, proc);
maximos.RemoveAt(proc);
nProcesos--;
proc = -1;
if (nProcesos == 0)
{
Console.WriteLine("Es estado seguro");
Console.ReadLine();
return;
}
}
}
Console.WriteLine("Es interbloqueo");
Console.ReadLine();

}

private static void añadirYeliminar(ref List<int> disponibles, ref List<List<int>> asignados, int proc)
{
for (int k = 0; k < asignados[proc].Count; k++)
{
disponibles[k] += asignados[proc][k];
}
asignados.RemoveAt(proc);
}
</source>

Esta echo en C# faltaria solamente leer por consola el numero de procesos y de recursos que queremos testear, o introduccirlos manualmente

Página Principal

2011-04-27T14:02:38Z

Jmf bsk: /* Interbloqueo */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla. ¡Regístrate y contribuye!

= Unidades didácticas =

A continuación encontrarás las unidades didácticas que forman parte de la asignatura.

== Introducción a los Sistemas Operativos ==

* [[Qué es un Sistema Operativo|Qué es un sistema operativo]]
* [[Introducción histórica|Una introducción histórica a los sistemas operativos]]
* [[Tipos de Sistemas Operativos|Tipos de sistemas operativos]]

== Fundamentos de Sistemas Operativos ==

* [[Conceptos básicos|Conceptos básicos]]
* [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* [[Llamadas al sistema|Llamadas al sistema]]
* [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]

== Procesos ==
* [[Multiprogramación|La multiprogramación]]
* [[Estados de los procesos|Estados de los procesos]]
* [[Planificador de procesos|El planificador de procesos]]
* [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* [[Bloque de control de procesos|El bloque de control del proceso]]
* [[Conmutación de procesos|La conmutación de procesos]]
* [[Hilos|Hilos]]
* [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* [[Planificación de procesos|La planificación de procesos]]
* [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* [[Criterios de planificación|Criterios de planificación]]
* [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* [[Ejercicios planificación de procesos|Ejercicios]]

== Otros aspectos relacionados con la planificación de procesos ==

* [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* [[Ejercicios otros aspectos de la planificación|Ejercicios]]

== Concurrencia de procesos ==

* [[Concurrencia de procesos|Concurrencia de procesos]]
* [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* [[Cerrojos|Cerrojos]]
* [[Ejercicio de concurrencia de procesos|Ejercicios]]

== Semáforos y comunicación ==

* [[Semáforos|Semáforos]]
* [[Monitores|Monitores]]
* [[Mensajería|Mensajería]]

== Interbloqueo ==

* [[Definición de interbloqueo|Definición]]
* [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* [[Algoritmo para averiguar interbloqueo]]

Sol-ejer3-planif-procesos

2011-03-22T23:12:17Z

Jmf bsk: /* Dudas */

= 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)

Sol-ejer3-planif-procesos

2011-03-22T23:10:56Z

Jmf bsk: /* Dudas */

= 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 lo de porque no se ejecuta otra vez el proceso a y b, creo que es porque su tiempo de ejecucion es 4, y por eso no aparece a partir del t = 18, porque se han terminado, y 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)