Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Memoria virtual con multiprogramacion

2020-04-28T16:25:33Z

Eleayogar:

Cuando se aplican métodos de memoria virtual en sistemas multiprogramados, surgen nuevos problemas o elecciones de diseño.
==Criterios locales y globales==
A la hora de elegir página víctima, podemos elegirla entre las asignadas al proceso (criterio local), o entre todas las páginas del sistema (Criterio global).
*'''Criterio local:''' Mantiene constante el número de páginas de un proceso cargadas en memoria, y es más eficiente, al operar sólo con las páginas del proceso. Se plantea el problema de determinar el número inicial de marcos.
*'''Criterio global:''' La asignación dinámica de marcos se adapta a las necesidades de los procesos. Se plantea el problema de que el criterio de sustitución favorece al proceso activo, ya que un proceso inactivo puede encontrarse que cuando le llegue el turno, se encuentre sus páginas movidas a memoria.
*'''Criterio mixto:''' Tiene las ventajas de ambos criterios, ya que, ante una sustitución, se aplica un criterio local, de manera que el algoritmo de sustitución opera sobre un conjunto menor de marcos, y de forma dinámica, se equilibra el número de marcos entre procesos.

==Modelo del conjunto de trabajo==
Es un modelo que sigue un criterio híbrido y define como conjunto de trabajo el rango de páginas con las que opera un proceso durante una fase de su ejecución, es decir, el conjunto de páginas que hay que mantener en memoria para que no se produzcan fallos de página mientras dure dicha fase. Por ejemplo, puede que, al iniciarse un proceso, necesite un rango de 10 o 20 páginas, y que, pasado un tiempo, se estabilice, usando únicamente 3 o 4. Su conjunto de trabajo es un rango de páginas que cambia a lo largo del tiempo.

El objetivo es evitar la hiperpaginación, es decir, la sobrecarga debida a un aumento de la frecuencia de fallos de página hasta que se produzca un fallo de página cada pocas instrucciones.

La estrategia es tener como máxima el no retirar nunca a un proceso una página perteneciente a su conjunto de trabajo.

==Aplicación de frecuencia de fallos de páginas==
Ya que el sistema operativo no puede saber cuál es el conjunto de trabajo de un proceso, se sigue una estrategia aproximada: Asignar dinámicamente el número de marcos en función de la frecuencia de fallos de página, que se limita superior e inferiormente.

Así, nunca habrá procesos con un número excesivo de marcos (Aprovechamiento) ni con menos de los necesarios (Posible hiperpaginación)
==Marcos de reserva==
Una posible decisión de diseño es la de mantener siempre una lista de marcos libres, ya que la memoria virtual funciona mejor si hay marcos libres cuando se produce un fallo de página.

Un demonio de paginación se ejecuta periódicamente, para descargar páginas que no estén en uso aplicando algún criterio de sustitución.

Esta decisión de diseño es discutible en sistemas interactivos, ya que, tras periodos de inactividad por parte del usuario, este se puede encontrar con una sobrecarga añadida en la reanudación, al haber muchos procesos cuyas páginas han sido descargadas.

==Carga de páginas por anticipado==
Para evitar fallos de página, se pueden cargar páginas antes de que hagan falta, aplicando criterios de:
*Localidad espacial: Al transferir una página, se transfieren también sus adyacentes.
*Conjuntos de trabajo: En caso de bloqueo, se anotan las páginas que supuestamente pertenecen al conjunto de trabajo, para que, al reactivarlo, se carguen todas esas páginas. El sistema operativo Android es un ejemplo de administrador de memoria que aplica esta técnica.

8.4 [[Ejercicios_memoria_virtual | Ejercicios de memoria virtual]]

Criterios de reemplazo

2020-04-28T16:24:49Z

Eleayogar:

La evaluación se hace en base a la '''tasa de fallos de página''', que es el número de fallos de página entre el número de accesos totales a página, con lo que su valor oscila en el rango [0,1].

El fallo de página se produce cuando se accede a una posición de memoria que pertenece a una página de memoria que esta descargada en disco.

Tasa fallos página = total fallos de pagina/total accesos a pagina

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

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

== Criterio de página óptima (OPT, MIN) ==

Este es un criterio teórico que viene a establecer la cota inferior de la tasa de ''fallos de página''. Consiste en escoger la página que mayor tiempo va a tardar en utilizarse. Este es el mejor caso, pero se necesita conocimiento de futuro, de ahí que sea un criterio teórico.

Ejemplo: Secuencia de acceso a página : 2,2,3,1,1,3,4,5,1,1,2,3,4
Suponiendo arranque en frío
Marco Marco Marco Marco
1 2 3 4
Memoria principal +-----+-----+-----+-----+
de 4 marcos | | | | |
+-----+-----+-----+-----+

*[[sol_1|Solución]]

Otra forma de evaluar la eficiencia de un criterio de selección de página víctima es observando su curva paracorde, que relaciona el nº de fallos de página con el nº de marcos. La de un buen criterio se aproximará a la curva del criterio óptimo, y la de uno malo, a la del criterio al azar, o incluso pésimo.

[[Archivo:Curvas paracordes.jpg]]

En el siguiente ejemplo real se compara la efectividad de varios criterios en varios programas:

[[Archivo:img26.png]]

== Criterio de página pésima (MAX)==

Este también es teórico y viene a establecer la cota superior de la ''tasa de fallos de página'', para ver lo peor que podría comportarse un criterio. Consiste en seleccionar la página que menor tiempo tardará en usarse. También implica tener conocimiento de futuro, por lo que no es implementable en la práctica.

*[[sol_2|Solución]]

== Criterio de selección estocástica (aleatoria) ==

Se trata también de un criterio teórico, serviría para aproximar la cota media de la ''tasa de fallos de página''. Consiste en seleccionar una página al azar.

Dado que su implementación es trivial, cualquier algoritmo que dé resultados similares a este será un mal criterio, pues seguro que su eficiencia será menor que la de no implementar ningún criterio y seleccionar una página al azar.

== Criterio MRU('''M'''ost '''R'''ecently '''U'''sed) ==

Se selecciona la última página a la que se ha accedido. Podría implementarse con una LIFO por orden de acceso. Es una aproximación implementable en la práctica del criterio MAX, pudiendo así compararlo con otros criterios. Según el principio de localidad, mientras más recientemente se haya accedido a una página, más probable es que vuelva a accederse a ella. Por ello, este criterio es muy deficiente, siendo su curva cercana a la pésima:

[[Archivo:MRU.jpg]]

*[[sol_3|Solución]]

== Criterio por orden de carga FIFO ==

Se selecciona la página que más tiempo lleva cargada en memoria principal. Se implementa con una FIFO por orden de carga, es decir, a medida que se cargan en memoria principal las páginas son añadidas a la cola.

El inconveniente de este criterio es que las páginas más usadas son las que más tiempo deberían permanecer en memoria, y son las más atacadas. No se debe suponer que, si las páginas “dejarán de ser necesarias”, implica que “ya no sean necesarias”.
Además, se produce la anomalía de Belady, efecto que consiste en la posibilidad de tener más fallos de página al aumentar el número de marcos en la memoria física:

*[[sol_5|Solución]]

== Criterio NRU ('''N'''ot '''R'''ecently '''U'''sed) ==

Ofrece dos bits para cada página:
* Bit R : Se pone a 1 si la página ha sido usada (tanto para lectura como para escritura).
* Bit M : Se pone a 1 si la página es modificada (escritura).

En resumen, el bit R se pondrá a 1 ante cualquier tipo de acceso, y el bit M se pondrá a 1 sólo ante eventos de escritura.

Para seleccionar la página víctima iteramos sobre los marcos cargados en memoria (comenzando por el primero de ellos) buscando el que cumpla lo siguiente, en este orden:

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

Periódicamente se pone a cero el bit R.

[[Archivo:LRU.jpg]]

*[[sol_6|Solución]]

== Criterio de 2ª oportunidad ==

Se trata de la combinación de los criterios FIFO y NRU, pero sin emplear el bit M de NRU. Cuando hay que seleccionar una página víctima, se recorre la lista de páginas por orden de carga en memoria hasta encontrar alguna que tenga el bit R a 0. Durante la iteración, si se encuentra una cuyo bit R valga 1, se pone a 0, se retira de la lista y se añade al final (para darle una segunda oportunidad). Cuando se añade una nueva página, se añade al final de la cola con el bit R a 1.
Añadir que, en este caso, no se pone el bit R a 0 periódicamente, ya que se hace directamente con la 2ª oportunidad.

[[Archivo:Segunda Oportunidad.jpg]]

*[[sol_7|Solución]]

;Criterio del reloj: Es una variante en la manera de implementar la 2ª oportunidad. Se emplea una lista circular. En lugar de eliminar y añadir elementos al final de la FIFO, mantenemos un puntero a la página siguiente de la última página víctima seleccionada, de manera que, para dar la 2ª oportunidad a una página, sólo hemos de poner su bit R a 0 y pasar al siguiente.

*[[sol_reloj|Solución]]

==Criterio de la 3ª oportunidad (Método Multics)==
Es otra variante del criterio NRU, en la que se mantiene una lista ordenada por orden de carga. Ante una sustitución, la primera candidata es la más antigua.

Si dicha página tiene el bit R a 1, se pone a 0.

Si dicha página tiene el bit R a 0, existen dos casos:
*Si tiene el bit M a 1, se pone a 0.
*Si tiene el bit M a 0, se selecciona como página víctima.

[[Archivo:Tercera oportunidad.jpg]]

*[[sol_tercera_oportunidad|Solución]]

== Criterio LRU ('''L'''east '''R'''ecently '''U'''sed) ==

Es justamente el criterio contrario al MRU. En LRU elegimos la página que más tiempo lleve sin ser accedida. Se implementa mediante una FIFO que mantiene el '''orden de acceso''' a las páginas. Es decir, cada vez que se accede a una página, en caso de estar ya en la FIFO, se retira de la cola y se añade al final.

*[[sol_8|Solución]]

== Criterio LFU ('''L'''east '''F'''recuently '''U'''sed) ==

Se selecciona a la página que haya sido accedida con menor frecuencia. Se implementa mediante un contador. Básicamente, por cada acceso se incrementa el contador de uso de la página. La página víctima será aquella con menor contador. Cuando una página es expulsada a disco su contador pasa a ser cero. Es inviable en la práctica, pues supone mantener contadores de tamaños muy grande, uno por cada página en memoria, y por cada acceso a memoria podría ser necesario ejecutar una rutina que actualice la lista.

*[[sol_9|Solución]]

== Aproximación discreta LRU ==

Se tiene un bit R y un contador por cada página. Cuando una página es cargada a un marco, se carga con su bit R a 1 y su contador inicial a 0. Cuando pasa un período determinado de tiempo (viene dado en el enunciado) se itera sobre toda la lista de páginas, y pueden ocurrir dos cosas:
* '''Si su bit R está a 1''': Se ponen su bit R a cero y su contador se incrementa.
* '''Si su bit R está a 0''': No se hace nada.

Cuando hay que seleccionar una página víctima, se escoge aquella cuyo contador sea más pequeño. En caso de empate, habrá que establecer un criterio de desempate.

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

== Sustitución por envejecimiento ==

Se emplea un registro R de N bits, asociado a cada página. Por cada acceso se pone a 1 el bit más significativo. Periódicamente se desplaza hacia la derecha el registro R. La página víctima será la que tenga el menor valor en el registro R (en caso de empate se emplea otro criterio). La información que contienen los bits menos significativos se pierden al realizar desplazamientos. Este criterio permite mantener un historial de acceso a las páginas, para seleccionar como víctima aquella que lleve más tiempo sin ser accedida.

*[[sol_10|Solución]]

= Implementaciones =

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

8.3 [[Memoria_virtual_con_multiprogramacion | Otros aspectos relacionados con la memoria virtual]]

Material teoría

2020-04-28T16:23:09Z

Eleayogar:

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla.

= Subida de notas =

Indica aquí tu UVUS si quieres que revise tus contribuciones para ser tenidas en cuenta en la subida de notas:

* beagalcar

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Arranque del sistema|Arranque del sistema]]
* 2.6. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 2.9. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]
* 2.10. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 3.1. [[Multiprogramación|La multiprogramación]]
* 3.2. [[Estados de los procesos|Estados de los procesos]]
* 3.3. [[Planificador de procesos|El planificador de procesos]]
* 3.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 3.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 3.6. [[Conmutación de procesos|La conmutación de procesos]]
* 3.7. [[Hilos|Hilos]]
* 3.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 4.1. [[Planificación de procesos|La planificación de procesos]]
* 4.2. [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 4.3. [[Criterios de planificación|Criterios de planificación]]
* 4.4. [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 4.5. [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 4.6. [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 4.7. [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 4.8. [[Ejercicios planificación de procesos|Ejercicios]]
* 4.9. [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 5.1. [[Concurrencia de procesos|Concurrencia de procesos]]
* 5.2. [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 5.3. [[Cerrojos|Cerrojos]]
* 5.4. [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 5.5. [[Semáforos|Semáforos]]
* 5.6. [[Monitores|Monitores]]
* 5.7. [[Mensajería|Mensajería]]
* 5.8. [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 6.1. [[Definición de interbloqueo|Definición]]
* 6.2. [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 6.3. [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 6.4. [[Ejercicios]]

== Administración de memoria ==

* 7.1. [[Introducción|Introducción]]
* 7.2. [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 7.3. [[Segmentación|Segmentación]]
* 7.4. [[Paginación|Paginación]]
* 7.5. [[Sistema combinado|Sistema combinado]]
* 7.6. [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 7.7. [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 8.1. [[Memoria Virtual|Introducción]]
* 8.2. [[Criterios de reemplazo|Criterios de reemplazo]]
* 8.3. [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 8.4. [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1. [[EstructuraES|Estructura dispositivo E/S]]
* 10.2. [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3. [[Diseño modular E/S|Diseño modular E/S]]
* 10.4. [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión E/S ==

* 11.1. [[Discos Magnéticos|Discos Magnéticos]]
* 11.2. [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3. [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4. [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5. [[Unidades SSD|Unidades SSD]]
* 11.6. [[Reloj hardware: Intel 8253]]
* 11.7. [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1. [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2. [[FAT|FAT]]
* 12.3. [[EXT2 |EXT2]]
* 12.4. [[Ejercicios Administración Ficheros|Ejercicios]]

== Seguridad ==

* 13.1. [[Definiciones de Seguridad]]

== Modelos de diseño de Sistemas Operativos ==

* 14.1. [[Virtualización]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Sistema combinado

2020-04-02T16:42:19Z

Eleayogar:

Consiste en combinar la segmentación y la paginación. La idea fundamental consiste en definir segmentos que están compuestos por N páginas. De ahí que reciba el nombre de '''segmentación paginada'''. Por tanto, cualquier segmento ocupa, como mínimo una página de memoria.

Por una parte, la segmentación proporciona ventajas hacia los procesos: organización de datos y código, mecanismos de protección, compartición de datos y código, y optimización en el espacio ocupado. Por otra parte, la paginación facilita la gestión de la memoria disponible.

Los procesos emplean direcciones lógicas de memoria segmentada, que son traducidas a direcciones lógicas paginadas (dirección intermedia), que a su vez deben de ser traducidas a direcciones físicas. Por tanto, cualquier acceso a memoria supone un total de tres accesos a memoria. Uno para acceder a la tabla de segmentos, otro para acceder a la tabla de páginas y, por último, otro más para acceder a la dirección física. Aquí hay un ejemplo de la arquitectura IA32: <center>

[[Archivo:Arquitecturaia32_2.jpg]] </center>

7.6 [[ Ejercicios_administración_de_memoria_contigua | Ejercicios (Administración de memoria contigua)]]

Paginación

2020-04-02T16:40:40Z

Eleayogar:

= Definición =

La paginación es una estrategia de organización de la memoria física que consiste en dividir la memoria en porciones de igual tamaño. A dichas porciones se las conoce como páginas físicas o marcos. La división de la memoria en páginas facilita la gestión de la memoria física.

Los marcos están identificados por un número, conocido como número de página física. Cada página física se asigna en exclusividad a un proceso.

A su vez, se dispone de páginas lógicas. Todo proceso tiene su propio espacio de páginas lógicas, cada página lógica está mapeada a un marco. El mapeo entre páginas lógicas y páginas físicas se mantiene en la tabla de páginas. Cada proceso dispone de su propia tabla de páginas. En tiempo de [[conmutación de procesos]], se restablece la tabla de páginas del proceso que pasa a estado a activo, por tanto, forma parte del contexto de la ejecución del proceso en estado activo.

El proceso dispone de todo el direccionamiento lógico, que puede emplear según sus necesidades. En un procesador de 32 bits, un proceso dispone de 2^32 = 4 GBytes de memoria lógica. Suponiendo que el tamaño de página es de 8 Kbytes (2^13 bytes), en un procesador de 32 bits (4 bytes, 2^2 byte) - se dispone de un total de 2^32 / 2^13 = 2^19 marcos = 524288 marcos.

El mecanismo de direcciones lógica permite aislar entre sí a los procesos en ejecución, puesto que no conocen la dirección física efectiva en la que se almacenan los datos a los que se hace referencia.

= Funcionamiento =

El traductor de memoria paginada toma la dirección lógica y, por medio de la tabla de página, obtiene la dirección física real.

Los bits más significativos de una dirección lógica representan el número de página lógica, los menos significativos el desplazamiento dentro de la página. Concretamente, en un procesador de 32 bits, con un tamaño de página de 4 Kbytes = 2^12, se emplean 12 bits para el desplazamiento dentro de la página. Es decir, para referenciar los datos que una página contiene. Los restantes 20 bits más significativos indican el número de página.

El traductor de memoria paginada es parte de la arquitectura, por tanto, el sistema operativo únicamente tiene que establecer la tabla de páginas del proceso en tiempo de conmutación, de manera que cualquier acceso a una dirección lógica se traduce a una dirección física de una manera transparente al proceso.

[[Archivo:Paginas.png]]

Las páginas disponen de mecanismos de protección, expresados en bits de lectura, escritura y ejecución. Lo que permite definir páginas de sólo lectura, por ejemplo, para almacenar constantes. Páginas de sólo lectura y ejecución, para almacenar código, así como páginas de lectura y escritura para el heap (montón) o la pila (stack) del proceso.

Si se accede a una página lógica que no existe en la tabla de páginas del proceso, el sistema eleva una excepción que resulta en la finalización de la ejecución del proceso.

= Otras características =

* ¿Cuál es el tamaño de página idóneo? Los valores óptimos para las porciones son: en arquitectura de 32 bits es de 4KB, y en arquitectura de 64 bits es de 8KB.

* Los criterios vistos en la gestión de memoria mediante particiones de tamaño variable no tienen aplicación en la gestión de la memoria paginada, pues todos los huecos disponibles son de igual tamaño.

== Dispositivo de traducción de direcciones paginadas ==

Podemos almacenar la tabla de páginas en el propio traductor o en memoria principal.

*'''Tabla de páginas en el traductor:'''

El dispositivo de traducción de memoria dispone de una zona en la que se almacena la tabla de páginas. En tiempo de conmutación, se tiene que copiar la tabla de páginas a memoria principal y se restaura la tabla de página del nuevo proceso que pasa a estado activo, lo cual ralentiza el tiempo de conmutación de procesos. Lo que hace que no sea viable en sistemas modernos, en los que se gestionan grandes cantidades de memoria.

*'''Tabla de páginas en memoria principal:'''

La tabla de página se almacena en la memoria principal, el dispositivo traductor dispone de unos registros que almacenan la dirección de memoria en la que se almacena la tabla de páginas y su tamaño. Debido a que la tabla de páginas está en la memoria principal se necesita, por cada acceso a memoria, un acceso a memoria adicional para obtener el número de página física asociado a la página lógica. Para mantener un tiempo de acceso aceptable se establece una memoria asociativa en el dispositivo de traducción de memoria paginada que conserva la relación página lógica <-> página física utilizadas recientemente.

==Tabla de páginas multinivel==
El objetivo es paginar la tabla de páginas lo que permite que esta no esté cargada completa en memoria y que no ocupe direcciones consecutivas.
En los ss.oo. con tablas de páginas multinivel los números de página se dividen en dos partes: los bits más significativos indican el directorio de páginas correspondiente y con los bits menos significativos el índice del directorio en el que se encuentra la página buscada:

[[Archivo:PaginacionMultinivel.jpg‎ ]]

*'''Tabla de páginas para todo el sistema:''' Es una variante de las tablas de página multinivel, en la que el dispositivo traductor sólo contiene una entrada por cada proceso, indexadas por PID, y una dirección de tabla que contiene las páginas de dicho proceso. Así, ante una conmutación de procesos basta con cambiar de PID.
==Elementos de administración==

Para mantener la contabilidad de marcos libres se pueden emplear estructuras de datos tales como:

*'''Mapa de bits de marcos libres:''' Que contiene 1 si está asignada a un proceso, o 0 si está libre.
*'''Lista de marcos libres:''' Hay una lista global de marcos libres y una lista por proceso de marcos ocupados.

Además, se puede emplear el mecanismo de los compañeros para mantener listas de varias páginas consecutivas (bloques) de tamaño en base a potencia de 2. Por ejemplo, suponiendo un sistema con páginas de 4 Bytes, bloques de 4 Kbytes (orden 0), bloques de 8 Kbytes (orden 1, dos páginas), bloques de 16 Kbytes (orden 2, cuatro páginas), bloques de 32 KBytes (orden 3, 8 páginas) y así sucesivamente.

Una reserva de página de orden 0 nunca falla a no ser que no haya memoria disponible en el sistema. La de orden 1 puede fallar si no hay dos páginas consecutivas.

El hecho de asignar páginas de manera consecutiva permite explotar mejor la propiedad de localidad espacial en el acceso a memoria.

7.5 [[Sistema_combinado | Sistema combinado]]

Segmentación

2020-04-02T16:38:54Z

Eleayogar:

=Definición=
Un segmento es un espacio de memoria de tamaño variable, compuesto por:
*Descriptor: Identificador único del segmento (dentro del espacio de memoria del proceso).
*Tamaño del segmento

=Funcionamiento=

[[Archivo:Segmentos.png|725px]]

=Características=
*Cada proceso en ejecución (esté activo, bloqueado o preparado) tiene su tabla de segmentos.

*Solapamiento: Se puede hacer que 2 segmentos se superpongan de manera que compartan direcciones de memoria física con direcciones lógicas diferentes. Para evitar problemas de concurrencia, debe indicarse explícitamente que una porción de memoria pueda ser compartida. De esta manera, procesos diferentes pueden compartir información y código usando la memoria común.

*Protección de memoria: añadir 3 bits a la tabla de descriptores de segmentos para los permisos ( r w x ).

*Cuando un proceso requiere más memoria se crea un nuevo segmento.

*Dos instancias de un mismo proceso pueden compartir segmentos de memoria de instrucciones/código, pero no para datos ya que esto complicaría la gestión.

*Es posible la redimensión de segmentos siempre que haya posiciones libres contiguas, o crear un nuevo segmento y copiar el contenido del anterior.

*Gestión compleja, sobre todo por su tamaño variable

*Permite la carga de segmentos a petición, de manera que no se disponga de todos los segmentos en memoria principal, que se puedan descargar a disco (en la zona de intercambio o swap) en base a un cierto criterio (ver [[Intro | Memoria virtual]]). Esta zona de intercambio puede ser:
**Un lugar fijo en el disco (Linux, Unix). El administrador de memoria decide qué segmento se va a descargar
**Un fichero oculto de tamaño fijo o variable dependiendo de la configuración dada por el usuario (Windows).

*La segmentación se hizo para equipos con poca memoria, no está pensada para sistemas modernos.

=Mecanismos=
Los diferentes mecanismos que nos ofrece la segmentación de memoria son los siguientes.
==Carga de segmentos a petición==
Es un mecanismo que permite a un proceso no disponer de todos sus segmentos en memoria principal, se pueden descargar a disco (en la zona de intercambio o swap) segmentos en base a un cierto criterio (ver [[Intro | Memoria virtual]]).

Esta zona de intercambio puede ser:

* Un lugar fijo en el disco (Linux, Unix). El administrador de memoria decide qué segmento se va a descargar

* Un fichero oculto de tamaño fijo o variable dependiendo de la configuración dada por el usuario (Windows).

==Formas de uso de los descriptores==
En cuanto a aspectos materiales, se plantea el problema de que no es habitual que la tabla de segmentos quepa en el dispositivo de traducción (Memory management unit o MMU), por lo que se almacena la tabla en memoria, y el MMU contiene su dirección. El problema es que esta técnica hace que el tiempo de acceso se duplique, al haber un primer acceso al MMU y un segundo acceso a la dirección efectiva. Se plantean dos soluciones no excluyentes:
* '''Uso de registros descriptores de segmento en MMU:'''
<blockquote>
En MMU nos encontraremos varios registros que pueden contener descriptores, en los que se copiarán los que se vayan a usar en un futuro inmediato. Hay dos tipos de registros:
*Registros de propósito general:
Registros sobre los que se cargan los próximos descriptores a usar, y dos tipos de direcciones:
 - Las que hacen referencia a un descriptor en la tabla de memoria (y necesitan más bits para hacer referencia al descriptor)
 - Las que hacen referencia a un descriptor en MMU (y necesitan menos bits para referir al descriptor)
*Registros especializados:
Registros capaces de albergar a un descriptor concreto, como el DS (Para manejo de datos), SS (Para manipulación de pila) o el CS (Para instrucciones de salto y llamadas a rutinas). También existen dos tipos de direcciones:
 - Las que hacen referencia a un descriptor en la tabla de memoria
 - Las que no hacen referencia a ningún descriptor, y emplean descriptores de MMU, según el tipo de instrucción
</blockquote>

* '''Uso de descriptores en memoria asociativa (Cache):'''
<blockquote>
La MMU contiene una memoria asociativa indexada por número de descriptor. Para cada acceso, se busca en la memoria asociativa el número de descriptor, y si no está, se carga a esta (Si se llena la memoria asociativa se lleva a cabo reemplazo). Este tipo de memoria es transparente, por lo que se puede usar en conjunción con registros descriptores de segmento en MMU.
</blockquote>

=Superposición de segmentos=

El administrador de memoria puede definir segmentos superpuestos para crear áreas de memoria compartidas entre dos o más procesos del sistema. Los procesos emplean una llamada al sistema explícita para solicitar la creación del área de memoria compartida. El mecanismo de segmentos solapados es un aspecto propio del administrador de memoria, del que se puede valer para implementar la memoria compartida.

=Crecimiento de proceso=
Existen dos formas de crecimiento: Asignando nuevos segmentos al proceso, y haciendo crecer algún segmento asignado.
Para crecer un segmento: si hay suficiente espacio libre contiguo, se actualiza el tamaño en el descriptor del segmento. Si no hay suficiente espacio: se define un nuevo segmento y se copia el contenido al nuevo segmento.

7.4 [[Paginación | Paginación]]

SO multiprogramables con particiones variables

2020-04-02T16:38:29Z

Eleayogar:

En este tipo de sistemas, las particiones para cada proceso se van creando a medida que son asignadas al procesador. Tiene como ventaja principal que evitamos el desperdicio de memoria dentro de cada bloque ya que cada uno está hecho a medida para el proceso que contiene. Por el contrario, una vez que un proceso ha concluido, su partición se queda en desuso y sería necesario aplicar algoritmos de desfragmentación de memoria (supone un alto coste de rendimiento) para poder unificar todas las partes que han quedado libres y así reciclar las particiones que quedaron huérfanas. Otra forma de obtener particiones de mayor tamaño es unificar dos o más huecos adyacentes en uno sólo.

''Ejemplo:''
_ _
|_| P1 = 3KB |_| P1 = 3KB
|_| P2 = 1KB |_| P2 = 1KB
|_| P3 = 6KB => Finaliza P3 => |_| Libre = 6KB
| | | |
|_| P4 = 31KB |_| P4 = 31KB
| | | |
|_| Libre = 21KB |_| Libre = 21KB

Si un nuevo proceso P5 requiriese 24KB de memoria, no podrían serle asignados, ya que los huecos no son contiguos y para disponer de los 27KB libres en total habría que realizar previamente una desfragmentación.

== Elementos de administración ==

* '''Mapas de bits''': Dividiendo la memoria en bloques (llamados unidades de asignación), se utiliza un bit para representar si dicho bloque está libre o asignado. El tamaño de los bloques tiene una cierta importancia, ya que cuanto mayor sea, menos bloques cabrán en memoria con lo que serán necesarios menos bits para controlar todos los bloques y el mapa de bits será de menor tamaño.

* '''Listas de control''': Se usa una lista de nodos ordenada por dirección. Por cada bloque libre u ocupado habrá un nodo con:
** Dirección inicial del bloque
** Tamaño del bloque
** Estado (Libre u ocupado)
** Proceso al que está asignado

= Criterios de asignación =

== Primer ajuste ==

Consiste en asignar el primer hueco disponible que tenga un espacio suficiente para almacenar el programa. La principal desventaja es el reiterado uso de las primeras posiciones de memoria. Este último inconveniente repercute negativamente en la circuitería, debido a que se produce un mayor desgaste en dichas posiciones.

Ejemplo: Suponiendo una memoria principal de 32 KB.

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

Solución:
0-5
P1 <---|---|---|---|---> | | | | | | | | | | | | | | |
6-11
P2 | <---|---|---> | | | | | | | | | | | | | | | |
12-19
P3 | | <---|---|---|---|---> | | | | | | | | | | | | |
20-26
P4 | | | <---> | | | | | | | | | | | | | | | |
20-26
P5 | | | | <---|---> | | | | | | | | | | | | | |
0-4
P6 | | | | | <---|---> | | | | | | | | | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

== Siguiente ajuste ==

Se continúa a partir de la posición de la última asignación realizada. Es muy probable que haya un hueco a partir de esa posición, reduciendo la longitud de la búsqueda. De esta forma se resuelve el inconveniente de usar en exceso las primeras posiciones de la memoria. Cuando se alcanza el final de la memoria se vuelve a comenzar la búsqueda desde el principio (por ello este criterio es también conocido como primer ajuste circular).

Ejemplo: Suponiendo una memoria principal de 32 KB.

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

Solución:

0-5
P1 <---|---|---|---|---> | | | | | | | | | | | | | | |
6-11
P2 | <---|---|---> | | | | | | | | | | | | | | | |
12-19
P3 | | <---|---|---|---|---> | | | | | | | | | | | | |
20-26
P4 | | | <---> | | | | | | | | | | | | | | | |
20-26
P5 | | | | <---|---> | | | | | | | | | | | | | |
27-31
P6 | | | | | <---|---> | | | | | | | | | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

'''DUDA:'''

Es evidente que cuando llega el P5 se necesitan 7 unidades de memoria, y éstas no están disponibles en el hueco de 27 a 31 (ahí solo hay 5) por lo que da la vuelta, vuelve a comenzar y lo asigna al primero que encuentra, que resulta ser casualmente, el 20-26. --[[Usuario:Ferguatol|fernandoenzo]] 22:14 19 dic 2011 (UTC)

Respuesta a la duda, el proceso no da la vuelta, tal y como se indica en teoría, Se continúa a partir de la posición de la última asignación realizada, que en este caso es la posición 20 --[[Usuario:Josleamat |Jose María Leal]] 18:43 18 dic 2017 (UTC)

== Mejor ajuste ==

Consiste en asignarle al proceso el hueco con menor desperdicio interno, i.e, el hueco el cual al serle asignado el proceso deja menos espacio sin utilizar. Su mayor inconveniente es su orden de complejidad (orden lineal, ''O(n)'') debido a que hay que recorrer todo el mapa de bits o toda la lista de control (una posible solución sería usar una lista de control encadenada que mantenga los huecos ordenados por tamaño creciente).
Otro problema es la fragmentación externa, debido a que se asigna el menor hueco posible, el espacio sobrante será del menor tamaño posible lo que da lugar a huecos de tamaño normalmente insuficiente para contener programas.

== Peor ajuste ==

Al contrario que el criterio anterior, se busca el hueco con mayor desperdicio interno, i.e, el hueco el cual al serle asignado el proceso deja más espacio sin utilizar, y se corta de él el trozo necesario (así la porción sobrante será del mayor tamaño posible y será más aprovechable). Tiene el mismo inconveniente en cuanto a orden de complejidad que el mejor ajuste (debido a la longitud de las búsquedas) y la fragmentación no resulta demasiado eficiente.

== Ajuste rápido ==

Mediante listas de control, se agrupan los huecos disponibles según su tamaño (0 < t < 10, 10 < t < 20, etc.). De esta manera, cuando se necesite un hueco, se seleccionarán los del grupo del tamaño que corresponda. En el caso de que haya varios huecos disponibles, se seleccionará uno en base a cualquiera de los criterios anteriores.

Organización de los huecos en el ajuste rápido:

Punteros a listas Lista de huecos
según tamaño
__________________
| | _____ _____ _____
| 0 < t < 10 |--->|_____|-->|_____|-->|_____|
|__________________|
| | _____ _____
| 10 < t < 20 |--->|_____|-->|_____|
|__________________|
| |
| ... |
|__________________|
| | _____
| t < 200 |--->|_____|
|__________________|

== Método de los compañeros ==

Es una variante del ajuste rápido, en el que los huecos se dividen en potencias de 2: 21, 22, ..., 2k. No es un método usado en la práctica, ya que, al realizar redondeos a potencias de 2, se produce un elevado desperdicio interno. Es un método rápido tanto en la asignación como en la liberación de bloques.
El funcionamiento es el siguiente:
Cuando se necesita un bloque de tamaño T se busca en la lista de la 1ª potencia mayor o igual a T (por ejemplo, 2k), si no hay ninguno se busca en la lista de la siguiente potencia (2k+1), si encontramos un bloque libre se retira y se divide por la mitad: una parte se le asigna al proceso y la otra se almacena en la lista de los huecos de tamaño 2k.

''Organización de los bloques:''

__________________
| | _____ _____ _____
| 2^(k+1) |--->|_____|-->|_____|-->|_____|
|__________________|
| | _____ _____
| 2^k |--->|_____|-->|_____|
|__________________|
| |
| ... |
|__________________|
| | _____
| 1 |--->|_____|
|__________________|

Debido a la forma de dividir los bloques al liberarse uno de ellos solamente podrá fusionarse con sus compañeros (bloques del mismo tamaño) con los que formará un bloque de tamaño superior.

''Divisiones sucesivas de los bloques:''
_______________________________________________
|0 |8 |
|_______________________|_______________________|
_______________________________________________
|0 |4 |8 |12 |
|___________|___________|___________|___________|
_______________________________________________
|0 |2 |4 |6 |8 |10 |12 |14 |
|_____|_____|_____|_____|_____|_____|_____|_____|
_______________________________________________
|0 | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|13|14|15|
|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|

=Implementación de ajustes en Java=

Se ha realizado un Anexo con la [[Implementación de ajustes en Java|implementación de los criterios de ajuste en Java]], con un gestor de memoria, sobre el que se implementan los métodos de primer ajuste, siguiente ajuste, mejor ajuste y peor ajuste.

Además, permite la visualización de la memoria en cada momento tanto como listas de control como mapas de bits.

7.3 [[Segmentación | Segmentación]]

Introducción

2020-04-02T16:38:03Z

Eleayogar:

El administrador de memoria es la parte del sistema operativo que se encarga de gestionar la memoria principal existente en el sistema. Para ello, asigna zonas de memoria principal a cada uno de los procesos existentes en base a sus necesidades.

Todo proceso, desde el punto de vista de la memoria, está compuesto de cuatro secciones:

* '''Código''': Se trata de la sección de memoria que contiene el código de nuestro proceso, entendido como la sección de instrucciones que componen nuestro programa.
* '''Variables globales y constantes''': Esta sección incluye las constantes definidas en el código del programa. Además, incluyen también las variables globales, que se trata de aquellas que son accesibles desde cualquier función.
* '''Pila (''Stack'')''': Se trata de la sección de memoria que se emplea para reservar espacio a las variables locales, y en la invocación de funciones (en las que se carga la dirección de retorno con respecto al código, la dirección de memoria en la que se encuentra definida la función y los parámetros de dicha función).
* '''Montón (''Heap'')''': Es la sección de memoria que se reserva de manera dinámica mediante las llamadas malloc() y free() de la biblioteca estándar de C, que invocan a las llamadas al sistema brk() y mmap() cuando corresponde.

Cuando se lanza un programa desde el lanzador de aplicaciones se hace uso de las llamadas al sistema ''fork'' y ''exec''.

La llamada ''fork'' crea una copia exacta del padre (salvo por el PID y la memoria que ocupa). Al proceso hijo se le facilita una copia de las variables del proceso padre y de los descriptores de fichero.

La llamada al sistema ''exec'' reemplaza el código del proceso clon recién creado por el de un programa que se encuentra almacenado en un fichero. El administrador de memoria actúa ante estas llamadas al sistema reservando memoria para el nuevo proceso que se acaba de lanzar.

En este tema, por razones de simplicidad, vamos a considerar que la administración de memoria se realiza de manera que '''todo''' el espacio de memoria ocupa una zona de memoria contigua. Es decir, no vamos a poder dividir las diferentes secciones de manera que se repartan en diferentes zonas de memoria que cuyo espacio de direccionamiento no sea consecutivo. No obstante, los sistemas operativos modernos '''no''' emplean las estrategias de asignación que vamos a ver a continuación:

* [[SO multiprogramables con particiones variables|Administración de memoria en sistemas operativos multiprogramables con particiones variables]]

Para más información, se puede consultar [https://stackoverflow.com/questions/6988487/what-does-the-brk-system-call-do|este enlace a stack overflow].

7.2 [[SO_multiprogramables_con_particiones_variables | SO multiprogramables con particiones variables]]

Algoritmo para averiguar interbloqueo

2020-04-02T16:36:06Z

Eleayogar:

== Algoritmo del Banquero ==

'''Introducción:'''

Este algoritmo recibe el nombre de banquero porque su funcionamiento es parecido a la gestión que hacen los bancos con las cuentas de crédito.
Necesita conocer de antemano las necesidades máximas de recursos por parte de cada proceso, esto es poco realista. Además, supone que cuando un proceso ha conseguido todos los recursos que necesita, los libera.

Para entenderlo un poco mejor hagamos la similitud con un banco:
Un banquero (s.o.) dispone de unos fondos (recursos) y tiene unos clientes (procesos). Cada cliente dispone de un crédito que corresponde al máximo que el banquero le prestará. El cliente irá solicitando fondos de ese crédito conforme los necesite. Si el banquero tuviese
fondos suficientes para prestar el máximo a cada cliente, no habría inconvenientes. Sin embargo, esto no es así, los recursos del banquero
son limitados, por lo que si todos reclaman todo su crédito no podrá satisfacerlos simultáneamente. Por lo tanto, la solución es que el
banquero gestione sus fondos de manera que todos los clientes puedan llegar al máximo en algún momento, aunque no lo hagan todos al mismo tiempo.

Estado seguro: El estado del sistema es seguro si existe una secuencia de asignaciones y liberaciones de recursos que permita a todos los procesos alcanzar en algún momento sus necesidades máximas de recursos.

La idea genérica del algoritmo es:

1. Buscar un proceso cuya suma recAsig + recDisp >= recMax
2. Suponemos que se asignan dichos recursos y el proceso termina su ejecución.
Sumamos sus recursos al vector recDisp y añadimos el proceso a la lista de finalizados.
3. Repetir primer paso hasta terminar todos los procesos (siendo un estado estable)
o bien hasta el punto en el que no sea posible ninguna asignación de recursos,
existiendo pues interbloqueo.

Ejemplo:

Proceso | Asignados | Maximos | Disponibles
| A B C D E | A B C D E | A B C D E
__________|_____________|___________|_______________
P0 | 1 0 2 1 1 | 1 2 2 1 2 | 0 0 2 1 1 //Recursos Disponibles Iniciales
P1 | 2 0 1 1 0 | 2 2 2 1 0 | 1 1 3 2 1 //P3 finalizado
P2 | 1 1 0 1 0 | 2 1 3 1 0 | 2 2 3 3 1 //P2 finalizado
P3 | 1 1 1 1 0 | 1 1 2 2 1 | 3 2 5 4 2 //P0 finalizado
//P1 finalizado
Pasos:
1. El primer proceso que cumple el paso 1 del algoritmo en esta tabla es P3:
[1 1 1 1 0]+[0 0 2 1 1] >= [1 1 2 2 1]
Lo consideramos terminado y añadimos sus recursos a los disponibles:
[1 1 1 1 0]+[0 0 2 1 1] = [1 1 3 2 1]
2. Volvemos a iterar desde P0. El siguiente proceso que puede adquirir los recursos necesarios
es P2. Añadimos sus recursos a la lista de disponibles.
3. Ahora nos es posible terminar P0 y por último P1.
4. Hemos logrado terminar todos los procesos sin problemas.

== Algoritmo en C# ==

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

Random r = new Random();

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

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

}

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

Faltaria solamente leer por consola el numero de procesos y de recursos que queremos testear, o introduccirlos manualmente

== Algoritmo en Python ==

<source lang="python">
def comprueba_configuracion(asignados, maximos, disponibles):
finalizados = []
i = 0
while(i < len(asignados)):
if not i in finalizados and puede_progresar(asignados[i], disponibles, maximos[i]):
print('Finaliza P%s\nDisponibles: %s' % (i,disponibles))
libera_recursos(asignados[i], disponibles)
finalizados.append(i) # Marca el proceso Pi como finalizado
i = 0
else:
i += 1

if(len(asignados) == len(finalizados)): # Si todos los procesos finalizan
print('\nEstado seguro para la configuracion de procesos-recursos dada')
else:
print('\nSe produce un interbloqueo')

# Incrementamos la lista de disponibles con los que tenia asignados
def libera_recursos(asignados, disponibles):
for i in range(len(disponibles)):
disponibles[i] += asignados[i]

# Devuelve True si el nº de elementos asignados mas los disponibles son mayores o iguales a los requeridos para continuar
def puede_progresar(asignados, disponibles, maximos):
resultado = True
for i in range(len(maximos)):
if(asignados[i] + disponibles[i] < maximos[i]):
resultado = False
break
return resultado

asignados = [
[1,0,2,1,1],
[2,0,1,1,0],
[1,1,0,1,0],
[1,1,1,1,0]
]
maximos = [
[1,2,2,1,2],
[2,2,2,1,0],
[2,1,3,1,0],
[1,1,2,2,1]
]
disponibles = [0,0,2,1,1]
</source>

Para este ejemplo (visto en clase) la salida sería:

<source lang="python">
>>> comprueba_configuracion(asignados, maximos, disponibles)
Finaliza P3
Disponibles: [0, 0, 2, 1, 1]
Finaliza P2
Disponibles: [1, 1, 3, 2, 1]
Finaliza P0
Disponibles: [2, 2, 3, 3, 1]
Finaliza P1
Disponibles: [3, 2, 5, 4, 2]

Estado seguro para la configuracion de procesos-recursos dada
</source>

== Algoritmo en Java ==
<source lang="java">
<pre>
public class Comprobaciones {

public static List<Proceso> devuelveLista(List<Proceso> asignados, List<Proceso> necesarios, Disponibles recursos){
List<Proceso> terminados = new ArrayList<Proceso>();
for(int i = 0; i < necesarios.size(); i++){
if(!(terminados.contains(asignados.get(i))) && ejecuta(asignados.get(i), necesarios.get(i), recursos)){
terminados.add(asignados.get(i));
System.out.println("Proceso " + asignados.get(i).getNombre() + " terminado");
for(int j = 0; j < recursos.getDisponibles().size(); j++){
recursos.setDisponible(recursos.getDisponibles().get(j) + asignados.get(i).getRecursosNecesarios().get(j), j);
}
System.out.println("Recursos disponibles: " + recursos.getDisponibles());
i = -1;
}

}
if(terminados.size() == asignados.size()){
System.out.println("Todos los procesos han sido ejecutados sin problemas.");
}
else{
System.out.println("Hay un interbloqueo, no se pueden seguir ejecutando procesos...");
}
return terminados;
}

public static Boolean ejecuta(Proceso asignados, Proceso necesarios, Disponibles disponibles){
// Devuelve True si tiene recursos suficientes...
Boolean ej = true;
for(int i = 0; i < necesarios.getRecursosNecesarios().size(); i++){
if((asignados.getRecursosNecesarios().get(i) + disponibles.getDisponibles().get(i)) < necesarios.getRecursosNecesarios().get(i)){
ej = false;
break;
}
}
return ej;
}

}
</pre>
</source>
<source lang="java">
<pre>
public static void main(String[] args) {

List<Proceso> asignados = creaAsignados();
List<Proceso> necesarios = creaNecesarios();
Disponibles disponibles = creaDisponibles();
Comprobaciones.devuelveLista(asignados, necesarios, disponibles);
}
</pre>
</source>
Resultado:
<pre>
Proceso P4 terminado
Recursos disponibles: [1, 1, 3, 2, 1]
Proceso P3 terminado
Recursos disponibles: [2, 2, 3, 3, 1]
Proceso P1 terminado
Recursos disponibles: [3, 2, 5, 4, 2]
Proceso P2 terminado
Recursos disponibles: [5, 2, 6, 5, 2]
Todos los procesos han sido ejecutados sin problemas.
</pre>
Nota: Las clases lo único que contienen son listas de enteros, y los procesos contienen además los nombres de los mismos.

6.4 [[Ejercicios | Ejercicios]]

Condiciones para el interbloqueo y estrategias de resolución

2020-04-02T16:35:31Z

Eleayogar:

= Condiciones para que se produzca interbloqueo =

Según [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman], para que se pueda producir un interbloqueo se tienen que dar las siguientes cuatro condiciones:

* '''Exclusión mutua''': cada recurso está asignado a un único proceso de manera exclusiva.
* '''Retención y espera''': los procesos que tienen, en un momento dado, recursos asignados con anterioridad, pueden solicitar nuevos recursos y esperar a que se le asignen sin liberar antes alguno de los recursos que ya tenía asignados.

* '''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. Ni siquiera el sistema operativo puede expropiárselo.

* '''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 =

Existen diversas estrategias frente a los interbloqueos, que se pueden agrupar en:

* Omisión
* Detección y recuperación
* Prevención
* Predicción

Que se detallan a continuación.

== Omisión ==

Considera que la probabilidad de un interbloqueo es muy baja, de modo que se confía en que no se van a producir. Por sorprendente que parezca, los sistemas operativos modernos convencionales suelen aplicar esta estrategia. Por justificar la decisión de los fabricantes de sistemas operativos cabe incidir en que las estrategias de resolución y prevención de interbloqueos tienen un coste alto desde el punto de vista del consumo de recursos de procesamiento y memoria.

== Detección y Recuperación ==

Esta estrategia permite la detección de una situación de interbloqueo y su consiguiente resolución. De entre las medidas de detección consideramos las siguientes:

* ''Grafo de relación recursos-procesos'': Consiste en la representación gráfica de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución. Esta técnica se basa en recorrer el grafo yendo de un nodo a otro, por lo que si se consigue volver al nodo de partida estaremos en un recorrido circular. Para que este tipo de error sea detectado usamos algoritmos de detección, se lanzan cuando se solicita un recurso ocupado, es decir, hay una nueva arista dentro de nuestro grafo y debemos comprobar que no da lugar a un recorrido cíclico.

Un ejemplo de grafo en el que se detecta un ciclo es el siguiente:

[[Archivo:deteccion_ciclo.png]]

* ''Matrices de relación recursos-procesos'': Consiste en la representación matricial de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución. Se distinguen dos tipos, el '''método mediante matrices binarias de relación''', y el '''método de detección matricial''':

=== Matrices binarias de relación ===
Una matriz binaria de relación es aquella que representa una relación R entre dos conjuntos, en la cual el primero de estos dos tiene múltiples asignaciones a elementos del segundo.

El método consiste en, aplicando matrices binarias de relación, utilizar el cierre transitivo para determinar si algún proceso está relacionado consigo mismo a través de otros, señalando así la existencia de ciclos. El procedimiento sería:

1.- Formar la matriz de espera (W: P->R): Los procesos P están a la espera de recursos R.

2.- Formar la matriz de asignación (A: R->P): Los recursos R están asignados a procesos P.

3.- Formar la matriz de procesos a la espera de procesos (T: WxA): Producto cartesiano de ambas matrices.

4.- Hallar el cierre transitivo de la matriz T: Que se puede obtener, por ejemplo, aplicando el Algoritmo de Warshall (algoritmo de análisis sobre grafos para encontrar el camino mínimo entre todos los pares de vértices en una única ejecución). El algoritmo es el siguiente:

Warshall(T, n){
for (k=1 to n){
for (i=1 to n){
for (j=1 to n){
Tij = Tij ⋁ (Tik ⋀ Tkj)
}
}
}
}

Donde n es la dimensión de la matriz T

5.- Si hay procesos que tengan un 1 en la diagonal principal, forman parte de algún ciclo.

Se trata de un método fácil de implementar, ya que solo se realizan operaciones con matrices y bucles, algo muy sencillo para una máquina. Sim embargo, tiene dos inconvenientes:
* El número de operaciones a realizar es muy alto teniendo en cuenta el tamaño que pueden alcanzar las matrices de recursos
* Solo se puede usar cuando solo existe una instancia de cada recurso.

=== Detección matricial ===
Método matricial que trata aquellos casos en los que existen múltiples instancias de un mismo recurso. Aísla grupos de procesos que no pueden proseguir la ejecución porque no pueden ver satisfechas sus peticiones pendientes.
Usan un método iterativo que:

1.-Marca procesos cuyas peticiones puedan satisfacerse con el actual vector de recursos disponibles.

2.-Suma al vector de disponibles los recursos asignados a los procesos marcados.

3.-Si todos los procesos están marcados: no hay interbloqueo.

4.-Si en una iteración no se marcan procesos: los procesos que quedan están interbloqueados.

== Resolución de interbloqueo ==

Tras la detección de un interbloqueo, se pueden aplicar algunas de las siguientes estrategias para resolverlo:

* ''Eliminación'': El sistema operativo selecciona a uno de los procesos que forma parte del interbloqueo y elimina el ciclo acabando con la ejecución de dicho proceso, si no es suficiente se eliminarán procesos hasta que se rompa el ciclo. La selección del proceso se realiza en base a un cierto criterio, por ejemplo, aquel proceso que lleve menos tiempo en ejecución o aquel que sea más voraz consumiendo recursos.Sin embargo, de una manera u otra el trabajo realizado por el proceso se pierde, algo que en algunos casos resulta inadmisible, como en sistemas en tiempo real. Aunque parezca una medida drástica, es la empleada en sistemas operativos convencionales. Aplicar el criterio de selección y eliminar procesos cuando el número de procesos es relativamente bajo puede solucionar el interbloqueo, pero si se da un bloqueo de por ejemplo, centenares de procesos, es una situación prácticamente inmanejable.

* ''Apropiación temporal'': Se retira la asignación de un recurso a un proceso (durante el tiempo necesario) para deshacer el interbloqueo (hemos de asegurarnos de que el proceso no se desbloquea al romperse el interbloqueo). Por ejemplo, supongamos que el recurso es una impresora: podríamos retirarle la asignación a un proceso P1 cuando este terminase de imprimir una página, asignarle la impresora a otro proceso P2 y volver a asignársela a P1 cuando P2 haya terminado su ejecución. El problema es que este método solo es posible dependiendo de la naturaleza del proceso. Con frecuencia es imposible recuperarse de esta manera ya que los recursos no pueden ser apropiados.

* ''Puntos de conformidad'',''sincronismo'' o ''checkpoints'': Consiste en tomar una imagen del estado del proceso, ya sea periódicamente o a instancia del propio proceso, de manera que si se produce un interbloqueo se vuelve a un estado de la ejecución anterior. Son muy poco usados ya que tienen un elevado coste en memoria y existe la posibilidad de que un proceso permanezca indefinidamente sin progresar, y no todos los recursos permiten almacenar y recuperar su estado. Además, puede darse el caso de que el estado del proceso sea externo al sistema (Como en el caso de una conexión a Base de Datos)

== Prevención ==

La prevención apunta a una serie de estrategias que eviten el interbloqueo. Concretamente, son cuatro las estrategias de prevención posibles en base a los principios que [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman] estableció como interbloqueo. Dichas estrategias son:

* ''Supresión de exclusión mutua'': Un proceso no puede tener acceso exclusivo a un recurso. No siempre es posible, y puede que lo único que haga sea cambiar el problema de sitio. Es una solución drástica, inviable. Por ejemplo, permitir que dos procesos usaran a la vez una impresora sería caótico.
* ''Supresión de retención y espera'' (1ª estrategia de Havender): El proceso debe tener asignado todos los recursos necesarios al inicio y no liberarlos hasta que éste finalice, se consigue utilizando un mismo semáforo para todos los recursos necesarios por el proceso. Esto presenta un inconveniente: si un recurso sólo se utiliza al final, estará ocupado durante toda la ejecución, no permitiendo ser usado por otros procesos. El aprovechamiento de recursos puede mejorarse mediante una programación más elaborada, dividiendo la ejecución del proceso en distintas fases y gestionando los recursos para cada una de ellas. Sin embargo, muchos procesos no saben cuántos recursos necesitarán hasta que hayan empezado a ejecutarse. No obstante, esta estrategia presenta unos inconvenientes: la posibilidad de aplazamiento indefinido por parte de aquellos procesos que usan más recursos, que siempre cuando no le falta uno le falta otro, lo que concluye en un mal aprovechamiento de recursos, obligando a los procesos a solicitar los recursos antes de que les haga falta y atentando contra el objetivo eficiente que nos proponemos.
* ''Supresión de no apropiación'' (2ª estrategia de Havender): Si un proceso está en ejecución y no puede obtener un recurso, dicho proceso libera todos los recursos que está usando y espera a que todos los que necesita estén disponibles. Es una estrategia optimista, usada cuando la probabilidad de que se produzca un interbloqueo en el sistema es baja. Problemas: se puede perder trabajo, además de presentar una carga extra la realización de peticiones.
* ''Supresión de espera circular'' (3ª estrategia de Havender): Si todos los recursos comunes a varios procesos se solicitan siempre en el mismo orden no se producen interbloqueos. De esta manera, se ordenan los recursos y se solicitan en ese orden. Por ejemplo: tenemos un proceso P1 y otro P2, de manera que ambos hacen uso de los recursos X e Y. En el siguiente caso, no pedirían los recursos en el mismo orden:

{| {{table}}
| align="center" style="background:#f0f0f0;"|'''P1:'''
| align="center" style="background:#f0f0f0;"|'''P2:'''
|-
| down(X)||down(Y)
|-
| down(Y)||down(X)
|-
| …||…
|-
| up(Y)||up(X)
|-
| up(X)||up(Y)
|}

Si se ejecuta la instrucción down(X) de P1, se conmuta a P2 y se ejecuta down(Y), se producirá un interbloqueo, ya que ambos estarán esperando a que el otro libere el recurso que necesitan.
Sin embargo, si pedimos los recursos siempre en el mismo orden de la siguiente forma:

{| {{table}}
| align="center" style="background:#f0f0f0;"|'''P1:'''
| align="center" style="background:#f0f0f0;"|'''P2:'''
|-
| down(X)||down(X)
|-
| down(Y)||down(Y)
|-
| …||…
|-
| up(Y)||up(Y)
|-
| up(X)||up(X)
|-
|
|}

Se puede comprobar que es imposible que se de un interbloqueo como en el caso anterior, ocurriendo lo mismo con cualquier número de procesos y recursos.

El principal inconveniente radica en que a veces, debido a la variedad y al número de recursos y procesos, es muy engorroso mantener un criterio de orden para todos los procesos de todo tipo.

== Predicción ==

El sistema operativo observa la evolución que siguen los procesos, y predice una posible situación de interbloqueo. Si detecta una alta probabilidad de que suceda, adopta una trayectoria de ejecución nueva para los procesos involucrados de manera que se garantice que no va a suceder un interbloqueo.

Si tuviéramos de antemano información sobre cómo los procesos van a usar los recursos, tal vez podríamos forzar un entrelazado de las asignaciones que nunca llevase a interbloqueo. Es un ejemplo el algoritmo del banquero. El inconveniente de este tipo de técnicas es que son poco realistas, ya que en sistemas reales no tenemos forma de predecir a la perfección el futuro de accesos a recursos.

6.3 [[Algoritmo_para_averiguar_interbloqueo | Algoritmo para averiguar interbloqueo]]

Definición de interbloqueo

2020-04-02T16:34:40Z

Eleayogar:

También conocido como '''bloqueo mutuo''' o '''deadlock'''.

Es una espera circular permanente de dos o más procesos. Existen una serie de [[Condiciones para el interbloqueo y estrategias de resolución#condiciones|condiciones]] para que se produzca y una serie de [[Condiciones para el interbloqueo y estrategias de resolución#estrategias|estrategias]] para resolverlos.

* Ejemplo simple:

[[Archivo: Ssoo wiki.png]]

Se aprecian dos procesos (P1 y P2), cada uno con un recurso diferente asociado (R1 y R2). Llega un punto en el que el proceso P1 ha adquirido el recurso R1 y el proceso P2 ha adquirido el recurso R2 y cada proceso necesita el otro recurso. Este es el punto de interbloqueo.

Según [http://es.wikipedia.org/wiki/Edsger_Dijkstra Dijkstra], una configuración de procesos y recursos es '''estado seguro''' si a partir de ella podemos seguir ejecutando código, es decir, no se producen interbloqueos.

= Ejemplo =

El siguiente ejemplo ilustra el problema con semáforos.

Dados dos procesos P1 y P2 con el siguiente código, con semáforos '''x''' e '''y''' con contadores a 1:

<pre> P1 P2
-- --

#1 while(1) { #1 while(1) {
#2 down(x); #2 down(y);
#3 acceso recurso_x(); #3 acceso_recurso_y();
#4 down(y); #4 down(x);
#5 acceso_recurso_y(); #5 acceso_recurso_x();
#6 up(y); #6 up(x);
#7 up(x); #7 up(y);
} }
</pre>

El cronograma, suponiendo Round Robin con quantum de 3 unidades sería:

<pre>
X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución
</pre>
<pre>
| #1| #2| #3| | | | #4| |
P1|---|---|---| | | |---X |
| | | | | | | | |
| | | | #1| #2| #3| | #4|
P2| | | |---|---|---| |---X
| | | | | | | | |
|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8
</pre>

En el que se puede ver la situación de interbloqueo.

Si repetimos con quantum 4:

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

La condición de carrera se produce igualmente, pero más tarde.

--[[Usuario:Leoberbue|Leoberbue]] ([[Usuario discusión:Leoberbue|discusión]]) 16:50 25 nov 2014 (CET)

6.2 [[Condiciones_para_el_interbloqueo_y_estrategias_de_resolución | Condiciones para el interbloqueo y estrategias de resolución]]

Ejercicios sincronización y comunicación

2020-04-02T16:33:51Z

Eleayogar:

= Ejercicio 1 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
if (get(s1) == 0) /* #4 */
up(s2); /* #5 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las líneas de código toman el mismo tiempo de ejecución.
* La función get(semáforo s) devuelve el valor del contador del semáforo.

El cronograma deberá incluir qué línea de código se ejecuta en cada unidad de ejecución.

[[solución ejercicio 1|Ver solución del ejercicio 1]]

= Ejercicio 2 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s2); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 2|Ver solución del ejercicio 2]]

= Ejercicio 3 =

En un examen de sistemas operativos, un estudiante plantea la siguiente solución basada en dos procesos, un proceso P1 productor y un proceso P2 consumidor, en el que el contador de los semáforos s1 y s2 valen inicialmente 0.

<source lang="c">
while(1) {
down(s1);
produce();
up(s2);
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
while(1) {
down(s2);
consume();
up(s1);
}
</source>

Responda brevemente si la solución que propone es idónea justificando su respuesta.

[[solución ejercicio 3|Ver solución del ejercicio 3]]

= Ejercicio 4 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
send(msg, P2); /* #2 */
recv(msg, P2); /* #3 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
recv(msg, P1); /* #2 */
send(msg, P1); /* #3 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
* El comportamiento de la primitiva send() es síncrono y el la primitiva recv() es bloqueante.
* Suponga que msg contiene un mensaje que se emplea como testigo y cuyo contenido no tiene relevancia.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 4|Ver solución del ejercicio 4]]

= Ejercicio 5 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s2); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto, con quantum ilimitado, por tanto, un proceso se mantiene en estado activo hasta que realice una operación bloqueante.
* Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 5|Ver solución del ejercicio 5]]

= Ejercicio 6 =

Dado dos procesos P1 y P2 cuyos códigos son los siguientes:

Código del Proceso 1:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
send(msg); /* #2 */
f(msg); /* #3 */
recv(msg); /* #4 */
}
</source>

Código del Proceso 2:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
recv(msg); /* #2 */
f(msg); /* #3 */
send(msg); /* #4 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
* El comportamiento de la primitiva send() es asíncrono y el de la primitiva recv() es bloqueante.
* Suponga que msg contiene un mensaje inicialmente bien formado cuyo contenido no tiene relevancia

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 6|Ver solución del ejercicio 6]]

= Ejercicio 7 =

En base a dos hilos h1 y h2 de un mismo proceso P cuyos codigos son los siguientes:

En el hilo h1 se ejecuta el siguiente código:

<source lang="c">
for (int i = 0; i<2; i++){ //#1
while(cerrojo_p2); //#2
cerrojo_p1 = 1; //#3
f(); //#4
cerrojo_p1 = 0; //#5

}
</source>

<source lang="c">
for (int i = 0; i<2; i++){ //#1
while(cerrojo_p1); //#2
cerrojo_p2 = 1; //#3
f(); //#4
cerrojo_p2 = 0; //#5

}
</source>
Proponga una solución en la que se reemplacen los cerrojos por semáforos. Realice el cronograma temporal de ejecución de la solución que propone.

Siendo cerrojo_p1 y cerrojo_p2 variables globales inicialmente a cero.

[[Usuario:Migoligon|Migoligon]] 17:57 4 dic 2011 (UTC)Creí que en el ejercicio 3 quedó claro que no debian iniciarse ambas a 0 porque era un error garrafal. Y ahora me encuentro esto y en las soluciones no diferencia s1 de s2, además de que la solución está preparada para que sea s1 = 1 y s2 = 0 no se de donde han sacado los datos para hacer la solución pero no creo que desde aqui.

Supongamos que:
*El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
*Se sabe que el hilo h1 es seleccionado en primer lugar por el planificador para ejecutarse.
*La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
el planificador

[[Usuario:Juacordia|Juacordia]] 16:33 5 dic 2011

Hola [[Usuario:Migoligon|Migoligon]] creo que estas confundiendo cerrojos por semaforos, una cosa es que los semaforos no puedan estar inicializados a cero y otra son los cerrojos. Espero haberte ayudado. PD: Los semaforos puedes ponerlos de otra manera.

[[solución ejercicio 7|Ver solución del ejercicio 7]]

= Ejercicio 8 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s1); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s2); /* #4 */
}
</source>

Suponiendo que los contadores de los semáforos s1 y s2 valen 1.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 8|Ver solución del ejercicio 8]]

= Ejercicio 9 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s); /* #2 */
f1(); /* #3 */
up(s); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s); /* #2 */
f2(); /* #3 */
up(s); /* #4 */
}
</source>

Suponiendo que el contador del semáforo s vale 1.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 9|Ver solución del ejercicio 9]]

6.1[[Definición_de_interbloqueo | Definición de interbloqueo]]

Mensajería

2020-04-02T16:32:46Z

Eleayogar:

Un mensaje es un contenedor que se emplea para intercambiar información entre dos o más procesos. Los mensajes tienen un cierto formato generalmente compuesto por una cabecera, que contiene información sobre la fuente y el destinatario, y un cuerpo, que contiene información específica.

Los mecanismos de mensajería se refieren al conjunto de funcionalidades que permiten al sistema operativo realizar la entrega de un mensaje a uno o varios procesos. Mediante dicho mecanismo también es posible resolver problemas de concurrencia.

Los sistemas operativos generalmente ofrecen dos llamadas al sistema para que un proceso pueda enviar y recibir mensajes:

* '''send(destino, mensaje)''': Envía un mensaje a un destino.
* '''receive(fuente, mensaje)''': Recibe un mensaje de una fuente.

Una operación compuesta derivada de las primitivas básicas es:

* '''sendrec (dest_fuent, mensaje)''': Envía un mensaje a un destino y recoge la respuesta.

Cualquier proceso que necesite comprobar si tiene mensajes para ser procesados por él debe invocar la llamada al sistema '''recv'''.

== Formas de identificación ==

Para identificar la fuente y el destino de nuestro mensaje se pueden emplear dos estrategias.

=== Denominación Directa ===

En este caso se emplea un ID que permite identificar a la fuente y al destinatario de manera unívoca en el sistema, por ejemplo, el PID de un proceso. La denominación directa permite tres configuraciones:

* ''Unicast'', de manera que la comunicación sucede entre una fuente y un destinatario.
* ''Broadcast'', el emisor envía un mensaje a '''todos''' los procesos existentes en el sistema.
* ''Multicast'', el emisor envía un mensaje a un grupo de procesos, siendo un grupo un subconjunto de procesos existentes en el sistema. El sistema operativo debe ofrecer llamadas al sistema que permitan a los procesos crear grupos y suscribirse a ellos. Un proceso puede suscribirse a tantos grupos como le sea necesario.

El principal inconveniente de la denominación directa es que se pierde el mensaje si el destino no se encuentra.

=== Denominación Indirecta ===

Se emplea un elemento intermediario denominado ''buzón''. El sistema operativo ofrece llamadas al sistema que permiten la creación y destrucción de buzones, por ejemplo, '''CreateMailbox''' y '''DestroyMailbox'''. Una vez creado el buzón, se emplea éste para realizar la comunicación entre procesos.

Con los buzones se pueden emplear cuatro formas diferentes de comunicación:
*Buzón limitado: De un proceso a otro.
*Buzón de entrada: De varios a uno.
*Buzón de salida: De uno a varios.
*Buzón múltiple: Varios procesos entre sí con el mismo buzón.

El receptor no conoce la identidad de quien envía el mensaje, a menos que el SO se haya encargado de ello. El problema surge cuando un proceso intruso y éste lee los mensajes de los buzones. Para remediarlo el SO establece permisos de acceso o contraseñas. O para evitar que el proceso infiltrado manipule los mensajes se puede también implementar firmas de certificación. y así garantizar la identidad de los remitentes.

== Formas de transmisión ==

Distinguimos tres formas de transmisión: Transmisión por copia, transmisión por referencia y transmisión por copia en caso de escritura.

=== Transmisión por copia ===

Si se emplea ''denominación directa'', al invocar el receptor la llamada ''recv'', el mensaje se copia del espacio de memoria del emisor al espacio de receptor. Esta forma de implementar la transmisión tiene un coste de orden lineal <math>O(n)</math>.

Si se emplea ''denominación indirecta'', al invocar ''send'' el emisor, el mensaje se copia del espacio de emisor al espacio del buzón, que se encuentra en el espacio de memoria del sistema operativo. Una vez que el receptor invoca ''receive'', se copia el mensaje al espacio de memoria que el receptor ha habilitado para almacenar el mensaje.

[[Archivo:SSOOMensajeria1.jpg]]

=== Transmisión por referencia ===

Es una mejora frente al mecanismo de transmisión por copia. Básicamente, en lugar de copiar el mensaje, lo que supone un coste de <math>O(n)</math>, se le devuelve al receptor una dirección de memoria en la que se encuentra el mensaje, lo que supone únicamente 4 u 8 bytes dependiendo del tamaño de palabra del procesador (si es de 32-bits o 64-bits).

Si se emplea junto a la '''denominación directa''', el sistema operativo le devuelve al receptor un puntero a la dirección en la que se encuentra el mensaje. Si el mensaje está en el espacio del emisor, son necesarios mecanismos explícitos de compartición de memoria entre procesos, ya que dos procesos cualesquiera no comparten memoria. Si el mensaje está en el espacio del sistema operativo, éste debe ofrecer a los procesos mecanismos para acceder a su espacio de memoria-

Si se emplea junto a la '''denominación indirecta''', el emisor crea un mensaje en el espacio del sistema operativo y se le ofrece un puntero al receptor.
[[Archivo:SSOOMensajeria2.jpg]]

=== Transmisión por copia en caso de escritura (COW) ===

Este método permite que los procesos emisor y receptor tengan acceso a la zona de memoria del mensaje de forma controlada. La zona puede pertenecer a uno de los procesos, o al SO, y se accede a ella a través de una ventana en el espacio de direcciones que inicialmente sólo permite consultar la información.

Cuando uno de los procesos intenta modificar el contenido del mensaje, se detecta esta escritura gracias al mecanismo de protección de la memoria. Entonces, el SO hace una copia para uno de ellos, actualiza las referencias, y deja que ambos procesos continúen.

Se mantiene un único espacio mientras sea posible. Si en muchas ocasiones se accede al mensaje para leer de él, se consigue un ahorro importante de espacio y tiempo. Pero hará falta incluir algún servicio para notificar al SO que ya no se necesita el espacio que haya asignado a la copia del mensaje, y que lo libere.

== Formas de comunicación ==

* Comportamiento del emisor, '''send()'''
** ''Síncrona'': el proceso emisor que realiza el send() queda bloqueado hasta que el receptor llama a recv() y el proceso bloqueado pasa a estado preparado.
** ''Asíncrona'': suponemos una estructura de datos con capacidad de almacenamiento limitada, dependiente del proceso destinatario o en el buzón del SO. Al ser enviados, los mensajes irán encolándose para que el proceso receptor pueda gestionarlos cuando pueda. De esta manera se aumenta el rendimiento, pero se requiere de políticas adicionales de tratamiento de los mensajes si la capacidad de almacenamiento de la estructura de datos se ve sobrepasada (PE, eliminación de mensajes, relocalización de memoria, etc..)

* Comportamiento del receptor, '''recv()'''
** ''Bloqueante'': una llamada a recv() sin mensajes a procesar pasa el proceso llamante a estado bloqueado. Un send() de otro proceso que añada un mensaje a la cola del proceso bloqueado hace que éste pase a estado preparado.
** ''No bloqueante'': una llamada a recv() sin mensajes a procesar devuelve un mensaje de error, pero la ejecución del proceso llamante continúa.

Entendemos por proceso llamante a aquel que hace uso de las llamadas send() y recv().

== Formato de los mensajes ==

=== Fijo ===

Los procesos acuerdan emplear un formato fijo para sus mensajes.

'''Ejemplo''': Simple Network Time Protocol.<ref> Véase http://tools.ietf.org/html/rfc4330, sección 4, Message Format.</ref>

1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|LI | VN |Mode | Stratum | Poll | Precision |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Delay |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Dispersion |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Reference Identifier |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Reference Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Originate Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Receive Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Transmit Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Key Identifier (optional) (32) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| |
| Message Digest (optional) (128) |
| |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

=== Variable ===

* Text-based human-readable.

# [http://en.wikipedia.org/wiki/Comma-separated_values Comma-Separated Value (CSV)]
# [http://en.wikipedia.org/wiki/XML Extensible Markup Language (XML) ]
# [http://en.wikipedia.org/wiki/JSON JavaScript Object Notation (JSON)]

=== Mixto ===

Los procesos acuerdan emplear mensaje con partes cuyo formato es fijo, como por ejemplo una cabecera inicial, seguido de partes de tamaño variable.

* Type-Length-Value

'''Ejemplo''': Usado en Netlink para la codificación de atributos de un mensaje.<ref>Ver Communicating between the kernel and user-space in Linux using Netlink Sockets (http://1984.lsi.us.es/~pablo/docs/spae.pdf)</ref>
{| 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"|'''Type-Length-Value'''
! width="15 px" style="background:#efefef;" | 0
! width="15 px" style="background:#efefef;" | 1
! width="15 px" style="background:#efefef;" | 2
! width="15 px" style="background:#efefef;" | 3
! width="15 px" style="background:#efefef;" | 4
! width="15 px" style="background:#efefef;" | 5
! width="15 px" style="background:#efefef;" | 6
! width="15 px" style="background:#efefef;" | 7
! width="15 px" style="background:#efefef;" | 8
! width="15 px" style="background:#efefef;" | 9
! width="15 px" style="background:#efefef;" | 10
! width="15 px" style="background:#efefef;" | 11
! width="15 px" style="background:#efefef;" | 12
! width="15 px" style="background:#efefef;" | 13
! width="15 px" style="background:#efefef;" | 14
! width="15 px" style="background:#efefef;" | 15
! width="15 px" style="background:#efefef;" | 16
! width="15 px" style="background:#efefef;" | 17
! width="15 px" style="background:#efefef;" | 18
! width="15 px" style="background:#efefef;" | 19
! width="15 px" style="background:#efefef;" | 20
! width="15 px" style="background:#efefef;" | 21
! width="15 px" style="background:#efefef;" | 22
! width="15 px" style="background:#efefef;" | 23
! width="15 px" style="background:#efefef;" | 24
! width="15 px" style="background:#efefef;" | 25
! width="15 px" style="background:#efefef;" | 26
! width="15 px" style="background:#efefef;" | 27
! width="15 px" style="background:#efefef;" | 28
! width="15 px" style="background:#efefef;" | 29
! width="15 px" style="background:#efefef;" | 30
! width="15 px" style="background:#efefef;" | 31

|-
| colspan=16, align="center"| Length
| colspan=16, align="center"| Type
|-
| colspan=32, align="center"| Value
|}

== Mensajería a través de la red ==

* Unicidad del destinatario, el PID ya no es suficiente, habría que decorar la manera de identificar al destino con el nombre del sistema. Por ejemplo: 23134@1984.lsi.us.es, siendo 1984.lsi.us.es el nombre del sistema en el que reside el proceso con PID 23134.
* Fiabilidad en la transmisión, son necesarios números de secuencia y acuses de recibo para garantizar que no hay pérdida de mensajes.
* Formato de los datos (http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html):
Estas consideraciones no aplican si el formato empleado a la hora de enviar datos en mensajes es en texto, tal como XML, JSON y CSV. Por tanto, sólo aplica a formatos con campos de tamaño fijo, donde un campo puede tener valores numéricos. Al enviar un entero a través de la red puede ser un problema debido a la forma en el que se representan los datos en la memoria dependiente de la arquitectura. Por ejemplo, un PC con arquitectura Intel x86 emplea formato little-endian, mientras que un SPARC de Sun Microsystems (ahora Oracle) emplea big-endian.

** Little Endian: Bytes menos significativo al principio.

<source lang="c">
int main(void)
{
int a = 10, i;
char *p = &a;

for (i=0; i<sizeof(a); i++) {
printf("posición %d: %.2x\n", i, p[i]);
}
}
</source>

Muestra el siguiente resultado en un PC:

posición 0: 0a (n+3)
posición 1: 00 (n+2)
posición 2: 00 (n+1)
posición 3: 00 (n)

** Big Endian: Bytes menos significativo al final.

posición 0: 00 (n)
posición 1: 00 (n+1)
posición 2: 00 (n+2)
posición 3: 0a (n+3)

En Internet se sigue la convención de expresar datos en Big Endian, habría que hacer la conversión. Habría que usar '''ntohl''' (network to host long).

En little-endian, la implementación de ntohl es la siguiente:

#define __constant_ntohl(x) ___constant_swab32((__be32)(x)

Ver /usr/include/linux/byteorder/little_endian.h

mientras que en big-endian es:

#define __constant_ntohl(x) ((__u32)(__be32)(x))

Si empleamos formatos textuales, como CSV, XML o JSON, que codifican la información en bytes, no tenemos este problema.

==Referencias==
'''Aún sin referencias.'''

5.8 [[Ejercicios_sincronización_y_comunicación | Ejercicios sincronización y comunicación]]

Monitores

2020-04-02T16:31:28Z

Eleayogar:

Idea desarrollada en los años 70 Brinch-Hansen y Hoare (https://web.archive.org/web/20091229162223/http://java.sun.com/developer/Books/performance2/chap4.pdf), que notaron los siguientes problemas con respecto al uso de los semáforos:

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

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

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

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

Permiten organizar procesos en espera mediante:

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

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

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

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

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

== Ejemplo del funcionamiento de una clase monitor ==

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

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

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

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

Dichos hilos tienen el siguiente código:

* Lector (h1):

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

* Escritor (h2):

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

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

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

Asignación del recurso procesador

| 1 |2.1|2.2|2.3| | |2.4|2.5| 3 | 1 | | | | |2.1|2.2|2.3|2.4| | | | |2.5| 3 | 1 | |
h1 <---|---|---|---P | |---|---|---|---P | | | |---|---|---|---| | | | |---|---|---> |
| | | | | 1 |2.1| | | | |2.2|2.3| 3 | 1 | | | | |2.1|2.2|2.3| 3 | | | | 1 |
h2 | | | | <---|---B P | | |---|---|---|---P | | | |---|---|---|---| | | |--->
----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

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

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

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

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

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

| 1 | 2 |2.1|2.2| | | |2.3|2.4|2.5| 3 | | | | | 1 | 2 |2.1|2.2| | |2.3|2.4|2.5| 3 |
h1 <---|---|---|---P | | |---|---|---|---P | | | |---|---|---|---P | |---|---|---|---P
| | | | | 1 | 2 |2.1| | | | |2.2|2.3| 3 | 1 | | | | | 2 |2.1| | | | |
h2 | | | | <---|---|---B | P | |---|---|---|---P | | | |---|---B | P | |
----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

| | | | | 1 |
h1 | | | | |--->
|2.2|2.3| 3 | 1 | |
h2 |---|---|---|---> |
|---|---|---|---|---|
25 26 27 28 29 30

--[[Usuario:Mangonvil1|Mangonvil1]] 17:20 14 dic 2011 (UTC)Creo que esta solución sería más correcta puesto que la línea 2 del código de cada hilo(en el hilo 1 el get() y en el hilo 2 el set(i)) hay que tratarla como una unidad de ejecución más. (Pendiente de que Pablo le de el visto bueno)

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

== Fuentes ==
Tema 4
http://hpjpc.googlecode.com/files/HPJPC%20Christopher%20and%20Thiruvathukal.pdf

5.7[[Mensajería | Mensajería]]

Semáforos

2020-04-02T16:30:50Z

Eleayogar:

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos es importante recordar cómo funciona el [[Estados de los procesos|diagrama de estados de los procesos]]

= Semáforos =

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

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

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

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

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

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

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

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

Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.

=== Ejemplo de uso de semáforos ===

Suponga el siguiente ejemplo en el que se quieren sincronizar dos hilos de un proceso, de manera que se dé la siguiente secuencia de ejecución: A, B, A, B, ... y así sucesivamente. El siguiente código resolvería el problema:

<source lang="c">
semaforo a = semaforo.create(1);
semaforo b = semaforo.create(0);

/* código del hilo A */
while (1) {
a.down();
printf("hilo A\n");
b.up();
}

/* código del hilo B */
while (1) {
b.down();
printf("hilo B\n");
a.up();
}
</source>

=== Tipos de semáforos ===

Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:

* Semáforo de exclusión mutua, inicialmente su contador vale 1 y permite que haya un único proceso simultáneamente dentro de la sección crítica.
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.
* Semáforo de espera, generalmente se emplea para forzar que un proceso pase a estado bloqueado hasta que se cumpla la condición que le permite ejecutarse. Por lo general, el contador vale 0 inicialmente, no obstante, podría tener un valor distinto de cero.

=== Ventajas e inconvenientes ===

La principal ventaja de los semáforos frente a los [[cerrojos]] es que permiten sincronizar dos o más procesos de manera que no se desperdician recursos de CPU realizando comprobaciones continuadas de la condición que permite progresar al proceso.

Los inconvenientes asociados al uso de semáforos son los siguientes:

* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.
* No hay nada que obligue a los programadores a usarlos.
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.
* Son independientes del recurso compartido al que se asocian.

Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].

=== Granularidad ===
Número de recursos controlados por cada semáforo. Hay de dos tipos:
* Granularidad fina: Un recurso por semáforo. Hay un mayor grado de paralelismo, lo que puede mejorar la rapidez de ejecución de la protección. Aunque a mayor número de semáforos existe una mayor probabilidad de que se dé un interbloqueo entre semáforos, que no sería una mejora de lo que intentamos evitar.
* Granularidad gruesa: Un semáforo para todos los recursos. Caso totalmente inverso al anterior: Ahora al tener un semáforo no se produce interbloqueo entre ellos, aunque los tiempos de ejecución son excesivamente largos.

5.6[[Monitores | Monitores]]

Cerrojos

2020-04-02T16:30:10Z

Eleayogar:

= Ejemplo de implementación =

El siguiente código sería un posible ejemplo del uso de control de concurrencia mediante cerrojos:

<source lang="c">
int cerrojo = 0; /* Inicializamos la variable cerrojo. Esto sería sólo válido para
hilos, ya que los procesos no comparten espacio de memoria. La variable se inicializa FUERA de los hilos.
Del while en adelante, ya es código perteneciente a los hilos en ejecución. */

while(cerrojo == 1); // Protocolo de
cerrojo = 1; // entrada

... // Sección crítica

cerrojo = 0; // Protocolo de salida
</source>

Sin embargo, esto es problemático: Supongamos que tenemos únicamente un proceso con dos hilos (Hx y Hy) y el planificador retira el hilo Hx justo antes de ejecutarse la instrucción ''cerrojo = 1;''. El hilo Hy ejecuta su código, entra en la sección crítica (Esto puede ocurrir ya que cerrojo sigue a 0) y el planificador le retira el uso del procesador dentro de ésta. A continuación, se le vuelve a asignar el procesador a Hx.

De esta forma, tenemos a dos hilos ejecutando código de la sección crítica. Para evitar este problema, debemos implementar los protocolos de entrada y salida de forma que se ejecuten en una sola instrucción, con lo cual o el planificador retira el uso del procesador antes de esta instrucción, o sino lo retira después de haberla ejecutado.

= Cerrojos mediante instrucciones atómicas =

Podemos implementar cerrojos mediante instrucciones especiales de comprobación y puesta a 0 y 1.

<source lang="c">
int cerrojo = 0;

void lock() {
while (__sync_lock_test_and_set(&cerrojo, 1));
}

void unlock() {
__sync_lock_release(&cerrojo);
}
</source>

El método lock comprueba mediante __sync_locktest_and_set(&cerrojo,1) el valor del cerrojo: si es 0, cambia el valor del cerrojo a 1 y devuelve 0, por tanto, se sale del while y entra en sección crítica; si es 1, devuelve 1 y continúa comprobando el valor, por tanto, no entra en la sección crítica hasta que cambie el valor del cerrojo.

El método unlock, mediante _sync_lock_release(&cerrojo), cambia el valor del cerrojo a 0.

* http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html
* http://stackoverflow.com/questions/1383363/is-my-spin-lock-implementation-correct-and-optimal

5.4[[Ejercicio_de_concurrencia_de_procesos | Ejercicio de concurrencia de procesos]]

5.5[[Semáforos | Semáforos]]

Mecanismos de sincronización

2020-04-02T16:29:31Z

Eleayogar:

= Optimistas =

Este mecanismo debe emplearse si el programador considera que la frecuencia de acceso a un recurso compartido es baja, es decir, que supone que la probabilidad de coincidencia de dos o más procesos al recurso compartido es baja.

El siguiente ejemplo muestra el código ejecutado por dos hilos: hx y hy de un mismo proceso.

<source lang="c">
int tabla[3] = { 100, 101, 102 }; /* tabla compartida por ambos hilos hx y hy. */

/* actividad del hilo */
void *actividad_hilo(void *ptr)
{
int i;

while(1) {
for (i=0; i<3; i++) {
actualiza_tabla(i);
sleep((random() % 10) + 1); /* hilo pasa a estado bloqueado durante 1 a 10 segundos. */
}
}
return NULL;
}

int main(void)
{
pthread_t hilo1, hilo2;

pthread_create(&hilo1, NULL, actividad_hilo, NULL); /* creación hilox. */
pthread_create(&hilo2, NULL, actividad_hilo, NULL); /* creación hiloy. */
pthread_join(hilo1, NULL);
pthread_join(hilo2, NULL);
}

void actualiza_tabla(int i) {
int tmp;
retry:
tmp = tabla[i]; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (tabla[i]+1 != tmp) { /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
}
tabla[i]=tmp;
}
</source>

Los inconvenientes de este tipo de mecanismo son dos:

* Se consume más memoria, pues hay que realizar una copia del recurso compartido para efectuar la actualización.
* En situaciones de coincidencia, se tiene que volver a realizar la operación, por tanto, se desperdician recursos de procesamiento.

En base al ejemplo anterior, hay que garantizar que la operación de comprobación y actualización es '''atómica'''. Se dice que una operación es '''atómica''' cuando es indivisible, es decir, que no quedamos en una situación intermedia al ejecutar dicha operación. Los procesadores incluyen una función llamada ''Test and Set'' (TAS) que nos permite ejecutar dos órdenes de manera '''atómica'''. Al ser una instrucción máquina el procesador nos garantiza que ningún proceso va a interrumpirla, evitando así la '''condición de carrera'''. Por ejemplo en x86 tenemos la instrucción ''LOCK BTS'' (Bit Test and Set) que nos permite añadir una cadena de bits para que se ejecute de manera '''atómica'''.

Como ventaja, este tipo de mecanismo nos ofrece un mayor grado de paralelismo, por tanto, una mayor tasa de transferencia, siempre que se emplee en una situación donde la frecuencia de concurrencia sea baja.

Por último, si el programador ha empleado una aproximación optimista para una situación en la que la frecuencia de coincidencia es alta, podría darse el caso de que un hilo no progrese en su ejecución de manera indefinida, al tener que volver a reintentar la actualización una y otra vez hasta conseguirlo sin que haya concurrencia.

Un mecanismo de sincronización optimista funciona de la siguiente manera:

* Paso 1. Realiza una copia del estado en el que está el recurso compartido.
* Paso 2. Opera con esa copia.
* Paso 3. Compruebo si mi copia alterada coincide con el original aplicándole también el tratamiento.

= Pesimistas =
Este mecanismo debe emplearse si se considera que la frecuencia de acceso al recurso compartido es alta.

En este mecanismo disponemos de tres partes:

* El protocolo de entrada, en el que se emplea un mecanismo que no permite continuar con la ejecución si otro u otros procesos están accediendo al recurso compartido.
* La sección crítica, en el que se realizan las operaciones pertinentes con el recurso compartido.
* El protocolo de salida, en el que se vuelve a permitir el acceso al recurso compartido.

El siguiente ejemplo muestra cómo se implementa el control de concurrencia pesimista para 2 hilos, hx y hy:

<source lang="c">
int compartida = 1;
protocolo_de_entrada(); /* no permito acceso a variable compartida. */
compartida++; /* sección crítica: actualización de la variable compartida. */
protocolo_de_salida(); /* vuelvo a permitir acceso a la variable compartida. */
</source>

Los protocolos de entrada y salida son, generalmente, operaciones costosas en términos de recursos de procesamiento, pues requieren el uso de instrucciones atómicas cuyo tiempo de ejecución es alto.

Por último, se podría emplear un control de concurrencia pesimista para resolver un problema que se resuelve con un control de concurrencia optimista, pero no al revés.

== Implementación del control de concurrencia pesimista ==

El control de concurrencia pesimista se puede implementar de dos formas mediante:

* Espera ocupada o activa, mediante '''cerrojos'''. En este mecanismo se comprueba continuamente la condición que permite franquear en el protocolo de entrada, por tanto, el proceso permanece en estado activo comprobando continuadamente la condición que le permite progresar en su ejecución, tiempo que está siendo desaprovechado por el procesador.
* Espera no ocupada o bloqueante, mediante '''semáforos''', '''monitores''' o '''mensajería'''. Estos mecanismos hacen que el proceso pase a estado bloqueado cuando no se puede franquear el protocolo de entrada, por tanto, al quedar un proceso que no puede progresar en estado bloqueado, el planificador de procesos tiene que seleccionar a otro proceso.

Nota aclarativa: Definición de ''espera ocupada o activa''

Esperar a que algo ocurra realizando continuas comprobaciones.
Ejemplo:
…
variable= 0;
while(variable==0);
…

5.3[[Cerrojos | Cerrojos]]

Concurrencia de procesos

2020-04-02T16:28:55Z

Eleayogar:

La concurrencia de procesos se refiere a las situaciones en las que dos o más procesos puedan coincidir en el acceso a un recurso compartido o, dicho de otra forma, que requieran coordinarse en su ejecución. Para evitar dicha coincidencia, el sistema operativo ofrece mecanismos de arbitraje que permiten coordinar la ejecución de los procesos.

= El problema del productor y consumidor =

Un ejemplo de un problema de concurrencia sería el siguiente: dados dos procesos A (productor) y B (consumidor) que se ejecutan indefinidamente en el tiempo, el proceso A debe recibir tiempo de ejecución antes que B. Tras esto, el proceso B debe recibir su oportunidad de ejecución, dando paso de nuevo al proceso A y así sucesivamente, siguiendo un esquema de alternancia estricta.

proceso A |-- -- --
|
proceso B | -- -- --
|_____________

Recuerde que el planificador de procesos, al desconocer la naturaleza de los procesos y sus objetivos, no dispone de información suficiente para garantizar la secuencia de ejecución descrita en el ejemplo anterior. De este modo, suponiendo que ambos procesos se encuentran en estado preparado, podría seleccionar al proceso B para pasar a estado activo antes de seleccionar al proceso A, situación que no es deseada.

El planificador de procesos, como hemos visto en capítulos anteriores, emplea [[Criterios de planificación|criterios de planificación]] que no tienen en consideración el objetivo de los procesos. Podemos decir que este '''desconoce''' cuál es el propósito de los procesos; únicamente puede observar si presentan un comportamiento más o menos interactivo.

Por tanto, el programador, a la hora de modelar los procesos, debe emplear los mecanismos de arbitraje que ofrece el sistema operativo y que permitirían resolver el problema de concurrencia que se plantee.

= Mecanismos de arbitraje =

Los mecanismos de arbitraje que ofrece el sistema operativo son dos principalmente:

* Mecanismos de '''sincronización''': el sistema operativo ofrece mecanismos que permiten a los procesos coordinar su ejecución para conseguir el objetivo sin que sucedan situaciones no deseadas, como por ejemplo que dos o más procesos coincidan simultáneamente en el acceso a un cierto recurso que no se puede compartir.

* Mecanismos de '''mensajería''': el sistema operativo ofrece mecanismos de comunicación entre procesos mediante mensajes. El intercambio de mensajes entre procesos permite coordinarlos.

= Programación concurrente =

El término programación concurrente se emplea con frecuencia para referirse a un conjunto de programas que funcionan en cooperación.

Hay tres formas de interacción entre procesos cooperativos:

*Concurrencia: Hay un recurso común, si varios procesos modificaran la misma información a la vez, cada uno podría destruir parte del trabajo de los demás. Si lo hacen uno tras otro, en serie, se obtendrá el resultado correcto.

*Sincronización: El Sistema Operativo se encarga de enviarle señales a los procesos para coordinar su evolución y conseguir que progrese armónicamente.

*Comunicación: El S.O. transmite mensajes entre los procesos, que se usan para intercambiar, enviar o recibir información.

Se le llama programación concurrente ya que la concurrencia fue la primera forma de iterar recursos entre procesos cooperativos.

= Sección crítica =

Una ''sección crítica'' se trata de una sección del código que no debe ser ejecutada por varios procesos o hilos simultáneamente. Un ejemplo de ''sección crítica'' es la sección de código en la que se accede a un recurso compartido. Para evitar el acceso simultaneo a la sección crítica se emplean mecanismos que garantizan la ''exclusión mutua''.

La exclusión mutua se debe realizar de forma coordinada y eficiente, para ello se requiere:

*No más de un proceso por sección crítica y recurso compartido.

*El mismo proceso no puede usar el mismo recurso compartido indefinidamente.

*Todo proceso debe entrar antes o después a usar el recurso.

*Si el recurso está sin uso, cualquiera que lo requiera dispondrá de él inmediatamente.

*Si hay varios esperando usar el recurso y éste se libera, uno de los que estaba esperando lo usará durante un tiempo determinado.

Para llevar esto a cabo se necesita un protocolo que indique cuando el recurso está libre y cuando está siendo ocupado.

= Tipos de mecanismos de sincronización =

Los mecanismos de sincronización los podemos catalogar en dos categorías:

*[[Mecanismos de sincronización#Optimista|Optimistas]]: Este mecanismo considera que la frecuencia de acceso a un cierto recurso compartido es ''baja''. Este tipo tiene más consumo de memoria, ya que tiene que copiar el recurso compartido y, en caso de interferencia en el hilo, tiene que volver a ejecutarlo y consume más recursos.

*[[Mecanismos de sincronización#Pesimista|Pesimistas]]: Este mecanismo permite coordinar la ejecución de dos o más procesos que acceden al recurso compartido con una frecuencia ''alta''.

Dependerá del criterio del programador el tipo de mecanismo que utilice ya que puede que no elija el tipo correcto. Por ejemplo, puede que la frecuencia de acceso a un cierto recurso sea alta y el programador le asigna un mecanismo optimista, esto provocaría no obtener el resultado esperado.

== ¿Cómo provocar errores de concurrencia en Java? ==
Pequeño experimento, por si queremos observar cómo se producen errores de concurrencia en operaciones tan simples como la actualización de una lista.

<source lang="java">
public static void main(String[] args) {

List<Integer> list = new ArrayList<Integer>();

/*
* EXPLICACIÓN:
*
* Tenemos creada una lista global, "list" , que será accedida al mismo
* tiempo por varios hilos. En este código se observa como a veces se
* producen errores de concurrencia al realizar modificaciones sobre la
* lista al mismo tiempo. Este es el motivo por el que debemos usar
* mecanismos como los semáforos u otras técnicas para prevenir este
* tipo de errores.
*
* Los errores de concurrencia en java se muestran como:
* ConcurrentModificationError
*
* También es curioso notar que los errores se dan sobretodo al principio, en
* los 30 primeros segundos, luego hay hilos que no se vuelven a
* ejecutar mientras que un par de ellos de forma aleatoria, se ejecutan
* cíclicamente, uno tras el otro.
*
*/
// -----------------------------------------------------------------------------------------------------------------------

// Los hilos con esta tarea añaden un número aleatorio de 0 a 100 en la
// lista cada seg.
Runnable tarea = () -> {
while (true) {
String nombreHilo = Thread.currentThread().getName();
System.out.println("Hola soy el hilo " + nombreHilo);
list.add(new Random().nextInt(100));
System.out.println(list);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
};

// Los hilos con esta tarea añaden también otro número aleatorio de 0 a
// 100 en la lista cada seg.

Runnable tarea2 = () -> {
while (true) {
String nombreHilo = Thread.currentThread().getName();
System.out.println("Hola soy el hilo " + nombreHilo);
list.add(new Random().nextInt(100));
System.out.println(list);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
};

// Los hilos con esta tarea eliminan un número de una posición aleatoria
// cada seg.
Runnable tarea3 = () -> {
while (true) {
String nombreHilo = Thread.currentThread().getName();
System.out.println("Hola soy el hilo " + nombreHilo);
Random r = new Random(list.size());
if (list.contains(r))
list.remove(r);
System.out.println(list);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
};

//Creación de Hilos.
Thread hilo = new Thread(tarea);
Thread hilo2 = new Thread(tarea2);
Thread hilo3 = new Thread(tarea3);
Thread hilo4 = new Thread(tarea3);
Thread hilo5 = new Thread(tarea);
Thread hilo6 = new Thread(tarea3);

//Ejecución.
hilo.start();
hilo2.start();
hilo3.start();
hilo4.start();
hilo5.start();
hilo6.start();

}

</source>

5.2[[Mecanismos_de_sincronización | Control optimista y pesimista de la concurrencia]]

Material teoría

2020-04-02T16:28:09Z

Eleayogar: /* Interbloqueo */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla.

= Subida de notas =

Indica aquí tu UVUS si quieres que revise tus contribuciones para ser tenidas en cuenta en la subida de notas:

* beagalcar

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Arranque del sistema|Arranque del sistema]]
* 2.6. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 2.9. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]
* 2.10. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 3.1. [[Multiprogramación|La multiprogramación]]
* 3.2. [[Estados de los procesos|Estados de los procesos]]
* 3.3. [[Planificador de procesos|El planificador de procesos]]
* 3.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 3.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 3.6. [[Conmutación de procesos|La conmutación de procesos]]
* 3.7. [[Hilos|Hilos]]
* 3.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 4.1. [[Planificación de procesos|La planificación de procesos]]
* 4.2. [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 4.3. [[Criterios de planificación|Criterios de planificación]]
* 4.4. [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 4.5. [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 4.6. [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 4.7. [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 4.8. [[Ejercicios planificación de procesos|Ejercicios]]
* 4.9. [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 5.1. [[Concurrencia de procesos|Concurrencia de procesos]]
* 5.2. [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 5.3. [[Cerrojos|Cerrojos]]
* 5.4. [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 5.5. [[Semáforos|Semáforos]]
* 5.6. [[Monitores|Monitores]]
* 5.7. [[Mensajería|Mensajería]]
* 5.8. [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 6.1. [[Definición de interbloqueo|Definición]]
* 6.2. [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 6.3. [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 6.4. [[Ejercicios]]

== Administración de memoria ==

* 7.1. [[Introducción|Introducción]]
* 7.2. [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 7.3. [[Segmentación|Segmentación]]
* 7.4. [[Paginación|Paginación]]
* 7.5. [[Sistema combinado|Sistema combinado]]
* 7.6. [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 7.7. [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1. [[Memoria Virtual|Introducción]]
* 9.2. [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3. [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4. [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1. [[EstructuraES|Estructura dispositivo E/S]]
* 10.2. [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3. [[Diseño modular E/S|Diseño modular E/S]]
* 10.4. [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión E/S ==

* 11.1. [[Discos Magnéticos|Discos Magnéticos]]
* 11.2. [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3. [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4. [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5. [[Unidades SSD|Unidades SSD]]
* 11.6. [[Reloj hardware: Intel 8253]]
* 11.7. [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1. [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2. [[FAT|FAT]]
* 12.3. [[EXT2 |EXT2]]
* 12.4. [[Ejercicios Administración Ficheros|Ejercicios]]

== Seguridad ==

* 13.1. [[Definiciones de Seguridad]]

== Modelos de diseño de Sistemas Operativos ==

* 14.1. [[Virtualización]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Material teoría

2020-04-02T16:27:43Z

Eleayogar: /* Administración de memoria */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla.

= Subida de notas =

Indica aquí tu UVUS si quieres que revise tus contribuciones para ser tenidas en cuenta en la subida de notas:

* beagalcar

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Arranque del sistema|Arranque del sistema]]
* 2.6. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 2.9. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]
* 2.10. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 3.1. [[Multiprogramación|La multiprogramación]]
* 3.2. [[Estados de los procesos|Estados de los procesos]]
* 3.3. [[Planificador de procesos|El planificador de procesos]]
* 3.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 3.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 3.6. [[Conmutación de procesos|La conmutación de procesos]]
* 3.7. [[Hilos|Hilos]]
* 3.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 4.1. [[Planificación de procesos|La planificación de procesos]]
* 4.2. [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 4.3. [[Criterios de planificación|Criterios de planificación]]
* 4.4. [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 4.5. [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 4.6. [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 4.7. [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 4.8. [[Ejercicios planificación de procesos|Ejercicios]]
* 4.9. [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 5.1. [[Concurrencia de procesos|Concurrencia de procesos]]
* 5.2. [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 5.3. [[Cerrojos|Cerrojos]]
* 5.4. [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 5.5. [[Semáforos|Semáforos]]
* 5.6. [[Monitores|Monitores]]
* 5.7. [[Mensajería|Mensajería]]
* 5.8. [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 7.1. [[Definición de interbloqueo|Definición]]
* 7.2. [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 7.3. [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 7.4. [[Ejercicios]]

== Administración de memoria ==

* 7.1. [[Introducción|Introducción]]
* 7.2. [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 7.3. [[Segmentación|Segmentación]]
* 7.4. [[Paginación|Paginación]]
* 7.5. [[Sistema combinado|Sistema combinado]]
* 7.6. [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 7.7. [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1. [[Memoria Virtual|Introducción]]
* 9.2. [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3. [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4. [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1. [[EstructuraES|Estructura dispositivo E/S]]
* 10.2. [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3. [[Diseño modular E/S|Diseño modular E/S]]
* 10.4. [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión E/S ==

* 11.1. [[Discos Magnéticos|Discos Magnéticos]]
* 11.2. [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3. [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4. [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5. [[Unidades SSD|Unidades SSD]]
* 11.6. [[Reloj hardware: Intel 8253]]
* 11.7. [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1. [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2. [[FAT|FAT]]
* 12.3. [[EXT2 |EXT2]]
* 12.4. [[Ejercicios Administración Ficheros|Ejercicios]]

== Seguridad ==

* 13.1. [[Definiciones de Seguridad]]

== Modelos de diseño de Sistemas Operativos ==

* 14.1. [[Virtualización]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Material teoría

2020-04-02T16:27:06Z

Eleayogar: /* Concurrencia de procesos */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla.

= Subida de notas =

Indica aquí tu UVUS si quieres que revise tus contribuciones para ser tenidas en cuenta en la subida de notas:

* beagalcar

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Arranque del sistema|Arranque del sistema]]
* 2.6. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 2.9. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]
* 2.10. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 3.1. [[Multiprogramación|La multiprogramación]]
* 3.2. [[Estados de los procesos|Estados de los procesos]]
* 3.3. [[Planificador de procesos|El planificador de procesos]]
* 3.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 3.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 3.6. [[Conmutación de procesos|La conmutación de procesos]]
* 3.7. [[Hilos|Hilos]]
* 3.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 4.1. [[Planificación de procesos|La planificación de procesos]]
* 4.2. [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 4.3. [[Criterios de planificación|Criterios de planificación]]
* 4.4. [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 4.5. [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 4.6. [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 4.7. [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 4.8. [[Ejercicios planificación de procesos|Ejercicios]]
* 4.9. [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 5.1. [[Concurrencia de procesos|Concurrencia de procesos]]
* 5.2. [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 5.3. [[Cerrojos|Cerrojos]]
* 5.4. [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 5.5. [[Semáforos|Semáforos]]
* 5.6. [[Monitores|Monitores]]
* 5.7. [[Mensajería|Mensajería]]
* 5.8. [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 7.1. [[Definición de interbloqueo|Definición]]
* 7.2. [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 7.3. [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 7.4. [[Ejercicios]]

== Administración de memoria ==

* 8.1. [[Introducción|Introducción]]
* 8.2. [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 8.3. [[Segmentación|Segmentación]]
* 8.4. [[Paginación|Paginación]]
* 8.5. [[Sistema combinado|Sistema combinado]]
* 8.6. [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 8.7. [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1. [[Memoria Virtual|Introducción]]
* 9.2. [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3. [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4. [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1. [[EstructuraES|Estructura dispositivo E/S]]
* 10.2. [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3. [[Diseño modular E/S|Diseño modular E/S]]
* 10.4. [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión E/S ==

* 11.1. [[Discos Magnéticos|Discos Magnéticos]]
* 11.2. [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3. [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4. [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5. [[Unidades SSD|Unidades SSD]]
* 11.6. [[Reloj hardware: Intel 8253]]
* 11.7. [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1. [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2. [[FAT|FAT]]
* 12.3. [[EXT2 |EXT2]]
* 12.4. [[Ejercicios Administración Ficheros|Ejercicios]]

== Seguridad ==

* 13.1. [[Definiciones de Seguridad]]

== Modelos de diseño de Sistemas Operativos ==

* 14.1. [[Virtualización]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Planificación en sistemas multiprocesadores

2020-04-02T16:26:47Z

Eleayogar:

=4.6 Planificación en sistemas multiprocesadores=

Los sistemas multiprocesadores son aquellos que disponen de 2 o más procesadores. Hasta el momento hemos aplicado los criterios de planificación considerando un único procesador. Con más de un procesador, tenemos que decidir a qué procesador se asignan cada uno de los procesos en ejecución. Hay dos estrategias de asignación en sistemas multiprocesadores, que son:

* '''Asignación estática''': Cuando un proceso pasa a estado activo por primera vez, se le asigna un determinado procesador (el que menor carga de trabajo tenga en ese momento) al que se asocia hasta fin de ejecución. Por tanto, un proceso tiene que pasar a estado activo empleando el mismo procesador hasta fin de ejecución. Dicho de otra manera, no es posible migrar procesos de un procesador a otro incluso si hay procesadores ociosos.

* '''Asignación dinámica''': En este caso, nuestros procesos en estado preparado pueden cambiar de procesador para pasar a estado activo si resulta que el último procesador en el que se ejecutó está ocupado y existe un procesador ocioso. Este método de asignación permite la migración de procesos de un procesador a otro, llevando a cabo un balanceo de carga de procesos entre los procesadores existentes. No obstante, la migración de un proceso de un procesador a otro es costosa. Por tanto, '''siempre que sea posible''' se intentará permanecer en el mismo procesador para no incurrir en la penalización asociada a los fallos de caché que resultan de la migración de procesos.

Los planificadores de los sistemas operativos modernos aplican una ''asignación híbrida'' de manera que emplea asignación estática la mayor parte del tiempo. Sin embargo, si el número de procesos asociados a un procesador supera en N unidades al de otro, se procede a migrar procesos al procesador con menor número de procesos para balancear la carga de trabajo. Este es el caso del planificador del núcleo de Linux.

El alto coste en la migración de procesos entre procesadores se debe a la penalización asociada a los fallos en la caché. Cada procesador generalmente dispone de una pequeña memoria asociativa de acceso rápido, también conocida como caché, en la que se almacenan los datos accedidos recientemente. Si migramos un proceso de procesador se tienen que cargar de nuevo los datos en la caché del nuevo procesador, incrementando de manera considerable los tiempos de accesos a datos.

A continuación, un ejemplo de planificación en sistemas multiprocesadores con dos CPUs que emplea asignación estática:
[[Archivo:Ejemplo de multiprocesador.png]]

Fíjese que tras el instante de tiempo 1, el proceso A continúa en el CPU 1 pues el proceso B se asignó al CPU 2, que estaba ocioso en ese instante de tiempo.

[[Ejercicios_otros_aspectos_de_la_planificación | Ejercicios]]

5.1. [[Concurrencia_de_procesos | Concurrencia de procesos]]

Planificación de procesos de tiempo real

2020-04-02T16:25:50Z

Eleayogar:

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

Un proceso de tiempo real es aquel cuya actividad tiene un '''plazo de finalización'''.

== ¿Qué es un sistema operativo de tiempo real? ==

Un sistema operativo de tiempo real dispone de un planificador de procesos que tiene mecanismos para hacer lo máximo posible para garantizar que sus procesos de tiempo real cumplan los plazos de finalización que tienen establecidos.

== Clasificación ==

Podemos clasificar los procesos de tiempo real de diferentes maneras:

Según el plazo de tiempo:
*'''Estricto(''hard-realtime'')''': se debe realizar en un plazo de tiempo determinado. Si no lo hace, 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. Ejemplo: Videoconferencia. (Mientras más rápido vaya mejor será la comunicación, pero si no, nos adaptamos a ella)

Según la periodicidad:

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

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

Podemos tener aplicaciones de tiempo real (flexibles) en sistemas operativos que no son de tiempo real (Linux, [http://darwinosx.blogspot.com/p/descarga-darwin-os.html Darwin], Windows).

En la planificación apropiativa por plazos (con prioridad estática), cada proceso tiene asociado un índice de prioridad y el procesador elige aquel proceso de la lista de preparados con mayor prioridad, es el más tradicional y puede ser llevado a cabo por el procesador de un sistema que no sea de tiempo real.

El siguiente ejemplo emplea planificación apropiativa por prioridades estática con actividades periódicas y aperiódicas:

____|__PA__|_PB__|_PC__|_PD___|
Datos del _H0_|__0___|_1___|_2___|_3*n__|
problema _t__|__2___|_4___|_2___|_1____|
plazo|__3___|_5___|_7___|_3*n+2|
prioridad|__-20_|_0___|_10__|_15___|
(-20 a 19)
UNIX
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
plazo = si la actividad no ha terminado de ejecutarse tras pasar este instante de tiempo, se aborta
* = el proceso se aborta

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

_____|_PA_|_PB_|_PC_|PD1ª_|PD2ª_|_PD_|
Cálculos __t__|_2__|_3__|_2__|_1__|_1__|_1__|
de tiempos __T__|_2__|_*__|_5__|_*__|_2__|_1__|
_T/t_|_1__|_*__|_5/2|_*__|_2__|_1__|
|
|_> Indice de penalización

Si alguna actividad entrante tiene más prioridad que la que se está ejecutando, ésta última pasa a estado preparado y se da paso a la nueva.

4.6. [[Planificación_en_sistemas_multiprocesadores | La planificación en sistemas multiprocesadores]]

Planificadores de sistemas operativos existentes

2020-04-02T16:25:24Z

Eleayogar:

= 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 más del sistema de planificación de Windows puedes leer el libro Windows Internals[https://repo.zenk-security.com/Linux%20et%20systemes%20d.exploitations/Windows%20Internals%20Part%201_6th%20Edition.pdf](PDF), donde se explica el funcionamiento y las caracteristicas de todo el SO.

4.5. [[Planificación_de_procesos_de_tiempo_real | La planificación de procesos de tiempo real]]

Planificación de procesos

2020-04-02T16:24:06Z

Eleayogar:

= Planificación de procesos =
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 una alta ''tasa de transferencia'' (throughput) y una baja latencia (latency), es deseable que un planificador implemente las siguientes características:

*'''Repetitividad''': con cargas de trabajo similares (cantidad de procesos a atender), el planificador debe comportarse de manera similar.
*'''Predecibilidad''': hace referencia al tiempo de terminación de un proceso para cierta carga de trabajo, que debe ser similar para cargas de trabajo parecidas.
*'''Eficiencia''': debe tomar decisiones rápidas para aumentar el rendimiento.
*'''Evitar conmutaciones innecesarias''': de nuevo, para aumentar el rendimiento y reducir la penalización asociada.
*'''Atención de prioridades''': uso de criterios de selección basados en prioridades
*'''Degradación uniforme del rendimiento''': a mayores cargas de trabajo el rendimiento debe degradarse uniformemente.
*'''Capacidad de respuesta instantánea''': los tiempos de espera para atender a un proceso deben ser aceptables de cara al usuario, generalmente <100ms para seres humanos.

4.2. [[Índices_de_evaluación | Índices de evaluación de la planificación de procesos]]

Hilos

2020-04-02T16:23:31Z

Eleayogar:

Un hilo es una línea de ejecución de un proceso. Todo proceso parte inicialmente con un único hilo principal, aunque el sistema operativo ofrece llamadas al sistema que permiten al programador crear y destruir hilos. Por tanto, un proceso está compuesto por uno o más hilos.

Los estados de un hilo son iguales a los de un proceso, por tanto, un hilo puede estar en estado preparado, bloqueado o activo en un cierto instante de tiempo. La conmutación entre hilos de un proceso es menos costosa que la conmutación de procesos, por tanto, el [[Planificador_de_procesos|planificador]] tiende a conmutar entre hilos de un proceso siempre que el proceso en su conjunto no haya agotado el tiempo máximo de asignación del procesador.

Los hilos nos permiten aprovechar la existencia de más de un procesador en el sistema, puesto que podemos asignar un hilo a cada uno de los procesadores que haya disponibles. Si hay más de un procesador, dos hilos de un mismo proceso pueden estar en estado activo simultáneamente. Por tanto, la programación con hilos nos permite sacar partido de las arquitecturas de multiprocesador que predominan en la actualidad.

Cuando se crea un hilo, el programador indica qué código ejecuta. Los hilos de un mismo proceso comparten el mismo espacio de memoria, por tanto, dos hilos del mismo proceso pueden compartir estructuras de datos,variables, código, archivos abiertos... Al acceder a los recursos del sistema de manera compartida, las tareas realizan un consumo de recursos inferior.

Veamos un ejemplo diseñado para un solo procesador:

[[Archivo:Uso_del_procesador_hilos.svg]]

Con multiprocesamiento podemos ejecutar diferentes procesos a la vez. Si tenemos un solo proceso podemos desdoblarlo en múltiples hilos.
Para aumentar su eficiencia, un programa en ejecución debe crear tantos hilos como el doble del número de procesadores de los que disponga el sistema. Por ejemplo: 4 hilos para un programa ejecutado con 2 procesadores. -> Número de hilos = Número de tareas realizadas "simultáneamente".

Las principales ventajas del uso de hilos son:

*'''Menor penalización''' en cuanto a conmutación. Ya que sólo se produce un salto en la ejecución de código del proceso, no interviene el planificador de procesos.

*Dos hilos de un mismo proceso '''comparten memoria''' aprovechando mejor los recursos y eliminando los mecanismos de comunicación necesarios para soluciones implementadas en varios procesos.

*Con un solo procesador es posible que una línea de proceso haga uso de una llamada al sistema que haga que el proceso pase a estado bloqueado. En este caso se puede llamar a otro hilo del mismo proceso en lugar de conmutar a otro proceso externo, ahorrando así tiempo de conmutación asociado a la ejecución del planificador de procesos.

¿Tareas simultaneas? EXPLICACIÓN:

Aunque un núcleo solo puede realizar una tarea a la vez, podemos usar los hilos para hacer creer al usuario ( y al ordenador ) que sí se puede hacer más de una tarea al mismo tiempo. En lugar de realizar una tarea al completo, se divide en porciones ( cada hilo se encarga de un aspecto concreto del programa ), de modo que se van alternando entre porciones de distintas tareas para que parezca que ambas se están ejecutando simultáneamente.

= Ejemplo =

El siguiente es un código en C de ejemplo en el que se muestra la creación de dos hilos. Se hace uso de la llamada al sistema ''sleep'' que hace que el proceso pase a estado bloqueado durante N segundos. Nótese que al compartir la variable ''a'', ambos hilos modifican su valor.

<source lang="c">
#include <stdio.h>
#include <pthread.h>

int a = 10;

void *codigo_hilo1(void *arg)
{
sleep(10);
a = a - 2;
printf("Soy el hilo 1 y la variable a vale %d\n", a);
return NULL;
}

void *codigo_hilo2(void *arg)
{
sleep(5);
a++;
printf("Soy el hilo 2 y la variable a vale %d\n", a);
return NULL;
}

int main(void)
{
pthread_t hilo1, hilo2;

pthread_create(&hilo1, NULL, codigo_hilo1, NULL);
pthread_create(&hilo2, NULL, codigo_hilo2, NULL);

pthread_join(hilo1, NULL);
pthread_join(hilo2, NULL);
}
</source>

Este ejemplo se compila en un terminal escribiendo: '''gcc archivo.c -lpthread'''

[[Ejercicios_Procesos | Ejercicios]]

4.1.[[Planificación de procesos| La planificación de procesos]]

Conmutación de procesos

2020-04-02T16:20:12Z

Eleayogar:

La conmutación de procesos es la operación que consiste en retirar el procesador a un proceso para asignárselo a otro. La conmutación se produce por cuatro razones:

#Un proceso agota el tiempo máximo asignado al procesador, por tanto, se debe dar paso a otro proceso para garantizar que la multiprogramación es llevada a cabo apropiadamente.
#Un proceso está pendiente de un evento externo, por tanto, pasa a estado bloqueado haciendo uso de la llamada al sistema bloqueante. El planificador debe asignar el procesador a otro nuevo proceso de entre los que están en estado preparado.
#Que termine la ejecución del proceso en cuestión.
#Que haya una [[Interrupciones_y_excepciones|interrupción]] proveniente de un dispositivo de E/S o por medio de la instrucción de la CPU que invoca al mecanismo de interrupción por software (por ejemplo, al invocar la instrucción ''int'' en procesadores x86).

Los pasos que se siguen son los siguientes:

# Pasar a modo privilegiado de la CPU.
# Guardar el contenido de los registros del hardware en el PCB (el llamado ''contexto de la ejecución''), así como otros datos que forman parte del contexto de la ejecución del proceso.
# Actualizar el estado del proceso en el PCB (el estado ha pasado de activo a bloqueado o preparado).
# Si se produjo una interrupción, atenderla.
# Seleccionar un nuevo proceso.
# Restaurar el contexto de ejecución del nuevo proceso seleccionado. En el caso de que el nuevo proceso no hubiese estado en el contexto de la ejecución deberá inicializarse.
# Pasar a modo no privilegiado.

[[Imagen:Asig2.png]]

El tiempo de conmutación se considera una penalización, ya que si realizamos muchas conmutaciones el rendimiento decrece y esto da al usuario la sensación de que sus actividades van a saltos. Para optimizar esto hay que evitar conmutaciones innecesarias, empleando para ello criterios de selección lo más eficientes posibles.

3.7.[[Hilos| Hilos]]

Bloque de control de procesos

2020-04-02T16:19:33Z

Eleayogar:

Para llevar a cabo la gestión de un proceso, es necesario que el sistema operativo guarde cierta información necesaria. Para ello, existe un registro especial que se conoce como '''el bloque de control del proceso BCP, o PCB en inglés (Process Control Block)'''.

El BCP es creado por el Sistema operativo cada vez que aparece un nuevo proceso. Los procesos son conocidos para el sistema operativo y por tanto elegibles para competir por los recursos del sistema sólo cuando existe un BCP activo asociado a ellos. Cuando el programa termina, el BCP es eliminado para dejar espacio libre en el registro, y usarlo para almacenar otros BCP.

El bloque de control de procesos difiere mucho de un sistema a otros, pero existen contenidos comunes:

* '''Identificador del proceso:''' Identificar de forma unívoca al proceso en el sistema, generalmente se emplea un entero sin signo que se denomina PID (Process IDentifier)

* '''Nombre del proceso'''.

* '''Estado del proceso para el planificador de procesos:''' preparado, activo o bloqueado.

* '''Contexto de la ejecución:''' valor de los registros del procesador, bits de estados, etc. Esto es, cada vez que se ejecuta el planificador y se realiza una [[Conmutación de procesos|conmutación de procesos]], la información sobre en qué lugar se encontraba la ejecución del proceso se encuentra guardada aquí, así como el lugar en el que se paró la ejecución del anterior proceso (cada una en su respectivo BCP).

* '''Aspectos relacionados con la administración de memoria:''' tales como el espacio de direcciones y la cantidad de memoria asignada a un proceso.

* '''Aspectos relacionados con la administración de ficheros:''' tales como los ficheros con los que el proceso está actualmente operando.

* '''Los procesadores en los que el proceso puede ejecutarse:''' en caso de soportar el sistema multiprocesador.

* '''En el caso de un sistema operativo tipo UNIX:''' el proceso padre de dicho proceso y la relación de procesos hijos.

* '''Estadísticas temporales:''' Tiempo de lanzamiento del proceso, tiempo en estado activo, etc.

En Linux, al PCB se le denomina ''Task Struct'', se puede consultar dicha estructura en:

http://lxr.linux.no/#linux+v2.6.37.2/include/linux/sched.h#L1182

http://lxr.linux.no/linux+v3.0.4/include/linux/sched.h#L1220

En el núcleo de Minix, al PCB se le denomina ''Process table'', puede consultarse su implementación en el siguiente enlace:

http://www.cise.ufl.edu/~cop4600/cgi-bin/lxr/http/source.cgi/kernel/proc.h

En el xv6, la estructura es pequeña y se puede consultar en el siguiente enlace:

https://github.com/mit-pdos/xv6-public/blob/master/proc.h#L37

3.6.[[Conmutación de procesos| La conmutación de procesos]]

Comportamiento de los procesos

2020-04-02T16:18:50Z

Eleayogar: /* Tipos de procesos */

= Tipos de procesos =

Un proceso, según su comportamiento, se puede catalogar en dos tipos:

* '''Procesos interactivos''': Son procesos cuyo comportamiento está limitado por operaciones de Entrada/Salida (I/O-bounded, en inglés). Este tipo de proceso realiza operaciones de Entrada/Salida con frecuencia. Por tanto, el proceso suele pasar a estado bloqueado al poco tiempo de estar asignado al procesador. Un ejemplo de este tipo de proceso es un editor de texto que solicita datos del teclado de manera continuada.
* '''Procesos por lotes''': Son procesos cuyo comportamiento está limitado por el procesador (processor-bounded, en inglés). Un ejemplo es un conversor de formato de vídeo MPG, este proceso ejecuta código de manera continuada hasta que el planificador decida retirarle el procesador. Por oposición, un ''proceso por lotes'' es un ''proceso no interactivo''.

Esta categorización debe entenderse como gradual, es decir, un proceso presenta un comportamiento interactivo en mayor o menor grado, o incluso su comportamiento puede variar a lo largo del tiempo, presentando un comportamiento interactivo inicialmente para, posteriormente, adoptar un comportamiento no interactivo.

[[Archivo:Procesos.jpg]]

En este ejemplo, podemos decir que el proceso Pa muestra un comportamiento '''interactivo''', ya que bloquea mucho, mientras que el proceso Pb muestra es un proceso '''por lotes''', ya que emplea el procesador hasta que el planificador se lo retira.

3.5.[[Bloque de control de procesos| El bloque de control del proceso]]

Planificador de procesos

2020-04-02T16:16:56Z

Eleayogar: /* Ejemplo */

= ¿Qué es el planificador de procesos? =

El planificador de procesos (''process scheduler'', en inglés) es la parte del sistema operativo que se encarga de seleccionar a qué proceso se asigna el recurso procesador y durante cuánto tiempo.

= ¿Qué funciones tiene el planificador de procesos? =

El planificador de procesos tiene como funciones principales:

* Llevar el control del estado de cada proceso.
* Decidir qué proceso usará el procesador y durante cuánto tiempo, para ello empleará un cierto criterio en base al cual tomará las decisiones. Si implementa multiprogramación, deberá emplear un criterio que evite que un proceso monopolice el procesador.
* Asignar el procesador al proceso, restableciendo el contexto de la ejecución del proceso por donde fuere. El contexto de la ejecución se encuentra almacenado en el PCB del proceso asignado.
* Retirar el procesador al proceso, salvando el contexto de la ejecución del proceso, para poder restablecerlo posteriormente una vez que vuelva a ser asignado. El contexto de la ejecución se almacenará en el PCB del proceso retirado.

El planificador de procesos es software, por tanto, requiere emplear el recurso procesador para ejecutar su código.

= Ejemplo =

Para la siguiente configuración de procesos:

* Proceso Pa: Llega en el instante de tiempo 0. Realiza una llamada al sistema bloqueante cada 1 unidad de tiempo, la operación bloqueante se resuelve tras 2 unidades de tiempo. Para finalizar su ejecución requiere 5 unidades de ejecución.
* Proceso Pb: Llega en el instante de tiempo 1. Para finalizar su ejecución requiere 4 unidades de ejecución.
* Suponga que el proceso Pa tiene mayor prioridad que el proceso Pb, por tanto, el planificador debe de dejar paso al proceso Pa siempre que éste esté en estado preparado.

La evolución de la asignación del procesador que realizaría el planificador es la siguiente:

[[Archivo:Procesos.jpg]]

3.4.[[Comportamiento de los procesos| El comportamiento de los procesos según el planificador]]

Estados de los procesos

2020-04-02T16:16:07Z

Eleayogar: /* 3.2 Estados de los procesos */

----
= 3.2 Estados de los procesos =

Todo proceso en un sistema operativo presenta un estado que indica la situación de la ejecución en que se encuentra. El número de posibles estados varía de un sistema operativo a otro.

== Diagrama de estados simplificado ==

Consideramos que todo proceso puede estar, como mínimo, en uno de los siguientes tres estados:

* '''Activo''': el proceso está empleando la CPU, por tanto, está ejecutándose. Puede haber tantos procesos activos como procesadores haya disponibles. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* '''Preparado''': el proceso no está ejecutándose, pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* '''Bloqueado''': el proceso está pendiente de un evento externo que le ha hecho bloquear, tales como una operación de lectura/escritura, la espera de finalización de un proceso hijo, una señal o una operación sobre un semáforo. El dispositivo/hecho externo "avisa" al S.O. cuando ha terminado la acción que realizaba mediante una INTERRUPCIÓN, dejando el S.O. lo que está haciendo para atender a esta última. Tras esto, el S.O. comprueba cuales son los procesos que fueron bloqueados por ese evento externo, cambiándolos al estado de preparado.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el '''planificador del sistema operativo''' en base a un cierto criterio. La transición de activo a bloqueado, y de bloqueado a preparado puede inducirlas el programador mediante llamadas al sistema.

[[Archivo:SSOO2.jpg]]

== Diagrama de Estados Ampliado ==
* '''En espera / Preparación''': Estado por el que pasan los procesos antes de pasar a estar preparados por primera vez. Los procesos, cuando comienzan a existir, no están preparados para comenzar a ejecutar instrucciones hasta que el sistema no ha llevado a cabo una serie de actividades. Una vez que el proceso está completamente cargado, ya se puede producir la primera transición al estado preparado.
* '''Terminado''': La transición de activo a este estado ocurre cuando el proceso realiza una llamada al sistema solicitando su propia terminación. En estas circunstancias, hay estructuras de datos correspondientes al proceso que no pueden ser liberadas hasta que el proceso padre del que está terminando recoja el código de terminación del mismo. Hasta que esto ocurra, estas estructuras se mantendrán y el proceso seguirá existiendo en estado terminado.
* '''Transición''': cuando la operación que mantiene a un proceso en estado bloqueado termina, el proceso puede haber perdido parte de los recursos que necesita para proseguir su ejecución. Este es por ejemplo el caso de un sistema con memoria virtual, en el que parte de las páginas de memoria del proceso han sido descargadas a disco. En dicho caso, el proceso tendría que pasar por un estado intermedio transición mientras recupera dichos recursos, y una vez que todos sus recursos vuelven a estar disponibles, volvería al estado preparado.

[[Archivo:SSOOProc.jpg]]

Hay tres posibles situaciones en las que se ejecutará el planificador del sistema operativo:
* El proceso que se encuentra en el estado activo hace una llamada al sistema que, por su naturaleza, resulta en una transición al estado bloqueado. Este es el caso de las llamadas read(), write(), wait(), pause(), entre muchas otras. Al pasar a estado bloqueado, se invoca al planificador para que decida que otro proceso se asignará al procesador.
* Si el proceso que se encuentra en el estado activo excede el tiempo máximo de asignación, en caso de que lo hubiere.
* Si el proceso que hasta ese momento se encontraba en estado activo termina de ejecutar su código.

Además, algunos sistemas operativos disponen de un estado terminado en el que los procesos pasan antes de terminar su ejecución.

En el caso del núcleo de Linux, existen tres tipos de estados bloqueado y dos estados terminado: http://www.ibm.com/developerworks/linux/library/l-task-killable/

3.3.[[Planificador de procesos| El planificador de procesos]]

Multiprogramación

2020-04-02T16:14:58Z

Eleayogar: /* La Multiprogramación */

= La Multiprogramación =

La multiprogramación es una técnica de multiplexación que permite la ejecución simultánea de múltiples procesos en un único procesador. En realidad, esta técnica produce una ilusión de paralelismo, de manera que parece que todos los procesos se están ejecutando a la vez. Sin embargo, hay un único proceso ejecutándose en el procesador a la vez.

Un método para la multiprogramación es el Foreground/Background (o ejecución jerarquizada) (usado en sistemas por tandas, nunca en interactivos), en él hay un proceso prioritario (el foreground (FG)) que se ejecuta con preferencia de todos los demás, cuando este proceso solicita una operación L/E(Lectura/Escritura), mientras el s.o. la realiza, el proceso FG estará bloqueado por esta operación y le cede el control al proceso background 1 (BG), y si éste realiza una operación L/E, al BG2,… Cuando uno de los procesos bloqueados se desbloquea, recibe el control del procesador. Para que este método funcione de forma óptima la mejor forma es colocar los procesos ordenados de mayor a menor cantidad de operaciones L/E.

El siguiente diagrama de ejemplo representa el uso del procesador por tres procesos:

[[Archivo:Uso_del_procesador_general.svg|500px]]

Como se puede observar en el ejemplo anterior, los procesos '''alternan periodos''' en los que '''progresan''' en su actividad, cuando están asignados al procesador, con periodos de inactividad, en los que '''no progresan''' en absoluto.

Si los periodos de inactividad son los suficientemente pequeños como para que el usuario del sistema operativo no los note, que en práctica se traduce a periodos de inactividad de menos de 100ms, el efecto causado es una ilusión de paralelismo. En caso contrario dará una sensación de que se producen "saltos".

El [[planificador de procesos|planificador de procesos]] es la parte del sistema operativo que se encarga de decidir qué proceso emplea el procesador en cada instante, por tanto, es el encargado de implementar la multiprogramación.

3.2.[[Estados de los procesos| Estados de los procesos]]

Criterios de planificación

2020-04-02T16:13:25Z

Eleayogar: /* Planificación apropiativa y no apropiativa */

= Planificación apropiativa y no apropiativa =

Un planificador no apropiativo carece de transición de activo a preparado en el diagrama de estado de un proceso.

Un planificador cualquiera, ya sea apropiativo o no, decide qué proceso se asigna al procesador si:

* El proceso activo pasa a estado bloqueado.
* El proceso activo termina su ejecución.

Un planificador apropiativo, además, se ejecuta si:

* Se lanza un nuevo proceso (véase ''prioridades'').
* El proceso activo agota el tiempo máximo de asignación del procesador (véase ''Turno Rotatorio'').

== Planificación por prioridades ==

Se establecen índices de prioridad a cada proceso:

* '''Índice estático''': Establecido por el usuario por medio de una llamada al sistema (ver sys_nice() y sys_setschedprio()). En el caso de sistemas operativos tipo Unix, se dispone de un í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 máximo denominado ''quantum'', tras el cual se le retira el procesador y se asigna a otro proceso de la cola de preparados. De esta manera, los procesos acceden al procesador por turnos, en base al orden de procesos que hay en la cola de preparados.

El tamaño del ''quantum'' es fundamental para determinar el comportamiento de este criterio de planificación. Si el ''quantum'' empleado es muy pequeño, por ejemplo, de 1000 ciclos, suponiendo que la conmutación de procesos requiere 1000 ciclos, el procesador empleará el 50% del tiempo en ejecutar el codigo del planificador de procesos del sistemas operativo. Sin embargo, si el ''quantum'' empleado es grande, por ejemplo, de 1 millon de ciclos, suponiendo una cola de procesos suficientemente grande y N procesos en la cola de preparados, el proceso que está al final de la cola no tendra oportunidad de ejecucion hasta pasados N * 1 millon de ciclos, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos''.

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

Los procesos recién lanzados y los que pasan de estado bloqueado a preparado se insertan siempre al final de la cola.

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> puesto que siempre se toma el primero proceso de la cola. Nótese que, a mayor número de procesos preparados, mayor tiempo tardará un proceso al final de la cola 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__|_3__|_9__|_5__|_12_| I = índice de penalización
_I__|_3/2| 9/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, 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.

Hay que tener en cuenta que:
* Cuando un proceso consume su quantum pasa al final de la cola de preparados.
* Un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo.

Ejemplo:

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

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

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

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

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

== Colas multinivel ==

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4.4. [[Planificadores_de_sistemas_operativos_existentes | Planificadores de sistemas operativos existentes]]

Índices de evaluación

2020-04-02T16:12:00Z

Eleayogar: /* ¿Cómo se evalúa un criterio de planificación? */

= ¿Cómo se evalúa un criterio de planificación? =

Los siguientes índices que nos permiten evaluar el planificador:

* '''Instante de lanzamiento''' (H0): Instante de lanzamiento del proceso.
* '''Instante de finalización''' (Hf): Instante de finalización del proceso.
* '''Tiempo de ejecución''' (tejecución): Unidades de tiempo que requiere el proceso para finalizar su ejecución.
* '''Tiempo de terminación''' (T = Hf - H0): Diferencia entre el instante de lanzamiento y el instante de terminación del proceso.
* '''Tiempo perdido''' (T-t): Es el tiempo durante el cual un proceso no está asignado al procesador, es decir, el tiempo en el que un proceso está en estado preparado o bloqueado.
* '''Índice de penalización''' (Ip = T / t): Indica que un proceso ha tardado x-1 veces más en ejecutarse que si hubiera tenido el procesador en exclusividad y sin que se hubiese producido ningún bloqueo. Nótese que el índice de penalización crece rápidamente para procesos cuyo tiempo de ejecución es pequeño, mientras que, para procesos con tiempo de ejecución mayores, lo hace de manera más suave.

Otros tiempos a tener en cuenta:

* '''Tiempo de inactividad''': Es un tiempo específico del procesador. Tiempo durante el cual el procesador está ocioso (''idle'', en inglés), es decir, que no tienen ningún proceso asignado. Un procesador está ocioso cuando no hay procesos en estado preparado.
* '''Tiempo del sistema''': Tiempo empleado por el [[planificador de procesos|planificador]] para la conmutación de procesos. Un buen planificador debe tomar muy poco tiempo en tomar la decisión de planificación y realizar la conmutación.
* '''Tiempo de espera''': Tiempo desde el instante de lanzamiento hasta que el proceso pasa a estado preparado.

Suponga el siguiente ejemplo, en el que hay dos procesos Px y Py, para ilustrar los índices definidos:

< indica que el proceso está preparado
> indica que el proceso ha finalizado su ejecución
$ indica que al proceso se le ha retirado el procesador
X indica la ejecución del planificador para la conmutación

| | | | | | |
Px <---|---$ |---> | |
Py | | <---> | | |
planificador | | X X | | |
|___|___|___|___|___|___|___
0 1 2 3 4 5 6

tiempo ->

Para el proceso Px:

* t = 3 : Indica que el proceso Px requiere 3 unidades de tiempo para ejecutarse.
* T = 4 : unidades de tiempo desde que se lanza hasta que se finaliza el proceso Px
* T-t = 1 : unidades de tiempo durante la cual el proceso Px no está asignado al procesador, por tanto, no progresa en su actividad.
* Ip = 4/3 = 1.34 : el proceso Px ha tardado un 34% de tiempo más en ejecutarse que si lo hubiera tenido en exclusividad (al haber tenido que compartir el procesador con Py).

En el ejemplo anterior, los tiempos de espera y del sistema se suponen despreciables (en la práctica no lo son, aunque son muy pequeños con respecto a los ilustrados).

4.3. [[Criterios_de_planificación | Criterios de planificación]]

Material teoría

2020-04-02T16:10:33Z

Eleayogar: /* Planificación de Procesos */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla.

= Subida de notas =

Indica aquí tu UVUS si quieres que revise tus contribuciones para ser tenidas en cuenta en la subida de notas:

* beagalcar

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Arranque del sistema|Arranque del sistema]]
* 2.6. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 2.9. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]
* 2.10. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 3.1. [[Multiprogramación|La multiprogramación]]
* 3.2. [[Estados de los procesos|Estados de los procesos]]
* 3.3. [[Planificador de procesos|El planificador de procesos]]
* 3.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 3.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 3.6. [[Conmutación de procesos|La conmutación de procesos]]
* 3.7. [[Hilos|Hilos]]
* 3.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 4.1. [[Planificación de procesos|La planificación de procesos]]
* 4.2. [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 4.3. [[Criterios de planificación|Criterios de planificación]]
* 4.4. [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 4.5. [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 4.6. [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 4.7. [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 4.8. [[Ejercicios planificación de procesos|Ejercicios]]
* 4.9. [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 6.1. [[Concurrencia de procesos|Concurrencia de procesos]]
* 6.2. [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 6.3. [[Cerrojos|Cerrojos]]
* 6.4. [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 6.5. [[Semáforos|Semáforos]]
* 6.6. [[Monitores|Monitores]]
* 6.7. [[Mensajería|Mensajería]]
* 6.8. [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 7.1. [[Definición de interbloqueo|Definición]]
* 7.2. [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 7.3. [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 7.4. [[Ejercicios]]

== Administración de memoria ==

* 8.1. [[Introducción|Introducción]]
* 8.2. [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 8.3. [[Segmentación|Segmentación]]
* 8.4. [[Paginación|Paginación]]
* 8.5. [[Sistema combinado|Sistema combinado]]
* 8.6. [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 8.7. [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1. [[Memoria Virtual|Introducción]]
* 9.2. [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3. [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4. [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1. [[EstructuraES|Estructura dispositivo E/S]]
* 10.2. [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3. [[Diseño modular E/S|Diseño modular E/S]]
* 10.4. [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión E/S ==

* 11.1. [[Discos Magnéticos|Discos Magnéticos]]
* 11.2. [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3. [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4. [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5. [[Unidades SSD|Unidades SSD]]
* 11.6. [[Reloj hardware: Intel 8253]]
* 11.7. [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1. [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2. [[FAT|FAT]]
* 12.3. [[EXT2 |EXT2]]
* 12.4. [[Ejercicios Administración Ficheros|Ejercicios]]

== Seguridad ==

* 13.1. [[Definiciones de Seguridad]]

== Modelos de diseño de Sistemas Operativos ==

* 14.1. [[Virtualización]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Material teoría

2020-04-02T16:09:47Z

Eleayogar: /* Procesos */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla.

= Subida de notas =

Indica aquí tu UVUS si quieres que revise tus contribuciones para ser tenidas en cuenta en la subida de notas:

* beagalcar

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Arranque del sistema|Arranque del sistema]]
* 2.6. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 2.9. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]
* 2.10. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 3.1. [[Multiprogramación|La multiprogramación]]
* 3.2. [[Estados de los procesos|Estados de los procesos]]
* 3.3. [[Planificador de procesos|El planificador de procesos]]
* 3.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 3.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 3.6. [[Conmutación de procesos|La conmutación de procesos]]
* 3.7. [[Hilos|Hilos]]
* 3.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 5.1. [[Planificación de procesos|La planificación de procesos]]
* 5.2. [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 5.3. [[Criterios de planificación|Criterios de planificación]]
* 5.4. [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 5.5. [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 5.6. [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 5.7. [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 5.8. [[Ejercicios planificación de procesos|Ejercicios]]
* 5.9. [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 6.1. [[Concurrencia de procesos|Concurrencia de procesos]]
* 6.2. [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 6.3. [[Cerrojos|Cerrojos]]
* 6.4. [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 6.5. [[Semáforos|Semáforos]]
* 6.6. [[Monitores|Monitores]]
* 6.7. [[Mensajería|Mensajería]]
* 6.8. [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 7.1. [[Definición de interbloqueo|Definición]]
* 7.2. [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 7.3. [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 7.4. [[Ejercicios]]

== Administración de memoria ==

* 8.1. [[Introducción|Introducción]]
* 8.2. [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 8.3. [[Segmentación|Segmentación]]
* 8.4. [[Paginación|Paginación]]
* 8.5. [[Sistema combinado|Sistema combinado]]
* 8.6. [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 8.7. [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1. [[Memoria Virtual|Introducción]]
* 9.2. [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3. [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4. [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1. [[EstructuraES|Estructura dispositivo E/S]]
* 10.2. [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3. [[Diseño modular E/S|Diseño modular E/S]]
* 10.4. [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión E/S ==

* 11.1. [[Discos Magnéticos|Discos Magnéticos]]
* 11.2. [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3. [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4. [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5. [[Unidades SSD|Unidades SSD]]
* 11.6. [[Reloj hardware: Intel 8253]]
* 11.7. [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1. [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2. [[FAT|FAT]]
* 12.3. [[EXT2 |EXT2]]
* 12.4. [[Ejercicios Administración Ficheros|Ejercicios]]

== Seguridad ==

* 13.1. [[Definiciones de Seguridad]]

== Modelos de diseño de Sistemas Operativos ==

* 14.1. [[Virtualización]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Modelos de Diseño de Sistemas Operativos

2020-03-02T19:40:22Z

Eleayogar: /* 2.8. Modelos de Diseño de SSOO */

= 2.8. Modelos de Diseño de SSOO =

== Modos de operación del procesador ==

Para entender los diseños de sistemas operativos existentes, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador determina qué conjunto de instrucciones y a qué recursos del procesador se puede acceder.

Los procesadores ofrecen, como mínimo, dos modos de funcionamiento del procesador:

* '''Modo privilegiado''', que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador. Es el modo en el que se ejecuta el núcleo de un sistema operativo.

* '''Modo no privilegiado''', que permite acceder a un subconjunto de las instrucciones que ofrece el procesador, es el modo en el que se ejecutan los procesos.

== 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. Es la parte del código del sistema operativo que se ejecuta en modo privilegiado del procesador.

Al operar en dicho modo, un error de programación en el núcleo del sistema operativo resulta 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 o BSOD]''.

== Tipos de Sistemas Operativos ==

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidades propias del sistema operativo que se implementan en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* '''Monolíticos:''' gestionan los cuatro componentes fundamentales del sistema operativo en modo supervisor, esto incluye, la planificación de procesos, la administración de la memoria principal, la gestión de E/S y el administrador de ficheros.

* '''Micronúcleos:''' implementan en su núcleo únicamente la planificación de procesos, la gestión de interrupciones (la parte básica fundamental de la gestión de E/S que necesariamente se tiene que realizar en modo privilegiado) y la comunicación entre procesos. Por tanto, la administración de memoria principal, la gestión de la E/S y la gestión de ficheros se realiza en modo usuario. En este tipo de sistema operativo hay procesos especiales propios del sistema operativo que implementan dichas funcionalidades en modo usuario y se denominan ''proceso servidor''.

Además, contamos con una clasificación intermedia:

* '''Híbrido:''' a mitad de camino entre monolítico y micronúcleo, incluyen la gestión de dispositivos de E/S en modo supervisor con el fin de mejorar el rendimiento del sistema.

En número de líneas de código, el núcleo monolítico es mayor que el micronúcleo, al implementar más componentes del sistema operativo que permiten la gestión del computador en el espacio del núcleo, es decir, en modo privilegiado.

Los sistemas operativo monolíticos ofrecen mejor rendimiento que los micronúcleos, pero los micronúcleos son más fiables, pues un fallo de programación en el núcleo lleva al traste con la ejecución del sistema.



=== Sistemas operativos Monolíticos ===

Los sistemas operativos monolíticos se caracterizan por implementar en el núcleo los cuatro componentes fundamentales del sistema operativo, que son la planificación de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida.

Los sistemas operativos de propósito general son predominantemente monolíticos hoy día, algunos ejemplos son:

* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux, y por tanto, Android también.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, este tipo de sistemas operativo dispone de un alto número de líneas de código ejecutándose en modo privilegiado. 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. Por ejemplo, un bug en el núcleo de un sistema operativo monolítico obliga a tener que reiniciar el sistema. En un sistema operativo monolítico, el código del núcleo se incluye en un único fichero binario que se carga en memoria principal en tiempo de arranque, por tanto, si se instala una nueva imagen, es necesario reiniciar el sistema operativo para que se inicie con la nueva versión que incluye la imagen actualizada.

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

=== Sistemas operativos Micronú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 se ejecutan en modo no privilegiado del procesador - que, por supuesto, se ejecutan fuera del espacio del núcleo del sistema operativo - y que implementan los siguientes componentes:

* 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 privilegiado, 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. Generalmente, si un proceso servidor tiene un bug en su código que hace que entre en una condición de error, se puede relanzar sin tener que reiniciar el sistema por completo.

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, y que generalmente únicamente tiene propósitos educativos y/o propósitos muy específicos.

Algunos ejemplos de sistemas operativos micronúcleos son:

* Symbian OS, hoy día en desuso.
* Minix, en sus versiones 2 y 3.

=== Sistemas operativos Híbridos ===

«Híbrido» implica que el núcleo en cuestión usa conceptos de arquitectura tanto del diseño monolítico como del micronúcleo, específicamente el paso de mensajes y la ejecución de ciertos componentes del sistema operativo en espacio de usuario.

Algunos ejemplos de núcleos híbridos:

* Microsoft Windows NT, usado en todos los sistemas que usan el código base de Windows NT.
* XNU (usado en Mac OS X), es un micronúcleo modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo basado en Mach.
* DragonFlyBSD, es el primer sistema BSD que adopta una arquitectura de núcleo híbrido sin basarse en Mach.
* ReactOS.

No hay que confundir el concepto «núcleo híbrido» con el soporte de módulos cargables después del arranque que está disponible en núcleos monolíticos.

=== Unikernel ===

Las aplicaciones se ejecutan en modo supervisor, dentro del espacio del núcleo del Sistema Operativo. Por tanto, la totalidad del código se ejecuta en modo privilegiado. Los procesos no invocan llamadas al sistema pues tienen acceso directo a los recursos del computador. El argumento para este diseño es el rendimiento a cambio de sacrificar la fiabilidad. Sólo es aplicable a sistemas de propósito muy específico.

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

3.2.[[Virtualización | Virtualización]]

Modelos de Diseño de Sistemas Operativos

2019-03-05T18:11:54Z

Eleayogar: /* Tipos de Sistemas Operativos */

= 3.1. Modelos de Diseño de SSOO =

== Modos de operación del procesador ==

Para entender los diseños de sistemas operativos existentes, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador determina qué conjunto de instrucciones y a qué recursos del procesador se puede acceder.

Los procesadores ofrecen, como mínimo, dos modos de funcionamiento del procesador:

* '''Modo privilegiado''', que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador. Es el modo en el que se ejecuta el núcleo de un sistema operativo.

* '''Modo no privilegiado''', que permite acceder a un subconjunto de las instrucciones que ofrece el procesador, es el modo en el que se ejecutan los procesos.

== 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. Es la parte del código del sistema operativo que se ejecuta en modo privilegiado del procesador.

Al operar en dicho modo, un error de programación en el núcleo del sistema operativo resulta 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 o BSOD]''.

== Tipos de Sistemas Operativos ==

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidades propias del sistema operativo que se implementan en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* '''Monolíticos:''' gestionan los cuatro componentes fundamentales del sistema operativo en modo supervisor, esto incluye, la planificación de procesos, la administración de la memoria principal, la gestión de E/S y el administrador de ficheros.

* '''Micronúcleos:''' implementan en su núcleo únicamente la planificación de procesos, la gestión de interrupciones (la parte básica fundamental de la gestión de E/S que necesariamente se tiene que realizar en modo privilegiado) y la comunicación entre procesos. Por tanto, la administración de memoria principal, la gestión de la E/S y la gestión de ficheros se realiza en modo usuario. En este tipo de sistema operativo hay procesos especiales propios del sistema operativo que implementan dichas funcionalidades en modo usuario y se denominan ''proceso servidor''.

Además, contamos con una clasificación intermedia:

* '''Híbrido:''' a mitad de camino entre monolítico y micronúcleo, incluyen la gestión de dispositivos de E/S en modo supervisor con el fin de mejorar el rendimiento del sistema.

El número de líneas de código, el núcleo monolítico es mayor que el micronúcleo, al implementar más componentes del sistema operativo que permiten la gestión del computador en el espacio del núcleo, es decir, en modo privilegiado.

Los sistemas operativo monolíticos ofrecen mejor rendimiento que los micronúcleos, pero los micronúcleos son más fiables, pues un fallo de programación en el núcleo lleva al traste con la ejecución del sistema.



=== Sistemas operativos Monolíticos ===

Los sistemas operativos monolíticos se caracterizan por implementar en el núcleo los cuatro componentes fundamentales del sistema operativo, que son la planificación de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida.

Los sistemas operativos de propósito general son predominantemente monolíticos hoy día, algunos ejemplos son:
el sistema
* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux, y por tanto, Android también.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, este tipo de sistemas operativo dispone de un alto número de líneas de código ejecutándose en modo privilegiado. 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. Por ejemplo, un bug en el núcleo de un sistema operativo monolítico obliga a tener que reiniciar el sistema. En un sistema operativo monolítico, el código del núcleo se incluye en un único fichero binario que se carga en memoria principal en tiempo de arranque, por tanto, si se instala una nueva imagen, es necesario reiniciar el sistema operativo para que se inicie con la nueva versión que incluye la imagen actualizada.

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

=== Sistemas operativos Micronú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 se ejecutan en modo no privilegiado del procesador - que, por supuesto, se ejecutan fuera del espacio del núcleo del sistema operativo - y que implementan los siguientes componentes:

* 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 privilegiado, 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. Generalmente, si un proceso servidor tiene un bug en su código que hace que entre en una condición de error, se puede relanzar sin tener que reiniciar el sistema por completo.

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, y que generalmente únicamente tiene propósitos educativos y/o propósitos muy específicos.

Algunos ejemplos de sistemas operativos micronúcleos son:

* Symbian OS, hoy día en desuso.
* Minix, en sus versiones 2 y 3.

=== Sistemas operativos Híbridos ===

«Híbrido» implica que el núcleo en cuestión usa conceptos de arquitectura tanto del diseño monolítico como del micronúcleo, específicamente el paso de mensajes y la ejecución de ciertos componentes del sistema operativo en espacio de usuario.

Algunos ejemplos de núcleos híbridos:

* Microsoft Windows NT, usado en todos los sistemas que usan el código base de Windows NT.
* XNU (usado en Mac OS X), es un micronúcleo modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo basado en Mach.
* DragonFlyBSD, es el primer sistema BSD que adopta una arquitectura de núcleo híbrido sin basarse en Mach.
* ReactOS.

No hay que confundir el concepto «núcleo híbrido» con el soporte de módulos cargables después del arranque que está disponible en núcleos monolíticos.

=== Unikernel ===

Las aplicaciones se ejecutan en modo supervisor, dentro del espacio del núcleo del Sistema Operativo. Por tanto, la totalidad del código se ejecuta en modo privilegiado. Los procesos no invocan llamadas al sistema pues tienen acceso directo a los recursos del computador. El argumento para este diseño es el rendimiento a cambio de sacrificar la fiabilidad. Sólo es aplicable a sistemas de propósito muy específico.

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

3.2.[[Virtualización | Virtualización]]

Interrupciones y excepciones

2019-03-05T18:10:27Z

Eleayogar:

==Tipos de interrupciones y excepciones==

* Una interrupción por hardware es un mecanismo de comunicación entre el procesador y los dispositivos de E/S. Sirve para indicar que un dispositivo de E/S tiene datos pendientes de ser tratados. Las interrupciones por hardware evitan que el sistema operativo tenga que muestrear periódicamente el estado de los dispositivos de E/S, de manera que son ellos mismos los que indican que hay datos a ser tratados.

* Una interrupción por software es un mecanismo de comunicación entre un proceso (que se ejecuta en modo usuario) y el sistema operativo (que se ejecuta en modo supervisor). El proceso emplea las interrupciones por software para notificar al sistema operativo que requiere de su intervención. En procesadores x86, para lanzar una interrupción por software un proceso ejecuta la instrucción '''int''' seguida de un número de 16 bits que indica el tipo de interrupción por software. Por ejemplo, las llamadas al sistema en x86 se implementan mediante interrupciones por software, por medio de la instrucción '''int 0x80''' (sin embargo, hoy día las arquitecturas de los procesadores modernos vienen con instrucciones especializadas para la invocación de llamadas al sistema como '''syscall''' en x86, por tanto, esta técnica ha caído en desuso).

Las excepciones son un tipo de interrupción que emplea el procesador para notificar al sistema operativo de un suceso excepcional, por ejemplo, cuando el proceso realiza la instrucción '''div''' para dividir un valor usando como denominador cero. El tratamiento que generalmente realiza el sistema operativo consiste en terminar con la ejecución del proceso.

El tratamiento de interrupciones es prioritario, por tanto, en caso de interrupción se deja de ejecutar el proceso para dar paso al manejador de las interrupciones.

==Tratamiento de interrupciones y excepciones==

El tratamiento de interrupciones es prioritario. Cuando se produce una interrupción:

1. Almacena el estado de la ejecución del proceso en el Bloque de Control de procesos (PCB).

2. Se pasa la CPU a modo supervisor.

3. Se ejecuta el código del sistema operativo que realiza el tratamiento de la interrupción. Este decide la acción correspondiente dependiendo del tipo de interrupción.

4. Se devuelve el control de la ejecución al planificador del sistema operativo.

2.4.[[Conceptos_básicos| Conceptos básicos]]

Interrupciones y excepciones

2019-03-05T18:10:06Z

Eleayogar:

==2.3. Tipos de interrupciones y excepciones==

* Una interrupción por hardware es un mecanismo de comunicación entre el procesador y los dispositivos de E/S. Sirve para indicar que un dispositivo de E/S tiene datos pendientes de ser tratados. Las interrupciones por hardware evitan que el sistema operativo tenga que muestrear periódicamente el estado de los dispositivos de E/S, de manera que son ellos mismos los que indican que hay datos a ser tratados.

* Una interrupción por software es un mecanismo de comunicación entre un proceso (que se ejecuta en modo usuario) y el sistema operativo (que se ejecuta en modo supervisor). El proceso emplea las interrupciones por software para notificar al sistema operativo que requiere de su intervención. En procesadores x86, para lanzar una interrupción por software un proceso ejecuta la instrucción '''int''' seguida de un número de 16 bits que indica el tipo de interrupción por software. Por ejemplo, las llamadas al sistema en x86 se implementan mediante interrupciones por software, por medio de la instrucción '''int 0x80''' (sin embargo, hoy día las arquitecturas de los procesadores modernos vienen con instrucciones especializadas para la invocación de llamadas al sistema como '''syscall''' en x86, por tanto, esta técnica ha caído en desuso).

Las excepciones son un tipo de interrupción que emplea el procesador para notificar al sistema operativo de un suceso excepcional, por ejemplo, cuando el proceso realiza la instrucción '''div''' para dividir un valor usando como denominador cero. El tratamiento que generalmente realiza el sistema operativo consiste en terminar con la ejecución del proceso.

El tratamiento de interrupciones es prioritario, por tanto, en caso de interrupción se deja de ejecutar el proceso para dar paso al manejador de las interrupciones.

==Tratamiento de interrupciones y excepciones==

El tratamiento de interrupciones es prioritario. Cuando se produce una interrupción:

1. Almacena el estado de la ejecución del proceso en el Bloque de Control de procesos (PCB).

2. Se pasa la CPU a modo supervisor.

3. Se ejecuta el código del sistema operativo que realiza el tratamiento de la interrupción. Este decide la acción correspondiente dependiendo del tipo de interrupción.

4. Se devuelve el control de la ejecución al planificador del sistema operativo.

2.4.[[Conceptos_básicos| Conceptos básicos]]

Tipos de Sistemas Operativos

2019-03-05T18:07:16Z

Eleayogar:

= 1.3. Tipos de Sistemas Operativos =
== 1.3.1. Según cuántas aplicaciones pueda ejecutar a la vez ==

=== '''Monoprogramables'''===
*En un determinado instante de tiempo, '''solo hay un único proceso en ejecución que monopoliza todos los recursos''' del sistema.
*Principal ventaja: su sencillez.
*Dos subtipos:
**Ofrece intérprete de órdenes.
**Ofrece entrada a través de cinta/switches o disquettes (SSOO históricos).
*Ejemplo: DOS (80's), BeOS (90's).

=== '''Multiprogramables''' ===

*Permiten ejecutar '''múltiples procesos en un único procesador'''. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
*Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).

====Características que pueden presentar:====

*Multiprogramación: se ejecutan varios procesos simultáneamente de manera que se reparte el uso del procesador. A esta característica también se le llama (de forma imprecisa) "multitarea".
**Multiusuario: admite múltiples usuarios trabajando simultáneamente.
**Multiacceso: el sistema ofrece varios mecanismos para el acceso concurrente a los diferentes procesos.
**Multiprocesamiento o multiprocesadores: soporta más de un procesador y hace uso de todos ellos.
***Tipos de sistemas multiprocesadores: especializados, con acoplamiento débil y con acoplamiento fuerte:
****Sistemas multiprocesadores con procesadores especializados: son sistemas que cuentan con un procesador de propósito general y varios procesadores especializados (como por ejemplo coprocesadores aritméticos o el procesador de una tarjeta gráfica). Dichos procesadores especializados solo son capaces de ejecutar un conjunto de operaciones específicas y funcionan únicamente cuando el procesador general se lo solicita, en ese momento colaboran con el procesador general.
****Sistemas multiprocesadores con acoplamiento débil: son sistemas con procesadores relativamente independientes, cada uno tiene su propia memoria y sus propios canales de E/S.
****Sistemas multiprocesadores con acoplamiento fuerte: son sistemas con varios procesadores de propósito general independientes entre sí pero que comparten la memoria y trabajan bajo un sistema operativo común.
**Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo específico. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) o '''flexible''' y hard (duro) o '''estricto'''. Un ejemplo puede ser el sistema operativo de tiempo real instalado en el procesador de un teléfono móvil; si llega una llamada tiene que pasarla en ese momento, si no, ese proceso deja de ser importante.
**Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO en soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

== 1.3.2. Según cómo se presta el servicio ==

Clasificación no excluyente:

* Sistemas operativos de servidor
* Sistemas operativos de ordenador personal
* Sistemas operativos en tiempo real
* Sistemas operativos embarcados / integrados / "embebidos" (dispositivos móviles o smartcard, p.ej.)
* Sistemas operativos web

2.1 [[Organización básica de un ordenador]]

Qué es un Sistema operativo

2019-03-05T18:06:02Z

Eleayogar:

[[Archivo:Arquitectura_SO.svg|right|370px]]
Un '''sistema operativo''' es el '''software''' que gestiona los tres recursos fundamentales de un computador (la parte hardware), que son:

* El procesador o CPU.
* La memoria principal.
* Los dispositivos de Entrada/Salida.

Las utilidades y características de estos son las siguientes:

* '''Abstrae del hardware''': Esto hace posible que los programas desarrollados para el sistema operativo en cuestión funcionen en distintos dispositivos, sin conocer sus detalles específicos. Es el sistema operativo el que se encarga de comunicarlo con el hardware.

* '''Proporciona una biblioteca de métodos a las aplicaciones de usuario''': Estos métodos o funciones pueden ser usados por los programadores a la hora de desarrollar sus aplicaciones.

* '''Gestiona los recursos de manera equitativa''': Un sistema operativo debe encargarse de que los procesos progresen en tiempo de ejecución. Un solo procesador debe encargarse de un gran número de procesos simultáneamente, y no es posible hacerlo en paralelo. El sistema operativo los gestiona para que todos los procesos avancen de manera ecuánime.

* '''Debe consumir el mínimo de recursos''': Para que los procesos se realicen de la manera más rápida posible, el sistema operativo debe consumir los menos recursos posibles, de manera que la mayor parte de recursos se dedique a estos procesos.

* '''Lanzador de aplicaciones''': El sistema operativo ofrece al usuario una interfaz que le permite lanzar las aplicaciones de usuario, ya sea de modo texto, gráfico basado en ventanas y ratón, táctil y la última implementada, mediante órdenes de voz.

1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]

Conceptos básicos

2019-03-04T18:28:08Z

Eleayogar:

= 2.4. Conceptos básicos =
A continuación, se desarrollan conceptos básicos que se emplearán a lo largo de la asignatura.

== Programa ==

Un programa es una secuencia de instrucciones que, al ejecutarse, desarrolla algún tipo de actividad.

Un programa, generalmente, se expresa en un lenguaje de programación de alto nivel (tales como C, C++, Python, Java, Perl, Php, C#, etc) que, mediante un compilador o máquina virtual, se traduce a instrucciones de bajo nivel que corresponden al juego de instrucciones que ofrece el procesador.

El juego de instrucciones del procesador viene determinado por el fabricante.

== Proceso ==

Un ''proceso'' es una instancia de un programa que está en ejecución. De partida todo proceso dispone de una única línea de ejecución. Se puede entender como la vista dinámica (en ejecución) de un programa.

=== Procesos en sistemas operativos tipo Unix ===

* Todo proceso en un sistema operativo tipo Unix tiene un proceso padre y a su vez puede disponer de uno o más procesos hijo.

* Todo proceso en un sistema operativo tipo Unix tiene un propietario, que se trata del usuario que ha lanzado dicho proceso.

* El proceso ''init'' es el padre de todos los procesos. Es la excepción a la norma general, pues no tiene padre. Es el primer proceso que se lanza desde la secuencia de arranque del sistema.

* La información necesaria para administrar un proceso se guarda en una estructura controlada por el S.O. llamada Bloque de Control de Procesos o PCB (Process Control Block).

* Para mostrar la relación actual de procesos en el sistema se puede emplear la orden ''ps''.

* Para identificar los procesos el sistema operativo Unix asigna un número de identificación del proceso, o pid (Process IDentification).

<source lang="bash">
$ ps -ef
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 11:48 ? 00:00:00 /sbin/init
...
practica 1712 1 18 12:08 ? 00:00:00 gnome-terminal
practica 1713 1712 0 12:08 ? 00:00:00 gnome-pty-helper
practica 1714 1712 20 12:08 pts/0 00:00:00 bash
practica 1731 1714 0 12:08 pts/0 00:00:00 ps -ef
</source>

La primera columna indica el UID del proceso, la segunda el PID, la tercera el PID del proceso padre. Por último, aparece el nombre del proceso en cuestión.

=== Procesos padre e hijo ===

* Todo proceso (padre) puede lanzar un proceso hijo en cualquier momento, para ello el sistema operativo nos ofrece una llamada al sistema que se denomina ''fork''.

* Un proceso hijo es un proceso clon del padre. Sin embargo, procesos padre e hijo no comparten memoria, son completamente independientes.

* Todo proceso padre es responsable de los procesos hijos que lanza, por ello, todo proceso padre debe recoger el resultado de la ejecución de los procesos hijos para que estos finalicen adecuadamente. Para ello, el sistema operativo ofrece la llamada ''wait'' que nos permite obtener el resultado de la ejecución de uno o varios procesos hijo.

* Si un proceso padre no recupera el resultado de la ejecución de su hijo, se dice que el proceso queda en estado '''zombi'''. Un proceso hijo zombi es un proceso que ha terminado su ejecución y que está pendiente de que su padre recoja el resultado de su ejecución.

== [[Llamadas_al_sistema|Llamadas a sistema ]]==

* Se implementan a través de una interfaz (o API) que ofrece el Sistema Operativo. Son mecanismos que el S.O. pone a disposición de los procesos para solicitar un servicio o recurso (otra definición, según Wikipedia: "''Llamadas que ejecutan los programas de aplicación para pedir algún servicio al S.O.''"). Estas llamadas a sistema evitan que el proceso acceda directamente a los recursos del hardware.
En el caso de Linux tiene aproximadamente 350 llamadas al sistema en la versión 3.0.0.
La mayor parte de los Sistemas Operativos suelen implementar la API POSIX por razones de portabilidad.

== Usuario ==

* Sujeto que interactúa con la computadora. Puede ser un humano o un autómata (software).

* En sistemas UNIX encontramos un código único para cada uno, el UID (User IDentifier). A su vez debe pertenecer a un grupo, definido por el GID (Group IDentifier).

== [[Introducción_en_la_administración_de_archivos#Fichero|Fichero ]]==

* Estructura de datos que almacena información.

Los ficheros se identifican mediante su nombre y su extensión (un apéndice que se utiliza para indicar el tipo de información que contiene el fichero).

El lugar donde se encuentra un fichero viene dado por su directorio. Dentro de un directorio pueden existir otros directorios (llamados subdirectorios), lo que da lugar a una organización en forma de árbol.

Al camino que debemos seguir para encontrar un fichero lo llamamos '''camino absoluto (absolute path)''', y al camino que debemos seguir para encontrar el fichero en relación a otro fichero que no sea el fichero raíz se le conoce como '''camino relativo (relative path)'''.

2.5.[[Arranque_del_sistema | Arranque del sistema]]

Modelos de Diseño de Sistemas Operativos

2019-03-03T17:19:58Z

Eleayogar:

= 3.1. Modelos de Diseño de SSOO =

== Modos de operación del procesador ==

Para entender los diseños de sistemas operativos existentes, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador determina qué conjunto de instrucciones y a qué recursos del procesador se puede acceder.

Los procesadores ofrecen, como mínimo, dos modos de funcionamiento del procesador:

* '''Modo privilegiado''', que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador. Es el modo en el que se ejecuta el núcleo de un sistema operativo.

* '''Modo no privilegiado''', que permite acceder a un subconjunto de las instrucciones que ofrece el procesador, es el modo en el que se ejecutan los procesos.

== 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. Es la parte del código del sistema operativo que se ejecuta en modo privilegiado del procesador.

Al operar en dicho modo, un error de programación en el núcleo del sistema operativo resulta 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 o BSOD]''.

== Tipos de Sistemas Operativos ==

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidades propias del sistemas operativo que se implementan en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* '''Monolíticos:''' gestionan los cuatro componentes fundamentales del sistema operativo en modo supervisor, esto incluye, la planificación de procesos, la administración de la memoria principal, la gestión de E/S y el administrador de ficheros.

* '''Micronúcleos:''' implementan en su núcleo únicamente la planificación de procesos, la gestión de interrupciones (la parte básica fundamental de la gestión de E/S que necesariamente se tiene que realizar en modo privilegiado) y la comunicación entre procesos. Por tanto, la administración de memoria principal, la gestión de la E/S y la gestión de ficheros se realiza en modo usuario. En este tipo de sistema operativo hay procesos especiales propios del sistema operativo que implementan dichas funcionalidades en modo usuario y se denominan ''proceso servidor''.

Además, contamos con una clasificación intermedia:

* '''Híbrido:''' a mitad de camino entre monolítico y micronúcleo, incluyen la gestión de dispositivos de E/S en modo supervisor con el fin de mejorar el rendimiento del sistema.

El número de líneas de código, el núcleo monolítico es mayor que el micronúcleo, al implementar más componentes del sistema operativo que permiten la gestión del computador en el espacio del núcleo, es decir, en modo privilegiado.

Los sistemas operativo monolíticos ofrecen mejor rendimiento que los micronúcleos, pero los micronúcleos son más fiables, pues un fallo de programación en el núcleo lleva al traste con la ejecución del sistema.



=== Sistemas operativos Monolíticos ===

Los sistemas operativos monolíticos se caracterizan por implementar en el núcleo los cuatro componentes fundamentales del sistema operativo, que son la planificación de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida.

Los sistemas operativos de propósito general son predominantemente monolíticos hoy día, algunos ejemplos son:
el sistema
* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux, y por tanto, Android también.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, este tipo de sistemas operativo dispone de un alto número de líneas de código ejecutándose en modo privilegiado. 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. Por ejemplo, un bug en el núcleo de un sistema operativo monolítico obliga a tener que reiniciar el sistema. En un sistema operativo monolítico, el código del núcleo se incluye en un único fichero binario que se carga en memoria principal en tiempo de arranque, por tanto, si se instala una nueva imagen, es necesario reiniciar el sistema operativo para que se inicie con la nueva versión que incluye la imagen actualizada.

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

=== Sistemas operativos Micronú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 se ejecutan en modo no privilegiado del procesador - que, por supuesto, se ejecutan fuera del espacio del núcleo del sistema operativo - y que implementan los siguientes componentes:

* 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 privilegiado, 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. Generalmente, si un proceso servidor tiene un bug en su código que hace que entre en una condición de error, se puede relanzar sin tener que reiniciar el sistema por completo.

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, y que generalmente únicamente tiene propósitos educativos y/o propósitos muy específicos.

Algunos ejemplos de sistemas operativos micronúcleos son:

* Symbian OS, hoy día en desuso.
* Minix, en sus versiones 2 y 3.

=== Sistemas operativos Híbridos ===

«Híbrido» implica que el núcleo en cuestión usa conceptos de arquitectura tanto del diseño monolítico como del micronúcleo, específicamente el paso de mensajes y la ejecución de ciertos componentes del sistema operativo en espacio de usuario.

Algunos ejemplos de núcleos híbridos:

* Microsoft Windows NT, usado en todos los sistemas que usan el código base de Windows NT.
* XNU (usado en Mac OS X), es un micronúcleo modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo basado en Mach.
* DragonFlyBSD, es el primer sistema BSD que adopta una arquitectura de núcleo híbrido sin basarse en Mach.
* ReactOS.

No hay que confundir el concepto «núcleo híbrido» con el soporte de módulos cargables después del arranque que está disponible en núcleos monolíticos.

=== Unikernel ===

Las aplicaciones se ejecutan en modo supervisor, dentro del espacio del núcleo del Sistema Operativo. Por tanto, la totalidad del código se ejecuta en modo privilegiado. Los procesos no invocan llamadas al sistema pues tienen acceso directo a los recursos del computador. El argumento para este diseño es el rendimiento a cambio de sacrificar la fiabilidad. Sólo es aplicable a sistemas de propósito muy específico.

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

3.2.[[Virtualización | Virtualización]]

Modelos de Diseño de Sistemas Operativos

2019-03-03T16:48:00Z

Eleayogar:

= 3.1. Modelos de Diseño de SSOO =

== Modos de operación del procesador ==

Para entender los diseños de sistemas operativos existentes, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador determina qué conjunto de instrucciones y a qué recursos del procesador se puede acceder.

Los procesadores ofrecen, como mínimo, dos modos de funcionamiento del procesador:

* '''Modo privilegiado''', que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador. Es el modo en el que se ejecuta el núcleo de un sistema operativo.

* '''Modo no privilegiado''', que permite acceder a un subconjunto de las instrucciones que ofrece el procesador, es el modo en el que se ejecutan los procesos.

== 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. Es la parte del código del sistema operativo que se ejecuta en modo privilegiado del procesador.

Al operar en dicho modo, un error de programación en el núcleo del sistema operativo resulta 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 o BSOD]''.

== Tipos de Sistemas Operativos ==

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidades propias del sistemas operativo que se implementan en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* '''Monolíticos:''' gestionan los cuatro componentes fundamentales del sistema operativo en modo supervisor, esto incluye, la planificación de procesos, la administración de la memoria principal, la gestión de E/S y el administrador de ficheros.

* '''Micronúcleos:''' implementan en su núcleo únicamente la planificación de procesos, la gestión de interrupciones (la parte básica fundamental de la gestión de E/S que necesariamente se tiene que realizar en modo privilegiado) y la comunicación entre procesos. Por tanto, la administración de memoria principal, la gestión de la E/S y la gestión de ficheros se realiza en modo usuario. En este tipo de sistema operativo hay procesos especiales propios del sistema operativo que implementan dichas funcionalidades en modo usuario y se denominan ''proceso servidor''.

Además, contamos con una clasificación intermedia:

* '''Híbrido:''' a mitad de camino entre monolítico y micronúcleo, incluyen la gestión de dispositivos de E/S en modo supervisor con el fin de mejorar el rendimiento del sistema.

El número de líneas de código, el núcleo monolítico es mayor que el micronúcleo, al implementar más componentes del sistema operativo que permiten la gestión del computador en el espacio del núcleo, es decir, en modo privilegiado.

Los sistemas operativo monolíticos ofrecen mejor rendimiento que los micronúcleos, pero los micronúcleos son más fiables, pues un fallo de programación en el núcleo lleva al traste con la ejecución del sistema.



=== Sistemas operativos Monolíticos ===

Los sistemas operativos monolíticos se caracterizan por implementar en el núcleo los cuatro componentes fundamentales del sistema operativo, que son la planificación de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida.

Los sistemas operativos de propósito general son predominantemente monolíticos hoy día, algunos ejemplos son:
el sistema
* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux, y por tanto, Android también.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, este tipo de sistemas de operativo dispone de un alto número de líneas de código ejecutándose en modo privilegiado. 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. Por ejemplo, un bug en el núcleo de un sistema operativo monolítico obliga a tener que reiniciar el sistema. En un sistema operativo monolítico, el código del núcleo se incluye en un único fichero binario que se carga en memoria principal en tiempo de arranque, por tanto, si se instala una nueva imagen, es necesario reiniciar el sistema operativo para que se inicie con la nueva versión que incluye la imagen actualizada.

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

=== Sistemas operativos Micronú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 se ejecutan en modo no privilegiado del procesador - que, por supuesto, se ejecutan fuera del espacio del núcleo del sistema operativo - y que implementan los siguientes componentes:

* 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 privilegiado, 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. Generalmente, si un proceso servidor tiene un bug en su código que hace que entre en una condición de error, se puede relanzar sin tener que reiniciar el sistema por completo.

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, y que generalmente únicamente tiene propósitos educativos y/o propósitos muy específicos.

Algunos ejemplos de sistemas operativos micronúcleos son:

* Symbian OS, hoy día en desuso.
* Minix, en sus versiones 2 y 3.

=== Sistemas operativos Híbridos ===

«Híbrido» implica que el núcleo en cuestión usa conceptos de arquitectura tanto del diseño monolítico como del micronúcleo, específicamente el paso de mensajes y la ejecución de ciertos componentes del sistema operativo en espacio de usuario.

Algunos ejemplos de núcleos híbridos:

* Microsoft Windows NT, usado en todos los sistemas que usan el código base de Windows NT.
* XNU (usado en Mac OS X), es un micronúcleo modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo basado en Mach.
* DragonFlyBSD, es el primer sistema BSD que adopta una arquitectura de núcleo híbrido sin basarse en Mach.
* ReactOS.

No hay que confundir el concepto «núcleo híbrido» con el soporte de módulos cargables después del arranque que está disponible en núcleos monolíticos.

=== Unikernel ===

Las aplicaciones se ejecutan en modo supervisor, dentro del espacio del núcleo del Sistema Operativo. Por tanto, la totalidad del código se ejecuta en modo privilegiado. Los procesos no invocan llamadas al sistema pues tienen acceso directo a los recursos del computador. El argumento para este diseño es el rendimiento a cambio de sacrificar la fiabilidad. Sólo es aplicable a sistemas de propósito muy específico.

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

3.2.[[Virtualización | Virtualización]]