Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Sol 7

2011-06-14T09:38:30Z

Marmaclar:

___1____ 2_____3_____4___
1º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1 Cola = 2-
Pagina 2 |_R=1_|_R=0_|_R=0_|_R=0_|
2º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1 Cola = 2-
Pagina 2 |_R=1_|_R=0_|_R=0_|_R=0_|
3º Acceso | | | | |
Acceso a: | 2 | 3 | | | Nª de fallos: 2 Cola = 2-3
Pagina 3 |_R=1_|_R=1_|_R=0_|_R=0_|
4º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3 Cola = 2-3-1
Pagina 1 |_R=1_|_R=1_|_R=1_|_R=0_|
5º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3 Cola = 2-3-1
Pagina 1 |_R=1_|_R=1_|_R=1_|_R=0_|
6º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3 Cola = 2-3-1
Pagina 3 |_R=1_|_R=1_|_R=1_|_R=0_|
7º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | 4 | Nª de fallos: 4 Cola = 2-3-1-4
Pagina 4 |_R=1_|_R=1_|_R=1_|_R=1_|
8º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5 Cola = 3-1-4-5
Pagina 5 |_R=1_|_R=0_|_R=0_|_R=0_|
9º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5 Cola = 3-1-4-5
Pagina 1 |_R=1_|_R=0_|_R=1_|_R=0_|
10º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5 Cola = 3-1-4-5
Pagina 1 |_R=1_|_R=0_|_R=1_|_R=0_|
11º Acceso | | | | |
Acceso a: | 5 | 2 | 1 | 4 | Nª de fallos: 6 Cola = 1-4-5-2
Pagina 2 |_R=1_|_R=1_|_R=1_|_R=0_|
12º Acceso | | | | |
Acceso a: | 5 | 2 | 1 | 3 | Nª de fallos: 7 Cola = 5-2-1-3
Pagina 3 |_R=1_|_R=1_|_R=0_|_R=1_|
13º Acceso | | | | |
Acceso a: | 5 | 2 | 4 | 3 | Nª de fallos: 8 Cola = 3-5-2-4
Pagina 4 |_R=0_|_R=0_|_R=1_|_R=1_|

--[[Usuario:Jherrera|Jherrera]] 09:34 14 jun 2011 (UTC)

Nota:la cola que se utiliza es por orden de carga como una FIFO.

[[Criterios_de_reemplazo|Volver]]

Ejercicios memoria virtual

2011-06-11T00:11:45Z

Marmaclar:

== Ejercicio 1 ==

Dada la siguiente secuencia de accesos a páginas:

1, 1, 1, 2, 3, 4, 5, 3, 1, 2, 3, 4
r, r, w, r, r, r, r, w, w, w, r, r

Suponiendo un sistema con un administrador de memoria teórico con cuatro marcos disponibles.

Elabore el cronograma que represente la evolución de la relación páginas/marcos a lo largo del tiempo. Además, calcule la tasa de fallo de página para los siguientes criterios:

* FIFO
* NRU (considere que el periodo de puesta a cero del bit R tiende a infinito, es decir, nunca se pone a cero)
* NRU con segunda oportunidad
* LRU
* LFU
* Sustitución por envejecimiento

Ver [[solución ejercicio 1 memoria virtual|Solución]] de este ejercicio.

== Ejercicio 2 ==

Dada la siguiente secuencia de accesos a páginas:

1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6

Suponiendo un sistema con un administrador de memoria teórico con cuatro marcos disponibles.

Elabore el cronograma que represente la evolución de la relación páginas/marcos a lo largo del tiempo. Además, calcule la tasa de fallo de página para los siguientes criterios:

* MRU
* LRU

Responda brevemente, ¿cuál de los dos ofrece mejor solución en este caso? ¿por qué?

Ver [[solución ejercicio 2 memoria virtual|Solución]] de este ejercicio.

== Ejercicio 3 ==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponga un sistema con un administrador de memoria teórico con cuatro marcos disponibles. Elabore el cronograma que represente la evolución de la relación páginas/marcos a lo largo del tiempo. Considere una situación de arranque en frío. Además, calcule la tasa de fallo de página. Todo ello para los siguientes criterios:

'''A)''' NRU (en caso de empate LRU).

{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
|+ align="center" style="background:DarkSlateBlue; color:white"|'''Acceso a página'''
!Marco
!1(r)
!3(r)
!3(w)
!3(r)
!4(r)
!5(r)
!1(r)
!2(w)
!5(w)
!1(w)
!3(r)
!4(r)
|-
|1
|
|
|
|
|
|
|
|
|
|
|
|
|-
|2
|
|
|
|
|
|
|
|
|
|
|
|
|-
|3
|
|
|
|
|
|
|
|
|
|
|
|
|-
|4
|
|
|
|
|
|
|
|
|
|
|
|
|-
|FP
|
|
|
|
|
|
|
|
|
|
|
|
|}

tasa de fallo de página=

'''B)''' Sustitución por envejecimiento (En caso de empate LRU). Úsese 3 bits de historia y hágase una puesta a cero cada cuatro accesos.

{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; width:500px; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
|+ align="center" style="background:DarkSlateBlue; color:white"|'''Acceso a página'''
!Marco
!2
!3
!3
!1
!4
!5
!4
!1
!5
!2
!3
!4
|-
|1
|
|
|
|
|
|
|
|
|
|
|
|
|-
|2
|
|
|
|
|
|
|
|
|
|
|
|
|-
|3
|
|
|
|
|
|
|
|
|
|
|
|
|-
|4
|
|
|
|
|
|
|
|
|
|
|
|
|-
|FP
|
|
|
|
|
|
|
|
|
|
|
|
|}

tasa de fallos de página=

(''[[Solución de los ejercicios de memoria virtual#Ejercicio 3|Ver solución]]'')

PD: Podrian colocar todos los ejercicios del examen C3, y aquel que sepa las soluciones que las coloque si es tan amable

Ejercicios de paginación y segmentación

2011-06-11T00:11:11Z

Marmaclar:

==Ejercicio 1==

El proceso ocupa: 1 KB de código, 4 KB de pila, 5KB ctes+globales

*Paginación pura (4KB de páginas) = 4 páginas -> 16 KB
El código requiere 1 página
La pila otra al completo
Las globales necesitan 2

*Segmentación pura = 3 segmentos, ocupan 10KB
El codigo ocupa un segmento de 1 KB
La pila uno de 4 KB
Para globales es otro de 5KB

*Combinado = 1 segmento de 4 páginas -> 16 KB

== Ejercicio 2==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponga un sistema operativo con un administrador de memoria paginada cuyo tamaño de página es de 8KB. Se conoce que el sistema operativo funciona sobre un procesador cuyo tamaño de palabra es de 64 bits.

'''A)''' Calcule el tamaño máximo que puede llegar a alcanzar la tabla de página de un proceso, suponiendo que cada entrada de la tabla de páginas ocupa 128 bits.

'''B)''' Calcule cuántas páginas puede llegar a ocupar como máximo la tabla de páginas.

'''C)''' Dado un proceso en ejecución que requiere 7 Mbytes, clacule cuántas entradas de la tabla de páginas están siendo empleadas por dicho proceso en el sistema descrito anteriormente.

(''[[Solución de los ejercicios de paginación y segmentación#Ejercicio 2|Ver solución]]'')

PD: Podrian colocar todos los ejercicios del examen C3, y aquel que sepa las soluciones que las coloque si es tan amable.

Solución ejercicio 1 memoria virtual

2011-06-07T09:15:01Z

Marmaclar: /* Sustitución por envejecimiento 1 */

= FIFO =
accesos a páginas
-------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
---------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | = | = | 1 | = | = | = |
--------------------------------------------------------------------------------
| 3 | | | | | 3 | = | = | = | = | 2 | = | = |
---------------------------------------------------------------------------------
| 4 | | | | | | 4 | = | = | = | = | 3 | = |
---------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | X | X | X | X |
página -------------------------------------------------------------------------

tiempo ->

9
talla de fallos de página = ------ = 0.75
12

= NRU =

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

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

tiempo ->

7
talla de fallos de página = ------ = 0.583
12

= NRU con 2º oportunidad =

accesos a páginas

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

tiempo ->

8
talla de fallos de página = ------
12

Creo que es asi, pero no me lo tomeis a pies juntillas que no estoy muy seguro.

= LRU =

accesos a páginas
-------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
---------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | = | = | 1 | = | = | = |
--------------------------------------------------------------------------------
| 3 | | | | | 3 | = | = | = | = | = | = | = |
---------------------------------------------------------------------------------
| 4 | | | | | | 4 | = | = | = | 2 | = | = |
---------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | X | X | | X |
página -------------------------------------------------------------------------

tiempo ->

8
talla de fallos de página = ------
12

= LFU =

accesos a páginas

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

tiempo ->

7
talla de fallos de página = ------
12

Duda!! Al quitar un elemento, se resetea su contador? yo he tomado que no..alguien sabe si debe permanecer su valor anterior?

Debería resetearse, no vamos a tener una estructura para guardar el contador de todas las páginas borradas, es una locura. --[[Usuario:Joscamsos|Joscamsos]] 08:47 7 jun 2011 (UTC)

= Sustitución por envejecimiento =

Periodo de 4, registro R de 3 bits, desempate: FIFO

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

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

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

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

9
tasa fallos pág = ----
13
Creo que está solución es correcta, la victima es el menor R, y he aplicado FIFO en caso de empate.
--[[Usuario:Marmaclar|Marmaclar]] 09:15 7 jun 2011 (UTC)

Solución ejercicio 1 memoria virtual

2011-06-07T09:12:41Z

Marmaclar: /* Sustitución por envejecimiento */

Solución ejercicio 3

2011-05-09T16:32:10Z

Marmaclar:

La solución no es correcta, ya que se bloquearía el proceso que ejecuta el while del productor y también el del consumidor, y no se avanzaría en la ejecución.
Sería correcto si el semáforo del productor se inicializara a 1.

También habría que asegurar que el proceso P1 comenzará antes que P2, no??
Por lo que seguro que funcionaria con el contador de P1 igual a 1, y contador de P2 igual a 0, no??

R:Creo que no, ya que en caso de que empieze por P2 bloquea a la espera de que algún proceso haga un UP sobre dicho semáforo.

Los procesos son lanzados y tu no sabes a priori qué proceso se va a ejecutar, por lo que tienes que asegurarte que si se ejecuta el consumidor antes que el productor pase a estado bloqueado. Creo que la solución ,tal y como se dice el compañero al principio, es modificar el contador del productor poniendolo a 1.--[[Usuario:Jherrera|Jherrera]]

Lo que he intentado dar a entender en (R:Creo que no, ya que en caso de que empieze por P2 bloquea a la espera de que algún proceso haga un UP sobre dicho semáforo) es lo que tu dices Jherrera.

Solución ejercicio 3

2011-05-09T16:08:32Z

Marmaclar:

Solución ejercicio 3

2011-05-09T15:08:10Z

Marmaclar: Página nueva: La solución no es correcta, ya que se bloquearía el proceso que ejecuta el while del productor y también el del consumidor, y no se avanzaría en la ejecución. Sería correcto si ...

Condiciones para el interbloqueo y estrategias de resolución

2011-04-27T18:27:55Z

Marmaclar: /* Condiciones */

== Condiciones ==

En la política del sistema operativo deben darse una serie de condiciones para que se produzca un interbloqueo.

* '''Exclusión mutua''': cada recurso está asignado a un único proceso o está disponible.

* '''Retención y espera''': los procesos que tienen, en un momento dado, recursos asignados con anterioridad, pueden solicitar nuevos recursos.

* '''No apropiación''': los recursos otorgados con anterioridad no pueden ser forzados a dejar un proceso. El proceso que los posee debe liberarlos en forma explícita.

* '''Espera circular''': debe existir una cadena circular de dos o más procesos, cada uno de los cuales espera un recurso poseído por el siguiente miembro de la cadena. Esta condición es una consecuencia potencial de las tres primeras, es decir, dado que se producen las tres primeras condiciones, puede ocurrir una secuencia de eventos que desemboque en un círculo vicioso de espera irresoluble.

Las tres primeras condiciones son necesarias, pero no suficientes para que exista interbloqueo. Sólo las cuatro condiciones en conjunto constituyen una condición necesaria y suficiente para el interbloqueo.

== Estrategias ==

=== Omisión ===

Consiste en suponer que los programadores lo han hecho bien, y obviar las posibles situaciones de interbloqueo. Es la más usada.

=== Detección y Recuperación ===

* '''Detección'''
** '''Grafo de relación recursos-procesos'''
** '''Matrices de relación recursos-procesos'''

* '''Recuperación'''
** '''Apropiación temporal'''
** '''Checkpoints''': Durante la ejecución de los procesos se toma una "foto" del estado de éstos, de manera que si se produce un interbloqueo se vuelve al estado anterior. Son muy poco usados ya que tienen un elevado coste en memoria y existe la posibilidad de que un proceso esté indefinidamente sin progresar.
** '''Eliminación''': El SO elimina un proceso en base a unos determinados criterios. Aunque parezca una medida drástica, es usada con frecuencia.

=== Prevención ===

* '''Supresión de exclusión mutua'''
* '''Supresión de retención y espera''': El proceso debe tener asignado todos los recursos necesarios al inicio y no liberarlos hasta que éste finalice. Esto hace que si por ejemplo un recurso sólo se utiliza al final, esté ocupado durante toda la ejecución, no permitiendo ser usado por otros procesos.
* '''Supresión de no apropiación''': El proceso libera todos los recursos que está usando y espera a que todos los que necesita estén disponibles
* '''Supresión de espera circular'''

=== Predicción ===

El sistema operativo observa la evolución que siguen los procesos, e intenta anticiparse a los futuros conflictos

Usuario:Marmaclar

2011-03-28T14:57:37Z

Marmaclar: Página nueva: Mario Macías Lara

Mario Macías Lara

Concurrencia de procesos

2011-03-28T14:56:47Z

Marmaclar:

=Formas de interacción entre procesos=
Hay dos formas de interacción entre los procesos :
* Relaciones de Concurrencia : los procesos A y B tienen objetivos diferentes y compiten por los recursos para conseguirlos.

* Relaciones de Cooperación : los procesos A y B tienen un mismo objetivo y ''se ponen de acuerdo'' a la hora de emplear los recursos existentes para alcanzarlos.

El sistema operativo ofrece mecanismos que los procesos pueden emplear para arbitrar el acceso a los recursos.

=Mecanismos de arbitraje=
Los mecanismos de arbitraje que ofrece el sistema operativo son :
* Sincronización: el sistema operativo ofrece mecanismos que permiten a los procesos coordinar la ejecución para conseguir su objetivo en armonía (y no de manera indeseada).
* Mensajería: el sistema operativo ofrece mecanismos de comunicación basados en mensaje.

=Programación concurrente=
La programación concurrente consiste en el conjunto de técnicas que nos permite la elaboración de programas que emplean alguno de los mecanismos de arbitraje, basados en sincronización o mensajería, para resolver situaciones de concurrencia o cooperación.

=Tipos de mecanismos de sincronización=
*Optimista: se considera que la frecuencia de acceso a un recurso compartido es ''baja''.
*Pesimista: se considera que la frecuencia de acceso a un recurso compartido es ''alta''.

Es el programador el que tiene que tomar una de estos mecanimos a la hora de realizar su programa.

Modelos de Diseño de Sistemas Operativos

2011-03-28T13:29:51Z

Marmaclar: /* Sistemas operativos Monolíticos */

= 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, el sistema de comunicación de procesos, el sistema de sincronizacion 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).

Discusión:Sol-ejer3-planif-procesos

2011-03-22T16:12:55Z

Marmaclar: Página blanqueada

Sol-ejer3-planif-procesos

2011-03-22T16:12:44Z

Marmaclar:

= Ejercicio 3 =

____|_PA_|_PB_|_PC_|_PD_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _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 | | | < |---|---| | | | | | |---|---|---|---| | | | |---|---|---|---| | |---|---> | | | |
PlnfX X X | X | X X X | | | X | | | X | | | X | | | X | X | X X X X X
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|_> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

_____|_PA_|_PB_|_PC_|_PD_|
Cálculos __t__|_4__|_4__|_12_|_12_|
de tiempos __T__|_31_|_31_|_24_|_25_|
_T/t_|7.75|7.75|_2__|2.08|

-Observaciones

Por que ejecutas seguidamente los procesos C y D seguidamente, ¿la cola 1 solo se ejecuta 1 vez y pasa a la 2ª o varias veces hasta que se agotan los procesos? ¿qué opináis?

Yo creo que la cola 1 tiene mas prioridad que la cola 2 y por eso se ejecutan los procesos de la cola 1 hasta que no queden más pero no estoy totalmente seguro de que sea así. No se si cuando se ejecutan los procesos de la cola 1 al pasar a preparados otra vez entran en la 2 o se quedan en la 1 yo supongo lo segundo

Yo también estoy de acuerdo con la repetitividad de C y D debido a la prioridad superior de la cola 1.
En respuesta a ¿dónde se quedan los procesos de la cola 1?, en el enunciado te comentan:
-Si el proceso está en la cola 2 y agota el quantum, pasa a la cola 1, en caso contrario, sigue en la cola 2.
-Si el proceso está en la cola 1 y agota el quantum, se mantiene en ella, pero si no lo agota completamente vuelve a la cola 2.

¿Cuanto tiempo es el bloqueo por E/S?

Sol-ejer3-planif-procesos

2011-03-22T16:11:27Z

Marmaclar:

Discusión:Sol-ejer3-planif-procesos

2011-03-22T16:10:36Z

Marmaclar: Página nueva: ¿Cuanto tiempo es la penalizacion por E/S?

¿Cuanto tiempo es la penalizacion por E/S?

Planificación en sistemas multiprocesadores

2011-03-21T17:02:54Z

Marmaclar:

En este tipo de sistemas disponemos de n (n>=2) procesadores, siendo los criterios de planificación los mismos seguidos hasta ahora pero contando con más de un procesador.
Hay que considerar que la asignación del proceso a un procesador puede ser
* Estática : en la que el proceso es asignado siempre a dicho procesador mientras este no haya terminado su ejecución.
* Dinámica : en la que se permite la migración del procesador o balanceo de carga.

Se utiliza principalmente la estática debido al principio de localidad espacial y temporal, cuando un proceso se carga en un procesador se carga en caché los datos más frecuentes accedidos por el proceso. Si cambiamos de procesador a dicho proceso habría que cargar de nuevo los datos en la caché del otro procesador.

Planificación de procesos

2011-03-21T16:28:33Z

Marmaclar: /* Aspectos para diseñar un buen criterio de planificación */

Todo planificador de procesos emplea uno o varios criterios (''scheduling policy'', en inglés) que determinan el criterio de selección del proceso que empleará el procesador.

== Aspectos para diseñar un buen criterio de planificación ==

Además de ofrecer un alto rendimiento (throughput) y una baja latencia (latency) propia de un buen planificador, debe cumplir las siguientes características:

*'''Repetitividad''' : con cargas de trabajo (cantidad de procesos a atender) similares, el procesador debe tener comportamientos similares.
*'''Predecibilidad''' : hace referencia al tiempo de terminación de un proceso para cierta carga de trabajo, deben ser similares con cargas de trabajo parecidas.
*'''Eficiencia''' : debe tomar decisiones rápidas para aumentar el rendimiento.
*'''Reducir el número de conmutaciones''' : de nuevo, para aumentar el rendimiento y reducir la penalización asociada.
*'''Atender prioridades'''.
* A mayores cargas de trabajo el rendimiento debe '''degradar uniformemente'''.
* Tiempos de espera para atender a un proceso debe ser aceptable (<100ms).

Planificación de procesos de tiempo real

2011-03-21T15:34:21Z

Marmaclar: /* Clasificación */

== ¿Qué es un proceso de tiempo real? ==

Proceso de tiempo real se denomina a aquella actividad que debe ser realizada en un plazo de tiempo, si la actividad no es realizada en dicho plazo de tiempo carece de sentido realizarla. Ej: Actividades industriales, videoconferencias, etc

== Clasificación ==

Podemos clasificar los procesos de tiempo real de diferentes maneras:

Segun el plazo de tiempo:
*'''Rígidos(''hard-realtime'')''' : se debe realizar en un plazo de tiempo estricto, sino deja de tener sentido. Si el plazo de tiempo para realizarla es superado el proceso se aborta. Ejemplo: Industriales ( sensores, activadores,...).

*'''Flexibles(''soft-realtime'')''' : es deseable que se cumpla el plazo de tiempo. Ej: Videoconferencia.(Contra mas rapido vaya mejor sera la comunicacion , pero si no , nos adaptamos a ella)

*'''Opcionales''' : conviene hacerla en el plazo de tiempo, pero sino es posible se puede posponer.

Segun la periodicidad:

*'''Aperiódicas''' : se deben a sucesos externos que deben ser atendidos. El sistema operativo no sabe, a priori, cuando van a llegar ni el tiempo que va a durar. Ej: Notificaciones de errores, Sensores de emergencia en un coche, Ventiladores para refrigeracion.

*'''Periódicas''' : se realizan cada cierto tiempo (actividad repetitiva).A diferencia del anterior el sistema operativo conoce a priori cuando van a llegar y su tiempo de duración Ej: leer una temperatura de un sensor.

== Métodos de planificación ==

Los métodos de planificación a utilizar en SSOO de tiempo real son:

*Planificación apropiativa con prioridad estática.

*Planificación de tablas estáticas : se conocen las actividades a realizar y se elabora un plan fijo de ejecución.

*Planificación dinámica: Es muy parecida a la de tablas estaticas , pero tambien admite actividades aperiodicas.

*Planificación dinámica con un mejor resultado: Las actividades fuera de plazo se abortan.

Criterios de planificación

2011-03-16T14:37:30Z

Marmaclar: /* Turno rotatorio con compensación */

= 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 repetitibilidad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.

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 lanzamiento. Su principales ventajas son su facilidad de implementación, y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración presentarán un alto índice de penalización.

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. Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Su orden de complejidad es O(n).

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__|_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 y elige el de mayor valor. Su orden de complejidad es O(n).

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_2__|_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
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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>---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Cálculos _t__|_3__|_5__|_4__|_3__|_5__|
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|
z(3)|_1__|_'''2/5'''|_0/4|____|____|
z(8)|_1__|_7/5|_'''5/4'''|_1/3|_2/5|
z(12)|_1__|_7/5|_9/4|_5/3|_'''6/5'''| z = índice de penalización
z(17)|_1__|_7/5|_9/4|'''10/3'''|11/5|
z(20)|_1__|_7/5|_9/4|13/3|11/5|

= Métodos apropiativos =

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

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

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.

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|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 '''quantuam''' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .

Si un proceso bloquea antes de consumir su '''quantum''', como sucede con proceso cuyo comportamiento está limitado por operaciones de entrada/salida, se añade al final de la cola. Esto beneficia a los procesos cuyo comportamiento está limitado por el procesador.

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

Qué es un Sistema Operativo

2011-03-14T15:47:26Z

Marmaclar: /* ¿Que es un Sistema Operativo? */

== ¿Que es un Sistema Operativo? ==
* El programa de programas.

* Gestiona los recursos que ofrece el material (el ''hardware'' del equipo):
** La CPU.
** La Memoria principal
** Los dispositivos de Entrada/Salida, tales como la tarjeta de vídeo, la de red, los dispositivos de almacenamiento masivo (disco duro, memoria flash), los dispositivos USB, teclado, ratón...

* Ofrece un lanzador de aplicaciones, que puede ser de dos tipos:
** Gestor de ventanas: las órdenes se dan con el ratón.
** Intérprete de órdenes/comandos (traducción defectuosa del original inglés ''command'', que significa orden), también llamado ''shell''. Las órdenes se escriben con el teclado.

* Ofrece una interfaz (API) a las aplicaciones para solicitar recursos, el SO hace de intermediario, el programa no accede al hardware directamente a obtener los recursos, sino que se los solicita al SO. Esta interfaz ha de ser estable (es decir, que no cambie con el tiempo)y homogenea.

== Principios de diseño de un buen Sistema Operativo ==

Los aspectos a tener en cuenta respecto a la gestión de recursos son:

* Realizar una gestión eficiente de los recursos
* Coordinar la asignación de los mismos (como un "director de orquesta")
* Hacer un reparto equitativo de ellos

Respecto a la API, debe:

* Ser estable, no debe cambiar con el tiempo.
* Ser homogénea.
* Ocultar los detalles de bajo nivel de los componentes, ofreciendo una capa de abstracción sobre el material.

Además, otro criterio a tener en cuenta por un buen sistema operativo es la portabilidad, es decir, que soporte diferentes arquitecturas, como por ejemplo la ARM (teléfonos móviles), la x86 de Intel, la SPARC (desarrollada por Sun Microsystems, ahora adquirida por Oracle), la PowerPC (creada por la alianza AIM: Apple-IBM-Motorola)...