Segmentación

2011-06-07T10:08:57Z

Ajaest: Retirada discusión en artículo principal

=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: 2 segmentos pueden compartir zona de memoria. Ojo! problemas de concurrencia. Habría que usar algún método para su sincronización si se intenta.

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

*Aspectos materiales : Hay 2 registros que funcionan como dispositivos de traducción segmentada; uno de dirección de comienzo de la tabla de segmentos, y otro para el número de entradas en ella.

*Esto supone dos accesos a memoria física real. La tabla de segmentos ocupa memoria, siendo deseable que permanezcan en cache.

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

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

*No se redimensionan. La variabilidad del tamaño de los segmentos solo puede ser establecida en el momento de su creación.

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

==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 variable (Windows).

==Enlace dinámico==
Uso de llamadas a funciones que están en disco.

Podemos tener referencias a funciones o bibliotecas que no estén en memoria principal (permite ir cargando bajo demanda los segmentos que contengan el código necesario).

Discusión:Segmentación

2011-06-07T10:06:11Z

Ajaest: Movida discusión desde artículo principal

=Características=

*No se redimensionan <<<--------------- ¿No eran de tamaño variable? [[Usuario: JCGarrido|JCGarrido]]

Se refiere a que una vez creado el segmento del tamaño deseado(lo que quiere decir que son variables) éste se mantiene de tamaño fijo mientras exista [[Usuario:Ajaest|ajaest]] 10:06 7 jun 2011 (UTC)

SO multiprogramables con particiones variables

2011-06-07T09:51:18Z

Ajaest: Aclaración sobre mejor y peor ajuste interno

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, se utiliza un bit para representar si dicho bloque está libre o asignado.

* '''Listas de control''': Se almacena en una lista el tamaño de los huecos y las posiciones de memoria entre las que se encuentran comprendidos.

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

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

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

* '''Peor ajuste''': Al contrario que el criterio anterior, se asigna a cada proceso el hueco con mayor ajuste interno, i.e, el hueco el cual al serle asignado el proceso deja más espacio sin utilizar. Tiene el mismo inconveniente en cuanto a orden de complejidad que el mejor ajuste.

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

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

SO multiprogramables con particiones variables

2011-06-07T09:47:33Z

Ajaest: Borrada discusión en artículo

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, se utiliza un bit para representar si dicho bloque está libre o asignado.

* '''Listas de control''': Se almacena en una lista el tamaño de los huecos y las posiciones de memoria entre las que se encuentran comprendidos.

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

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

* '''Mejor ajuste''': Consiste en asignarle al proceso el hueco con menor ajuste interno. Su mayor inconveniente es su orden de complejidad (orden lineal, ''O(n)'')

* '''Peor ajuste''': Al contrario que el criterio anterior, se asigna a cada proceso el hueco con mayor ajuste interno. Tiene el mismo inconveniente en cuanto a orden de complejidad que el mejor ajuste.

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

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

Discusión:SO multiprogramables con particiones variables

2011-06-07T09:45:57Z

Ajaest: Movida discusión desde artículo principal

Petición:Por favor,alguien que entienda bien el mejor ajuste y el peor ajuste, que explique lo que significa que tenga menor o mayor ajuste interno, que no se entiende bien.
Gracias.

Creo que se refiere al desperdicio interno de una partición, por ejemplo si una partición es de 15 KB y un proceso ocupa 5KB el desperdicio interno de dicha particion serian 10KB.--[[Usuario:DvS 013|DvS 013]] 10:46 4 jun 2011 (UTC)

<[[Usuario:PCamino|pablo]]> Claro, el mejor ajuste consiste en meter el proceso en el hueco mas pequeño en que quepa, tras dar un repaso a los disponibles.

SO multiprogramables con particiones fijas

2011-06-07T09:35:48Z

Ajaest: /* Mecanismos de protección de memoria */

La memoria se encuentra dividida en particiones, en cada una habrá un proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.

=Estrategias=
Las estrategias a seguir cuando no hay memoria suficiente para otro proceso son dos:
*Cancelación: "lo siento, no hay memoria libre, prueba más tarde".
*Espera: añadir el proceso a una cola hasta que haya memoria disponible.

=Limitaciones=
*Si un proceso necesita mayor memoria que la partición más grande, entonces éste no se ejecuta.
*Desperdicio de memoria. Por ejemplo, si los procesos son muy pequeños y las particiones grandes.

=Criterios de asignación=
Se lanza un proceso, y hay que elegir a qué partición va (estrategia de espera). Puede haber una cola por partición, o una sola para todas las particiones.

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

*'''Mejor ajuste estático''': se adjudica cada proceso a la menor partición que quepa. Si la menor en la que cabe está ocupada, se espera. Complejidad: O(1)

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

*'''Primer ajuste''': cuando una partición queda libre, se asigna el primer proceso según el orden de la cola que quepa en ella. Complejidad: O(1)

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

*'''Mejor ajuste dinámico''': cuando una partición queda libre, se asigna el mayor proceso que quepa en ella. Complejidad: O(nlog(p))

[[solución ajuste dinámico|Ver solución]]

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

*'''Subparticiones''': No es un criterio como tal sino que viene a complementar a los anteriores. Si no hay un proceso que pueda aprovechar la partición madre: se asignan las subparticiones a procesos pequeños (para que el desperdicio interno sea lo menor posible). Si llega un proceso grande: los procesos pequeños se vuelcan a disco y se asigna partición madre.
''Partición madre'': tipo especial de partición que se puede dividir en múltiples particiones menores.

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

*'''Montaje absoluto''': Se asigna una dirección de memoria constante, siendo por tanto este método muy restrictivo. Se utiliza para la carga del sistema operativo.

* '''Carga con reubicación''': Al realizar la carga, se le aplica a las direcciones lógicas del programa un ''offset'' o desplazamiento. Este desplazamiento es establecido por el programador antes de que se ejecute el programa.

* '''Reubicación dinámica''': A diferencia de la carga con reubicación, el desplazamiento se asigna en tiempo de ejecución.
** '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.

= Mecanismos de protección de memoria =

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

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

* '''Ampliación registros valla''' : De esta manera se conocen la posición inicial y final, de manera que si no está entre esas dos posiciones no se permite el acceso a memoria.

SO multiprogramables con particiones fijas

2011-06-07T09:34:24Z

Ajaest: Los bits de protección son a particiones y no a palabras

La memoria se encuentra dividida en particiones, en cada una habrá un proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.

=Estrategias=
Las estrategias a seguir cuando no hay memoria suficiente para otro proceso son dos:
*Cancelación: "lo siento, no hay memoria libre, prueba más tarde".
*Espera: añadir el proceso a una cola hasta que haya memoria disponible.

=Limitaciones=
*Si un proceso necesita mayor memoria que la partición más grande, entonces éste no se ejecuta.
*Desperdicio de memoria. Por ejemplo, si los procesos son muy pequeños y las particiones grandes.

=Criterios de asignación=
Se lanza un proceso, y hay que elegir a qué partición va (estrategia de espera). Puede haber una cola por partición, o una sola para todas las particiones.

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

*'''Mejor ajuste estático''': se adjudica cada proceso a la menor partición que quepa. Si la menor en la que cabe está ocupada, se espera. Complejidad: O(1)

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

*'''Primer ajuste''': cuando una partición queda libre, se asigna el primer proceso según el orden de la cola que quepa en ella. Complejidad: O(1)

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

*'''Mejor ajuste dinámico''': cuando una partición queda libre, se asigna el mayor proceso que quepa en ella. Complejidad: O(nlog(p))

[[solución ajuste dinámico|Ver solución]]

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

*'''Subparticiones''': No es un criterio como tal sino que viene a complementar a los anteriores. Si no hay un proceso que pueda aprovechar la partición madre: se asignan las subparticiones a procesos pequeños (para que el desperdicio interno sea lo menor posible). Si llega un proceso grande: los procesos pequeños se vuelcan a disco y se asigna partición madre.
''Partición madre'': tipo especial de partición que se puede dividir en múltiples particiones menores.

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

*'''Montaje absoluto''': Se asigna una dirección de memoria constante, siendo por tanto este método muy restrictivo. Se utiliza para la carga del sistema operativo.

* '''Carga con reubicación''': Al realizar la carga, se le aplica a las direcciones lógicas del programa un ''offset'' o desplazamiento. Este desplazamiento es establecido por el programador antes de que se ejecute el programa.

* '''Reubicación dinámica''': A diferencia de la carga con reubicación, el desplazamiento se asigna en tiempo de ejecución.
** '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.

= Mecanismos de protección de memoria =

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

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

* '''Ampliación registros valla''' : De esta manera se conocen la posición inicial y final, de manera que si no está entre esas dos posiciones no se permite el acceso a memoria.

SO multiprogramables con particiones fijas

2011-06-01T15:39:10Z

Ajaest: Nota sobre orden de las soluciones

La memoria se encuentra dividida en particiones, en cada una habrá un proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.

=Estrategias=
Las estrategias a seguir cuando no hay memoria suficiente para otro proceso son dos:
*Cancelación: "lo siento, no hay memoria libre, prueba más tarde".
*Espera: añadir el proceso a una cola hasta que haya memoria disponible.

=Limitaciones=
*Si un procesos necesita mayor memoria que la partición máxima, entonces este no se ejecuta.
*Desperdicio de memoria. Por ejemplo, si los procesos son muy pequeños y las particiones grandes.

=Criterios de asignación=
Se lanza un proceso, y hay que elegir a que partición va (estrategia de espera). Puede haber una cola por partición, o una sola para todas las particiones.

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

*'''Mejor ajuste estático''': se adjudica cada proceso a la menor partición que quepa. Complejidad: O(1)

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

*'''Primer ajuste''': cuando una partición queda libre, se asigna el primer proceso que quepa en ella. Complejidad: O(1)

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

*'''Mejor ajuste dinámico''': cuando una partición queda libre, se asigna el mayor proceso que quepa en ella. Complejidad: O(nlog(p))

[[solución ajuste dinámico|Ver solución]]

*'''Mejor que quepa con aplazamiento limitado''': Cuando queda una partición libre, se selecciona el mayor proceso que quepa en ella, pero se cuenta el nº de veces que un proceso se aplaza. Si se superan esas '''n''' veces (umbral), se le da paso.

*'''Subparticiones''': No es un criterio como tal sino que viene a complementar a los anteriores. Si no hay un proceso que pueda aprovechar partición madre: se asignan las subparticiones a procesos pequeños (para que el desperdicio interno sea lo menor posible). Si llega un proceso grande: los procesos pequeños se vuelcan a disco y se asigna partición madre.
''Partición madre'': tipo especial de partición que se puede dividir en múltiples particiones menores.

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

*'''Montaje absoluto''': Se asigna una dirección de memoria constante, siendo por tanto este método muy restrictivo. Se utiliza para la carga del sistema operativo.

* '''Carga con reubicación''': Al realizar la carga, se le aplica a las direcciones lógicas del programa un ''offset'' o desplazamiento asociada. Este desplazamiento es establecido por el programador antes de que se ejecute el programa.

* '''Reubicación dinámica''': A diferencia de la carga con reubicación, el desplazamiento se asigna en tiempo de ejecución.
** '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.

= Mecanismos de protección de memoria =

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

* '''Ampliación bits de protección'''

* '''Ampliación registros valla''' : De esta manera se conocen la posición inicial y final, de manera que si no esta entre esas dos posiciones no se permite el acceso a memoria.

Discusión:Solución ejercicio 1

2011-05-10T20:54:49Z

Ajaest:

No estoy del todo seguro de la solución dada. Teniendo en cuenta los valores en cada momento de semáforos(justo después de ejecutar la instrucción y antes de que lo haga el planificador):

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin del proceso

| | | #1| #2| #3| #4| #5| #1| | #2| | | | #3| #4| #5| #1| | | |
p1| | |---|---|---|---|---|---| |---X / | |---|---|---|---> | | |
| | | | | | | | | | | | | | | | | | | | |
| #1| #2| | | | | | | #3| | #4| #1| #2| | | | | #3| #4| #1|
p2|---|---X | | | | / |---| |---|---|---| | | / |---|---|--->
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
*********************************************************************************
s1.cont | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 2 | 2 |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
s1.prlist | | | | | | | | | |p1 | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
s2.cont | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
s2.prlist | |p2 |p2 |p2 |p2 |p2 | | | | | | | p2| p2| p2| | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
p1.quantum | 3 | 3 | 2 | 1 | 0 | 2 | 1 | 0 | 3 | 2 | 2 | 2 | 2 | 1 | 0 | 3 | 2 | nc| nc| nc|
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
p2.quantum | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 3 | 2 | 1 | 0 | 3 | 3 | 3 | 3 | 2 | 1 | 0 |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
(2) (1) (2)
(1) A p2 solo le quedaba una unidad de tiempo de su quantum, así que solo ejecuta una línea y no 3. Aquí cabría preguntarse si al pasar a estado bloqueado un nuevo quantum le es asignado

(2) pese a que p1 agota su quantum, como p2 está bloqueado y p1 es el único proceso se le asigna un nuevo quantum

Discusión:Solución ejercicio 1

2011-05-10T20:54:39Z

Ajaest:

No estoy del todo seguro de la solución dada. Teniendo en cuenta los valores en cada momento de semáforos(justo después de ejecutar la instrucción y antes de que lo haga el planificador):

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin del proceso

| | | #1| #2| #3| #4| #5| #1| | #2| | | | #3| #4| #5| #1| | | |
p1| | |---|---|---|---|---|---| |---X / | |---|---|---|---> | | |
| | | | | | | | | | | | | | | | | | | | |
| #1| #2| | | | | | | #3| | #4| #1| #2| | | | | #3| #4| #1|
p2|---|---X | | | | / |---| |---|---|---| | | / |---|---|--->
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
*********************************************************************************
s1.cont | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 2 | 2 |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
s1.prlist | | | | | | | | | |p1 | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
s2.cont | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
s2.prlist | |p2 |p2 |p2 |p2 |p2 | | | | | | | p2| p2| p2| | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
p1.quantum | 3 | 3 | 2 | 1 | 0 | 2 | 1 | 0 | 3 | 2 | 2 | 2 | 2 | 1 | 0 | 3 | 2 | nc| nc| nc|
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
p2.quantum | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 3 | 2 | 1 | 0 | 3 | 3 | 3 | 3 | 2 | 1 | 0 |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
(2) (1) (2)
(1) A p2 solo le quedaba una unidad de tiempo de su quantum, así que solo ejecuta una línea y no 3. Aquí cabría preguntarse si al pasar a estado bloqueado un nuevo quantum le es asignado
(2) pese a que p1 agota su quantum, como p2 está bloqueado y p1 es el único proceso se le asigna un nuevo quantum

2011-05-10T18:13:28Z

Ajaest: Página blanqueada

Discusión:Solución de los ejercicios de concurrencia

2011-05-10T18:13:18Z

Ajaest:

He de suponer que lock_down==lock y lock_up = unlock, no? creo que con lock y unlock queda bastante más claro

Discusión:Mecanismos de sincronización

2011-05-10T18:03:18Z

Ajaest:

- A mi enteder en el fragmento de codigo de :
<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (compartida+1 != tmp) /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
</source>
¿no deberia en vez de modificar la variable temporal , modificar la variable compartida?

Ya que como dice al principio los dos procesos tienen el mismo codigo entonces, en ambos la variable compartida no es modificada,
se modifica la variable temporal.

Ejemplo: El proceso A empieza a ejecutarse y se queda en la linea tmp ++ por que agota su ventana de tiempo, el proceso B empieza a ejecutar, y tmb se queda en estado preparado por que agota su ventana de tiempo en la instruccion tmp ++, en este caso ambos procesos han acedido al recurso comportido y la instruccion if la cumple.

¿Que os parece?

----

Ese trozo de código es incompleto a mi parecer. ¿Lo que dices es esto?
<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
'''compartida++'''; /* actualizo la varible */
if (compartida != '''tmp + 1''') /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
</source>

No creo que actualizar la variable compartida antes de hacer ninguna comprobación sea correcto.

Pienso que seria mejor actualizar el valor de la variable una vez hecha la comprobación:
<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (compartida+1 != tmp) /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
'''else
compartida = tmp;''' /* Actualizo el valor de la variable compartida. */
</source>

Lo más probable es que la intención de ese trozo fuese mostrar la idea principal, por eso no aparece la modificación de la variable compartida. Pero tampoco estoy seguro de esto. ¿Alguna otra opinión?

----
Esto no tieme ningún sentido:
<source lang ="c">
int compartida = 1, tmp;
</source>
¿Está asignando dos valores a la misma variable? Creo que tal y como está planteado el ejemplo debería ser como sigue:
<source lang ="c">
int compartida = 1; //Inicialización, puesta de manera ilustrativa pero irrelevante su valor y cuando se hace
/* Código no concurrente */
//...
/* Modificación de variable compartida, código concurrente */
{ //Limitamos la existencia de la variable temporal con las llaves
retry: //GOTO y etiqueta fuera sin for, si lo viera algún talibán de C...
int tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (compartida+1 != tmp) /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
else
compartida = tmp; //Esto es chungo, porque aunque sea verdad el código del if nada
} //garantiza que la variable compartida no cambie mientras se llega al
//else
</source>

De todas maneras, por lo que he puesto en el último comentario, el ejemplo creo que tampoco es bueno. Al final, la operación de comprobación exige un bloque sincronizado que englobe al if-else, paradigma de las técnicas no optimistas

2011-03-22T19:02:11Z

Ajaest: imagen SO

= Modos de operación del procesador =

Para entender los modelos de diseño de los sistemas operativos, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador indica que conjunto de instrucciones y a qué recursos del procesador se puede acceder en un cierto instante de tiempo.

En la actualidad, un procesador ofrece como mínimo dos modos de operación que son:

* Modo supervisor, que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador.
* Modo usuario, que tiene algunas restricciones de acceso a aspectos del procesador o de ejecución de instrucciones.

= Núcleo del sistema operativo =

El núcleo del sistema operativo, también conocido por la terminología inglesa ''kernel'', es la parte más esencial del sistema operativo. Se trata de la capa visible de software más baja del sistema y provee y gestiona de forma segura los recursos del sistema a través de las llamadas al sistema.

El núcleo de un sistema operativo suele operar en modo supervisor. Al operar en dicho modo un error de programación en el núcleo del sistema operativo puede resultar en un error fatal del cual el sistema sólo puede recuperarse mediante el reinicio del sistema. A tal error fatal también se le conoce en los sistemas operativos UNIX por la locución inglesa ''[http://es.wikipedia.org/wiki/Kernel_panic kernel panic]''.

= Tipos de Sistemas Operativos =

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidad implementada en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* Monolíticos: son núcleos de gran tamaño con poca modularidad y flexibilidad pero con una gran cantidad de funcionalidades, las cuales son normalmente compiladas junto al núcleo en el mismo momento.
* Micronúcleos: son núcleos de pequeño tamaño que fueron compilados sólo con las necesidades más básicas del sistema operativo. El resto de funcionalidades son añadidas mediante la adición de módulos externos al núcleo, lo que les proporciona flexibilidad y facilidad de ampliación en detrimento del desempeño necesario para la gestión dinámica de éstos.

No obstante, existen tipologías híbridas o que acentúan algunos aspectos, que también detallamos en esta sección.

[[Imagen:OS-structure2.svg|thumb| Comparativa de distribución de funcionalidades entre distintos tipos de SO]]

== Sistemas operativos Monolíticos ==

Los sistema operativos monolíticos se caracterizan por emplear un núcleo que implementa la planificación de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida. Por tanto, a mayor funcionalidad implementada en el núcleo, mayor número de líneas de código que se ejecutan en modo supervisor.

Los sistemas operativos monolíticos son los predominantes hoy día, algunos ejemplos son:

* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, al emplear un núcleo que incluye gran parte de las funcionalidades básicas del sistema operativo, dispone de un alto número de líneas de código ejecutándose en modo supervisor. Por ello, un error de programación en el núcleo puede provocar un ''kernel panic''. Además el hecho de añadir nuevas funcionalidades provocaría una nueva recompilación del núcleo llevando a reiniciar el sistema para que se apliquen los nuevos cambios.

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

== Sistemas operativos Micronúcleo ==

También conocidos como sistemas operativos exokernel o exonúcleo, se caracterizan por disponer de un núcleo que implementa únicamente:

* Planificación de procesos
* Mecanismo de comunicación entre procesos
* Gestión de interrupciones

Además, existen procesos servidores que están fuera del núcleo, que se ejecutan en modo usuario del procesador, y que implementan la:

* Administración de memoria principal
* Administración de ficheros
* Gestión de dispositivos de entrada/salida.

Siguiendo este esquema, cuando un proceso cualquiera solicita un servicio a través de una llamada al sistema, el micronúcleo canaliza la petición al proceso servidor correspondiente. Dicha comunicación se realiza mediante mensajería.

La principal ventaja de los sistemas operativos micronúcleo es que, al ejecutar menos líneas de código en modo supervisor, de manera intuitiva son más fiables. Otras ventajas son que se garantiza el aislamiento de las partes que estan fuera del nucleo, como los modulos son independientes unos de otros, si cae alguno de ello los demas no se ven afectados y pueden seguir funcionando.

Sin embargo, el principal problema que presentan es el rendimiento, puesto que cualquier petición requiere mensajería, que lleva consigo un coste extra debido a la construcción de los mensajes, el reparto y la interpretación. Son estos problemas relacionados con el rendimiento los que hacen que no existan sistemas operativos micronúcleo desplegables en productivo, a excepción de Minix 2, que tiene propósitos educativos.

== Sistemas basados en Máquinas Virtuales ==

Implementan el material (hardware) en el software. Algunos sistemas operativos ofrecen técnicas de paravirtualización.

Paravirtualización: técnica de programación que ofrecen algunos SO anfitrión para facilitar la virtualización y el rendimiento de máquinas virtuales. Ofrecen llamadas directas al sistema
o acceso a una API especial del anfitrión para acceder directamente a los recursos. Observamos que se deposita una gran confianza en los procesos de la VM por motivos de rendimiento.

* Ventajas de las Máquinas Virtuales

** Ahorro de coste material.
** Se pueden tener diferentes SO en un mismo sistema.
** Se adopta a las necesidades de usuario.
** Se puede deslocalizar la máquina virtual (deslocalización: migrar a otro SO sin sufrir ningún cambio ).

* Desventajas de las Maquinas Virtuales

** Rendimiento (KVM + paravirtualizacion 10%).
** Punto único de fallos(si falla algún componente y las aplicaciones están montadas en él provoca un fallo general).

= Otro material a consultar =

El estudiante puede encontrar el siguiente material de interés para complementar sus conocimientos:

* Debate entre Linus Torvalds, creador del núcleo Linux, que sigue el paradigma monolítico y Andrew S. Tanembaum, creador de Minux, que sigue el modelo micronúcleo: http://oreilly.com/catalog/opensources/book/appa.html (en inglés).