Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Subidas de notas

2014-02-26T13:35:53Z

Albrojfer1:

Pérez Asién, Manuel (manperasi)

Rojas Fernández, Alberto (albrojfer1)

Subidas de notas

2014-02-26T13:35:25Z

Albrojfer1:

Pérez Asién, Manuel (manperasi)
Rojas Fernández, Alberto (albrojfer1)

Evaluame mis contribuciones a la wiki

2014-01-02T17:01:18Z

Albrojfer1:

A continuación, indica tu nombre y apellidos:

* Juan Carlos Roldán Salvador IS-G1
* Daniel Ayala Hernández IS-G1
* Daniel de los Reyes Leal IS-G1
* 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
* José Antonio Rojo Vidal IS-G1
* Jorge Rodríguez Fuerte IS-G1
* Alberto Rojas Fernández IS-G1

Usuario:Albrojfer1

2013-12-17T22:08:20Z

Albrojfer1:

~ Alberto Rojas Fernández 2º ING SOFTWARE 2013 - 2014 ~

*[http://www.linkedin.com/pub/alberto-rojas-fernández/7b/461/830 LinkedIn]
*[http://www.codecademy.com/es/albertfx Codeacademy]
*[https://github.com/AlbertFX91 Github]

Usuario:Albrojfer1

2013-12-17T22:02:41Z

Albrojfer1: Página creada con '~ Alberto Rojas Fernández 2º ING SOFTWARE 2013 - 2014 ~'

~ Alberto Rojas Fernández 2º ING SOFTWARE 2013 - 2014 ~

Sol tercera oportunidad

2013-12-17T22:01:03Z

Albrojfer1:

'''2(W)--2(R)--3(R)--1(R)--1(W)--3(W)--4(W)--5(W)--1(R)--1(R)--2(W)--3(R)--4(R)'''

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

9
Tasa fallos pág = ───── = 0,692307
13

Sol tercera oportunidad

2013-12-17T21:57:25Z

Albrojfer1: Página creada con ' '''2(W)--2(R)--3(R)--1(R)--1(W)--3(W)--4(W)--5(W)--1(R)--1(R)--2(W)--3(R)--4(R)''' ___1____ 2_____3_____4___ 1º Acceso | …'

Segmentación

2013-12-17T21:17:36Z

Albrojfer1: /* Características */

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

*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 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:
 - 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.

Criterios de reemplazo

2013-12-17T20:57:52Z

Albrojfer1: /* Criterio de la 3ª oportunidad (Método Multics) */

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.

<math>tasa fallos pagina = \frac{total fallos de pagina}{total accesos a pagina}</math>

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
___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 de 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:

[[Archivo:FIFO.jpg]]

*[[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 a 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 ordenanda 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 y se pasa al final de la lista (recibe una segunda oportunidad).

Si dicha página tiene el bit R a 0, existen dos casos:
*Si tiene el bit M a 1, se pone a 0 y se pasa al final de la lista.
*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)

Criterios de reemplazo

2013-12-17T20:53:05Z

Albrojfer1: /* Criterio de 2ª oportunidad */

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.

<math>tasa fallos pagina = \frac{total fallos de pagina}{total accesos a pagina}</math>

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
___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 de 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:

[[Archivo:FIFO.jpg]]

*[[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 a 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 ordenanda 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 y se pasa al final de la lista (recibe una segunda oportunidad).

Si dicha página tiene el bit R a 0, existen dos casos:
*Si tiene el bit M a 1, se pone a 0 y se pasa al final de la lista.
*Si tiene el bit M a 0, se selecciona como página víctima.

[[Archivo:Tercera oportunidad.jpg]]

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

Paginación

2013-12-16T20:04:27Z

Albrojfer1: /* Dispositivo de traducción de direcciones paginadas */

=Definición=
La paginación es una estrategia de organización de la memoria que consiste en dividir la memoria en porciones de igual tamaño, 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 tabla de páginas 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.
==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.

Solución del ejercicio 4 de paginación

2013-12-16T13:54:17Z

Albrojfer1:

'''A)'''Razone si las direcciones de memoria 0xabc10008 y 0xabc100aa pertenecen al mismo marco. ¿Y las direcciones 0xabc1fa00 y 0xabc2fa08?
En las direcciones de memoria 0xabc180008 y 0xabc100aa, como el tamaño de pagina es de 4 Kbytes = 212, podemos diferenciar dos partes:
- Número de página física (primeros 20 bytes)
- Desplazamiento (12 bytes siguientes)
En un tamaño de palabra de 32 bits (20+12).
Para comprobar si pertenecen al mismo marco miramos si el número de página física es el mismo, y en las dos direcciones que nos
dan lo es:___abc10___
Mientras que en las direcciones 0xabc1fa00 y 0xabc2fa08 podemos ver que no es el mismo marco: ___abc1f___ no es igual a ___abc2f___

'''B)'''¿De cuántas páginas físicas dispone el sistema?
Si tenemos 256 Kbytes de tamaño de memoria, es decir, 218, y 4 Kbytes de tamaño de página, 212:
218(del tamaño de memoria) / 212(del tamaño de página) = 26 páginas físicas, porciones de una zona de memoria.

''C)'' Si las páginas fueran de 1 KByte, ¿pertenecen las direccion 0xabc10008 y 0xabc800aa al mismo marco? Razone la respuesta.

- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.

0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

'''Desglose de direcciones'''

┌───────────────────────────┬────────────┐
0xabc10008:│1010 1011 1100 '''0001''' 0000 00│00 0000 1000│
0xabc800aa:│1010 1011 1100 '''1000''' 0000 00│00 1010 1010│
└───────────────────────────┴────────────┘
''marco'' ''desplazamiento''

''D)'' Indique el tamaño máximo de la tabla de páginas de un proceso suponiendo que cada entrada ocupa 8 bytes.
Para calcular el tamaño máximo de la tabla de de páginas de un proceso:
- ''Número de páginas máximo'': 64 páginas (26)
- ''Tamaño de entrada'': 8 bytes(23)
'''Tamaño máximo''': número de páginas máximo * tamaño de entrada = 26 * 23 = '''512 bytes'''

Solución del ejercicio 4 de paginación

2013-12-16T13:53:07Z

Albrojfer1:

'''A)'''Razone si las direcciones de memoria 0xabc10008 y 0xabc100aa pertenecen al mismo marco. ¿Y las direcciones 0xabc1fa00 y 0xabc2fa08?
En las direcciones de memoria 0xabc180008 y 0xabc100aa, como el tamaño de pagina es de 4 Kbytes = 212, podemos diferenciar dos partes:
- Número de página física (primeros 20 bytes)
- Desplazamiento (12 bytes siguientes)
En un tamaño de palabra de 32 bits (20+12).
Para comprobar si pertenecen al mismo marco miramos si el número de página física es el mismo, y en las dos direcciones que nos dan lo es:___abc10___
Mientras que en las direcciones 0xabc1fa00 y 0xabc2fa08 podemos ver que no es el mismo marco: ___abc1f___ no es igual a ___abc2f___

'''B)'''¿De cuántas páginas físicas dispone el sistema?
Si tenemos 256 Kbytes de tamaño de memoria, es decir, 218, y 4 Kbytes de tamaño de página, 212:
218(del tamaño de memoria) / 212(del tamaño de página) = 26 páginas físicas, porciones de una zona de memoria.

''C)'' Si las páginas fueran de 1 KByte, ¿pertenecen las direccion 0xabc10008 y 0xabc800aa al mismo marco? Razone la respuesta.

- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.

0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

'''Desglose de direcciones'''

┌───────────────────────────┬────────────┐
0xabc10008:│1010 1011 1100 '''0001''' 0000 00│00 0000 1000│
0xabc800aa:│1010 1011 1100 '''1000''' 0000 00│00 1010 1010│
└───────────────────────────┴────────────┘
''marco'' ''desplazamiento''

''D)'' Indique el tamaño máximo de la tabla de páginas de un proceso suponiendo que cada entrada ocupa 8 bytes.
Para calcular el tamaño máximo de la tabla de de páginas de un proceso:
- ''Número de páginas máximo'': 64 páginas (26)
- ''Tamaño de entrada'': 8 bytes(23)
'''Tamaño máximo''': número de páginas máximo * tamaño de entrada = 26 * 23 = '''512 bytes'''

Solución del ejercicio 4 de paginación

2013-12-16T13:51:35Z

Albrojfer1:

'''A)'''Razone si las direcciones de memoria 0xabc10008 y 0xabc100aa pertenecen al mismo marco. ¿Y las direcciones 0xabc1fa00 y 0xabc2fa08?
En las direcciones de memoria 0xabc180008 y 0xabc100aa, como el tamaño de pagina es de 4 Kbytes = 2^12, podemos diferenciar dos partes:
- Número de página física (primeros 20 bytes)
- Desplazamiento (12 bytes siguientes)
En un tamaño de palabra de 32 bits (20+12).
Para comprobar si pertenecen al mismo marco miramos si el número de página física es el mismo, y en las dos direcciones que nos dan lo es:___abc10___
Mientras que en las direcciones 0xabc1fa00 y 0xabc2fa08 podemos ver que no es el mismo marco: ___abc1f___ no es igual a ___abc2f___

'''B)'''¿De cuántas páginas físicas dispone el sistema?
Si tenemos 256 Kbytes de tamaño de memoria, es decir, 2^18, y 4 Kbytes de tamaño de página, 2^12:
2^18(del tamaño de memoria) / 2^12(del tamaño de página) = 2^6 páginas físicas, porciones de una zona de memoria.

''C)'' Si las páginas fueran de 1 KByte, ¿pertenecen las direccion 0xabc10008 y 0xabc800aa al mismo marco? Razone la respuesta.

- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.

0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

'''Desglose de direcciones'''

┌───────────────────────────┬────────────┐
0xabc10008:│1010 1011 1100 '''0001''' 0000 00│00 0000 1000│
0xabc800aa:│1010 1011 1100 '''1000''' 0000 00│00 1010 1010│
└───────────────────────────┴────────────┘
''marco'' ''desplazamiento''

''D)'' Indique el tamaño máximo de la tabla de páginas de un proceso suponiendo que cada entrada ocupa 8 bytes.
Para calcular el tamaño máximo de la tabla de de páginas de un proceso:
- ''Número de páginas máximo'': 64 páginas (26)
- ''Tamaño de entrada'': 8 bytes(23)
'''Tamaño máximo''': número de páginas máximo * tamaño de entrada = 26 * 23 = '''512 bytes'''

SO multiprogramables con particiones variables

2013-12-16T13:50:20Z

Albrojfer1: /* Método de los compañeros */

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. Las dos principales desventajas son su alto desperdicio interno, y el elevado 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)

== Mejor ajuste ==

Consiste en asignarle al proceso el hueco con menor ajuste 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 seria 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 sera 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 ajuste 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.

SO multiprogramables con particiones variables

2013-12-16T13:47:00Z

Albrojfer1: /* Método de los compañeros */

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. Las dos principales desventajas son su alto desperdicio interno, y el elevado 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)

== Mejor ajuste ==

Consiste en asignarle al proceso el hueco con menor ajuste 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 seria 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 sera 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 ajuste 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 2^k), si no hay ninguno se busca en la lista de la siguiente potencia (2^k+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 2^k.

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

SO multiprogramables con particiones variables

2013-12-16T13:46:22Z

Albrojfer1: /* Siguiente ajuste */

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. Las dos principales desventajas son su alto desperdicio interno, y el elevado 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)

== Mejor ajuste ==

Consiste en asignarle al proceso el hueco con menor ajuste 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 seria 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 sera 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 ajuste 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 2^k), si no hay ninguno se busca en la lista de la siguiente potencia (2^k+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 2^k.

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

Condiciones para el interbloqueo y estrategias de resolución

2013-12-12T21:35:43Z

Albrojfer1: /* Prevenció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 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 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, 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 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.

Condiciones para el interbloqueo y estrategias de resolución

2013-12-12T21:34:51Z

Albrojfer1: /* Prevenció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 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 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, 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 especialmente tengo la certeza de que hay una probabilidad muy baja de que se produzca un interbloqueo. 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.

Solución del ejercicio 4 de paginación

2013-12-05T11:04:31Z

Albrojfer1:

''C)'' Si las páginas fueran de 1 KByte, ¿pertenecen las direccion 0xabc10008 y 0xabc800aa al mismo marco? Razone la respuesta.
- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.

0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

'''Desglose de direcciones'''

┌───────────────────────────┬────────────┐
0xabc10008:│1010 1011 1100 '''0001''' 0000 00│00 0000 1000│
0xabc800aa:│1010 1011 1100 '''1000''' 0000 00│00 1010 1010│
└───────────────────────────┴────────────┘
''marco'' ''desplazamiento''

''D)'' Indique el tamaño máximo de la tabla de páginas de un proceso suponiendo que cada entrada ocupa 8 bytes.
Para calcular el tamaño máximo de la tabla de de páginas de un proceso:
- ''Número de páginas máximo'': 64 páginas (2^6)
- ''Tamaño de entrada'': 8 bytes(2^3)
'''Tamaño máximo''': número de páginas máximo * tamaño de entrada = 2^6 * 2^3 = '''512 bytes'''

Solución del ejercicio 4 de paginación

2013-12-05T10:57:19Z

Albrojfer1:

C) Si las páginas fuesen de 1 Kb(2^10 bits), la distribución sería:
- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.

0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

'''Desglose de direcciones'''

┌───────────────────────────┬────────────┐
0xabc10008:│1010 1011 1100 '''0001''' 0000 00│00 0000 1000│
0xabc800aa:│1010 1011 1100 '''1000''' 0000 00│00 1010 1010│
└───────────────────────────┴────────────┘
''marco'' ''desplazamiento''

Solución del ejercicio 4 de paginación

2013-12-05T10:54:21Z

Albrojfer1:

C) Si las páginas fuesen de 1 Kb(2^10 bits), la distribución sería:
- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.
0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

'''Desglose de direcciones'''

┌---------------------------┬------------┐
0xabc10008:|1010 1011 1100 '''0001''' 0000 00|00 0000 1000|
0xabc800aa:|1010 1011 1100 '''1000''' 0000 00|00 1010 1010|
└---------------------------┴------------┘
''marco'' ''desplazamiento''

Solución del ejercicio 4 de paginación

2013-12-05T10:52:17Z

Albrojfer1: Página creada con 'C) Si las páginas fuesen de 1 Kb(2^10 bits), la distribución sería: - Bits de marco = '''22 bits de marco''' - Bits de desplazamiento = '''10 bits de desplazam…'

C) Si las páginas fuesen de 1 Kb(2^10 bits), la distribución sería:
- Bits de marco = '''22 bits de marco'''
- Bits de desplazamiento = '''10 bits de desplazamiento'''.
0xabc10008 -> Marco: abc10 y los dos primeros bits de 0 = 00
0xabc800aa -> Marco: abc80 y los dos primeros bits de 0 = 00

Aunque los dos últimos bits coincidan, la primera parte no, por lo tanto '''no son del mismo marco'''.

''Desglose de direcciones''

┌---------------------------┬------------┐
0xabc10008:|1010 1011 1100 0001 0000 00|00 0000 1000|
0xabc800aa:|1010 1011 1100 1000 0000 00|00 1010 1010|
└---------------------------┴------------┘
marco desplazamiento

Sistema combinado

2013-12-05T08:09:27Z

Albrojfer1:

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

<center>[[Archivo:Sistema combinado.jpg]]</center>

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 el uso de la memoria virtual, y genera dispersión en memoria. Además como la paginación es transparente, se puede usar paginación bajo un sistema segmentado sin problema.

Los procesos emplean direcciones lógica de memoria segmentada, que son traducidas a direcciones lógicas páginadas, 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>

Archivo:Arquitecturaia32 2.jpg

2013-12-05T08:08:31Z

Albrojfer1:

Algoritmo para averiguar interbloqueo

2013-11-27T20:41:29Z

Albrojfer1: /* Algoritmo en Java */

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

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 3 2 1]
Lo consideramos terminado y añadimos sus recursos a los disponibles
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.

Segmentación

2013-11-26T09:50:09Z

Albrojfer1: /* Características */

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

*Es posible la redimensión de un segmento.

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