Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Página con listado de personas que han contribuido

2012-01-26T15:23:34Z

Sergaralo:

A continuación, la lista de usuarios/as de la Universidad de Sevilla que han contribuido a la wiki. Si ponéis tu usuario/a estás solicitando al profesor que evalúe tus contribuciones a la wiki para la subida de notas de hasta 2 puntos posible:

* luigarhor
* rafperper
* sergaralo

Ejercicios de Entrada/Salida

2012-01-23T15:50:32Z

Sergaralo:

== Ejercicio 1 ==
''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2011/12, del 23 de Enero de 2012]''

Suponiendo que el procesador está asignado a un proceso en ejecución, por tanto, es estado activo, qué sucede cuando un dispositivo indica al procesador mediante una interrupción que dispone de datos a ser tratados? Marque la opción pertinente.

A) Se continúa con la ejecución del proceso activo hasta que éste pase a estado bloqueado, entonces se realizar el tratamiento de la interrupción, que consistirá en invocar al gestor de dispositivo para que realice el tratamiento oportuno.

B) Se retira el proceso activo, que pasará a estado preparado, y se ejecutará el código del gestor de dispositivos.

C) Se invoca al planificador de procesos para que evalúe si tiene mayor prioridad la interrupción o el proceso.

''([[Solución de los ejercicios de Entrada/Salida#Ejercicio 1|Ver solución]])''

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

''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2011/12, del 23 de Enero de 2012]''

Represente gráficamente el diseño modular basado en capas de E/S de un sistema operativo. Incluya una breve descripción de cada capa junto con flechas que reflejen el flujo de comunicación entre cada una de ellas.

''([[Solución de los ejercicios de Entrada/Salida#Ejercicio 2|Ver solución]])''

Ejercicios de Entrada/Salida

2012-01-23T15:50:07Z

Sergaralo: /* Ejercicio 2 */

== Ejercicio 1 ==
''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponiendo que el procesador está asignado a un proceso en ejecución, por tanto, es estado activo, qué sucede cuando un dispositivo indica al procesador mediante una interrupción que dispone de datos a ser tratados? Marque la opción pertinente.

A) Se continúa con la ejecución del proceso activo hasta que éste pase a estado bloqueado, entonces se realizar el tratamiento de la interrupción, que consistirá en invocar al gestor de dispositivo para que realice el tratamiento oportuno.

B) Se retira el proceso activo, que pasará a estado preparado, y se ejecutará el código del gestor de dispositivos.

C) Se invoca al planificador de procesos para que evalúe si tiene mayor prioridad la interrupción o el proceso.

''([[Solución de los ejercicios de Entrada/Salida#Ejercicio 1|Ver solución]])''

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

''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2011/12, del 23 de Enero de 2012]''

Represente gráficamente el diseño modular basado en capas de E/S de un sistema operativo. Incluya una breve descripción de cada capa junto con flechas que reflejen el flujo de comunicación entre cada una de ellas.

''([[Solución de los ejercicios de Entrada/Salida#Ejercicio 2|Ver solución]])''

Ejercicios de Entrada/Salida

2012-01-23T15:49:57Z

Sergaralo: /* Ejercicio 2 */ Añadida su aparición en el examen del 23 de enero del 2012

== Ejercicio 1 ==
''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponiendo que el procesador está asignado a un proceso en ejecución, por tanto, es estado activo, qué sucede cuando un dispositivo indica al procesador mediante una interrupción que dispone de datos a ser tratados? Marque la opción pertinente.

A) Se continúa con la ejecución del proceso activo hasta que éste pase a estado bloqueado, entonces se realizar el tratamiento de la interrupción, que consistirá en invocar al gestor de dispositivo para que realice el tratamiento oportuno.

B) Se retira el proceso activo, que pasará a estado preparado, y se ejecutará el código del gestor de dispositivos.

C) Se invoca al planificador de procesos para que evalúe si tiene mayor prioridad la interrupción o el proceso.

''([[Solución de los ejercicios de Entrada/Salida#Ejercicio 1|Ver solución]])''

== Ejercicio 2 ==
''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''
''[Este ejercicio formó parte del cuarto control de Evaluación Continua del curso 2011/12, del 23 de Enero de 2012]''

Represente gráficamente el diseño modular basado en capas de E/S de un sistema operativo. Incluya una breve descripción de cada capa junto con flechas que reflejen el flujo de comunicación entre cada una de ellas.

''([[Solución de los ejercicios de Entrada/Salida#Ejercicio 2|Ver solución]])''

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

2012-01-23T15:48:32Z

Sergaralo: //Solucion ejercicios examen del 23 de enero de 2012

== Ejercicio 1 ==

A) '''Incoherencia nº1:''' Fichero2.txt está asociado a un bloque corrupto, el número 4.

'''Incoherencia nº2:''' Cuando se accede al bloque 7 (correspondiente al archivo Imagen2.jpg), el siguiente en ser accedido es el número 4, que además de estar asociado a otro archivo, está corrupto.

B)
Entrada al directorio raíz E: 1 acceso al bloque 2
Entrada a Imagen.jpg: 1 acceso al bloque 3
Siguiente bloque de Imagen.jpg: 1 acceso al bloque 5
Siguiente bloque de Imagen.jpg: 1 acceso al bloque 6 y final de fichero.
Total: 4 accesos

Mejorada explicación del primer apartado y corregida la del segundo. --[[Usuario:Ferguatol|fernandoenzo]] 16:27 22 ene 2012 (UTC)

== Ejercicio 2 ==

Bloque del i-nodo: 1 acceso
Camino hacia el bloque del doble indirecto: 2 accesos
Acceso al bloque del doble indirecto: 1 acceso
Total: 4 accesos

== Ejercicio 3 ==
c) 5 accesos a bloque
Nos indican que tenemos que acceder al bloque 1035, en EXT2 para poder tener esta cantidad de bloque se necesita usar el doble indirecto.

Tabla de archivo (cuenta como un acceso): 1 acceso
Bloque del i-nodo: 1 acceso
Camino hacia el bloque del doble indirecto: 2 accesos
Acceso al bloque del doble indirecto: 1 acceso
Total: 5 accesos

== Ejercicio 4 ==
EXT2

Ejercicios Administración Ficheros

2012-01-23T15:45:04Z

Sergaralo: //Añadidos ejercicios del examen del 23 de enero del 2012

== Ejercicio 1 ==
''[Este ejercicio fue parte del cuarto Control de Evaluación Contínua del Curso 2010/11, del 8 de junio de 2011]''

El siguiente sistema de ficheros FAT dispone de la siguiente tabla:

{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
!bloque
!etiqueta
|-
| 0
|X
|-
| 1
| X
|-
| 2
| E
|-
| 3
| 5
|-
|4
|BAD
|-
|5
|6
|-
|6
|EOF
|-
|7
|4
|-
|8
|EOF
|}

Donde la tabla de entrada de directorios raíz situada en el bloque 2 contiene:
{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
!Fichero
!Bloque
|-
|Imagen.jpg
|3
|-
|Fichero.txt
|8
|-
|Fichero2.txt
|4
|-
|Imagen2.jpg
|7
|}

A) ¿Encuentra alguna incoherencia en la configuración actual? Justifique brevemente su respuesta.

B) ¿Cuántos accesos a bloque serán necesarios para alcanzar el último bloque del fichero Imagen.jpg? Considere el acceso a bloque que supone la consulta a la tabla de entrada de directorio. Justifique brevemente su respuesta.

(''[[Solución de los ejercicios de administración de ficheros#Ejercicio 1|Ver solución]]'')

== Ejercicio 2 ==
''[Este ejercicio fue parte del cuarto Control de Evaluación Contínua del Curso 2010/11, del 8 de junio de 2011]''

Indique cuántos accesos a bloque hay que realizar para alcanzar un bloque referenciado por el doble indirecto de un i-nodo. Considere que un i-nodo ocupa un bloque.

(''[[Solución de los ejercicios de administración de ficheros#Ejercicio 2|Ver solución]]'')

== Ejercicio 3 ==
''[Este ejercicio fue parte del cuarto Control de Evaluación Contínua del Curso 2011/12, del 23 de Enero de 2012]''
En un sistema de archivo EXT2, para acceder al bloque 1035 de un archivo cuantos accesos a bloque hay que realizar. Cuente el acceso a la tabla de archivo como un acceso a bloque.

a) 4 accesos a bloque

b) 3 accesos a bloque

c) 5 accesos a bloque

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

== Ejercicio 4 ==
''[Este ejercicio fue parte del cuarto Control de Evaluación Contínua del Curso 2011/12, del 23 de Enero de 2012]''
Un administrador de sistema tiene que elegir que sistema de archivo usar entre FAT16, FAT32 y EXT2 para un sistema como mucho archivos pequeños y multitud de accesos aleatorios. Elige cual es la mejor opción.

(''[[Solución de los ejercicios de administración de ficheros#Ejercicio 2|Ver solución]]'')

Solución de los ejercicios de memoria virtual

2012-01-03T17:17:23Z

Sergaralo: /* NRU */ Errata

= NRU =

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

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

tiempo ->

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

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

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

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

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

Introducción histórica

2011-11-08T12:43:53Z

Sergaralo: /* 1.2. Introducción histórica a los SSOO */ Errata en PDP-1

= 1.2. Introducción histórica a los SSOO =

En 1940, durante la 2º Guerra Mundial, se inicia la primera generación de ordenadores con el [http://es.wikipedia.org/wiki/ENIAC ENIAC] (1943-1945), desarrollado en EEUU. Y posteriormente, en 1949, el [http://es.wikipedia.org/wiki/EDSAC EDSAC], desarrollado en Inglaterra.

Más tarde, se desarrollarían los primeros lenguajes de programación y los primeros ordenadores comerciales, como el IBM 701, 702 y el 650, utilizados principalmente para el cálculo científico en aplicaciones de gestión. También se crearían otros ordenadores como el UNIVAC I o el MARK I (Harvard Mark I).

Máquinas relevantes:

*ENIAC:
**Máquina de cálculo completamente electrónica.
**Arquitectura no Von-Neumann.
**17468 lámparas.
**20 registros de 10 lámparas para representar el BCD.
*EDSAC:
**Primera máquina con arquitectura Von Neumann.
**Programada en lenguaje ensamblador.
*Primeras máquinas comerciales (a partir de 1951):
**Univac I y Mark I
**IBM 701
**IBM 702 e IBM 650

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

*Durante la 2º Generación de Ordenadores, una generación en donde los equipos eran más fiables, se crearía el primer germen de sistemas operativos, que lo que quería conseguir era un programa para reservar memoria y automatizar ciertas tareas (como por ejemplo lecturas de cintas magnéticas).

-Máquinas relevantes

A) TRADIC:
* Ordenador completamente transistorizado.
* Suficientemente pequeño para montarse en un B-52.
* Primera unidad destinada a venta: 1958.
B) IBM 7094
* Memoria: 32K-palabras de 32 bits.
* Potencia de cálculo: 0,35MIPS.
C) PDP-1:
* Uno de los primeros micro-computadores
* 4K-palabras de 18 bits
* Precio: 5% de IBM 7094

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

*En la 3º Generación de Ordenadores (años 1960-1970), se consiguió una alta escala de integración en circuitos, en los que se consigue más capacidad de memoria, y más rendimiento y velocidad en los equipos. Se crean los mainFrame , equipos centrales para procesar una gran cantidad de datos, como por ejemplo IBM 360 y los "mini"ordenadores, en la universidades (DIGITAL PDP - 7 , PDP - 11).

-Máquinas relevantes
A) Aparece el concepto de familia de ordenadores.
* Poder elegir diferentes configuraciones.
* Catálogo de dispositivos y periféricos compatibles.
B) IBM 360
* Sistemas operativos: OS/360
* Lenguaje de control de trabajos: JCL
* Lenguaje de programación: PL/1
C) MULTICS
* Diferentes empresas ayudando en su desarrollo.
* Sistema operativo interactivo en tiempo compartido.
* Pensado para dar servicio de computo a toda una ciudad.
D) Hardware:
*GE-645, 2 procesadores con 256 K-palabras de 36 bits.

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

*En 1973 , se crea el primer sistema operativo de tipo [http://es.wikipedia.org/wiki/Unix UNIX]

*En 1980, los fabricantes más conocidos crean sistemas operativos basados en UNIX, como IBM crea AIX, SUN crea Solaris, Digital crea The64,HP crea HP-UX y Microsoft crea Xenix. También paralelamente en la Universidad de California se crea un sistema operativo llamado BSD que se distribuye para usos didácticos.

*En 1983, Richard Stallman inicia un proyecto llamado [http://es.wikipedia.org/wiki/GNU GNU] que consiste en desarrollar un sistema operativo, que se puede distribuir de manera gratuita y libre.

*En 1990, se crea el Intel 80386 y la universidad de California distrubuye el sistema BSD + un soporte real

*En 1992, se lanza el 1º sistema operativo de tipo GNU / LINUX

Planificadores de sistemas operativos existentes

2011-10-31T14:22:39Z

Sergaralo: /* Planificador de Windows */

= Planificador de Linux 2.6 =

Este planificador posee 140 prioridades (de 0 a 139), de 0 a 99 son para tiempo real y para el resto de procesos que no son de tiempo real de 100 a 139 basadas en el Nice(de -20 a 19).

Posee un mapa de bits (140 bits), 1 bit para cada prioridad en la que implementan distintas estructuras SCHED_FIFO y SCHED_RR ambas para tiempo real y el resto SCHED_OTHER. Esta ultima estructura posee el número de procesos preparados y dos colas, una para los procesos pendientes y otra para los que ya han consumido su ''quantum''. Cuando un proceso solo consume una parte de su ''quantum'' es insertado al final de la cola de pendientes con lo que le queda de su ventana de tiempo(es decir, si ha consumido el 25% la siguiente vez que sea asignado al procesador solo tendra el 75% del ''quantum''), y si consume totalmente su tiempo de asignación al procesador este pasa a la cola de consumido hasta que este totalmente vacía la cola de pendientes. (Esto se hace para compensar los procesos más interactivos)

Esquema de estructura de SCHED_OTHER:

struct{
int num_procesos_preparados
cola pendientes
cola consumido_quantum
}

= Planificador Mac Os X (Darwin) =

La planificación en el kernel de Mac OS X esta basada en cuatro listas de ejecución, cada una de ellas con diferente prioridad. Un hilo puede migrar de un nivel de prioridad a otro en función de sus requerimientos, dependiendo de la política en concreto que se utilice en el sistema. En general, es posible manejar estas prioridades mediante los procedimientos definidos en el estándar de llamadas POSIX. Con lo que podemos decir, que se trata de un '''criterio de planificación en colas multinivel''' mezclado con '''prioridades'''. Algo parecido al planificador SCHED_OTHER de Linux.

Las cuatro listas de ejecución que maneja el planificador de Mac OS X, son:

[[Archivo:DarwinSched.svg]]

= Planificador de Windows =

El planificador utiliza un sistema de multi-cola ordenadas por prioridades. Son 32 niveles de prioridades (de 0 a 31) que se dividen de la siguiente forma:

- Niveles 16 a 31: Tiempo Real
- Niveles 1 a 15: Variable
- Nivel 0: Reservado para el sistema

El planificador utiliza Round Robin para recorrer las distintas colas. Tiene un quantum fijo que por defecto valdrá q=2 o q=12, dependiendo de si es un SO de servidor o de usuario. El quantum se puede cambiar entre estos dos valores a través del sistema.

Windows utiliza este sistema de planificación desde Windows NT.
Si quieres saber mas del sistema de planificación de Windows puedes leer el libro Windows Internals[http://download.sysinternals.com/Files/WindowsInternals-Ch05.pdf](PDF), donde se explica el funcionamiento y las caracteristicas del todo el SO.

Planificadores de sistemas operativos existentes

2011-10-31T14:21:53Z

Sergaralo: /* Planificador de Windows */

= Planificador de Linux 2.6 =

Este planificador posee 140 prioridades (de 0 a 139), de 0 a 99 son para tiempo real y para el resto de procesos que no son de tiempo real de 100 a 139 basadas en el Nice(de -20 a 19).

Posee un mapa de bits (140 bits), 1 bit para cada prioridad en la que implementan distintas estructuras SCHED_FIFO y SCHED_RR ambas para tiempo real y el resto SCHED_OTHER. Esta ultima estructura posee el número de procesos preparados y dos colas, una para los procesos pendientes y otra para los que ya han consumido su ''quantum''. Cuando un proceso solo consume una parte de su ''quantum'' es insertado al final de la cola de pendientes con lo que le queda de su ventana de tiempo(es decir, si ha consumido el 25% la siguiente vez que sea asignado al procesador solo tendra el 75% del ''quantum''), y si consume totalmente su tiempo de asignación al procesador este pasa a la cola de consumido hasta que este totalmente vacía la cola de pendientes. (Esto se hace para compensar los procesos más interactivos)

Esquema de estructura de SCHED_OTHER:

struct{
int num_procesos_preparados
cola pendientes
cola consumido_quantum
}

= Planificador Mac Os X (Darwin) =

La planificación en el kernel de Mac OS X esta basada en cuatro listas de ejecución, cada una de ellas con diferente prioridad. Un hilo puede migrar de un nivel de prioridad a otro en función de sus requerimientos, dependiendo de la política en concreto que se utilice en el sistema. En general, es posible manejar estas prioridades mediante los procedimientos definidos en el estándar de llamadas POSIX. Con lo que podemos decir, que se trata de un '''criterio de planificación en colas multinivel''' mezclado con '''prioridades'''. Algo parecido al planificador SCHED_OTHER de Linux.

Las cuatro listas de ejecución que maneja el planificador de Mac OS X, son:

[[Archivo:DarwinSched.svg]]

= Planificador de Windows =

El planificador utiliza un sistema de multi-cola ordenadas por prioridades. Son 32 niveles de prioridades (de 0 a 31) que se dividen de la siguiente forma:
- Niveles 16 a 31: Tiempo Real
- Niveles 1 a 15: Variable
- Nivel 0: Reservado para el sistema

El planificador utiliza Round Robin para recorrer las distintas colas. Tiene un quantum fijo que por defecto valdrá q=2 o q=12, dependiendo de si es un SO de servidor o de usuario. El quantum se puede cambiar entre estos dos valores a través del sistema.

Windows utiliza este sistema de planificación desde Windows NT.
Si quieres saber mas del sistema de planificación de Windows puedes leer el libro Windows Internals[http://download.sysinternals.com/Files/WindowsInternals-Ch05.pdf](PDF), donde se explica el funcionamiento y las caracteristicas del todo el SO.

Planificadores de sistemas operativos existentes

2011-10-31T13:47:28Z

Sergaralo:

= Planificador de Linux 2.6 =

Este planificador posee 140 prioridades (de 0 a 139), de 0 a 99 son para tiempo real y para el resto de procesos que no son de tiempo real de 100 a 139 basadas en el Nice(de -20 a 19).

Posee un mapa de bits (140 bits), 1 bit para cada prioridad en la que implementan distintas estructuras SCHED_FIFO y SCHED_RR ambas para tiempo real y el resto SCHED_OTHER. Esta ultima estructura posee el número de procesos preparados y dos colas, una para los procesos pendientes y otra para los que ya han consumido su ''quantum''. Cuando un proceso solo consume una parte de su ''quantum'' es insertado al final de la cola de pendientes con lo que le queda de su ventana de tiempo(es decir, si ha consumido el 25% la siguiente vez que sea asignado al procesador solo tendra el 75% del ''quantum''), y si consume totalmente su tiempo de asignación al procesador este pasa a la cola de consumido hasta que este totalmente vacía la cola de pendientes. (Esto se hace para compensar los procesos más interactivos)

Esquema de estructura de SCHED_OTHER:

struct{
int num_procesos_preparados
cola pendientes
cola consumido_quantum
}

= Planificador Mac Os X (Darwin) =

La planificación en el kernel de Mac OS X esta basada en cuatro listas de ejecución, cada una de ellas con diferente prioridad. Un hilo puede migrar de un nivel de prioridad a otro en función de sus requerimientos, dependiendo de la política en concreto que se utilice en el sistema. En general, es posible manejar estas prioridades mediante los procedimientos definidos en el estándar de llamadas POSIX. Con lo que podemos decir, que se trata de un '''criterio de planificación en colas multinivel''' mezclado con '''prioridades'''. Algo parecido al planificador SCHED_OTHER de Linux.

Las cuatro listas de ejecución que maneja el planificador de Mac OS X, son:

[[Archivo:DarwinSched.svg]]

= Planificador de Windows =

El planificador utiliza un sistema de multi-cola ordenadas por prioridades. Son 32 niveles de prioridades (de 0 a 31) que se dividen de la siguiente forma:
- Niveles 16 a 31: Tiempo Real
- Niveles 1 a 15: Variable
- Nivel 0: Reservado para el sistema

El planificador utiliza Round Robin para recorrer las distintas colas. Tiene un quantum fijo que por defecto valdrá q=2 o q=12, dependiendo de si es un SO de servidor o de usuario. El quantum se puede cambiar entre estos dos valores a través del sistema.

Windows utiliza este sistema de planificación desde Windows NT.

Planificadores de sistemas operativos existentes

2011-10-31T13:47:13Z

Sergaralo:

= Planificador de Linux 2.6 =

Este planificador posee 140 prioridades (de 0 a 139), de 0 a 99 son para tiempo real y para el resto de procesos que no son de tiempo real de 100 a 139 basadas en el Nice(de -20 a 19).

Posee un mapa de bits (140 bits), 1 bit para cada prioridad en la que implementan distintas estructuras SCHED_FIFO y SCHED_RR ambas para tiempo real y el resto SCHED_OTHER. Esta ultima estructura posee el número de procesos preparados y dos colas, una para los procesos pendientes y otra para los que ya han consumido su ''quantum''. Cuando un proceso solo consume una parte de su ''quantum'' es insertado al final de la cola de pendientes con lo que le queda de su ventana de tiempo(es decir, si ha consumido el 25% la siguiente vez que sea asignado al procesador solo tendra el 75% del ''quantum''), y si consume totalmente su tiempo de asignación al procesador este pasa a la cola de consumido hasta que este totalmente vacía la cola de pendientes. (Esto se hace para compensar los procesos más interactivos)

Esquema de estructura de SCHED_OTHER:

struct{
int num_procesos_preparados
cola pendientes
cola consumido_quantum
}

= Planificador Mac Os X (Darwin) =

La planificación en el kernel de Mac OS X esta basada en cuatro listas de ejecución, cada una de ellas con diferente prioridad. Un hilo puede migrar de un nivel de prioridad a otro en función de sus requerimientos, dependiendo de la política en concreto que se utilice en el sistema. En general, es posible manejar estas prioridades mediante los procedimientos definidos en el estándar de llamadas POSIX. Con lo que podemos decir, que se trata de un '''criterio de planificación en colas multinivel''' mezclado con '''prioridades'''. Algo parecido al planificador SCHED_OTHER de Linux.

Las cuatro listas de ejecución que maneja el planificador de Mac OS X, son:

[[Archivo:DarwinSched.svg]]

= Planificador de Windows =

El planificador utiliza un sistema de multi-cola ordenadas por prioridades. Son 32 niveles de prioridades (de 0 a 31) que se dividen de la siguiente forma:
- Niveles 16 a 31: Tiempo Real
- Niveles 1 a 15: Variable
- Nivel 0: Reservado para el sistema

El planificador utiliza Round Robin para recorrer las distintas colas. Tiene un quantum fijo que por defecto valdrá q=2 o q=12, dependiendo de si es un SO de servidor o de usuario. El quantum se puede cambiar entre estos dos valores a través del sistema.

Windows utiliza este sistema de planificación desde Windows NT.

Criterios de planificación

2011-10-31T12:48:25Z

Sergaralo: /* Turno rotatorio estricto (Round Robin: RR) */

=4.3.1 Métodos no apropiativos =

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

== Estocástico ==

Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitividad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.

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

== Con conocimiento del futuro ==

En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.

Ejemplo:

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

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

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

En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.

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

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

Ejemplo:

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

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

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

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

Se selecciona el proceso que requiera menos tiempo de ejecución de entre todos los que están listos para ejecutarse. Se necesita conocer con antelación el tiempo de ejecucion de cada proceso, algo que es muy dificil en muchas ocasiones.
Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Otro inconveniente es que todo trabajo corto que llegue cuando ya ha comenzado un trabajo largo tiene un gran retraso. Su orden de complejidad es O(n).

Ejemplo:

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

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

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

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

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

Ejemplo:

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

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

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

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

=4.3.2 Métodos apropiativos =

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

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

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

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

Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución del que le falta al actual, se le retira el procesador al actual proceso y se le asigna al nuevo. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.Con este método los procesos más largos se ven perjudicados, pues se puede retrasar tanto su tiempo de inicio, como el de finalización.

Ejemplo:

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

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

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|
de tiempos _T__|_3__|_8__|_1__|_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 disminuyéndola cuando tiene adjudicado el procesador.

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

El orden es siempre O(n).

Ejemplo:

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

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

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

== Turno rotatorio ==

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

En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado ''quantum'', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.

El tamaño del ''quantum'' es fundamental para determinar el comportamiento de este criterio de planificación.
Si el ''quantum'' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, si el ''quantum'' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .

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

Puesto que el reparto del procesador es estricto, los procesos recién lanzados deben de acceder al procesador lo antes posible, por tanto, se añaden inicialmente al principio de la cola. Si son varios los procesos que han sido lanzados, se ejecutaran por orden de llegada.

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

Ejemplo:

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

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

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

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

Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio (dispondrá de otro quantum completo).
Este tipo de criterio tiene un problema y es que se pueden posponer indefinidamente algunos procesos si hay varios procesos que bloqueen.

Ejemplo:

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

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

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

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

Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.

== Colas multinivel ==

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

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

# Esta primera cola es para procesos que poseen 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.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_| Pa y Pc bloquean cada 1 unidad de tiempo
Datos del _H0_|_0__|_1__|_2__|_3__| El bloqueo se resuelve tras 2 unidades de tiempo
problema _t__|_2__|_4__|_2__|_7__|
Colas multinivel: 1. Procesos interactivos (quantum = 1 unidad de tiempo)
2. Procesos por lotes (quantum = 2 unidad de tiempo)
Inicialmente todos los procesos van a la cola 2
Los procesos que no consuman su quantum al menos una vez pasan a la cola 1
Las colas implementan turno rotatorio estricto

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

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

Modelos de Diseño de Sistemas Operativos

2011-10-19T19:15:44Z

Sergaralo: /* Núcleo del sistema operativo */

= 2.5. Modelos de Diseño de SSOO =

== 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 qué 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 del 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]'' y en los sistemas operativos Windows por el nombre de ''[http://www.google.es/url?sa=t&source=web&cd=1&ved=0CCwQFjAA&url=http%3A%2F%2Fes.wikipedia.org%2Fwiki%2FPantalla_azul_de_la_muerte&ei=s02WTqvCCMjHtAaxuJyBBA&usg=AFQjCNE2tZra15VdohxjrhSogTQZOVedKg Pantallazo azul]''.

== 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 (muchas líneas de código) con un alto número de funcionalidades, las cuales normalmente son 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.
* Pico/Nanonúcleos: son núcleos muy pequeños y flexibles, incluso mas pequeños que los Micronúcleos. Se usan en sistemas muy específicos, como satélites, en los que ya se sabe los procesos que se van a realizar. Son muy fiables.

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 están fuera del núcleo, como los módulos son independientes unos de otros, si cae alguno de ello los demás 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. Otro ejemplo de micronúcleo es Symbian OS.

=== 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 Máquinas Virtuales
** Rendimiento (KVM + paravirtualización 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).

Qué es un Sistema Operativo

2011-10-18T11:19:39Z

Sergaralo: /* 1.1.2. Principios de diseño de un buen Sistema Operativo */

= 1.1. ¿Qué es un Sistema Operativo? =
== 1.1.1. ¿Qué es un Sistema Operativo? ==
* El programa de programas. En el arranque de la computadora, es cargado a la memoria RAM por la [http://es.wikipedia.org/wiki/BIOS BIOS].

* Gestiona los recursos que ofrece el material (el ''hardware'' del equipo):
** La [http://es.wikipedia.org/wiki/Unidad_central_de_procesamiento CPU] (unidad central de procesamiento o procesador).
** La [http://es.wikipedia.org/wiki/Memoria_principal Memoria principal].
** Los [http://es.wikipedia.org/wiki/Entrada/salida#Dispositivos_de_entrada_y_salida dispositivos de Entrada/Salida], tales como la tarjeta de vídeo, la tarjeta 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 homogénea.

*Tarda un tiempo, período de arranque, en inicializar los recursos.

== 1.1.2. 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.
* No permitir que las aplicaciones accedan directamente a los recursos sino que sea a través del sistema operativo.

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 (hardware).

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(32 bits), los actuales Intel64 y AMD64(64 bits), la SPARC (desarrollada por Sun Microsystems, ahora adquirida por Oracle), la PowerPC (creada por la alianza AIM: Apple-IBM-Motorola)...