Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Evaluame mis contribuciones a la wiki

2013-02-05T09:06:00Z

Marperrei1:

A continuación, indica tu nombre y apellidos:

* Juan Carlos Roldán Salvador
* Daniel Ayala Hernández
* Daniel de los Reyes Leal
* Olga Minerva Moreno Martín IS-G1
* Vanessa Chipirrás Navalón IC
* Alejandro Sánchez Medina IS-G1
* Francisco Javier Borrego Cejudo IC-G2
* Samuel Martin Arenas IC-G2
* Álvaro Fernández García IS-G1
* Rafael Gomez Galbarro GIC2
*María Pérez Reina IS-G1

Memoria Virtual

2013-01-21T20:44:41Z

Marperrei1:

La memoria virtual es una técnica que puede implementar el administrador de memoria con soporte de paginación para aumentar el grado de multiprogramación. Para ello se emplea una zona en disco conocida como ''zona de intercambio'' o ''swap'' para descargar en ella segmentos o páginas que se encuentran en memoria principal.

La zona de intercambio se implementa siguiendo dos posibles estrategias:

* Se destina una parte del disco reservada explícitamente para ello. En este caso, dicho espacio de memoria no puede ser empleado para almacenar información útil del usuario. Los sistemas operativos tipo-Unix implementan esta estrategia.

* Se emplea un fichero oculto que puede tener un tamaño fijo(donde dicho espacio estará reservado y el usuario no podra hacer uso de el) o variable para almacenar las páginas descargadas. Los sistemas operativos de tipo-Microsoft implementan esta aproximación.

La técnica de memoria virtual se manifiesta cuando toda la memoria principal está en uso y, por tanto, no existe espacio libre para cargar una cierta pagina que es requerida por un proceso. Ante esta situación, el mecanismo de memoria virtual permite seleccionar una página víctima que será descargada a la zona de intercambio. De esta manera se libera memoria principal para poder cargar la página que nuestro proceso en estado activo requiere. La selección de las páginas víctima se hace en base a diferentes criterios que veremos en esta unidad didáctica. También hay programas que hacen uso de esta memoria virtual aún cuando hay memoria física disponible, como por ejemplo programas de edición fotográfica [http://www.tweakhound.com/wp-content/uploads/2011/10/lowmem_cs5.gif provocan errores] sin él.

Por tanto, en caso de que un proceso activo requiera una página o segmento que está descargado en la zona de intercambio, '''hay que seleccionar una página víctima''' de otro proceso, preferentemente en estado preparado o bloqueado, que será descargada en disco para hacer espacio a la página requerida.

Los tiempos de descarga y recarga de páginas tienen una penalización considerable. Esto se debe a los tiempos de acceso al dispositivo disco magnético son mucho mayores que los de la memoria principal. En general, un buen criterio de reemplazo de páginas debe no descargar páginas que vayan a ser necesitadas en poco tiempo, reduciendo así la cantidad de accesos a disco asociados a la descarga y recarga de páginas. A día de hoy con el auge de los [http://es.wikipedia.org/wiki/Unidad_de_estado_s%C3%B3lido SSD (Solid-State Drive)], podríamos mitigar esto en gran parte debido a basarse en memoria flash y tener tiempos de acceso del orden de 0.1ms e inferiores al no depender de partes mecánicas para la lectura/escritura de datos.

== Elementos de análisis ==
Dado un criterio de sustitución, nos preguntamos si es bueno o malo, y lo comparamos con otro para saber cual es el mejor y cuanto mejor. El criterio de localidad no es una herramienta, sino una propiedad que empíricamente se comprueba que se cumple. Las herramientas para conocerlo son:

''' Cadenas de referencia '''

Secuencia de páginas referidas por un proceso. Suponiendo que un proceso hace los siguientes accesos a memoria (pagina/desplazamiento):
0, 1, 0, 0/6, 0/8, 1/0, 0/0, 0/2,2, 255, 2… 1/1, 1/4, 0/8, 2/15, 2/18, 2/15, 2/18, 255/32, 255/36, 2/15

No nos importan ni los desplazamientos ni que se acceda varias veces consecutivas a la misma página, el fallo de página se produce en el primer acceso. En una cadena de referencia, nunca aparecerán varias referencias consecutivas a la misma página. Realizar la traza de lo programado es complicado porque no conocemos el futuro, se obtiene una simulación.

''' Índices de valoración '''

Sirve para medir las prestaciones de los criterios. Todos ellos están referidas a una cadena de referencia.
*F(m): Número de fallos de páginas con m marcos.
*f= F(m) /A: Tasa de fallos de páginas.
*fc= (F(m) -m )/A: Tasa de fallos de páginas en caliente.
*F(m) -m: Número de fallos de páginas en caliente.
*A = Número de accesos.

''' Curva paracorde '''

Representación del número de fallos de páginas para una cadena de referencia, frente al número de marcos utilizados. Sea p = número de páginas (distintas) en cadena de referencia. El número característico es el área bajo la curva, y es una buena medida de la calidad del algoritmo.

''' Principio de localidad '''
*Localidad espacial: Si una página es accedida es muy probable que se acceda eventualmente a una página próxima a ella.

*Localidad temporal: Si una página es accedida en un instante de tiempo, es muy probable que en el futuro inmediato vuelva a ser accedida.

El principio de localidad nos beneficia pues, si los accesos a memoria fuesen totalmente aleatorios, la probabilidad de producirse un fallo sería inversamente proporcional al número de marcos, con lo que la curva paracorde sería una recta de pendiente negativa. No obstante, se comprueba que las curvas paracordes típicas tienen una forma como la que presentamos, sensiblemente mejor que la probabilidad inversa al número de páginas.

A continuación, nos centraremos en el estudio de los diferentes [[Criterios de reemplazo|criterios de reemplazo]] para páginas que permiten seleccionar la página víctima.

Paginación

2013-01-21T20:29:26Z

Marperrei1: Traductores sin tabla de página

=Definición=
La paginación es una estrategia de organización de la memoria similar a la segmentación pero con ciertas diferencias, por ejemplo la memoria se considera un espacio continuo dividido en porciones de igual tamaño fijo (frente a la división en segmentos de tamaño variable de la segmentación), a dichas porciones se las conoce como marcos de página o simplemente como páginas.
Las páginas están definidas por un número de página, que identifica de forma única a cada página (dentro del espacio de memoria de un proceso). Cada página se asigna en exclusividad a un proceso.

=Funcionamiento=

Desde el punto de vista de la paginación la traducción de las direcciones de memoria se basa en dos conceptos:

1. El dispositivo traductor divide las direcciones lógicas en 2 partes de la siguiente forma: los n bits más significativos identifican la página mientras que el resto identifica el desplazamiento.

2. Cuando el traductor dinámico de páginas recibe, en una dirección lógica, un número de página este examina una tabla (llamada tabla de páginas) en la cual se relacionan las páginas lógicas con las páginas físicas y obtiene la dirección real (Número de marco) de la siguiente forma:

[[Archivo:Paginas.png]]

Al igual que en la segmentación al intentar acceder a una página ausente se produce un fallo (llamado en este caso '''fallo de página''').

=Otras características=
*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 el tema anterior no se aplican aquí, no tiene sentido hacerlo ya que todas las páginas de memoria son iguales.

==Dispositivo de traducción de direcciones paginadas==
Se dispone de la tabla de páginas de cada proceso en memoria para llevar a cabo la traducción. La tabla de páginas se indexa por número de página.

El dispositivo de traducción de direcciones paginadas debe ser un dispositivo muy rápido, ya que se usa con cada acceso a memoria que se realiza. El tamaño de la tabla de páginas es uno de los aspectos que más influye en el diseño del dispositivo e incluso en la organización de la propia tabla. Otro aspecto relevante es la localización de dicha tabla, la cual puede encontrarse en el traductor o guardada en memoria:
*'''Tabla de páginas en el traductor:'''

Se usa en equipos cuyo espacio de direcciones es de pocas páginas.
El dispositivo de traducción contiene un conjunto de registros organizados como una memoria en los cuales almacena la tabla de páginas.
Dicha página debe sustituirse (lo cual aumenta el tiempo de conmutación) en dos situaciones distintas: al cambiar de proceso y al transferir el control al ss.oo. (en este caso se reduce el tiempo de conmutación utilizando dos tablas separadas, una para los procesos y otra para el ss.oo., las cuales se utilizan dependiendo del modo de uso de la cpu, supervisor o usuario).

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

Se usa en equipos con mucha memoria, en los cuales el número de páginas puede llegar a ser muy alto con lo que el tiempo necesario para cargar las páginas en el traductor es demasiado alto.
La tabla de páginas es guardada en la memoria principal y el dispositivo traductor tiene la dirección de comienzo y el tamaño de la tabla, debido a que la tabla 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 que conserva las parejas página lógica-página física utilizadas recientemente.

También hay dispositivos traductores que no utilizan tablas de páginas, buscan directamente la información en una memoria asociativa, y si no la encuentran, lanzan una excepción que manejará el sistema operativo. Así, el SO es el responsable de determinar la asociación entre números de página y números de marco, y además de actualizar la memoria asociativa, lo que da cierta flexibilidad.

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

==Traductores sin tabla de página==
El hardware no impone estructura de tabla de página, solo dispone de memoria asociativa (cache). Si no se encuentra la página en esta memoria, se lanza una excepción. El Sistema Operativo es responsable de determinar la asociación entre el nº de página y el nº de marco, y actualizar la memoria asociativa.

Si se hace más grande la memoria asociativa, disminuirá el nº de búsquedas fallidas, que puede compensar la pérdida por programas en vez de por hardware. Esto es propio de procesadores RISC, Procesadores MIPS ( PlayStation 1 y 2, Sony PSP, Nintendo 64...).
Las ventajas son la flexibilidad, el hardware no impone la organización de la Tabla de Páginas; el traductor se simplifica notablemente; y parte del ahorro en hardware del traductor se puede invertir en aumentar el tamaño de la memoria asociativa.

==Elementos de administración==
La administración es sencilla ya que todas las porciones de memoria son de igual tamaño (se limita a comprobar si hay suficientes marcos libres para ejecutar el proceso).

Se pueden usar:

*'''Tabla de asignación de marcos a procesos:''' Tiene una entrada por marco, que contiene el PID del proceso que lo tiene asignado, o 0, si está libre.
*'''Lista de marcos asignados a procesos:''' Dado que el número de marcos es fijo, se implementa mediante una tabla. Estas listas tienen una entrada por marco. En cada entrada está, o el siguiente marco en la lista, o -1 si el marco es el último. Hay una lista global de marcos libres, y una lista por proceso de marcos ocupados. Para ayudar a la gestión, cada proceso tiene en su PCB los índices del primer y el último marco que tiene asignados.

Segmentación

2013-01-21T20:21:08Z

Marperrei1:

=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 de indicarse explícitamente que una porción de memoria puede 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.

*No se redimensionan.

*Gestión compleja, sobretodo 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).

=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 configuracion 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 (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:
<br>- Las que hacen referencia a un descriptor en la tabla de memoria (y necesitan más bits para hacer referencia al descriptor)
<br>- 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:
<br>- Las que hacen referencia a un descriptor en la tabla de memoria
<br>- 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=
Varios segmentos pueden estar parcial o totalmente solapados en memoria. Una dirección física se puede corresponder con múltiples direcciones lógicas. Los segmentos superpuestos pueden tener incluso distintos permisos (segmento 0 y 1 ). Si son totalmente superpuestos se denominan segmentos alias.

Se aplica para implementar la técnica de "copy on write" (animación). Se crea inicialmente un segmento de datos, con permiso de lectura y escritura. Al crear el segmento de COW, este se crea con la misma dirección y tamaño (totalmente solapado), pero nótese que se quita el permiso de escritura en ambos segmentos. Si se intenta escribir en uno de los dos, se produce un fallo de protección. Entonces se copia el segundo segmento sobre una nueva ubicación, actualizándose su dirección y restituyéndose en ambos el permiso de escritura.
Otra aplicación: en un micro que no permita modificar segmento de código, se puede crear un segmento alias de dato para modificarlo.

=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 detrás, se cambia el tamaño en el descriptor; si no hay suficiente espacio: se copia al hueco libre (compactando si es necesario) y se cambia el tamaño ( y dirección base, claro está).
Existe la posibilidad de crecimiento automático, a cada segmento se asocia un atributo "permitir crecer"; Si se sobrepasa el límite en un segmento que puede crecer, el tratamiento de la excepción es el que hará crecer al segmento.
Gracias a la segmentación, todas las direcciones son reubicables.

SO multiprogramables con particiones fijas

2013-01-21T20:05:51Z

Marperrei1: /* Primer ajuste */

En la administración de memoria con particiones de tamaño fijo consideramos que la memoria se encuentra dividida en porciones fijas de diferente tamaño. La división se realizaría durante la instalación del sistema operativo, y para modificar el esquema de particionamiento necesitaríamos reiniciar el sistema para que surtan efecto los cambios. Por cada partición sólo puede haber un único proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.

Esta aproximación tiene dos limitaciones importantes, que son:

* Si un proceso necesita más memoria que la partición más grande puede ofrecer, entonces éste no se puede ejecutar.
* Alto desperdicio de memoria, particularmente en el caso de que un proceso ocupe una partición de tamaño mayor al que necesita.

= Criterios de asignación =

Cuando se lanza un programa, el administrador de memoria tiene que decidir en qué partición de memoria va a cargar el proceso recién creado. Para ello se emplean diferentes criterios.

== Mejor ajuste estático ==

Se adjudica a cada proceso a la menor partición en la que quepa. Si la menor partición en la que cabe estuviera ocupada, dicho proceso tiene que esperar a que se libere. Esta estrategia evita el desperdicio de memoria. Sin embargo, puede retrasar la ejecución de un proceso estando libre otras particiones sin usarse. Este mecanismo se puede implementar con una cola por partición. El orden de complejidad computacional sería <math>O(1)</math>.

=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | m(P)|
---------------------
P1 | 0 | 7 | 2 |
P2 | 1 | 4 | 7 |
P3 | 2 | 5 | 8 |
P4 | 3 | 5 | 15 |
P5 | 4 | 3 | 3 |
P6 | 5 | 2 | 17 |

Y la siguiente configuración de memoria:
_____
|_____| M1 = 8 u.m.
|_____| M2 = 8 u.m.
| |
|_____| M3 = 16 u.m.
| |
| |
| | M4 = 32 u.m.
|_____|

La solución sería:

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

=== Otro ejemplo ===

Tenemos los siguientes procesos: m(P1) = 6KB, m(P2) = 1KB, m(P3) = 3KB, m(P4) = 31KB, m(P5) = 30KB;
suponemos que la decisión sobre la asignación de procesos a particiones se hace ordenadamente de manera
consecutiva según el número del proceso y una memoria de 64 KB divididos en 4 huecos como sigue:

[[solución mejor ajuste estático|Ver solución]]

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Por tanto, los procesos nunca esperan siempre que hay alguna partición libre. Complejidad: O(1).
La ventaja es que es eficiente, pues no es necesario explorar la lista completa. Los inconvenientes son que no tiene en cuenta la fragmentación producida; se produce un desgaste por el elevado uso de las primeras posiciones de memoria; y la eficiencia disminuye con el tiempo. Esto último puede solucionarse añadiendo un enlace entre bloques libres.

[[solución primer ajuste|Ver solución]]
=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | m(P)|
---------------------
P1 | 0 | 7 | 2 |
P2 | 1 | 4 | 7 |
P3 | 2 | 5 | 8 |
P4 | 3 | 5 | 15 |
P5 | 4 | 3 | 3 |
P6 | 5 | 2 | 17 |

Y la siguiente configuración de memoria:
_____
|_____| M1 = 8 u.m.
|_____| M2 = 8 u.m.
| |
|_____| M3 = 16 u.m.
| |
| |
| | M4 = 32 u.m.
|_____|

La solución sería:

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

== Mejor ajuste dinámico ==

De entre todos los procesos que pueden asignarse a una partición, se asigna el mayor proceso que quepa en ella. Por tanto, se itera sobre todos los procesos que se quieren cargar en memoria para ver cuál de ellos es el que menor desperdicio produce. Tal y como sucedía con el mejor ajuste estático, los procesos tienen que esperar a que quede libre la partición en la que menor desperdicio se produce. --[[Usuario:Pneira|Pneira]] 13:40 13 dic 2011 (UTC)

El principal inconveniente de este criterio es que los procesos que mayor desperdicio generan van a ser postergados indefinidamente. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | m(P)|
---------------------
P1 | 0 | 7 | 2 |
P2 | 0 | 4 | 7 |
P3 | 0 | 5 | 8 |
P4 | 1 | 5 | 15 |
P5 | 1 | 3 | 3 |
P6 | 1 | 2 | 17 |

Y la siguiente configuración de memoria:
_____
|_____| M1 = 8 u.m.
|_____| M2 = 8 u.m.
| |
|_____| M3 = 16 u.m.
| |
| |
| | M4 = 32 u.m.
|_____|

La solución sería:

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

== Mejor ajuste dinámico con aplazamiento limitado ==

Es una variante del criterio anterior que evita el aplazamiento indefinido. Cuando queda una partición libre, se selecciona el mayor proceso que quepa en ella, pero se cuenta el nº de veces que un proceso se aplaza. Si se superan esas '''n''' veces (umbral), se le da paso.

=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | m(P)|
---------------------
P1 | 0 | 7 | 2 |
P2 | 0 | 4 | 7 |
P3 | 0 | 5 | 8 |
P4 | 1 | 5 | 6 |
P5 | 1 | 3 | 7 |
P6 | 1 | 2 | 5 |

Suponiendo que todo proceso puede ser aplazado como máximo una sola vez.

Y la siguiente configuración de memoria:
_____
|_____| M1 = 8 u.m.
|_____| M2 = 8 u.m.
| |
|_____| M3 = 16 u.m.
| |
| |
| | M4 = 32 u.m.
|_____|

La solución sería:

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

== Subparticiones ==

No es un criterio como tal sino que viene a complementar a los anteriores. Si no hay un proceso que pueda aprovechar la partición madre: se asignan las subparticiones a procesos pequeños (para que el desperdicio interno sea lo menor posible). Si llega un proceso grande: los procesos pequeños se vuelcan a disco hasta que haya sitio para ellos y se asigna la partición madre al proceso grande.

Partición madre: tipo especial de partición que se puede dividir en múltiples particiones menores.

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

En el momento de lanzamiento hay que realizar la carga del código del proceso en memoria. Hay diferentes estrategias de colocación, que son:

*'''Montaje absoluto''': El compilador genera un ejecutable que sólo pueda ser cargado en una cierta posición de memoria. Básicamente, las instrucciones de memoria emplean direccionamiento fijo. Se asigna una dirección de memoria fija en tiempo de compilación de manera que cuando se lance el programa tiene que cargarse obligatoriamente en la posición de memoria para la que fue compilada. Por tanto, se trata de un método poco flexible pues requiere la recompilación del programa para ejecutar el proceso en una posición de memoria diferente. Se emplea para la carga del ejecutable en el que se encuentra el sistema operativo nada más comenzar el arranque.

* '''Carga con reubicación''': Es un mecanismo más flexible al anterior. Básicamente, en tiempo de compilación se genera un ejecutable que supone que la posición de memoria de comienzo del proceso va a ser la dirección 0. Luego, en el momento de lanzamiento, se reajustan las instrucciones de acceso a memoria que hay en el código del proceso al cargarlo en una cierta partición. Este reajuste consiste en sumar a la dirección de memoria que hay en el código de cada instrucción de memoria la dirección de comienzo de la partición en la que se va a cargar el procesos. Aunque es un método más flexible que el anterior, no permite migrar de una partición a otra una vez cargado el proceso en memoria.

* '''Reubicación dinámica''': Es el mecanismo más flexible de los tres. De nuevo, en tiempo de compilación se genera un ejecutable que supone que la posición de memoria de comienzo del proceso va a ser la dirección 0. Se supone la existencia de un registro en la arquitectura en el que se carga la posición de memoria de comienzo de la partición. En '''tiempo de ejecución''' se va a sumar a la posición de memoria a la que se quiere acceder la dirección de memoria del registro que contiene el lugar en el que comienza la partición. A diferencia de la carga con reubicación, permite la migración de un proceso de una partición a otra, para ello lo que hay que hacer es modificar el registro y mover el código del proceso a la nueva partición en la que se quiere colocar.

* '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.

= Mecanismos de protección de memoria =

Es necesario proteger el SO frente a procesos; y proteger a los procesos entre sí.

* '''Bits de protección''' : Se le asigna a cada zona/partición de la memoria principal una zona con información sobre el propietario y los permisos de lectura/escritura

* '''Ampliación registros valla''' : De esta manera se conocen la posición inicial y final, de manera que si no está entre esas dos posiciones no se permite el acceso a memoria. Los registros de posición inicial y final sólo pueden ser modificados en modo supervisor, por tanto, es el sistema operativo en que durante la conmutación de procesos establece el valor de estos registros.

Condiciones para el interbloqueo y estrategias de resolución

2013-01-21T08:59:05Z

Marperrei1: /* Detección y Recuperación */

== 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 tenia 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 hay múltiples instancias equivalentes de un mismo tipo de 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.

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. 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. 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 procesos y se solicitan en ese orden. Por ejemplo: tenemos un proceso A y otro B, 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;"|'''A:'''
| align="center" style="background:#f0f0f0;"|'''B:'''
|-
| 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 A, se conmuta a B 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;"|'''A:'''
| align="center" style="background:#f0f0f0;"|'''B:'''
|-
| 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.

Definición de interbloqueo

2013-01-21T08:55:51Z

Marperrei1: Generalización de la definición

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:

[[Imagen:GrafoDeadlock.jpg]]

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.

Un conjunto de P procesos está interbloqueado si y sólo si cada proceso Pi, que pertenezca a P, está bloqueado en espera de un evento que sólo puede ser provocado por otro proceso Pi, que pertenece a P. Si uno de los procesos está esperando a algo que no depende de los demás es una espera en cadena. La utilidad de los grafos de relación proceso/recurso es que habrá interbloqueo si y sólo si en el grafo se produce un ciclo.

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.

Evaluame mis contribuciones a la wiki

2013-01-21T08:49:56Z

Marperrei1:

Diseño modular E/S

2013-01-21T08:45:19Z

Marperrei1:

El diseño de software de lectura/escritura nos plantea las siguientes necesidades:
* Modelar un '''diseño por capas o estratos''', dotando de una abstracción que oculte las peculiaridades de los dispositivos a las capas superiores, que deben ofrecer una interfaz homogénea.

* Hacer a los '''programas independientes de los dispositivos''', que no tienen por qué conocer el soporte que manejan. Esto es deseable en cuanto a que el fabricante del dispositivo podría dejar de fabricar el dispositivo, por tanto, el proceso tendría que ser reescrito para soportar el nuevo dispositivo. De igual manera, si el dispositivo para el que está diseñado el proceso que conoce los detalles de bajo nivel no está disponible en el sistema, nuestro proceso quedaría inservible.

* Dar un '''criterio uniforme de denominación''': En sistemas Unix, por ejemplo, se trata a cada dispositivo como a un fichero

* '''Tratamiento de errores''' lo más '''próximo''' posible a su '''origen''': si un estrato detecta un error y puede solucionarlo, lo oculta a los niveles superiores. Si no, informa a nivel superior.

* Forzar a que un '''proceso tenga que pasar por el sistema operativo''', que es quien garantiza que el reparto de recursos es equitativo. Si un proceso dispone de acceso directo a un dispositivo, podría adoptar un comportamiento ''abusón'' de manera que no permitiera a otros procesos emplearlo.

* '''Gestionar el acceso compartido''' a los dispositivos: Por ejemplo, un disco magnético puede ser accedido de forma compartida, mientras que un soporte de cinta, es deseable que no lo sea

La forma de cubrir todas estas necesidades es crear la siguiente abstracción:

[[Archivo:diseño modular.jpg|center|x400px]]

'''Nota''': el SSI es una subrutina de manejo de interrupciones.

Existen 4 niveles Software y 2 Hardware. El nivel de SSI de manera lógica pertenece al gestor de dispositivos, si bien se puede considerar como un subnivel separado por ejecutarse en núcleo. La abstracción de proceso respecto al dispositivo permite la independencia de los procesos, y fuerza a que un proceso tenga que pasar por el Sistema Operativo, que garantiza que el reparto de recursos es equitativo. Si un proceso tuviera acceso directo a un dispositivo, podría adoptar un comportamiento abusón de manera que no permitiera a otros procesos emplearlo.

* '''El Software de L/E en espacio del usuario''', suele consistir en una librería de funciones que aporta un mayor grado de abstracción sobre el API del SO.

* '''El Software de E/L independiente de dispositivo''':
-Dota de estructura de sistema de archivos a la información contenida en los dispositivos.
-Gestiona el espacio libre y ocupado en el dispositivo.
-Trata errores del sistema de archivos.
-Homogeiniza los dispositivos.
-Denominación uniforme de dispositivos.
-Protege de archivos y dispositivos.
-Tamaño de bloque independiente de dispositivo.
-Hace independiente el hecho de que el dispositivo sea de bloques o de caracteres.
-Asigna y libera dispositivos.

* '''Gestor de dispositivo''' :
-Gestiona normalmente todos los dispositivos de un = tipo.
-Contiene el código dependiente del dispositivo.
-Acepta peticiones abstractas del nivel superior, convirtiéndolas a peticiones concretas que se traducen en comandos para el dispositivo, y programa dichos comandos en el dispositivo, programando también si es oportuno el controlador de DMA.
-Supervisa el correcto funcionamiento del dispositivo, tratando los errores que puedan ocurrir.

* '''Subprogramas de Interrupción (SSI)''':
-Atienden las interrupciones generadas por los dispositivos
-La forma en la que se atienden depende de la estrategia seguida por cada SO:
-Desde realizar el tratamiento completo, hasta
-Avisar a hardware que la interrupción ha sido aceptada e informar a nivel superior.

Gestión de Entrada/Salida

2013-01-21T08:35:13Z

Marperrei1: /* Gestión de E/S híbrida */

El sistema operativo puede gobernar el dispositivo E/S a través del gestor de dispositivos de tres maneras posibles:

* Gestión de E/S por programas.
* Gestión de E/S por interrupciones.
* Gestión híbrida de E/S.

= Gestión de E/S por programas =

El gestor de dispositivo periódicamente comprueba el estado del dispositivo. Para ello comprueba mediante los registros de estado del puerto de E/S si hay datos provenientes del dispositivo que deben ser tratados.
Un ejemplo de lectura de un único dispositivo sería:
<div style="font-family:Consolas, Courier New, Courier;border:1px dashed #9ab;text-indent: 5%">
configurar_dispositivo();

while(!fin_lectura) {

operacion_cualquiera();

while (!dato_recibido());

leer_dato();
</div>

La "lista de dispositivos" se puede recorrer en base a dos criterios distintos:

-Con prioridad uniforme: Todos los dispositivos reciben las mismas oportunidades de ser atendidos: se pregunta al primer dispositivo si requiere atención, y se le atiende. Después se pasa al siguiente, y así sucesivamente hasta dar una vuelta completa.

-Con prioridad escalonada: Tras atender a cualquier dispositivo, se vuelve a comenzar el sondeo por el primer dispositivo. El orden es determinante, pues se establece una relación de prioridad entre dispositivos determinada por ese orden.

Es ineficaz en sistemas interactivos, debido a que requiere espera ocupada y resulta engorrosa para atender a varios dispositivos simultáneamente, al implicar establecer prioridades entre estos.

= Gestión de E/S por interrupciones =

Una interrupción por hardware es una señal proveniente de un dispositivo de E/S para notificar al procesador de un cierto evento que debe ser tratado. Por ejemplo, un proceso hace uso de la llamada al sistema ''read'' para solicitar información que se encuentra en disco magnético. Una vez que la información está disponible, la interrupción es empleada para que se ejecute el gestor de dispositivos y obtenga los datos para dicho proceso, que ya están disponibles.

Las interrupciones son un mecanismo que ofrece la arquitectura para conectar los dispositivos de E/S con el procesador. No obstante, los datos provenientes del dispositivo de E/S se obtienen a través del bus.

El dispositivo de E/S emplea una de las líneas de interrupción que conectan al dispositivo con el procesador. Cada una de estas líneas corresponden con un cierto dispositivo o una familia de dispositivos de naturaleza similar. La asignación de líneas y dispositivo es estática y sucede en tiempo de arranque, por tanto, no cambia a lo largo del tiempo. En caso de que haya datos a tratar en el dispositivo, se notifica al procesador mediante la línea de interrupción. Ante esto, el planificador debe apartar el proceso que esté en estado activo para conmutar al gestor de dispositivo, el cual realizará el tratamiento de la interrupción, obteniendo los datos del dispositivo de E/S que están pendientes de ser tratados.

Por tanto, por cada interrupción se debe [[Conmutación_de_procesos|conmutar]] al gestor de dispositivos.

La ventaja es que la gestión de los dispositivos se desacopla de las demás actividades del sistema. Si hay que gestionar múltiples dispositivos, se lleva a cabo una interrupción por dispositivo, otra para todos los dispositivos, y si se agrupan, una interrupción por grupo.
Las interrupciones no son reentrantes, esto quiere decir que cuando se está realizando el tratamiento de una interrupción se desactiva temporalmente la notificación por interrupciones. Por tanto, una interrupción se ejecuta hasta fin de tratamiento, y en ningún caso es interrumpida por otra interrupción.

= Gestión de E/S híbrida =

La elección de L/E guiada por programas o por interrupción depende del carácter "asíncrono" del dispositivo y ("síncrono")de la diferencia de velocidad entre CPU y dispositivo. Los dispositivos "asíncronos es mejor tratarlos por interrupción. Por otro lado, con los dispositivos "síncronos", si la CPU es mucho + rápida se guía por interrupción, y si tiene = orden de magnitud, es admisible por programación (Siempre que el time de servicio del dispositivo esté en el orden del time de ejecución de las instrucciones del procesador). Si el dispositivo es suficientemente rápido, la espera ocupada puede ser + eficiente que la interrupción.

La gestión híbrida es la más usada en sistemas operativos modernos, y consiste en emplear una combinación de las soluciones anteriores. En principio, se realiza una gestión por interrupciones, pero ante situaciones de estrés en las que se ofrezca una carga de trabajo muy alta, que pueda llevar a una sobrecarga de conmutaciones, se limita en el tiempo la consulta de datos. Por ejemplo, si la tarjeta de red estuviera saturando el procesador con interrupciones, se puede optar por atenderlas todas juntas periódicamente (En lotes).

Gestión de Entrada/Salida

2013-01-21T08:30:36Z

Marperrei1: /* Gestión de E/S por interrupciones */

El sistema operativo puede gobernar el dispositivo E/S a través del gestor de dispositivos de tres maneras posibles:

* Gestión de E/S por programas.
* Gestión de E/S por interrupciones.
* Gestión híbrida de E/S.

= Gestión de E/S por programas =

El gestor de dispositivo periódicamente comprueba el estado del dispositivo. Para ello comprueba mediante los registros de estado del puerto de E/S si hay datos provenientes del dispositivo que deben ser tratados.
Un ejemplo de lectura de un único dispositivo sería:
<div style="font-family:Consolas, Courier New, Courier;border:1px dashed #9ab;text-indent: 5%">
configurar_dispositivo();

while(!fin_lectura) {

operacion_cualquiera();

while (!dato_recibido());

leer_dato();
</div>

La "lista de dispositivos" se puede recorrer en base a dos criterios distintos:

-Con prioridad uniforme: Todos los dispositivos reciben las mismas oportunidades de ser atendidos: se pregunta al primer dispositivo si requiere atención, y se le atiende. Después se pasa al siguiente, y así sucesivamente hasta dar una vuelta completa.

-Con prioridad escalonada: Tras atender a cualquier dispositivo, se vuelve a comenzar el sondeo por el primer dispositivo. El orden es determinante, pues se establece una relación de prioridad entre dispositivos determinada por ese orden.

Es ineficaz en sistemas interactivos, debido a que requiere espera ocupada y resulta engorrosa para atender a varios dispositivos simultáneamente, al implicar establecer prioridades entre estos.

= Gestión de E/S por interrupciones =

Una interrupción por hardware es una señal proveniente de un dispositivo de E/S para notificar al procesador de un cierto evento que debe ser tratado. Por ejemplo, un proceso hace uso de la llamada al sistema ''read'' para solicitar información que se encuentra en disco magnético. Una vez que la información está disponible, la interrupción es empleada para que se ejecute el gestor de dispositivos y obtenga los datos para dicho proceso, que ya están disponibles.

Las interrupciones son un mecanismo que ofrece la arquitectura para conectar los dispositivos de E/S con el procesador. No obstante, los datos provenientes del dispositivo de E/S se obtienen a través del bus.

El dispositivo de E/S emplea una de las líneas de interrupción que conectan al dispositivo con el procesador. Cada una de estas líneas corresponden con un cierto dispositivo o una familia de dispositivos de naturaleza similar. La asignación de líneas y dispositivo es estática y sucede en tiempo de arranque, por tanto, no cambia a lo largo del tiempo. En caso de que haya datos a tratar en el dispositivo, se notifica al procesador mediante la línea de interrupción. Ante esto, el planificador debe apartar el proceso que esté en estado activo para conmutar al gestor de dispositivo, el cual realizará el tratamiento de la interrupción, obteniendo los datos del dispositivo de E/S que están pendientes de ser tratados.

Por tanto, por cada interrupción se debe [[Conmutación_de_procesos|conmutar]] al gestor de dispositivos.

La ventaja es que la gestión de los dispositivos se desacopla de las demás actividades del sistema. Si hay que gestionar múltiples dispositivos, se lleva a cabo una interrupción por dispositivo, otra para todos los dispositivos, y si se agrupan, una interrupción por grupo.
Las interrupciones no son reentrantes, esto quiere decir que cuando se está realizando el tratamiento de una interrupción se desactiva temporalmente la notificación por interrupciones. Por tanto, una interrupción se ejecuta hasta fin de tratamiento, y en ningún caso es interrumpida por otra interrupción.

= Gestión de E/S híbrida =

Esta aproximación es la más usada en sistemas operativos modernos, y consiste en emplear una combinación de las soluciones anteriores. En principio, se realiza una gestión por interrupciones, pero ante situaciones de estrés en las que se ofrezca una carga de trabajo muy alta, que pueda llevar a una sobrecarga de conmutaciones, se limita en el tiempo la consulta de datos. Por ejemplo, si la tarjeta de red estuviera saturando el procesador con interrupciones, se puede optar por atenderlas todas juntas periódicamente (En lotes).

Gestión de Entrada/Salida

2013-01-21T08:28:24Z

Marperrei1: /* Gestión de E/S por programas */

El sistema operativo puede gobernar el dispositivo E/S a través del gestor de dispositivos de tres maneras posibles:

* Gestión de E/S por programas.
* Gestión de E/S por interrupciones.
* Gestión híbrida de E/S.

= Gestión de E/S por programas =

El gestor de dispositivo periódicamente comprueba el estado del dispositivo. Para ello comprueba mediante los registros de estado del puerto de E/S si hay datos provenientes del dispositivo que deben ser tratados.
Un ejemplo de lectura de un único dispositivo sería:
<div style="font-family:Consolas, Courier New, Courier;border:1px dashed #9ab;text-indent: 5%">
configurar_dispositivo();

while(!fin_lectura) {

operacion_cualquiera();

while (!dato_recibido());

leer_dato();
</div>

La "lista de dispositivos" se puede recorrer en base a dos criterios distintos:

-Con prioridad uniforme: Todos los dispositivos reciben las mismas oportunidades de ser atendidos: se pregunta al primer dispositivo si requiere atención, y se le atiende. Después se pasa al siguiente, y así sucesivamente hasta dar una vuelta completa.

-Con prioridad escalonada: Tras atender a cualquier dispositivo, se vuelve a comenzar el sondeo por el primer dispositivo. El orden es determinante, pues se establece una relación de prioridad entre dispositivos determinada por ese orden.

Es ineficaz en sistemas interactivos, debido a que requiere espera ocupada y resulta engorrosa para atender a varios dispositivos simultáneamente, al implicar establecer prioridades entre estos.

= Gestión de E/S por interrupciones =

Una interrupción por hardware es una señal proveniente de un dispositivo de E/S para notificar al procesador de un cierto evento que debe ser tratado. Por ejemplo, un proceso hace uso de la llamada al sistema ''read'' para solicitar información que se encuentra en disco magnético. Una vez que la información está disponible, la interrupción es empleada para que se ejecute el gestor de dispositivos y obtenga los datos para dicho proceso, que ya están disponibles.

Las interrupciones son un mecanismo que ofrece la arquitectura para conectar los dispositivos de E/S con el procesador. No obstante, los datos provenientes del dispositivo de E/S se obtienen a través del bus.

El dispositivo de E/S emplea una de las líneas de interrupción que conectan al dispositivo con el procesador. Cada una de estas líneas corresponden con un cierto dispositivo o una familia de dispositivos de naturaleza similar. La signación de líneas y dispositivo es estática y sucede en tiempo de arranque, por tanto, no cambia a lo largo del tiempo. En caso de que haya datos a tratar en el dispositivo, se notifica al procesador mediante la línea de interrupción. Ante esto, el planificador debe apartar el proceso que esté en estado activo para conmutar al gestor de dispositivo, el cual realizará el tratamiento de la interrupción, obteniendo los datos del dispositivo de E/S que están pendientes de ser tratados.

Por tanto, por cada interrupción se debe [[Conmutación_de_procesos|conmutar]] al gestor de dispositivos.

Las interrupciones no son reentrantes, esto quiere decir que cuando se está realizando el tratamiento de una interrupción se desactiva temporalmente la notificación por interrupciones. Por tanto, una interrupción se ejecuta hasta fin de tratamiento, y en ningún caso es interrumpida por otra interrupción.

= Gestión de E/S híbrida =

Esta aproximación es la más usada en sistemas operativos modernos, y consiste en emplear una combinación de las soluciones anteriores. En principio, se realiza una gestión por interrupciones, pero ante situaciones de estrés en las que se ofrezca una carga de trabajo muy alta, que pueda llevar a una sobrecarga de conmutaciones, se limita en el tiempo la consulta de datos. Por ejemplo, si la tarjeta de red estuviera saturando el procesador con interrupciones, se puede optar por atenderlas todas juntas periódicamente (En lotes).