Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Sol reloj

2011-06-15T08:58:53Z

JDomingo:

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

8
tasa fallos pág = ---- = 0,615
13
Según los apuntes de M.Rovayo se implementa como una cola circular con un puntero que señala a la última exploración realizada (NO A LA ÚLTIMA PÁGINA EXAMINADA). En esta cola solo se desplaza el puntero(que indica la página víctima). En el momento que llega la página 5 ,la cola está de la siguiente forma :

2(R=1)->3(R=1)->1(R=1)->4(R=1)
^ luego da una vuelta cambiando todos los bits R a 0 y el primero
| que se encuentra es de nuevo el 2, luego lo cambia por el 5.

--[[Usuario:Jherrera|Jherrera]] 13:03 13 jun 2011 (UTC)

----

En el ultimo acceso la cola está de la siguiente forma: 5(R=1) -> 2(R=1) -> 1(R=0) -> 3(R=1) al cargar la página 4 queda:
5(R=0) -> 2(R=0) -> 4(R=1) -> 3(R=1) ^
^ |
|

--[[Usuario:Jherrera|Jherrera]] 10:26 14 jun 2011 (UTC)

----

Cierto, elimino el comentario. Es así, pero antes del ultimo acceso el puntero señala al 5. Supongo que es así como lo tienes, pero el formato del wiki desplaza la flecha a una posición errónea (al menos a mi me señala al 1).

[[Criterios_de_reemplazo|Volver]]

Solución de los ejercicios de administración de ficheros

2011-06-15T08:25:47Z

JDomingo: /* Ejercicio 1 */

== Ejercicio 1 ==

A. Los archivos Fichero2.txt e Imagen2.jpg están corruptos, ya que ambos tienen (o envían) a una etiqueta 'BAD'.

Aparte de que los ficheros esten corruptos, la incoherencia es que un mismo bloque (el 4, obviando que esta dañado) esta asignado a dos ficheros distintos según esa configuración, ¿no? --[[Usuario:JDomingo|J. Domingo]] 08:25 15 jun 2011 (UTC)

B.
Entrada a directorio raíz E: 1 acceso
Entrada a Imagen.jpg: 1 acceso
Llegada a etiqueta EOF: 3 accesos
Total: 5 accesos

¿No serían 4 accesos? A los bloques 2, 3, 5 y 6. Cuando se llega a la etiqueta EOF no hacen falta más accesos, ¿no?--[[Usuario:Alexrdp|Alexrdp]] 17:33 13 jun 2011 (UTC)

Coincido en que son 4 accesos. 1 para entrada a directorio raiz. 1 de entrada a Imagen.jpg. Y 2 más para llegar a EOF. Tambien creo que es asi ¿no? --[[Usuario:JDomingo|J. Domingo]] 13:07 14 jun 2011 (UTC)

Tambíen considero que son 4 acceso --[[Usuario:Alberto|Alberto]]

== Ejercicio 2 ==

1º: Acceso al bloque del i-nodo.
2 y 3º: Acceso a los bloques para alcanzar el bloque del doble indirecto.
4º: Acceso al bloque del doble indirecto.

Total: 4 accesos

Solución de los ejercicios de administración de ficheros

2011-06-15T08:25:35Z

JDomingo: /* Ejercicio 1 */

== Ejercicio 1 ==

A. Los archivos Fichero2.txt e Imagen2.jpg están corruptos, ya que ambos tienen (o envían) a una etiqueta 'BAD'.

Aparte de que los ficheros esten corruptos, la incoherencia es que un mismo bloque (el 4, obviando que esta dañado) esta asignado a dos ficheros distintos según esa configuración, ¿no? --~~

B.
Entrada a directorio raíz E: 1 acceso
Entrada a Imagen.jpg: 1 acceso
Llegada a etiqueta EOF: 3 accesos
Total: 5 accesos

¿No serían 4 accesos? A los bloques 2, 3, 5 y 6. Cuando se llega a la etiqueta EOF no hacen falta más accesos, ¿no?--[[Usuario:Alexrdp|Alexrdp]] 17:33 13 jun 2011 (UTC)

Coincido en que son 4 accesos. 1 para entrada a directorio raiz. 1 de entrada a Imagen.jpg. Y 2 más para llegar a EOF. Tambien creo que es asi ¿no? --[[Usuario:JDomingo|J. Domingo]] 13:07 14 jun 2011 (UTC)

Tambíen considero que son 4 acceso --[[Usuario:Alberto|Alberto]]

== Ejercicio 2 ==

1º: Acceso al bloque del i-nodo.
2 y 3º: Acceso a los bloques para alcanzar el bloque del doble indirecto.
4º: Acceso al bloque del doble indirecto.

Total: 4 accesos

Solución de los ejercicios de administración de ficheros

2011-06-15T08:25:03Z

JDomingo: /* Ejercicio 1 */ Posible Mejora de Respuesta

== Ejercicio 1 ==

A. Los archivos Fichero2.txt e Imagen2.jpg están corruptos, ya que ambos tienen (o envían) a una etiqueta 'BAD'.

Aparte de que los ficheros esten corruptos, la incoherencia es que un mismo bloque (el 4, obviando que esta dañado) esta asignado a dos ficheros distintos según esa configuración, ¿no? --

B.
Entrada a directorio raíz E: 1 acceso
Entrada a Imagen.jpg: 1 acceso
Llegada a etiqueta EOF: 3 accesos
Total: 5 accesos

¿No serían 4 accesos? A los bloques 2, 3, 5 y 6. Cuando se llega a la etiqueta EOF no hacen falta más accesos, ¿no?--[[Usuario:Alexrdp|Alexrdp]] 17:33 13 jun 2011 (UTC)

Coincido en que son 4 accesos. 1 para entrada a directorio raiz. 1 de entrada a Imagen.jpg. Y 2 más para llegar a EOF. Tambien creo que es asi ¿no? --[[Usuario:JDomingo|J. Domingo]] 13:07 14 jun 2011 (UTC)

Tambíen considero que son 4 acceso --[[Usuario:Alberto|Alberto]]

== Ejercicio 2 ==

1º: Acceso al bloque del i-nodo.
2 y 3º: Acceso a los bloques para alcanzar el bloque del doble indirecto.
4º: Acceso al bloque del doble indirecto.

Total: 4 accesos

Solución de los ejercicios de administración de ficheros

2011-06-14T13:07:42Z

JDomingo: /* Ejercicio 1 */

== Ejercicio 1 ==

A. Los archivos Fichero2.txt e Imagen2.jpg están corruptos, ya que ambos tienen (o envían) a una etiqueta 'BAD'.

B.
Entrada a directorio raíz E: 1 acceso
Entrada a Imagen.jpg: 1 acceso
Llegada a etiqueta EOF: 3 accesos
Total: 5 accesos

¿No serían 4 accesos? A los bloques 2, 3, 5 y 6. Cuando se llega a la etiqueta EOF no hacen falta más accesos, ¿no?--[[Usuario:Alexrdp|Alexrdp]] 17:33 13 jun 2011 (UTC)

Coincido en que son 4 accesos. 1 para entrada a directorio raiz. 1 de entrada a Imagen.jpg. Y 2 más para llegar a EOF. Tambien creo que es asi ¿no? --[[Usuario:JDomingo|J. Domingo]] 13:07 14 jun 2011 (UTC)

== Ejercicio 2 ==

1º: Acceso al bloque del i-nodo.
2 y 3º: Acceso a los bloques para alcanzar el bloque del doble indirecto.
4º: Acceso al bloque del doble indirecto.

Total: 4 accesos

Solución de los ejercicios de gestión de L/E

2011-06-14T12:56:25Z

JDomingo:

== Ejercicio 1 ==

{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
| '''4-scan'''
| 3
| 15
|45
| 80
| 79
|20
| 4
| 1
|19
| 21
| 23
|67
|-
| '''sstf'''
| 1
| 3
|4
|15
| 19
| 20
|21
| 23
| 45
|67
| 79
| 80
|-
| '''6c-scan'''
| 1
| 3
|15
| 45
| 79
|80
| 4
| 19
|20
| 21
| 23
|67
|}

[[Ejercicios_Gestión_L/E|Volver]]

Solución de los ejercicios de gestión de L/E

2011-06-14T12:56:07Z

JDomingo:

Solución de los ejercicios de gestión de L/E

2011-06-14T12:54:47Z

JDomingo:

Solución de los ejercicios de gestión de L/E

2011-06-14T12:54:04Z

JDomingo: Mejorada la accesibilidad

Solución de los ejercicios de gestión de L/E

2011-06-14T12:52:05Z

JDomingo: Corregido metodo 4-scan

Sol reloj

2011-06-13T20:17:49Z

JDomingo: Correccion ultimo acceso

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

8
tasa fallos pág = ---- = 0,615
13
Según los apuntes de M.Rovayo se implementa como una cola circular con un puntero que señala a la última exploración realizada (NO A LA ÚLTIMA PÁGINA EXAMINADA). En esta cola solo se desplaza el puntero(que indica la página víctima). En el momento que llega la página 5 ,la cola está de la siguiente forma :

2(R=1)->3(R=1)->1(R=1)->4(R=1)
^ luego da una vuelta cambiando todos los bits R a 0 y el primero
| que se encuentra es de nuevo el 2, luego lo cambia por el 5.

--[[Usuario:Jherrera|Jherrera]] 13:03 13 jun 2011 (UTC)

En el ultimo acceso la cola esta de la siguiente forma: 1(R=0) -> 5(R=1) -> 2(R=1) -> 3(R=1)
^
|
Al llegar la pagina 4, recorre la cola poniendo los bits de 5, 2 y 3 a 0, y cuando da la vuelta se encuentra el bit de 1 a 0 y la reemplaza, por tanto al final el bit de 3 (en el cuarto marco) tambien es 0. --[[Usuario:JDomingo|J. Domingo]] 20:17 13 jun 2011 (UTC)

[[Criterios_de_reemplazo|Volver]]

Sol 6

2011-06-13T19:34:19Z

JDomingo: Corregido un fallo

La lista de paginas a la que se acceden son las siguientes :
''' 2(R)--2(W)--3(R)--1(R)--1(W)--3(R)--4(W)--5(R)--1(R)--1(W)--2(R)--3(W)--4(R)'''

El bit R se pone a 0 cada 4 accesos
___1__ __ 2__ __3___ __4___
1º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1
Pagina 2 |R=1M=0|R=0M=0|R=0M=0|R=0M=0|
|______|______|______|______|
2º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1
Pagina 2 |R=1M=1|R=0M=0|R=0M=0|R=0M=0|
|______|______|______|______|
3º Acceso | | | | |
Acceso a: | 2 | 3 | | | Nª de fallos: 2
Pagina 3 |R=1M=1|R=1M=0|R=0M=0|R=0M=0|
|______|______|______|______|
4º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 1 |R=1M=1|R=1M=0|R=1M=0|R=0M=0|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
5º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 1 |R=0M=1|R=0M=0|R=1M=1|R=0M=0|
|______|______|______|______|
6º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 3 |R=0M=1|R=1M=0|R=1M=1|R=0M=0|
|______|______|______|______|
7º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | 4 | Nª de fallos: 4
Pagina 4 |R=0M=1|R=1M=0|R=1M=1|R=1M=1|
|______|______|______|______|
8º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 5 |R=1M=0|R=1M=0|R=1M=1|R=1M=1|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
9º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 1 |R=0M=0|R=0M=0|R=1M=1|R=0M=1|
|______|______|______|______|
10º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 1 |R=0M=0|R=0M=0|R=1M=1|R=0M=1|
|______|______|______|______|
11º Acceso | | | | |
Acceso a: | 5 | 2 | 1 | 4 | Nª de fallos: 6
Pagina 2 |R=0M=0|R=1M=0|R=1M=1|R=0M=1|
|______|______|______|______|
12º Acceso | | | | |
Acceso a: | 3 | 2 | 1 | 4 | Nª de fallos: 7
Pagina 3 |R=1M=1|R=1M=0|R=1M=1|R=0M=1|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
13º Acceso | | | | |
Acceso a: | 3 | 2 | 1 | 4 | Nª de fallos: 7
Pagina 4 |R=0M=1|R=0M=0|R=0M=1|R=1M=1|
|______|______|______|______|

--[[Usuario:Fcoramlop|Fcoramlop]] 22:17 4 jun 2011 (UTC)
7
tasa fallos pág = ---- = 0,5385
13

[[Criterios_de_reemplazo|Volver]]

El acceso 10 no debería de ser fallo, no?
Y el acceso 11 podria elegir el marco 1 y quitar la pagina 5?? Es que de esa forma también bajaría la tasa de fallos a 6/13... Con los bits R y M no sabes que la página 5 llego despues de la 3...
Alguien responde?? --[[Usuario:Lcarlosp|Lcarlosp]] 11:54 6 jun 2011 (UTC)

[[Usuario:Lcarlosp|Lcarlosp]] Efectivamente en el acceso 10 no debería ser fallo, ¿alguien en contra? y lo del acceso 11 depende del criterio que se siga en caso de empate, parece ser que en este caso es criterio por orden de carga FIFO. --[[Usuario:Robertomartin|Robertomartin]] 15:59 6 jun 2011 (UTC)

<[[Usuario:PCamino|pablo]]> Creo humildemente que eso está equivocado. El contenido final me sale igual: 3 (01), 2 (00), 1 (01), 4 (11), pero el MR es 7/13 (xvxxvvxxvvxxv)

<[[Usuario:alberto|alberto]]> En el acceso 7 , porque al meter 4, tanto R como M pasan a 1 directamente , no sería 10 ?

En el acceso 7, al meter el 4 si observas es de W, por lo que ambos valores R y M tienen que ir a 1 1 directamente y no 1 0.--[[Usuario:Luiferest|Luiferest]] 15:22 7 jun 2011 (UTC)

--[[Usuario:JDomingo|J. Domingo]] 19:33 13 jun 2011 (UTC) Efectivamente el acceso 10 no debe ser fallo, de hecho en el mismo ejemplo se ve que no cambia ningun marco. Lo corrijo (¡si está equivocado vuelvan a editar!). A mi me sale igual que en el ejemplo, escogiendo FIFO como politica de desempate.

Sol 6

2011-06-13T19:33:10Z

JDomingo:

La lista de paginas a la que se acceden son las siguientes :
''' 2(R)--2(W)--3(R)--1(R)--1(W)--3(R)--4(W)--5(R)--1(R)--1(W)--2(R)--3(W)--4(R)'''

El bit R se pone a 0 cada 4 accesos
___1__ __ 2__ __3___ __4___
1º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1
Pagina 2 |R=1M=0|R=0M=0|R=0M=0|R=0M=0|
|______|______|______|______|
2º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1
Pagina 2 |R=1M=1|R=0M=0|R=0M=0|R=0M=0|
|______|______|______|______|
3º Acceso | | | | |
Acceso a: | 2 | 3 | | | Nª de fallos: 2
Pagina 3 |R=1M=1|R=1M=0|R=0M=0|R=0M=0|
|______|______|______|______|
4º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 1 |R=1M=1|R=1M=0|R=1M=0|R=0M=0|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
5º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 1 |R=0M=1|R=0M=0|R=1M=1|R=0M=0|
|______|______|______|______|
6º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 3 |R=0M=1|R=1M=0|R=1M=1|R=0M=0|
|______|______|______|______|
7º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | 4 | Nª de fallos: 4
Pagina 4 |R=0M=1|R=1M=0|R=1M=1|R=1M=1|
|______|______|______|______|
8º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 5 |R=1M=0|R=1M=0|R=1M=1|R=1M=1|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
9º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 1 |R=0M=0|R=0M=0|R=1M=1|R=0M=1|
|______|______|______|______|
10º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 1 |R=0M=0|R=0M=0|R=1M=1|R=0M=1|
|______|______|______|______|
11º Acceso | | | | |
Acceso a: | 5 | 2 | 1 | 4 | Nª de fallos: 6
Pagina 2 |R=0M=0|R=1M=0|R=1M=1|R=0M=1|
|______|______|______|______|
12º Acceso | | | | |
Acceso a: | 3 | 2 | 1 | 4 | Nª de fallos: 7
Pagina 3 |R=1M=1|R=1M=0|R=1M=1|R=0M=1|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
13º Acceso | | | | |
Acceso a: | 3 | 2 | 1 | 4 | Nª de fallos: 8
Pagina 4 |R=0M=1|R=0M=0|R=0M=1|R=1M=1|
|______|______|______|______|

--[[Usuario:Fcoramlop|Fcoramlop]] 22:17 4 jun 2011 (UTC)
7
tasa fallos pág = ---- = 0,5385
13

[[Criterios_de_reemplazo|Volver]]

El acceso 10 no debería de ser fallo, no?
Y el acceso 11 podria elegir el marco 1 y quitar la pagina 5?? Es que de esa forma también bajaría la tasa de fallos a 6/13... Con los bits R y M no sabes que la página 5 llego despues de la 3...
Alguien responde?? --[[Usuario:Lcarlosp|Lcarlosp]] 11:54 6 jun 2011 (UTC)

[[Usuario:Lcarlosp|Lcarlosp]] Efectivamente en el acceso 10 no debería ser fallo, ¿alguien en contra? y lo del acceso 11 depende del criterio que se siga en caso de empate, parece ser que en este caso es criterio por orden de carga FIFO. --[[Usuario:Robertomartin|Robertomartin]] 15:59 6 jun 2011 (UTC)

<[[Usuario:PCamino|pablo]]> Creo humildemente que eso está equivocado. El contenido final me sale igual: 3 (01), 2 (00), 1 (01), 4 (11), pero el MR es 7/13 (xvxxvvxxvvxxv)

<[[Usuario:alberto|alberto]]> En el acceso 7 , porque al meter 4, tanto R como M pasan a 1 directamente , no sería 10 ?

En el acceso 7, al meter el 4 si observas es de W, por lo que ambos valores R y M tienen que ir a 1 1 directamente y no 1 0.--[[Usuario:Luiferest|Luiferest]] 15:22 7 jun 2011 (UTC)

--[[Usuario:JDomingo|J. Domingo]] 19:33 13 jun 2011 (UTC) Efectivamente el acceso 10 no debe ser fallo, de hecho en el mismo ejemplo se ve que no cambia ningun marco. Lo corrijo (¡si está equivocado vuelvan a editar!). A mi me sale igual que en el ejemplo, escogiendo FIFO como politica de desempate.

Solución ejercicio 5

2011-05-10T18:21:00Z

JDomingo:

--[[Usuario:Josmorgav1|Josmorgav1]] 10:13 10 may 2011 (UTC) Posible solución al ejercicio 5

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución

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

Pablo Camino says: Me sale igual

A mi también, [[Usuario:DvS 013|DvS 013]]

También a mí. --[[Usuario:JDomingo|J. Domingo]] 18:21 10 may 2011 (UTC)

Semáforos

2011-05-04T20:31:16Z

JDomingo: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutandose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra]. Los semáforos nos permiten '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que nos permiten sincronizar la ejecución de dos o más procesos.

Los semáforos son un tipo de datos (TAD) que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos, inicialmente vacía.

Son usados para controlar el acceso a ciertas partes de un programa llamadas '''secciones críticas''', en la que se manipulan recursos que deben ser tratados de forma especial.

El valor del semáforo, tanto en su inicialización como a lo largo de la ejecución del proceso, es muy importante ya que será lo que controle el número de procesos accediendo al recurso compartido de manera simultánea.

El tipo mas simple de semáforo es el binario. Pueden tomar como valor 0 o 1 y sólo permite el acceso a un único proceso a la vez.

Los semáforos disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
proceso a estado bloqueado
añade proceso a s.lista
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Los semáforos son un mecanismo de esperas no ocupadas, lo que significa que permite sincronizar a los procesos de forma que no se desperdician recursos de CPU cuando un cierto no proceso no tiene actividad a realizar (la espera ocupada, también conocida como espera activa, es en la que se queda comprobando la condición hasta verificarla, como el caso de los cerrojos).

'''Granularidad''': número de recursos controlados por un semáforo

'''Problemas''': El uso de semáforos también tiene algunos inconvenientes, entre los que destacan:

* Facilidad para emplearlos incorrectamente.
* Son independientes del lenguaje de programación, y por tanto no hay comprobación ninguna en tiempo de compilación.
* No hay nada que obligue a usarlos.
* Son independientes del recurso compartido al que intentan regular.

Debido a ellos fueron desarrollados los [[Monitores]].

'''Ejemplo productor-consumidor''': Supongamos un proceso que produce y otro que consume lo producido. Lo deseable es que el productor actúe primero, y no más de 1 vez consecutiva, puesto que el consumidor consume de 1 en 1.

{|cellpadding="4"
!style="border-style: solid; border-width: 0 1px 1px 1px"|Inicializacion
!style="border-style: solid; border-width: 0 1px 1px 0"|Productor
!style="border-style: solid; border-width: 0 1px 1px 0"|Consumidor
|-
|width="200"|semaforo prod,cons;
|width="90"|while(1){
|width="90"|while(1){
|-
|semaforo_create(cons,0);
|align="center"| down (prod);
|align="center"| down (cons);
|-
|semaforo_create(prod,1);
|align="center"| produce();
|align="center"| consume();
|-
|
|align="center"| up(cons);
|align="center"| up(prod);
|-
|
| }
| }
|}

Discusión:Mecanismos de sincronización

2011-05-03T18:14:31Z

JDomingo: Respuesta 1

- A mi enteder en el fragmento de codigo de :
<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (compartida+1 != tmp) /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
</source>
¿no deberia en vez de modificar la variable temporal , modificar la variable compartida?

Ya que como dice al principio los dos procesos tienen el mismo codigo entonces, en ambos la variable compartida no es modificada,
se modifica la variable temporal.

Ejemplo: El proceso A empieza a ejecutarse y se queda en la linea tmp ++ por que agota su ventana de tiempo, el proceso B empieza a ejecutar, y tmb se queda en estado preparado por que agota su ventana de tiempo en la instruccion tmp ++, en este caso ambos procesos han acedido al recurso comportido y la instruccion if la cumple.

¿Que os parece?

----

Ese trozo de código es incompleto a mi parecer. ¿Lo que dices es esto?
<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
'''compartida++'''; /* actualizo la varible */
if (compartida != '''tmp + 1''') /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
</source>

No creo que actualizar la variable compartida antes de hacer ninguna comprobación sea correcto.

Pienso que seria mejor actualizar el valor de la variable una vez hecha la comprobación:
<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (compartida+1 != tmp) /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
'''else
compartida = tmp;''' /* Actualizo el valor de la variable compartida. */
</source>

Lo más probable es que la intención de ese trozo fuese mostrar la idea principal, por eso no aparece la modificación de la variable compartida. Pero tampoco estoy seguro de esto. ¿Alguna otra opinión?

----

Discusión:Mecanismos de sincronización

2011-05-03T18:02:26Z

JDomingo:

Semáforos

2011-05-02T17:17:00Z

JDomingo: /* Semáforos */ Agregado uso

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutandose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra]. Los semáforos nos permiten '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que nos permiten sincronizar la ejecución de dos o más procesos.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos, inicialmente vacía.

Son usados para controlar el acceso a ciertas partes de un programa llamadas '''secciones críticas''', en la que se manipulan recursos que deben ser tratados de forma especial.

El valor del semáforo, tanto en su inicialización como a lo largo de la ejecución del proceso, es muy importante ya que será lo que controle el número de procesos accediendo al recurso compartido de manera simultánea.

El tipo mas simple de semáforo es el binario. Pueden tomar como valor 0 o 1 y sólo permite el acceso a un único proceso a la vez.

Los semáforos disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
proceso a estado bloqueado
añade proceso a s.lista
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Los semáforos son un mecanismo de esperas no ocupadas, lo que significa que permite sincronizar a los procesos de forma que no se desperdician recursos de CPU cuando un cierto no proceso no tiene actividad a realizar (la espera ocupada, también conocida como espera activa, es en la que se queda comprobando la condición hasta verificarla).

'''Granularidad''': número de recursos controlados por un semáforo

'''Problemas''': El uso de semáforos también tiene algunos inconvenientes, entre los que destacan:

* Facilidad para emplearlos incorrectamente.
* Son independientes del lenguaje de programación, y por tanto no hay comprobación ninguna en tiempo de compilación.
* No hay nada que obligue a usarlos.
* Son independientes del recurso compartido al que intentan regular.

'''Ejemplo productor-consumidor''': Supongamos un proceso que produce y otro que consume lo producido. Lo deseable es que el productor actúe primero, y no más de 1 vez consecutiva, puesto que el consumidor consume de 1 en 1.

{|cellpadding="4"
!style="border-style: solid; border-width: 0 1px 1px 1px"|Inicializacion
!style="border-style: solid; border-width: 0 1px 1px 0"|Productor
!style="border-style: solid; border-width: 0 1px 1px 0"|Consumidor
|-
|width="200"|semaforo prod,cons;
|width="90"|while(1){
|width="90"|while(1){
|-
|semaforo_create(cons,0);
|align="center"| down (prod);
|align="center"| down (cons);
|-
|semaforo_create(prod,1);
|align="center"| produce();
|align="center"| consume();
|-
|
|align="center"| up(cons);
|align="center"| up(prod);
|-
|
| }
| }
|}

Semáforos

2011-05-02T17:08:37Z

JDomingo: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutandose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra]. Los semáforos nos permiten '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que nos permiten sincronizar la ejecución de dos o más procesos.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos, inicialmente vacía.

Los semáforos disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
proceso a estado bloqueado
añade proceso a s.lista
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Los semáforos son un mecanismo de esperas no ocupadas, lo que significa que permite sincronizar a los procesos de forma que no se desperdician recursos de CPU cuando un cierto no proceso no tiene actividad a realizar (la espera ocupada, también conocida como espera activa, es en la que se queda comprobando la condición hasta verificarla).

'''Granularidad''': número de recursos controlados por un semáforo

'''Problemas''': El uso de semáforos también tiene algunos inconvenientes, entre los que destacan:

* Facilidad para emplearlos incorrectamente.
* Son independientes del lenguaje de programación, y por tanto no hay comprobación ninguna en tiempo de compilación.
* No hay nada que obligue a usarlos.
* Son independientes del recurso compartido al que intentan regular.

'''Ejemplo productor-consumidor''': Supongamos un proceso que produce y otro que consume lo producido. Lo deseable es que el productor actúe primero, y no más de 1 vez consecutiva, puesto que el consumidor consume de 1 en 1.

{|cellpadding="4"
!style="border-style: solid; border-width: 0 1px 1px 1px"|Inicializacion
!style="border-style: solid; border-width: 0 1px 1px 0"|Productor
!style="border-style: solid; border-width: 0 1px 1px 0"|Consumidor
|-
|width="200"|semaforo prod,cons;
|width="90"|while(1){
|width="90"|while(1){
|-
|semaforo_create(cons,0);
|align="center"| down (prod);
|align="center"| down (cons);
|-
|semaforo_create(prod,1);
|align="center"| produce();
|align="center"| consume();
|-
|
|align="center"| up(cons);
|align="center"| up(prod);
|-
|
| }
| }
|}

Semáforos

2011-05-02T17:06:11Z

JDomingo: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutandose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra]. Los semáforos nos permiten '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que nos permiten sincronizar la ejecución de dos o más procesos.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos, inicialmente vacía.

Los semáforos disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
proceso a estado bloqueado
añade proceso a s.lista
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Los semáforos son un mecanismo de esperas no ocupadas, lo que significa que permite sincronizar a los procesos de forma que no se desperdician recursos de CPU cuando un cierto no proceso no tiene actividad a realizar (la espera ocupada, también conocida como espera activa, es en la que se queda comprobando la condición hasta verificarla).

'''Granularidad''': número de recursos controlados por un semáforo

'''Ejemplo productor-consumidor''': Supongamos un proceso que produce y otro que consume lo producido. Lo deseable es que el productor actúe primero, y no más de 1 vez consecutiva, puesto que el consumidor consume de 1 en 1.

{|cellpadding="4"
!style="border-style: solid; border-width: 0 1px 1px 1px"|Inicializacion
!style="border-style: solid; border-width: 0 1px 1px 0"|Productor
!style="border-style: solid; border-width: 0 1px 1px 0"|Consumidor
|-
|width="200"|semaforo prod,cons;
|width="90"|while(1){
|width="90"|while(1){
|-
|semaforo_create(cons,0);
|align="center"| down (prod);
|align="center"| down (cons);
|-
|semaforo_create(prod,1);
|align="center"| produce();
|align="center"| consume();
|-
|
|align="center"| up(cons);
|align="center"| up(prod);
|-
|
| }
| }
|}

No obstante el uso de semáforos también tiene algunos inconvenientes, entre los que destacan:

* Facilidad para emplearlos incorrectamente.
* Son independientes del lenguaje de programación, y por tanto no hay comprobación ninguna en tiempo de compilación.
* No hay nada que obligue a usarlos.
* Son independientes del recurso compartido al que intentan regular.

Semáforos

2011-05-02T17:04:34Z

JDomingo: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutandose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra]. Los semáforos nos permiten '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que nos permiten sincronizar la ejecución de dos o más procesos.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos, inicialmente vacía.

Los semáforos disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
proceso a estado bloqueado
añade proceso a s.lista
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Los semáforos son un mecanismo de esperas no ocupadas, lo que significa que permite sincronizar a los procesos de forma que no se desperdician recursos de CPU cuando un cierto no proceso no tiene actividad a realizar (la espera ocupada, también conocida como espera activa, es en la que se queda comprobando la condición hasta verificarla).

'''Granularidad''': número de recursos controlados por un semáforo

'''Ejemplo productor-consumidor''': Supongamos un proceso que produce y otro que consume lo producido. Lo deseable es que el productor actúe primero, y no más de 1 vez consecutiva, puesto que el consumidor consume de 1 en 1.

{|cellpadding="4"
!style="border-style: solid; border-width: 0 1px 1px 1px"|Inicializacion
!style="border-style: solid; border-width: 0 1px 1px 0"|Productor
!style="border-style: solid; border-width: 0 1px 1px 0"|Consumidor
|-
|width="200"|semaforo prod,cons;
|width="90"|while(1){
|width="90"|while(1){
|-
|semaforo_create(cons,0);
|align="center"| down (prod);
|align="center"| down (cons);
|-
|semaforo_create(prod,1);
|align="center"| produce();
|align="center"| consume();
|-
|
|align="center"| up(cons);
|align="center"| up(prod);
|-
|
| }
| }
|}

No obstante el uso de semáforos también tiene algunos inconvenientes, entre los que destacan:
* Facilidad para emplearlos incorrectamente.
* Son independientes del lenguaje de programación, y por tanto no hay comprobación ninguna en tiempo de compilación.
* No hay nada que obligue a usarlos.
* Son independientes del recurso compartido al que intentan regular.

Semáforos

2011-05-02T17:03:46Z

JDomingo: /* Semáforos */ Agregado inconvenientes

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutandose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra]. Los semáforos nos permiten '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que nos permiten sincronizar la ejecución de dos o más procesos.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos, inicialmente vacía.

Los semáforos disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
proceso a estado bloqueado
añade proceso a s.lista
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Los semáforos son un mecanismo de esperas no ocupadas, lo que significa que permite sincronizar a los procesos de forma que no se desperdician recursos de CPU cuando un cierto no proceso no tiene actividad a realizar (la espera ocupada, también conocida como espera activa, es en la que se queda comprobando la condición hasta verificarla).

'''Granularidad''': número de recursos controlados por un semáforo

'''Ejemplo productor-consumidor''': Supongamos un proceso que produce y otro que consume lo producido. Lo deseable es que el productor actúe primero, y no más de 1 vez consecutiva, puesto que el consumidor consume de 1 en 1.

{|cellpadding="4"
!style="border-style: solid; border-width: 0 1px 1px 1px"|Inicializacion
!style="border-style: solid; border-width: 0 1px 1px 0"|Productor
!style="border-style: solid; border-width: 0 1px 1px 0"|Consumidor
|-
|width="200"|semaforo prod,cons;
|width="90"|while(1){
|width="90"|while(1){
|-
|semaforo_create(cons,0);
|align="center"| down (prod);
|align="center"| down (cons);
|-
|semaforo_create(prod,1);
|align="center"| produce();
|align="center"| consume();
|-
|
|align="center"| up(cons);
|align="center"| up(prod);
|-
|
| }
| }
|}

No obstante el uso de semáforos también tiene algunos inconvenientes, entre los que destacan:
- Facilidad para emplearlos incorrectamente.
- Son independientes del lenguaje de programación, y por tanto no hay comprobación ninguna en tiempo de compilación.
- No hay nada que obligue a usarlos.
- Son independientes del recurso compartido al que intentan regular.

Criterios de planificación

2011-03-23T02:22:25Z

JDomingo: Según gráfico y cálculos, Pc llega en H0=3

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

== 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_|
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| z = índice de penalización
_z__|_1__|_7/5|_7/2|_6/5|_8/5|

== 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 lleva más tiempo en estado preparado, sin estar en estado activo. Estima los índices de penalización, P=T/t=(w+t)/t y elige el de mayor valor. Este método puede producir aplazamientos de ejecución de procesos,pero no son indefinidos. Su orden de complejidad es O(n).

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|

= Métodos apropiativos =

El planificador puede retirar el procesador en cualquier momento al proceso activo. Suele darse en sistemas operativos [[Multiprogramación|multiprogramables]]. Este metodo es necesario si existen procesos de alta prioridad.

== 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, se le asigna el procesador, sólo si el proceso nuevo necesita menos tiempo del que le falta al actual. 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__|_14_|_3__| z = índice de penalización
_z__|_1__|_8/5|_1__|14/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 disminuyendola 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 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 cuyo comportamiento está limitado por el procesador, pues se pasan más tiempo asignados al procesador.

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

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.

== 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 mayor 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.

Modelos de Diseño de Sistemas Operativos

2011-03-22T21:45:22Z

JDomingo: errata

= Modos de operación del procesador =

Para entender los modelos de diseño de los sistemas operativos, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador indica que conjunto de instrucciones y a qué recursos del procesador se puede acceder en un cierto instante de tiempo.

En la actualidad, un procesador ofrece como mínimo dos modos de operación que son:

* Modo supervisor, que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador.
* Modo usuario, que tiene algunas restricciones de acceso a aspectos del procesador o de ejecución de instrucciones.

= Núcleo del sistema operativo =

El núcleo del sistema operativo, también conocido por la terminología inglesa ''kernel'', es la parte más esencial del sistema operativo. Se trata de la capa visible de software más baja del sistema y provee y gestiona de forma segura los recursos del sistema a través de las llamadas al sistema.

El núcleo de un sistema operativo suele operar en modo supervisor. Al operar en dicho modo un error de programación en el núcleo del sistema operativo puede resultar en un error fatal del cual el sistema sólo puede recuperarse mediante el reinicio del sistema. A tal error fatal también se le conoce en los sistemas operativos UNIX por la locución inglesa ''[http://es.wikipedia.org/wiki/Kernel_panic kernel panic]''.

= Tipos de Sistemas Operativos =

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidad implementada en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* Monolíticos: son núcleos de gran tamaño con poca modularidad y flexibilidad pero con una gran cantidad de funcionalidades, las cuales son normalmente compiladas junto al núcleo en el mismo momento.
* Micronúcleos: son núcleos de pequeño tamaño que fueron compilados sólo con las necesidades más básicas del sistema operativo. El resto de funcionalidades son añadidas mediante la adición de módulos externos al núcleo, lo que les proporciona flexibilidad y facilidad de ampliación en detrimento del desempeño necesario para la gestión dinámica de éstos.

No obstante, existen tipologías híbridas o que acentúan algunos aspectos, que también detallamos en esta sección.

[[Imagen:OS-structure2.svg|880px| Comparativa de distribución de funcionalidades entre distintos tipos de SO]]

== Sistemas operativos Monolíticos ==

Los sistema operativos monolíticos se caracterizan por emplear un núcleo que implementa la planificación de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida. Por tanto, a mayor funcionalidad implementada en el núcleo, mayor número de líneas de código que se ejecutan en modo supervisor.

Los sistemas operativos monolíticos son los predominantes hoy día, algunos ejemplos son:

* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, al emplear un núcleo que incluye gran parte de las funcionalidades básicas del sistema operativo, dispone de un alto número de líneas de código ejecutándose en modo supervisor. Por ello, un error de programación en el núcleo puede provocar un ''kernel panic''. Además el hecho de añadir nuevas funcionalidades provocaría una nueva recompilación del núcleo llevando a reiniciar el sistema para que se apliquen los nuevos cambios.

Como principal ventaja, los sistemas operativo monolíticos ofrecen un alto rendimiento puesto que las peticiones entre los diferentes componentes se reducen a invocaciones de funciones.

== Sistemas operativos Micronúcleo ==

También conocidos como sistemas operativos exokernel o exonúcleo, se caracterizan por disponer de un núcleo que implementa únicamente:

* Planificación de procesos
* Mecanismo de comunicación entre procesos
* Gestión de interrupciones

Además, existen procesos servidores que están fuera del núcleo, que se ejecutan en modo usuario del procesador, y que implementan la:

* Administración de memoria principal
* Administración de ficheros
* Gestión de dispositivos de entrada/salida.

Siguiendo este esquema, cuando un proceso cualquiera solicita un servicio a través de una llamada al sistema, el micronúcleo canaliza la petición al proceso servidor correspondiente. Dicha comunicación se realiza mediante mensajería.

La principal ventaja de los sistemas operativos micronúcleo es que, al ejecutar menos líneas de código en modo supervisor, de manera intuitiva son más fiables. Otras ventajas son que se garantiza el aislamiento de las partes que estan fuera del nucleo, como los modulos son independientes unos de otros, si cae alguno de ello los demas no se ven afectados y pueden seguir funcionando.

Sin embargo, el principal problema que presentan es el rendimiento, puesto que cualquier petición requiere mensajería, que lleva consigo un coste extra debido a la construcción de los mensajes, el reparto y la interpretación. Son estos problemas relacionados con el rendimiento los que hacen que no existan sistemas operativos micronúcleo desplegables en productivo, a excepción de Minix 2, que tiene propósitos educativos.

== Sistemas basados en Máquinas Virtuales ==

Implementan el material (hardware) en el software. Algunos sistemas operativos ofrecen técnicas de paravirtualización.

Paravirtualización: técnica de programación que ofrecen algunos SO anfitrión para facilitar la virtualización y el rendimiento de máquinas virtuales. Ofrecen llamadas directas al sistema
o acceso a una API especial del anfitrión para acceder directamente a los recursos. Observamos que se deposita una gran confianza en los procesos de la VM por motivos de rendimiento.

* Ventajas de las Máquinas Virtuales

** Ahorro de coste material.
** Se pueden tener diferentes SO en un mismo sistema.
** Se adapta a las necesidades de usuario.
** Se puede deslocalizar la máquina virtual (deslocalización: migrar a otro SO sin sufrir ningún cambio ).

* Desventajas de las Maquinas Virtuales

** Rendimiento (KVM + paravirtualizacion 10%).
** Punto único de fallos(si falla algún componente y las aplicaciones están montadas en él provoca un fallo general).

= Otro material a consultar =

El estudiante puede encontrar el siguiente material de interés para complementar sus conocimientos:

* Debate entre Linus Torvalds, creador del núcleo Linux, que sigue el paradigma monolítico y Andrew S. Tanembaum, creador de Minux, que sigue el modelo micronúcleo: http://oreilly.com/catalog/opensources/book/appa.html (en inglés).

Llamadas al sistema

2011-03-22T21:32:31Z

JDomingo: /* Compatibilidad hacia atrás y hacia delante */ d

Las llamadas al sistema son el conjunto de instrucciones de medio-bajo nivel pertenecientes al sistema operativo que proveen a los programas de recursos y funciones de software y hardware que generalmente necesitan de una gestión especial por ser recursos compartidos por otros programas y procesos.

=Compatibilidad hacia atrás y hacia delante=

En un sistema operativo bien diseñado la interfaz de las llamadas al sistema han de ser ser estables a lo largo del tiempo, de forma que la modificación de su funcionamiento interno no repercuta en el funcionamiento externo de estás para asegurar la compatibilidad hacia atrás([http://en.wikipedia.org/wiki/Backward_compatibility Backward compatibility]). Además, aquellas llamadas que queden obsoletas o en desuso han de ser conservadas para, de la misma manera, asegurar el funcionamiento de programas antiguos ([http://en.wikipedia.org/wiki/Legacy_system?=Legacy_support Legacy Support]).

En ocasiones los sistemas operativos pueden incluir en su diseño criterios de compatibilidad hacia adelante([http://en.wikipedia.org/wiki/Forward_compatibility Fordward compatibility]). Un ejemplo de este tipo de sistemas son aquellos capaces de mostrar información detallada al usuario de aquello que no pueden comprender o los sistemas ignorantes, que son aquellos que solo ejecutan lo que pueden comprender y obvian el resto.

Llamadas al sistema

2011-03-22T21:28:16Z

JDomingo:

Las llamadas al sistema son el conjunto de instrucciones de medio-bajo nivel pertenecientes al sistema operativo que proveen a los programas de recursos y funciones de software y hardware que generalmente necesitan de una gestión especial por ser recursos compartidos por otros programas y procesos.

=Compatibilidad hacia atrás y hacia delante=

En un sistema operativo bien diseñado la interfaz de las llamadas al sistema han de ser ser estables a lo largo del tiempo, de forma que la modificación funcionamiento interno de no repercuta en el funcionamiento externo de estás para asegurar la compatibilidad hacia atrás([http://en.wikipedia.org/wiki/Backward_compatibility Backward compatibility]). Además, aquellas llamadas que queden obsoletas o en desuso han de ser conservadas para, de la misma manera, asegurar el funcionamiento de programas antiguos ([http://en.wikipedia.org/wiki/Legacy_system?=Legacy_support Legacy Support]).

En ocasiones los sistemas operativos pueden incluir en su diseño criterios de compatibilidad hacia adelante([http://en.wikipedia.org/wiki/Forward_compatibility Fordward compatibility]). Un ejemplo de este tipo de sistemas son aquellos capaces de mostrar información detallada al usuario de aquello que no pueden comprender o los sistemas ignorantes, que son aquellos que solo ejecutan lo que pueden comprender y obvian el resto.

Usuario:JDomingo

2011-02-21T15:43:52Z

JDomingo: Página nueva: José Domingo García Torrejón

José Domingo García Torrejón

Usuario discusión:JDomingo

2011-02-21T15:43:21Z

JDomingo: Página blanqueada

Usuario discusión:JDomingo

2011-02-21T15:42:35Z

JDomingo: Página nueva: José Domingo García Torrejón

José Domingo García Torrejón