Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Página Principal

2018-01-19T19:35:41Z

Fracarcab: /* Importante */

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

= Novedades y noticias =

* Primer control, jueves 16 de noviembre (Temas 1, 2, 3, 4 y 5).
* Segundo control, jueves 7 de diciembre（Temas 6 y 7).
* Tercer control, jueves 21 de diciembre (Temas 8 y 9).
* Cuarto control, viernes 19 de enero

= Importante =

Si has realizado cambios en la Wiki y quieres que se te tenga en cuenta, añade tus datos a continuación:

Apellidos, Nombre (UVUS)
Gómez Mateos, Juan (juagommat)
Leal Mateu, José María (josleamat)
Carande Cabeza, Fco. Javier (fracarcab)

= Notas exámenes =

C1 C2 C3
Romero Sánchez, Pablo 3 8,75 5
Tejera García, Juan M. 4 8 2,5
Celis Gómez, Juan M. 3 - -
Carande Cabeza, Javier 8 7,5 5
Herrería Orio, Asier 5 8 3
Heredia Pérez, Elena 9 7 3,25
Jimenez Romero, Jesús 9,25 9,5 6,25
Gómez Mateos, Juan 7 6,25 3,75
Chura Pascual, Albaro 4,25 3,75 3,75
Romero Vázquez, Damián 7,5 6,75 5,25
Santos Aguila, David 4,5 0,5 3,5
Puerto Borrego, Antonio 5,5 6 6,25
Villamor Carrasco, José 1 6,25 0
García Arroyo, Manuel 7,5 3,25 4,25
Serrano Fernández, Jesús 6,5 - 5
Rus Gómez, Alberto 2 8,75 2,25
Juan Rodríguez, Simón 4,5 10 5
Jiménez Quintero, Eduardo 4 7,5 4,5
Lobato Salas, Jesús 2 8,75 8,25
Triguero Navarro, Antonio 8 8,25 10
Gutiérrez Sanjuán, Isaac 0,25 2,5 -
García Latorre, Isaías 3 4,25 -
Viana Hirasawa, André H. 9,25 8,75 5,5
Blasco Vázquez, Javier 8,5 7,5 9,5
Navas Gutiérrez, Ángeles 3 4,25 4,5
Leal Malter, José M. 6 5,5 2,5
Moreno Murube, Alberto 7 7,5 1,25
Belloso Caso, Gabriel 2,75 7,5 7,5
Valdivieso Casado, José 10 10 5,25
Hidalgo Cotán, Alejandro 7 10 7,5
Viera Chaves, Fco. Javier 4 7,5 5,5
Oviedo Ramirez, Alexis 4,5 5,5 6,5
Olabarrieta Eduardo, I 6,5 8 2,75
Reina Ballesta, Irene 6 2,5 3,75
Macias Vellarino, Juan 2 - -
Ruiz Porro, Jorge 2 0,5 -
Martagón Cabrera, Fco. 2,5 3,75 1,25
Alonso Sánchez, Víctor 4 8,75 2,5
Gustos Hidalgo, Eduardo - 5,5 5

Revisión: Viernes 19 de enero a las 19h30.
C3
Valdivieso Casado, José Antonio 5,25
Chura Pascual, Álbaro 3,75
Lobato Salas, Jesús 8,25
Viera Chaves, Fco. Javier 5,5
Carande Cabeza, Javier 5
Gómez Mateos, Juan 3,75
Tejera García, Juan M. 2,5
Leal Matén, José M. 2,5
Reina Ballesta, Irene 3,75
Herrería Oriol, Asier 3
Jiménez Romero, Jesús 6,25
Serrano Fernández, Jesús 5
Hidalgo Cotán, Alejando 7,5
Puerto Borreguero, Antonio J. 6,25
Heredía Pérez, Elena 3,25
Navas Gutiérrez, Ángeles 4,5
Santos Aguilar, David 3,5
Triguero Navarro, Antonio 10
Rus Gómez, Alberto 2,25
García Arroyo, Manuel 4,25
Viana Hirawa, André Henrique 5,5
Jiménez Quintero, Eduardo 4,5
Villamor Carrasco, José María 0
Alonso Sánchez, Víctor 2,5
Juan Rodríguez, Simón 5
Blasco Vázquez, Javier 9,5
Olarrieta Eduardo, Irania 2,75
Martagón Cabrera, Francisco 1,25
Romero Sánchez, Pablo 5
Gustos Hidalgo, Eduardo 5
Romero Vázquez, Damián 5,25
Oviedo Ramírez, Alexis 6,5
Moreno Morabe, Alberto 1,25
Belloso Caro, Gabriel 7,5

Notas provisionales, pendiente de comprobación la pertenencia al grupo.

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

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

== Fundamentos de Sistemas Operativos ==

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

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

* 3.1. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 3.2. [[Virtualización]]
* 3.3. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 4.1. [[Multiprogramación|La multiprogramación]]
* 4.2. [[Estados de los procesos|Estados de los procesos]]
* 4.3. [[Planificador de procesos|El planificador de procesos]]
* 4.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 4.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 4.6. [[Conmutación de procesos|La conmutación de procesos]]
* 4.7. [[Hilos|Hilos]]
* 4.8. [[Ejercicios Procesos|Ejercicios]]

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

== Concurrencia de procesos ==

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

== Interbloqueo ==

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

== Administración de memoria ==

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

== Memoria virtual ==

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

== Entrada/Salida ==

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

== Gestión E/S ==

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

== Administración de archivos ==

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

== Anexo ==

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

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

Página Principal

2018-01-19T19:35:25Z

Fracarcab: /* Importante */

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

= Novedades y noticias =

* Primer control, jueves 16 de noviembre (Temas 1, 2, 3, 4 y 5).
* Segundo control, jueves 7 de diciembre（Temas 6 y 7).
* Tercer control, jueves 21 de diciembre (Temas 8 y 9).
* Cuarto control, viernes 19 de enero

= Importante =

Si has realizado cambios en la Wiki y quieres que se te tenga en cuenta, añade tus datos a continuación:

Apellidos, Nombre (UVUS)

Gómez Mateos, Juan (juagommat)

Leal Mateu, José María (josleamat)

Carande Cabeza, Fco. Javier (fracarcab)

= Notas exámenes =

C1 C2 C3
Romero Sánchez, Pablo 3 8,75 5
Tejera García, Juan M. 4 8 2,5
Celis Gómez, Juan M. 3 - -
Carande Cabeza, Javier 8 7,5 5
Herrería Orio, Asier 5 8 3
Heredia Pérez, Elena 9 7 3,25
Jimenez Romero, Jesús 9,25 9,5 6,25
Gómez Mateos, Juan 7 6,25 3,75
Chura Pascual, Albaro 4,25 3,75 3,75
Romero Vázquez, Damián 7,5 6,75 5,25
Santos Aguila, David 4,5 0,5 3,5
Puerto Borrego, Antonio 5,5 6 6,25
Villamor Carrasco, José 1 6,25 0
García Arroyo, Manuel 7,5 3,25 4,25
Serrano Fernández, Jesús 6,5 - 5
Rus Gómez, Alberto 2 8,75 2,25
Juan Rodríguez, Simón 4,5 10 5
Jiménez Quintero, Eduardo 4 7,5 4,5
Lobato Salas, Jesús 2 8,75 8,25
Triguero Navarro, Antonio 8 8,25 10
Gutiérrez Sanjuán, Isaac 0,25 2,5 -
García Latorre, Isaías 3 4,25 -
Viana Hirasawa, André H. 9,25 8,75 5,5
Blasco Vázquez, Javier 8,5 7,5 9,5
Navas Gutiérrez, Ángeles 3 4,25 4,5
Leal Malter, José M. 6 5,5 2,5
Moreno Murube, Alberto 7 7,5 1,25
Belloso Caso, Gabriel 2,75 7,5 7,5
Valdivieso Casado, José 10 10 5,25
Hidalgo Cotán, Alejandro 7 10 7,5
Viera Chaves, Fco. Javier 4 7,5 5,5
Oviedo Ramirez, Alexis 4,5 5,5 6,5
Olabarrieta Eduardo, I 6,5 8 2,75
Reina Ballesta, Irene 6 2,5 3,75
Macias Vellarino, Juan 2 - -
Ruiz Porro, Jorge 2 0,5 -
Martagón Cabrera, Fco. 2,5 3,75 1,25
Alonso Sánchez, Víctor 4 8,75 2,5
Gustos Hidalgo, Eduardo - 5,5 5

Revisión: Viernes 19 de enero a las 19h30.
C3
Valdivieso Casado, José Antonio 5,25
Chura Pascual, Álbaro 3,75
Lobato Salas, Jesús 8,25
Viera Chaves, Fco. Javier 5,5
Carande Cabeza, Javier 5
Gómez Mateos, Juan 3,75
Tejera García, Juan M. 2,5
Leal Matén, José M. 2,5
Reina Ballesta, Irene 3,75
Herrería Oriol, Asier 3
Jiménez Romero, Jesús 6,25
Serrano Fernández, Jesús 5
Hidalgo Cotán, Alejando 7,5
Puerto Borreguero, Antonio J. 6,25
Heredía Pérez, Elena 3,25
Navas Gutiérrez, Ángeles 4,5
Santos Aguilar, David 3,5
Triguero Navarro, Antonio 10
Rus Gómez, Alberto 2,25
García Arroyo, Manuel 4,25
Viana Hirawa, André Henrique 5,5
Jiménez Quintero, Eduardo 4,5
Villamor Carrasco, José María 0
Alonso Sánchez, Víctor 2,5
Juan Rodríguez, Simón 5
Blasco Vázquez, Javier 9,5
Olarrieta Eduardo, Irania 2,75
Martagón Cabrera, Francisco 1,25
Romero Sánchez, Pablo 5
Gustos Hidalgo, Eduardo 5
Romero Vázquez, Damián 5,25
Oviedo Ramírez, Alexis 6,5
Moreno Morabe, Alberto 1,25
Belloso Caro, Gabriel 7,5

Notas provisionales, pendiente de comprobación la pertenencia al grupo.

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

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

== Fundamentos de Sistemas Operativos ==

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

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

* 3.1. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 3.2. [[Virtualización]]
* 3.3. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 4.1. [[Multiprogramación|La multiprogramación]]
* 4.2. [[Estados de los procesos|Estados de los procesos]]
* 4.3. [[Planificador de procesos|El planificador de procesos]]
* 4.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 4.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 4.6. [[Conmutación de procesos|La conmutación de procesos]]
* 4.7. [[Hilos|Hilos]]
* 4.8. [[Ejercicios Procesos|Ejercicios]]

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

== Concurrencia de procesos ==

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

== Interbloqueo ==

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

== Administración de memoria ==

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

== Memoria virtual ==

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

== Entrada/Salida ==

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

== Gestión E/S ==

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

== Administración de archivos ==

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

== Anexo ==

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

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

Solución ejercicio 1 memoria virtual

2017-12-21T11:03:21Z

Fracarcab: /* LRU */ Corrección del ejercicio, fallo en el tiempo 10 y 11

= FIFO =

Acceso
a 1 1 1 2 3 4 5 3 1 2 3 4
página
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 2 | | | | 2 | = | = | = | = | 1 | = | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 3 | | | | | 3 | = | = | = | = | 2 | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 4 | | | | | | 4 | = | = | = | = | 3 | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Fallo | | | | | | | | | | | | |
de | x | | | x | x | x | x | | x | x | x | x |
página | | | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Tiempo 1 2 3 4 5 6 7 8 9 10 11 12

nº fallos de página 9
Tasa de fallos de página = --------------------- = ---- = 0,75
nº accesos a páginas 12

= NRU =
Considere que el periodo de puesta a cero del bit R tiende a infinito, es decir, nunca se pone a cero.

En caso de empate, se emplea LRU(Least Recently Used): ''elegimos la página que más tiempo lleve sin ser accedida''

Acceso
a 1(R) 1(R) 1(W) 2(R) 3(R) 4(R) 5(R) 3(W) 1(W) 2(W) 3(R) 4(R)
página
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 1 | = | = | = | = | = | = | = | = | = | = | = |
Marco 1 | R=1 | = | = | = | = | = | = | = | = | = | = | = |
| M=0 | = | M=1 | = | = | = | = | = | = | = | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| | | | 2 | = | = | 5 | = | = | = | = | 4 |
Marco 2 | | | | R=1 | = | = | R=1 | = | = | = | = | R=1 |
| | | | M=0 | = | = | M=0 | = | = | = | = | M=0 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| | | | | 3 | = | = | = | = | = | = | = |
Marco 3 | | | | | R=1 | = | = | = | = | = | = | = |
| | | | | M=0 | = | = | M=1 | = | = | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| | | | | | 4 | = | = | = | 2 | = | = |
Marco 4 | | | | | | R=1 | = | = | = | R=1 | = | = |
| | | | | | M=0 | = | = | = | M=1 | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Fallo | | | | | | | | | | | | |
de | x | | | x | x | x | x | | | x | | x |
página | | | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Tiempo 1 2 3 4 5 6 7 8 9 10 11 12

nº fallos de página 7
Tasa de fallos de página = --------------------- = ---- = 0,5833333333333333
nº accesos a páginas 12

'''Pregunta''': Creo que hay un error en el paso 10 cuando cargamos la pagina 2, en el criterio NRU comenzamos por el primer marco y buscamos la pagina victima, en este caso creo que seria la pagina 5 que esta cargada en el marco 2 y tienen R=1, M=0 no la pagina 4 como pone en el ejercicio.

'''Respuesta''': No, es un empate. Por lo que aplicamos el criterio LRU entre 4 y 5, y 4 es la que lleva más tiempo sin usarse.

= NRU con 2º oportunidad =

accesos a páginas

| r | r | w | r | r | r | r | w | w | w | r | r |
-------------------------------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | 1 | = | = | = | = | = | 1 | = | = | = | = | 1 |
---------------------------------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | 2 | = | 1 | = | = | 1 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | | | | 1 | = | = | 0 | = | 1 | = | = | 0 |
---------------------------------------------------------------------------------------------------------
| 3 | | | | | 3 | = | 3 | 3 | = | = | 3 | 3 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | | | | | 1 | = | 0 | 1 | = | = | 1(=) | 0 |
---------------------------------------------------------------------------------------------------------
| 4 | | | | | | 4 | 4 | = | = | 2 | = | 2 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | | | | | | 1 | 0 | = | = | 1 | = | 0 |
---------------------------------------------------------------------------------------------------------
fallo | AF | | | AF | AF | AF | 5R1 | | 1R2 | 2R4 | | 4R5 |
página -------------------------------------------------------------------------------------------------
contenido | 1 | 1 | 1 | 1-2 | 1-2-3 |1-2-3-4|2-3-4-5|2-3-4-5|3-4-5-1|5-1-3-2|5-1-3-2|1-3-2-4|
de la cola -------------------------------------------------------------------------------------------------

tiempo ->

nº fallos de página 8
Tasa de fallos de página = --------------------- = ---- = 0,6666666666666667
12

= LRU =

Acceso
a 1 1 1 2 3 4 5 3 1 2 3 4
página
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 2 | | | | 2 | = | = | = | = | 1 | = | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 3 | | | | | 3 | = | = | = | = | 2 | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 4 | | | | | | 4 | = | = | = | = | 3 | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Fallo | | | | | | | | | | | | |
de | x | | | x | x | x | x | | x | x | x | x |
página | | | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Tiempo 1 2 3 4 5 6 7 8 9 10 11 12

nº fallos de página 9
Tasa de fallos de página = --------------------- = ---- = 0,75
nº accesos a páginas 12

= LFU =

En caso de empate, se emplea LRU(Least Recently Used): ''elegimos la página que más tiempo lleve sin ser accedida''

Acceso
a 1 1 1 2 3 4 5 3 1 2 3 4
página
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 1 | 1 | = | = | = | = | = | = | = | = | = | = | = |
Contador | C=1 | C=2 | C=3 | = | = | = | = | = | C=4 | = | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 2 | | | | 2 | = | = | 5 | = | = | = | = | 4 |
Contador | | | | C=1 | = | = | C=1 | = | = | = | = | C=1 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 3 | | | | | 3 | = | = | = | = | = | = | = |
Contador | | | | | C=1 | = | = | C=2 | = | = | C=3 | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 4 | | | | | | 4 | = | = | = | 2 | = | = |
Contador | | | | | | C=1 | = | = | = | C=1 | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Fallo | | | | | | | | | | | | |
de | x | | | x | x | x | x | | | x | | x |
página | | | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Tiempo 1 2 3 4 5 6 7 8 9 10 11 12

nº fallos de página 7
Tasa de fallos de página = --------------------- = ---- = 0,5833333333333333
nº accesos a páginas 12

Observación: al quitar un elemento se resetea su contador

= Sustitución por envejecimiento =
Periodo = 4

Registro R de 3 bits.

En caso de empate = FIFO por orden de carga

Acceso
a 1 1 1 2 - 3 4 5 3 - 1 2 3 4
página
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 1 | 1 | = | = | = | = | = | = | 5 | = | = | = | = | = | 4 |
Bit R | 100 | = | = | = | 010 | = | = | 100 | = | 010 | = | = | = | 100 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 2 | | | | 2 | = | = | = | = | = | = | 1 | = | = | = |
Bit R | | | | 100 | 010 | = | = | = | = | 001 | 100 | = | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 3 | | | | | | 3 | = | = | = | = | = | 2 | = | = |
Bit R | | | | | | 100 | = | = | = | 010 | = | 100 | = | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 4 | | | | | | | 4 | = | = | = | = | = | 3 | = |
Bit R | | | | | | | 100 | = | = | 010 | = | = | 100 | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Fallo | | | | | | | | | | | | | | |
de | x | | | x | - | x | x | x | | - | x | x | x | x |
página | | | | | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Tiempo 1 2 3 4 - 5 6 7 8 - 9 10 11 12

Periodo 4 3 2 1 0 4 3 2 1 0 4 3 2 1

nº fallos de página 9
Tasa de fallos de página = --------------------- = ---- = 0,75
nº accesos a páginas 12

Memoria virtual con multiprogramacion

2017-12-20T22:16:29Z

Fracarcab: /* Modelo del conjunto de trabajo */

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

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

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

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

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

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

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

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

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

9.4 [[Ejercicios_memoria_virtual | Ejercicios de memoria virtual]]

Sol reloj

2017-12-19T19:22:04Z

Fracarcab:

Solución:
nº fallos de página 8
Tasa de fallos de página = --------------------- = ---- = 0,615
nº accesos a páginas 13

La lista de páginas a la que se acceden son las siguientes: '''2--2--3--1--1--3--4--5--1--1--2--3--4'''

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

Acceso
a 2 2 3 1 1 3 4 5 1 1 2 3 4
página
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 1 | 2 | = | = | = | = | = | = | 5 | = | = | = | = | = |
Bit R | R=1 | = | = | = | = | = | = | R=1 | = | = | = | = | R=0 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 2 | | | 3 | = | = | = | = | = | = | = | 2 | = | = |
Bit R | | | R=1 | = | = | = | = | R=0 | = | = | R=1 | = | R=0 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 3 | | | | 1 | = | = | = | = | = | = | = | = | 4 |
Bit R | | | | R=1 | = | = | = | R=0 | R=1 | = | = | R=0 | R=1 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Marco 4 | | | | | | | 4 | = | = | = | = | 3 | = |
Bit R | | | | | | | R=1 | R=0 | = | = | = | R=1 | = |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Fallo | | | | | | | | | | | | | |
de | x | | x | x | | | x | X | | | X | X | X |
página | | | | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Tiempo 1 2 3 4 5 6 7 8 9 10 11 12 13

[[Criterios_de_reemplazo|Volver]]

Sol 7

2017-12-19T19:12:49Z

Fracarcab: Se ha deshecho la revisión 3846 de Fracarcab (disc.)

Solución:
nº fallos de página 8
Tasa de fallos de página = --------------------- = ---- = 0,6153846153846154
nº accesos a páginas 13

La lista de páginas a la que se acceden son las siguientes: '''2(R)--2(R)--3(R)--1(R)--1(R)--3(R)--4(R)--5(R)--1(R)--1(R)--2(R)--3(R)--4(R)'''

'''Criterio NRU con 2º oportunidad''': combinación de criterios NRU y FIFO. Se selecciona la página víctima por orden de carga en memoria hasta encontrar a alguna que tenga el bit a 0. Si durante dicha iteración, se encuentra una página cuyo bit vale 1, se pone a 0, se retira de la lista y se añade al final (para darle una 2º oportunidad). Cuando se añade una nueva página, se añade al final de la cola con el bit R a 1. Añadir que, en este caso, no se pone el bit R a 0 periódicamente, ya que se hace directamente con la 2ª oportunidad.

'''Nota: la cola que se utiliza es una FIFO por orden de carga.'''

Acceso Fallo
a Marco Marco Marco Marco de
página 1 2 3 4 página Tiempo Cola (FIFO por orden de carga)
+-----+-----+-----+-----+--------+
| 2 | | | | |
2 | R=1 | | | | x | 1 2
+-----+-----+-----+-----+--------+
| = | | | | |
2 | R=1 | | | | | 2 2
+-----+-----+-----+-----+--------+
| = | 3 | | | |
3 | R=1 | R=1 | | | x | 3 2 <- 3
+-----+-----+-----+-----+--------+
| = | = | 1 | | |
1 | R=1 | R=1 | R=1 | | x | 4 2 <- 3 <- 1
+-----+-----+-----+-----+--------+
| = | = | = | | |
1 | R=1 | R=1 | R=1 | | | 5 2 <- 3 <- 1
+-----+-----+-----+-----+--------+
| = | = | = | | |
3 | R=1 | R=1 | R=1 | | | 6 2 <- 3 <- 1
+-----+-----+-----+-----+--------+
| = | = | = | 4 | |
4 | R=1 | R=1 | R=1 | R=1 | x | 7 2 <- 3 <- 1 <- 4
+-----+-----+-----+-----+--------+
| 5 | = | = | = | |
5 | R=1 | R=0 | R=0 | R=0 | x | 8 3 <- 1 <- 4 <- 5
+-----+-----+-----+-----+--------+
| = | = | = | = | |
1 | R=1 | R=0 | R=1 | R=0 | | 9 3 <- 1 <- 4 <- 5
+-----+-----+-----+-----+--------+
| = | = | = | = | |
1 | R=1 | R=0 | R=1 | R=0 | | 10 3 <- 1 <- 4 <- 5
+-----+-----+-----+-----+--------+
| = | 2 | = | = | |
2 | R=1 | R=1 | R=1 | R=0 | x | 11 1 <- 4 <- 5 <- 2
+-----+-----+-----+-----+--------+
| = | = | = | 3 | |
3 | R=1 | R=1 | R=0 | R=1 | x | 12 5 <- 2 <- 1 <- 3
+-----+-----+-----+-----+--------+
| = | = | 4 | = | |
4 | R=0 | R=0 | R=1 | R=1 | x | 13 3 <- 5 <- 2 <- 4
+-----+-----+-----+-----+--------+

[[Criterios_de_reemplazo|Volver]]

Sol 7

2017-12-19T18:54:47Z

Fracarcab: Corrección del ejercicio

Solución:
nº fallos de página 8
Tasa de fallos de página = --------------------- = ---- = 0,6153846153846154
nº accesos a páginas 13

La lista de páginas a la que se acceden son las siguientes: '''2(R)--2(R)--3(R)--1(R)--1(R)--3(R)--4(R)--5(R)--1(R)--1(R)--2(R)--3(R)--4(R)'''

'''Criterio NRU con 2º oportunidad''': combinación de criterios NRU y FIFO. Se selecciona la página víctima por orden de carga en memoria hasta encontrar a alguna que tenga el bit a 0. Si durante dicha iteración, se encuentra una página cuyo bit vale 1, se pone a 0, se retira de la lista y se añade al final (para darle una 2º oportunidad). Cuando se añade una nueva página, se añade al final de la cola con el bit R a 1. Añadir que, en este caso, no se pone el bit R a 0 periódicamente, ya que se hace directamente con la 2ª oportunidad.

'''Nota: la cola que se utiliza es una FIFO por orden de carga.'''

Acceso Fallo
a Marco Marco Marco Marco de
página 1 2 3 4 página Tiempo Cola (FIFO por orden de carga)
+-----+-----+-----+-----+--------+
| 2 | | | | |
2 | R=1 | | | | x | 1 2
+-----+-----+-----+-----+--------+
| = | | | | |
2 | R=1 | | | | | 2 2
+-----+-----+-----+-----+--------+
| = | 3 | | | |
3 | R=1 | R=1 | | | x | 3 2 <- 3
+-----+-----+-----+-----+--------+
| = | = | 1 | | |
1 | R=1 | R=1 | R=1 | | x | 4 2 <- 3 <- 1
+-----+-----+-----+-----+--------+
| = | = | = | | |
1 | R=1 | R=1 | R=1 | | | 5 2 <- 3 <- 1
+-----+-----+-----+-----+--------+
| = | = | = | | |
3 | R=1 | R=1 | R=1 | | | 6 2 <- 3 <- 1
+-----+-----+-----+-----+--------+
| = | = | = | 4 | |
4 | R=1 | R=1 | R=1 | R=1 | x | 7 2 <- 3 <- 1 <- 4
+-----+-----+-----+-----+--------+
| 5 | = | = | = | |
5 | R=1 | R=0 | R=0 | R=0 | x | 8 3 <- 1 <- 4 <- 5
+-----+-----+-----+-----+--------+
| = | = | = | = | |
1 | R=1 | R=0 | R=1 | R=0 | | 9 3 <- 1 <- 4 <- 5
+-----+-----+-----+-----+--------+
| = | = | = | = | |
1 | R=1 | R=0 | R=1 | R=0 | | 10 3 <- 1 <- 4 <- 5
+-----+-----+-----+-----+--------+
| = | 2 | = | = | |
2 | R=0 | R=1 | R=1 | R=0 | x | 11 1 <- 4 <- 5 <- 2
+-----+-----+-----+-----+--------+
| 3 | = | = | = | |
3 | R=1 | R=1 | R=1 | R=0 | x | 12 2 <- 1 <- 4 <- 3
+-----+-----+-----+-----+--------+
| = | = | = | = | |
4 | R=0 | R=0 | R=0 | R=1 | | 13 2 <- 1 <- 4 <- 3
+-----+-----+-----+-----+--------+

[[Criterios_de_reemplazo|Volver]]

Solución del ejercicio 4 de paginación

2017-12-19T17:58:54Z

Fracarcab:

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

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

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

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

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

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

'''Desglose de direcciones'''

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

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

Solución ejercicio2Mejor Ajuste Dinámico

2017-12-19T16:59:45Z

Fracarcab: Respuesta a pregunta

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

Revisado --[[Usuario:Pneira|Pneira]] 16:01 22 dic 2011 (UTC)

-Una duda: ¿Por qué se ejecuta antes P3 que P2? [[Usuario:jesgonbel|jesgonbel]]
Se ejecuta antes debido al criterio de mejor ajuste dinamico, en el cual entra antes el que mayor M ocupa de todas en las que quepan. Quiere decir, P3 entra antes ya que ocupa 3 mientras que P2 ocupa 1, por lo que el que menos memoria desperdicia es P3.

Solución Ejercicio clase Mejor Ajuste Dinámico

2017-12-19T16:45:04Z

Fracarcab: Corrección del ejercicio

A
P1 <---|---|---|---> | | | | | | | | | | | | | | | |
A
P2 | < | | |---|---|---|---> | | | | | | | | | | | |
B
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

Segmentación

2017-12-18T16:55:04Z

Fracarcab: /* Formas de uso de los descriptores */

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

=Funcionamiento=

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

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

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

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

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

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

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

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

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

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

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

Esta zona de intercambio puede ser:

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

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

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

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

=Superposición de segmentos=

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

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

8.4 [[Paginación | Paginación]]

Segmentación

2017-12-18T16:54:45Z

Fracarcab: /* Formas de uso de los descriptores */

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

=Funcionamiento=

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

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

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

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

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

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

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

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

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

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

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

Esta zona de intercambio puede ser:

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

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

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

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

=Superposición de segmentos=

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

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

8.4 [[Paginación | Paginación]]

SO multiprogramables con particiones fijas

2017-12-15T13:02:14Z

Fracarcab: /* Métodos de colocación en memoria */

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

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

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

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

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

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

La solución sería:

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

== Subparticiones ==

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

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

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

SO multiprogramables con particiones fijas

2017-12-15T13:01:14Z

Fracarcab: /* Métodos de colocación en memoria */

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

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

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

= Criterios de asignación =

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

== Mejor ajuste estático ==

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

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

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

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

La solución sería:

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

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

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

=== Ejemplo ===

Dada la siguiente configuración de procesos:

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

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

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

La solución sería:

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

== Subparticiones ==

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

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

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

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

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

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

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

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

= Mecanismos de protección de memoria =

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

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

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

Solución ejercicio 1

2017-12-07T10:50:56Z

Fracarcab:

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución.

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

Observaciones:
* El proceso P2 bloquea al hacer down sobre el semáforo s2 cuyo contador vale 0.
* En el instante 15, el proceso P2 bloquea de nuevo pues hace down sobre el semáforo s2 cuyo contador vale 0.
* En los semáforos no se vuelve a comprobar la condición que hizo que el proceso bloqueara, a diferencia de los cerrojos.

--[[Usuario:Pneira|Pneira]] 08:59 10 may 2011 (UTC)

'''Duda sobre el ejercicio:'''

He realizado varias veces la traza de los procesos y en el instante 15 el semáforo de s2 me sale 1,no sé si me estaré pasando algún detalle por alto.S2 empieza en 0,en el instante 7 P1 realiza un up en s2 (valor s2=1), y se realiza un down en el instante 15 por lo que volvería a valer 0, ¿qué estoy pasando por alto? :S --[[Usuario:Josedelfer|Josedelfer]] 11:00 13 dic 2011 (UTC)

--[[Usuario:Albsolnog|Albsolnog]] 11:36 13 dic 2011 (UTC) Fijate que para t=6 p2 estaba bloqueado y por tanto almacenado en la lista, justo aqui p1 realiza un up(S2) '''en el instante 6 no en el 7''' lo que implica que p2 pasa a estado preparado pero su contador no se toca (mira el codigo de up())

--[[Usuario:Josedelfer|Josedelfer]] 13:24 13 dic 2011 (UTC) Es cierto,cuando esta bloqueado al hacer el up no aumenta el contador,era el detalle que estaba pasando por alto. Gracias

--[[Usuario:Josleamat|Josleamat]] 12:28 6 dic 2017 (UTC) Hola, en el instante 17, el proceso p1, debería de continuar con su quantum hasta agotarlo, donde se debe de bloquear en la linea de codigo 2, donde hace un down y pasa ha estado bloqueado.

Criterios de planificación

2017-11-14T10:56:24Z

Fracarcab: /* Planificación por prioridades */

= Planificación apropiativa y no apropiativa =

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

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

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

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

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

== Planificación por prioridades ==

Se establecen índices de prioridad a cada proceso:

* '''Índice estático''': Establecido por el usuario por medio de una llamada al sistema (ver sys_nice() y sys_setschedprio()). En el caso de sistemas operativos tipo Unix, se dispone de un índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).
* '''Índice dinámico''': Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos, aumentándola cuando un proceso está a la espera o disminuyéndola cuando tiene adjudicado el procesador.

El método funciona de la siguiente manera: El planificador mantiene ordenada la cola de procesos preparados, según prioridades decrecientes. Si el proceso en ejecución se bloquea, el planificador selecciona el primero de la lista. Cuando un proceso pasa a la situación de preparado, comprueba si su prioridad es mayor que la del proceso activo. En tal caso, suspende la ejecución de éste, colocándolo al principio de la cola de preparados, y elige al recién llegado; si no, lo inserta en la cola según su prioridad.
Cuando hay varios procesos con la misma prioridad se pueden aplicar diversos criterios, como seguir el orden de llegada a la cola de preparados, o el que necesite menos tiempo para acabar, entre otros.

El orden es siempre O(n).

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática
_p__|_0__|-20_|_4__|_10_|

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

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización
_z__|_3__|_1__|_3__|12/7|

== Turno rotatorio ==

=== Turno rotatorio estricto (Round Robin: RR) ===

En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado ''quantum'', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.

El tamaño del ''quantum'' es fundamental para determinar el comportamiento de este criterio de planificación.
Si el ''quantum'' empleado es pequeño, por ejemplo, de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, si el ''quantum'' empleado es grande, por ejemplo, de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso.

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

Puesto que el reparto del procesador es estricto, los procesos recién lanzados deben acceder al procesador lo antes posible, por tanto, se les da oportunidad de ejecución por orden de llegada por delante de los procesos en la cola de procesos preparados. De esta manera, se evita que los procesos recién lanzados queden postergados indefinidamente.

Este criterio se puede implementar con una cola, de manera que el orden de complejidad en la selección del proceso que pasa a estado activo es <math>O(1)</math>. Nótese que, a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo

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

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización
_z__|_5/2|10/4|_5/2|12/7|

=== Turno rotatorio con compensación ===

Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio (dispondrá de otro quantum completo).
Este tipo de criterio tiene un problema y es que se pueden posponer indefinidamente algunos procesos si hay varios procesos que bloqueen.

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

Ejemplo:

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

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

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

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

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

== Colas multinivel ==

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Modelos de Diseño de Sistemas Operativos

2017-11-12T18:17:58Z

Fracarcab: /* Exonúcleos y Uninúcleos */

= 3.1. Modelos de Diseño de SSOO =

== Modos de operación del procesador ==

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

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

* '''Modo privilegiado'''(supervisor), que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador (no tiene ninguna relación con el modo "root" o administrador de algunos sistemas operativos).

* '''Modo no privilegiado'''(usuario), que tiene algunas restricciones de acceso a aspectos del procesador o de ejecución de instrucciones.

== Núcleo del sistema operativo ==

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

El núcleo de un sistema operativo suele operar en modo privilegiado. Al operar en dicho modo un error de programación en el núcleo del sistema operativo puede resultar en un error fatal del cual el sistema sólo puede recuperarse mediante el reinicio del sistema. A tal error fatal también se le conoce en los sistemas operativos UNIX por la locución inglesa ''[http://es.wikipedia.org/wiki/Kernel_panic kernel panic]'' y en los sistemas operativos Windows por el nombre de ''[http://www.google.es/url?sa=t&source=web&cd=1&ved=0CCwQFjAA&url=http%3A%2F%2Fes.wikipedia.org%2Fwiki%2FPantalla_azul_de_la_muerte&ei=s02WTqvCCMjHtAaxuJyBBA&usg=AFQjCNE2tZra15VdohxjrhSogTQZOVedKg Pantallazo azul o BSOD]''.

== Tipos de Sistemas Operativos ==

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

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

* '''Micronúcleos:''' realizan la planificación de procesos, la gestión de interrupciones (una de las partes fundamentales de la gestión de E/S) y la comunicación entre procesos, en modo supervisor. La administración de memoria y la gestión de la E/S se realizan en modo usuario, a partir de procesos del sistema operativo especial que se denominan ''proceso servidor''.

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

En número de líneas de código, el núcleo monolítico es mayor que el micronúcleo, al gestionar más recursos del computador en modo supervisor.

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


=== Sistemas operativos Monolíticos ===

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

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

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

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

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

=== Sistemas operativos Micronúcleo ===

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

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

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

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

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

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

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

=== Sistemas operativos Híbridos ===

Los núcleos híbridos se encuentran entre los monolíticos y los micronúcleo. La mayoría de sistemas operativos modernos pertenecen a esta categoría, siendo el más popular Microsoft Windows. XNU, el núcleo de Mac OS X, también es un micronúcleo modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo basado en Mach. DragonFlyBSD es el primer sistema BSD que adopta una arquitectura de núcleo híbrido sin basarse en Mach.

Algunos ejemplos de núcleos híbridos:

* Microsoft Windows NT, usado en todos los sistemas que usan el código base de Windows NT
* XNU (usado en Mac OS X)
* DragonFlyBSD
* ReactOS

Hay gente que confunde el término «núcleo híbrido» con los núcleos monolíticos que pueden cargar módulos después del arranque, lo que es un error. «Híbrido» implica que el núcleo en cuestión usa conceptos de arquitectura o mecanismos tanto del diseño monolítico como del micronúcleo, específicamente el paso de mensajes y la ejecución de ciertos componentes del sistema operativo en espacio de usuario.

=== Exonúcleos, Piconúcleos y Nanonúcleos ===

Son casos excepcionales, no aplican a sistemas operativos de propósito general.

Además, contamos con sistemas operativos pico y nanonúcleos de propósito específico que se puede considerar un subtipo de Micronúcleo.

'''Este tipo de sistemas operativos permiten al proceso acceder a ciertos recursos del sistema directamente, sin intervención del sistema operativo'''. Es propio de entornos de propósito específico, donde el fabricante del sistema operativo y de las aplicaciones son el mismo. No permiten la instalación de aplicaciones de terceros. Son propio de sistemas estancos. Propio de industria aeronáutica, automoción y aeroespacial.

Los '''Exokernel o exonúcleo''' son sistemas caracterizados principalmente por tener aplicaciones de usuarios capaces de acceder a recursos del sistema sin necesidad de realizar llamadas al sistema. Se da en sistemas operativos de tiempo real, de propósito específico. Generalmente empleados en industria aeronáutica, automotriz y telecomunicaciones.

=== Unikernel ===

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

== Otro material a consultar ==

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

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

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