Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Página con listado de personas que han contribuido

2012-01-28T14:37:28Z

Peducemar:

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

* luigarhor
* rafperper
* sergaralo
* josalgrod1
* felgaroje
* luimunlei
* [https://1984.lsi.us.es/wiki-ssoo/index.php/Usuario:Lorruimor Lorruimor]
* albsolnog
* framorexp
* javgarang
* FerGuaTol
* jesgonbel
* fraperdom
* antdomflo
* antmorzam
* migoligon
* danplaseg
* peducemar

Estructura típica de dispositivo E/S

2012-01-21T11:23:59Z

Peducemar: Deshecha la edición 2351 de Danplaseg (disc.)

En general, la estructura típica de un dispositivo de entrada/salida está dividida en tres partes:

* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador. Algunos ejemplos de interfaces de este tipo son los buses PCI, PCMCIA, USB, PCI-express o SATA entre muchos otros.
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:
**Registros de órdenes
**Registros de estado
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.

Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).

La conexión existente entre el procesador y el dispositivo de E/S queda resumida de la siguiente manera:

[[Archivo:Dispositivos ES.svg|Estructura del dispositivo]]

= Gestor de dispositivos =

El gestor de dispositivo, popularmente conocido por la palabra inglesa ''driver'', es la parte del sistema operativo que se encarga de gobernar un cierto dispositivo o una familia de dispositivos de naturaleza similar. El gestor de dispositivo se trata de una pieza de software que conoce los detalles de bajo nivel del dispositivo. De esta manera el driver hace uso del conjunto de instrucciones que ofrece el puerto de E/S, los registros de estado y de lectura
y escritura, para gobernar el dispositivo. Si el fabricante del dispositivo no ofrece un ''driver'' para un cierto sistema operativo, el dispositivo y los recursos que ofrece no puede ser gestionado por el sistema operativo. Por lo general el fabricante de un dispositivo desarrolla el gestor de dispositivo para los sistemas operativos mayoritarios (i.e. Windows y Linux) para asegurar que su dispositivo alcanza la mayor cuota de usuarios posibles.

Los gestores de dispositivos representan en torno al 70% de los sistemas operativos<ref>Construction of a Highly Dependable Operating System, Proc. 6th European Dependable Computing Conference (EDCC-6), pp. 3-12, Oct. 2006</ref>. Por lo general, en los sistemas operativos monolíticos se ejecutan en el espacio del núcleo del sistema operativo por razones de rendimiento. Por tanto, se ejecutan en modo privilegiado, así un error de programación en un ''driver'' lleve a un cuelgue completo del sistema con casi total seguridad. Se estima que en torno al 85% de cuelgues de Microsoft Windows XP <ref>Recovering Device Drivers, Proc. OSDI '04, pp. 1-16, 2004</ref>se debe a errores de programación en ''drivers''.

No obstante, en sistemas operativos convencionales como Windows, Linux y Mac, existen mecanismos que permiten ejecutar ''drivers'' como procesos de usuario, tal y como sucede en sistemas operativo de tipo micronúcleo. De esta manera, un error de programación no produce el cuelgue del sistema completo. No obstante, dichos gestores de dispositivos se limitan a dispositivos particularmente lentos en los que la tasa de transferencia de datos es baja y los tiempos de respuesta del dispositivo son altos, por ejemplo, los gestores de dispositivos para lectores de tarjetas inteligentes (smartcards, lo que incluye las tarjetas SIM que se emplean en telefonía móvil) en Linux funcionan en espacio de usuario.

==Notes==
<references/>

Solución Ejercicio clase Mejor Ajuste Estático

2011-12-19T09:04:53Z

Peducemar:

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

- El proceso 4 que ocupa 9 unidades de memoria no cabría en la memoria C que es de 8 ¿no? Debería usarse la memoria D ¿no?

- Yo he cambiado la C por la D porque creo que es una errata de quien lo ha subido.

- Sí que era una errata. Gracias por corregirme.

Ejercicios administración de memoria contigua

2011-12-02T16:00:28Z

Peducemar: /* Ejercicio 2 */

=Ejercicios Clase=

==Ejercicio 1==
Ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[Solución Ejercicio clase Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

==Ejercicio 2==
Segundo ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

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

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

Calcula los cronogramas tal y como se hizo en el ejercicio anterior.

PD: Ejercicio NO resuelto en clase.

Ejercicios administración de memoria contigua

2011-12-02T15:57:47Z

Peducemar: /* Ejercicios Clase */

=Ejercicios Clase=

==Ejercicio 1==
Ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[Solución Ejercicio clase Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

==Ejercicio 2==
Segundo ejercicio visto el martes 29 de Noviembre de 2011 en clase [[2º Ejercicio clase 29/11/11|Ver Ejercicio]]
(Por resolver).

Ejercicios administración de memoria contigua

2011-12-02T15:56:54Z

Peducemar: Página creada con '=Ejercicios Clase= ==Ejercicio 1== Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase Ver Ejercicio, junto con las soluciones …'

=Ejercicios Clase=

==Ejercicio 1==
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]], junto con las soluciones también vistas en clase.

==Ejercicio 2==
Segundo ejercicio visto el martes 29 de Noviembre de 2011 en clase [[2º Ejercicio clase 29/11/11|Ver Ejercicio]]
(Por resolver).

SO multiprogramables con particiones fijas

2011-12-02T15:55:38Z

Peducemar: Traslado de Ejercicios

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Por tanto, los procesos nunca esperan siempre que hay alguna partición libre. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Al quedar libre una partición, se asigna el mayor proceso que quepa en ella. Por tanto, no es necesario que los procesos esperen indefinidamente a que la menor partición en la que quepan quede libre. Basta que haya una partición libre para que pueda ser asignado.

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

Solución Ejercicio clase Mejor Ajuste Dinámico

2011-12-02T10:18:52Z

Peducemar: Página blanqueada

2º Ejercicio clase 29/11/11

2011-12-01T21:01:28Z

Peducemar: creacion enunciado

Dada la siguiente configuración de procesos:

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

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

Ejercicio clase 291111

2011-12-01T21:01:14Z

Peducemar: errata

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[Solución Ejercicio clase Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

SO multiprogramables con particiones fijas

2011-12-01T20:59:21Z

Peducemar: /* Ejercicios Clase */

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

=Ejercicios Clase=

==Ejercicio 1==
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]], junto con las soluciones también vistas en clase.

==Ejercicio 2==
Segundo ejercicio visto el martes 29 de Noviembre de 2011 en clase [[2º Ejercicio clase 29/11/11|Ver Ejercicio]]
(Por resolver).

SO multiprogramables con particiones fijas

2011-12-01T20:58:16Z

Peducemar: /* Ejercicio 1 */

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

=Ejercicios Clase=

==Ejercicio 1==
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]], junto con las soluciones también vistas en clase.

SO multiprogramables con particiones fijas

2011-12-01T20:57:58Z

Peducemar: /* Ejercicios Clase */

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

=Ejercicios Clase=

=Ejercicio 1=
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]], junto con las soluciones también vistas en clase.

SO multiprogramables con particiones fijas

2011-12-01T20:57:41Z

Peducemar: /* Ejercicios Clase */

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

===Ejercicios Clase===

=Ejercicio 1=
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]], junto con las soluciones también vistas en clase.

SO multiprogramables con particiones fijas

2011-12-01T20:57:20Z

Peducemar: creación apartado Ejercicios Clase

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

==Ejercicios Clase==

=Ejercicio 1=
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]], junto con las soluciones también vistas en clase.

SO multiprogramables con particiones fijas

2011-12-01T20:56:06Z

Peducemar: /* Ejemplo 3 */ traslado a otra parte de la pagina

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

Ejercicio clase 291111

2011-12-01T20:55:20Z

Peducemar:

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[Solución Ejercicio clase Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

Solución Ejercicio clase Primer Ajuste

2011-12-01T20:54:48Z

Peducemar: Solución Ejercicio clase Por Orden de LLegada trasladada a Solución Ejercicio clase Primer Ajuste

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

Solución Ejercicio clase Por Orden de LLegada

2011-12-01T20:54:48Z

Peducemar: Solución Ejercicio clase Por Orden de LLegada trasladada a Solución Ejercicio clase Primer Ajuste

#REDIRECCIÓN [[Solución Ejercicio clase Primer Ajuste]]

Ejercicio clase 291111

2011-12-01T20:54:33Z

Peducemar: /* Ejemplo */

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[solución Ejercicio clase Por Orden de LLegada|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

Solución Ejercicio clase Mejor Ajuste Dinámico

2011-12-01T20:54:10Z

Peducemar: Página creada con 'Mismo cronograma que Primer Ajuste'

Mismo cronograma que Primer Ajuste

Ejercicio clase 291111

2011-12-01T20:53:50Z

Peducemar: /* Ejemplo */

=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[solución Ejercicio clase Por Orden de LLegada|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

Solución Ejercicio clase Primer Ajuste

2011-12-01T20:52:20Z

Peducemar: Solucion

Solución Ejercicio clase Mejor Ajuste Estático

2011-12-01T20:49:37Z

Peducemar: Solución

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

Ejercicio clase 291111

2011-12-01T20:45:05Z

Peducemar: /* Ejemplo */

=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma por Orden de Llegada [[solución Ejercicio clase Por Orden de LLegada|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

Ejercicio clase 291111

2011-12-01T20:42:49Z

Peducemar: /* Ejemplo */

=== Ejemplo ===

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático

b) Determina el cronograma por Orden de Llegada

c) Determina el cronograma del Mejor Ajuste Dinámico

Ejercicio clase 291111

2011-12-01T20:40:56Z

Peducemar: /* Ejemplo */

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático

b) Determina el cronograma por Orden de Llegada

c) Determina el cronograma del Mejor Ajuste Dinámico

Ejercicio clase 291111

2011-12-01T20:40:41Z

Peducemar:

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

a) Determina el cronograma del Mejor Ajuste Estático
b) Determina el cronograma por Orden de Llegada
c) Determina el cronograma del Mejor Ajuste Dinámico

Ejercicio clase 291111

2011-12-01T20:39:54Z

Peducemar: /* EJERCICIO DE CLASE */

Dada la siguiente configuración de procesos:

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

Y la siguiente configuración de memoria:
_______
|_____| a = 4KB
|_____| b = 4KB
| |
|_____| c = 8KB
| |
| |
| | d = 16KB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático
b) Determina el cronograma por Orden de Llegada
c) Determina el cronograma del Mejor Ajuste Dinámico

Ejercicio clase 291111

2011-12-01T20:39:01Z

Peducemar:

==EJERCICIO DE CLASE==
Dada la siguiente configuración de procesos:

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

Y la siguiente configuración de memoria:
_______
|_____| a = 4KB
|_____| b = 4KB
| |
|_____| c = 8KB
| |
| |
| | d = 16KB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático
b) Determina el cronograma por Orden de Llegada
c) Determina el cronograma del Mejor Ajuste Dinámico

Ejercicio clase 291111

2011-12-01T20:38:36Z

Peducemar: Página creada con 'Dada la siguiente configuración de procesos: | H0 | t | m(P)| --------------------- P1 | 0 | 4 | 3 | P2 | 1 | 4 | 1 | P3 | 2 | 5 | 2 | P4 | 3 | 2 | 9…'

Dada la siguiente configuración de procesos:

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

Y la siguiente configuración de memoria:
_______
|_____| a = 4KB
|_____| b = 4KB
| |
|_____| c = 8KB
| |
| |
| | d = 16KB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático
b) Determina el cronograma por Orden de Llegada
c) Determina el cronograma del Mejor Ajuste Dinámico

SO multiprogramables con particiones fijas

2011-12-01T20:32:47Z

Peducemar: Añadir enlace a ejercicio dado en clase

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

=== Otro ejemplo ===

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

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

=== Ejemplo 3===
Aquí está el ejercicio visto el martes 29 de Noviembre de 2011 en clase [[Ejercicio clase 291111|Ver Ejercicio]]

== Primer ajuste ==

Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Complejidad: O(1)

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

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

== Mejor ajuste dinámico ==

Cuando una partición queda libre, se asigna el mayor proceso que quepa en ella, sin importar el desperdicio. Complejidad: O(n).

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

Sol-ejer2-2-otros-aspectos

2011-11-06T17:36:27Z

Peducemar: Corrrección-lapsus

____|_PA_|_PB_|_PC_| Prioridad C<B<A
Datos del ___H0_|_0__|_1__|_2__| PA bloquea cada 1 u.t.
problema ___t__|_3__|_5__|_6__| PB bloquea cada 3 u.t.
_plazo|_6__|_15_|_15_| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
--- = proceso ejecutándose
* = el proceso aborta

| | | | | | | | | | | | | | | |
Pa <---# | <---| | * | | | | | | | | |
Pb | <---|---| |---# | <---|---| | | | | |
Pc | | < | | |---|---| | |---|---|---|---> | |
Planificador X X X X X | X X | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

'''OBSERVACIONES:'''

*Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

-Creo que hay un error en el instante de tiempo 3 debería comenzar Pa porque tiene prioridad sobre Pb y en el instante de tiempo 4 empezar Pb y ser bloqueada en el instante de tiempo 5 con lo que en el momento 5 empieza Pc hasta el momento 7 que es el tiempo de bloqueo de Pb.
--[[Usuario:Sertrimur|Sertrimur]] 17:23 5 nov 2011 (UTC)==Por prioridades apropiativo en tiempo real==

--[[Usuario:Peducemar|Peducemar]] Cierto, ya está corregido. Gracias.

Sol-ejer2-2-otros-aspectos

2011-11-04T20:25:52Z

Peducemar: Página creada con '==Por prioridades apropiativo en tiempo real== ____|_PA_|_PB_|_PC_| Prioridad C<B<A Datos del ___H0_|_0__|_1__|…'

==Por prioridades apropiativo en tiempo real==

____|_PA_|_PB_|_PC_| Prioridad C<B<A
Datos del ___H0_|_0__|_1__|_2__| PA bloquea cada 1 u.t.
problema ___t__|_3__|_5__|_6__| PB bloquea cada 3 u.t.
_plazo|_6__|_15_|_15_| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
--- = proceso ejecutándose
* = el proceso aborta

| | | | | | | | | | | | | | | |
Pa <---# | < |---# * | | | | | | | | |
Pb | <---|---|---# | <---|---> | | | | | | |
Pc | | < | | |---| | |---|---|---|---|---> | |
Planificador X X X X X | X X | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

'''OBSERVACIONES:'''

*Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

Sol-ejer2-1-otros-aspectos

2011-11-04T20:25:27Z

Peducemar: /* Por prioridades apropiativo en tiempo real */

Sol-ejer2-1-otros-aspectos

2011-11-04T20:08:04Z

Peducemar: /* Por prioridades apropiativo en tiempo real */ errata

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

==Por prioridades apropiativo en tiempo real==

____|_PA_|_PB_|_PC_| Prioridad C<B<A
Datos del ___H0_|_0__|_1__|_2__| PA bloquea cada 1 u.t.
problema ___t__|_3__|_5__|_6__| PB bloquea cada 3 u.t.
_plazo|_6__|_15_|_15_| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
--- = proceso ejecutándose
* = el proceso aborta

| | | | | | | | | | | | | | | |
Pa <---# | < |---# * | | | | | | | | |
Pb | <---|---|---# | <---|---> | | | | | | |
Pc | | < | | |---| | |---|---|---|---|---> | |
Planificador X X X X X | X X | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

'''OBSERVACIONES:'''

*Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

Sol-ejer2-1-otros-aspectos

2011-11-04T20:02:19Z

Peducemar: Traza de Tiempo Real por Prioridades

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

==Por prioridades apropiativo en tiempo real==

____|_PA_|_PB_|_PC_| Prioridad C<B<A
Datos del ___H0_|_0__|_1__|_2__| PA bloquea cada 1 u.t.
problema ___t__|_3__|_5__|_6__| PB bloquea cada 3 u.t.
_plazo|_6__|_15_|_15_| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
--- = proceso ejecutándose
* = el proceso aborta

| | | | | | | | | | | | | | | |
Pa <---# | < |---# * | | | | | | | | |
Pb | <---|---|---# |---|---> | | | | | | | |
Pc | | < | | | | |---|---|---|---|---|---> | |
Planificador X X X X X | X X | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

'''OBSERVACIONES:'''

*Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

Sol-ejer2-1-otros-aspectos

2011-11-04T19:48:46Z

Peducemar: errata

Sol-ejer2-1-otros-aspectos

2011-11-04T19:46:28Z

Peducemar: /* SJF Apropiativo con multiprocesamiento */ Observaciones

Sol-ejer2-1-otros-aspectos

2011-11-04T19:38:36Z

Peducemar: creación traza SJF Aprop.

Archivo:0rCyR8Gg.svg

2011-10-27T15:42:52Z

Peducemar:

Planificador de procesos

2011-10-13T20:04:01Z

Peducemar: /* Ejemplo dado en clase */

= ¿Qué es el planificador de procesos? =

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

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

El planificador de procesos tiene como funciones principales:

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

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

= Ejemplo dado en clase =
'''
Teniendo en cuenta las siguientes circunstancias:'''

*Un proceso Pa, que bloquea cada 2 unidades de tiempo.

*Un proceso Pb.

*Prioridad Pa>Pb.

*El evento externo que verifica el fin de bloqueo de Pa llega tras 2 unidades de tiempo.

La '''representación''' obtenida sería:

[[Archivo:Procesos.jpg]]

En este ejercicio podríamos decir que el proceso A ('''Pa''') es un proceso '''interactivo''', ya que bloquea mucho y que el proceso B ('''Pb''') es '''por lotes''', ya que apenas bloquea.

Planificador de procesos

2011-10-13T19:57:39Z

Peducemar: /* ¿Qué funciones tiene el planificador de procesos? */

Archivo:Procesos.jpg

2011-10-13T19:56:32Z

Peducemar:

Tipos de Sistemas Operativos

2011-10-13T19:24:14Z

Peducemar: /* 1.3.1. Según cuántas aplicaciones pueda ejecutar a la vez */

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

*a. Monoprogramables
**En un determinado instante de tiempo, sólo hay un único proceso en ejecución que monopoliza todos los recursos del sistema.
**Principal ventaja: su sencillez.
** Generalmente, no tienen mecanismos de protección de memoria (esta característica los hace más proclives a virus).
**Dos subtipos:
***Ofrece intérprete de órdenes.
***Ofrece entrada a través de cinta/switches (SSOO históricos).
**Ejemplo: DOS.

*b. Multiprogramables
**Permiten ejecutar múltiples procesos en un único procesador. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
**Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).
**b.1. Características que pueden presentar:
***Multiprogramación: se ejecutan varios procesos simultáneamente de manera que se reparte el uso del procesador. A esta característica también se le llama "Multitarea".
***Multiusuario: admite múltiples usuarios trabajando simlutáneamente.
***Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
***Multiprocesamiento: soporta más de un procesador y hace uso de todos ellos.
***Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) o '''flexible''' y hard(duro) o '''estricto'''.
***Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO es soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

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

*a. Por tanda
**Actividades que se realizan por lote y en serie (una detrás de otra).

*b. Interactivos
**Varias actividades en ejecución intercalándose.

*c. Combinados
**En los combinados se combinan los dos anteriores , en los que dependerá del proceso que se esté ejecutando.

== Ejemplos de SS.OO. actuales ==

*POSIX: Portable Operating System Interface X. Es un tipo de API. La mayoría de los SS.OO. actuales la implementan.

*WIN32: Lo usan los SS.OO. ReactOS y Windows.

*Existe el llamado Wine, un emulador de Windows, que convierte llamadas de Win32 a POSIX.

Tipos de Sistemas Operativos

2011-10-13T19:20:11Z

Peducemar: /* Ejemplos de SS.OO. actuales */

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

*a. Monoprogramables
**En un determinado instante de tiempo, sólo hay un único proceso en ejecución que monopoliza todos los recursos del sistema.
**Principal ventaja: su sencillez.
** Generalmente, no tienen mecanismos de protección de memoria (esta característica los hace más proclives a virus).
**Dos subtipos:
***Ofrece intérprete de órdenes.
***Ofrece entrada a través de cinta/switches (SSOO históricos).
**Ejemplo: DOS.

*b. Multiprogramables
**Permiten ejecutar múltiples procesos en un único procesador. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
**Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).
**b.1. Características que pueden presentar:
***Multiprogramación: se ejecutan varios procesos simultáneamente de manera que se reparte el uso del procesador. A esta característica también se le llama "Multitarea".
***Multiusuario: admite múltiples usuarios trabajando simlutáneamente.
***Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
***Multiprocesamiento: soporta más de un procesador y hace uso de todos ellos.
***Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) y hard (duro).
***Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO es soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

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

*a. Por tanda
**Actividades que se realizan por lote y en serie (una detrás de otra).

*b. Interactivos
**Varias actividades en ejecución intercalándose.

*c. Combinados
**En los combinados se combinan los dos anteriores , en los que dependerá del proceso que se esté ejecutando.

== Ejemplos de SS.OO. actuales ==

*POSIX: Portable Operating System Interface X. Es un tipo de API. La mayoría de los SS.OO. actuales la implementan.

*WIN32: Lo usan los SS.OO. ReactOS y Windows.

*Existe el llamado Wine, un emulador de Windows, que convierte llamadas de Win32 a POSIX.

Tipos de Sistemas Operativos

2011-10-13T19:19:56Z

Peducemar: /* Ejemplos de SS.OO. actuales */

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

*a. Monoprogramables
**En un determinado instante de tiempo, sólo hay un único proceso en ejecución que monopoliza todos los recursos del sistema.
**Principal ventaja: su sencillez.
** Generalmente, no tienen mecanismos de protección de memoria (esta característica los hace más proclives a virus).
**Dos subtipos:
***Ofrece intérprete de órdenes.
***Ofrece entrada a través de cinta/switches (SSOO históricos).
**Ejemplo: DOS.

*b. Multiprogramables
**Permiten ejecutar múltiples procesos en un único procesador. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
**Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).
**b.1. Características que pueden presentar:
***Multiprogramación: se ejecutan varios procesos simultáneamente de manera que se reparte el uso del procesador. A esta característica también se le llama "Multitarea".
***Multiusuario: admite múltiples usuarios trabajando simlutáneamente.
***Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
***Multiprocesamiento: soporta más de un procesador y hace uso de todos ellos.
***Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) y hard (duro).
***Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO es soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

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

*a. Por tanda
**Actividades que se realizan por lote y en serie (una detrás de otra).

*b. Interactivos
**Varias actividades en ejecución intercalándose.

*c. Combinados
**En los combinados se combinan los dos anteriores , en los que dependerá del proceso que se esté ejecutando.

== Ejemplos de SS.OO. actuales ==

*POSIX: Portable Operating System Interface X. Es un tipo de API. La mayoría de los SS.OO. actuales la implementan.

*WIN32: Lo usan los SS.OO. ReactOS y Windows.

*Existe el llamado Wine, un emulador de Windows, que convierte llamadas de Win32 a POSIX.

Tipos de Sistemas Operativos

2011-10-13T19:19:29Z

Peducemar: /* 1.3. Tipos de Sistemas Operativos */

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

*a. Monoprogramables
**En un determinado instante de tiempo, sólo hay un único proceso en ejecución que monopoliza todos los recursos del sistema.
**Principal ventaja: su sencillez.
** Generalmente, no tienen mecanismos de protección de memoria (esta característica los hace más proclives a virus).
**Dos subtipos:
***Ofrece intérprete de órdenes.
***Ofrece entrada a través de cinta/switches (SSOO históricos).
**Ejemplo: DOS.

*b. Multiprogramables
**Permiten ejecutar múltiples procesos en un único procesador. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
**Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).
**b.1. Características que pueden presentar:
***Multiprogramación: se ejecutan varios procesos simultáneamente de manera que se reparte el uso del procesador. A esta característica también se le llama "Multitarea".
***Multiusuario: admite múltiples usuarios trabajando simlutáneamente.
***Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
***Multiprocesamiento: soporta más de un procesador y hace uso de todos ellos.
***Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) y hard (duro).
***Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO es soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

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

*a. Por tanda
**Actividades que se realizan por lote y en serie (una detrás de otra).

*b. Interactivos
**Varias actividades en ejecución intercalándose.

*c. Combinados
**En los combinados se combinan los dos anteriores , en los que dependerá del proceso que se esté ejecutando.

== Ejemplos de SS.OO. actuales ==

**POSIX: Portable Operating System Interface X. Es un tipo de API. La mayoría de los SS.OO. actuales la implementan.

**WIN32: Lo usan los SS.OO. ReactOS y Windows.

***Existe el llamado Wine, un emulador de Windows, que convierte llamadas de Win32 a POSIX.

Estados de los procesos

2011-10-11T20:57:22Z

Peducemar: /* Diagrama de estados simplificado */

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

= Diagrama de estados simplificado =

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

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

[[Archivo:SSOO2.jpg]]

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

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

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

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

Planificador de procesos

2011-10-11T20:53:52Z

Peducemar:

El planificador de procesos (''process scheduler'', en inglés) es la parte del sistema operativo que se encarga seleccionar qué proceso emplea el procesador. Tiene como funciones principales:

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

El planificador de procesos es código, por tanto, requiere emplear el recurso procesador para la realizar su función.

== Objetivos de un buen planificador de procesos ==

Un buen planificador de procesos debe ofrecer:

* Alto <nowiki>"rendimiento"</nowiki> (''throughput'' (''tasa de transferencia''), en inglés) en base a la cantidad de procesos que puede soportar. A mayor cantidad, mayor rendimiento.
* Baja latencia (''latency'', en inglés) en referencia al tiempo de respuesta a los procesos. Si el proceso tarda mucho en ser asignado al procesador, se dice que la latencia será alta. Se considera una latencia aceptable a tiempos menores a 200 ms para garantizar una buena experiencia al usuario.