Capitulo 9 Memoria Virtual

Capítulo 9: Memoria Virtual Introducción Paginación por Demanda Copy-on-Write Reemplazando páginas Alocación de Frames Thrashing Alocación de Memoria del Kernel Otras Consideraciones Ejemplos

Objetivos Describir los beneficios de un sistema de memoria virtual Explicar los conceptos de paginación bajo demanda, algoritmos para reemplazar páginas, y la alocación de frames de páginas Discutir el principio del modelo del working-set (conjunto-de-trabajo)

Introducción Memoria virtual – separación de la memoria lógica del usuario, de la memoria física No todo el programa necesita estar en memoria para su ejecución El espacio de direcciones lógicas puede ser mucho más grande que el de direcciones físicas Permite que espacios de direcciones se compartan por varios procesos Hace que la creación de procesos sea más eficiente Puede ser implementada vía: Paginación bajo demanda Segmentación bajo demanda

Espacio de Direcciones Virtual

Librería Compartida con Memoria Virtual

Paginación Bajo Demanda Se trae una página a memoria solo cuando se la necesita Necesitamos menos E/S Necesitamos menos memoria Respuestas más rápidas Más usuarios Si se necesita una página  se la referencia No está en memoria  traerla a memoria Swapping Perezoso – Nunca traer una página a memoria a menos que se la necesite Al swapper que trabaja con páginas se lo llama paginador

Bit Válido-Inválido v v v v i i i … . Frame # valid-invalid bit page table En memoria NO en memoria Si se referencia a esta página  page fault

Page Fault La primera referencia a una página generará una trampa al S.O. : page fault S.O. examin decide si: Referencia es ilegal  abortar No está en memoria Obtener un frame vacío Cargar la página (de backing store) al frame Establecer bit de validación = v Re-iniciar la instrucción que causó el page fault

Análisis de Rendimiento Tasa de page faults: 0  p  1.0 p = 0 si no hay page faults p = 1 si cada referencia conlleva una falla Effective Access Time (EAT) Tiempo de acceso efectivo EAT = (1 – p ) x memory access + p (page fault overhead + swap page out + swap page in + restart overhead )

Ejemplo Tiempo de acceso a memoria = 200 nanosegundos Tiempo de procesamiento de un page-fault promedio = 8 millisegundos EAT = (1 – p) x 200 + p (8 milliseconds) = (1 – p) x 200 + p x 8,000,000 = 200 + p x 7,999,800 Si una de 1000 referencias causa una page fault: EAT = 8.2 milisegundos

Memoria compartida Memoria virtual permite otros beneficios Shared memory Creacion rapida de procesos Archivos mapeados en memoria

Copy-on-Write Copy-on-Write (COW) permite que los procesos padre e hijo inicialmente compartan las mismas páginas en memoria Si alguno de los procesos modifica una página compartida, recién en ese momento se copia la página COW permite una creación eficiente de procesos pues las instrucciones no se cargan en memoria principal nuevamente Páginas libres se obtienen de un pool de páginas

Ejemplo Proceso1 modifica la página C Copia de C

¿ Y si no hay frames libres? Hacer swaping del proceso completo. Reemplazar una página Swap out Políticas Rendimiento: debe resultar en el mínimo número de page faults La misma página puede ser cargada en memoria múltiples veces.

Reemplazando Páginas Usar un modify (dirty) bit para reducir la sobrecarga de las transferencias de páginas Solamente las páginas modificadas se escriben en disco Permite que una memoria virtual grande se pueda usar a pesar de tener una memoria física más pequeña

Reemplazando Páginas: Básico Localizar la página deseada en disco Encontrar un frame libre: Si hay uno libre, usarlo Si no hay un frame libre, usar algoritmo para escojer a una víctima Traer la página deseada al (nuevo) frame Actualizar las tablas de páginas y frames Re-iniciar el proceso

Algoritmos para Reemplazar Páginas Meta: conseguir la tasa de page-faults más baja Evaluar el algoritmo al ejecutarlo en un string particular de referncias de memoria (string de referencia) y calculando el # de page faults que ocurren En todos nuestros ejemplos, el string será: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

Algoritmo FIFO String de referencias: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 3 frames (3 páginas pueden estar en memoria en un momento dado por proceso) 4 frames Anomalía de Belady: más frames  (a veces) más page faults 1 2 3 1 2 3 4 1 2 5 3 4 9 page faults 1 2 3 1 2 3 5 1 2 4 5 10 page faults 4 4 3

Algoritmo Ó ptimo Reemplazar una página que no será utilizada por el mayor periodo de tiempo Ejemplo con 4 frames: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 ¿ Cómo sabemos esto? Usado como referencia para medir rendimiento de algoritmos 1 2 3 4 6 page faults 4 5

Algoritmo Least Recently Used (LRU) String de referencia: 1, 2, 3, 4, 1, 2, 5 , 1, 2, 3 , 4 , 5 Implementación con un contador Cada entrada de página tiene un contador; cada vez que una página es referenciada, copiar la lectura del reloj en el contador Cuando una página debe ser cambiada, usar el contador para seleccionar una 5 2 4 3 1 2 3 4 1 2 5 4 1 2 5 3 1 2 4 3

Algoritmo LRU (cont.) Implementación con una pila Mantener una pila de los #s de páginas en una estructura de datos doblemente enlazada Cuando una página es referenciada: Moverla al tope de la pila Requiere 6 cambios de punteros No es necesario buscar en la estructura de datos Se remueve la pagina que esta al fondo de la pila

Algoritmos de Aproximación LRU Algunos HW dan soporte parcial a LRU Bit de referencia Con cada página asociar un bit, incialmente = 0 Cuando una página se referencia, setear el bit en 1 Reemplazar una página cuyo bit sea 0 (si una existe) Bits adicionales? Segunda oportunidad Usa bit de referencia Reemplazar en sentido del rejol Si página a ser reemplazada tiene bit = 1, entonces: hacer bit = 0 dejar la página en memoria reemplazar la siguiente página, siguiendo las mismas reglas

Algoritmo de Segunda Oportunidad (reloj)

Algoritmos de Conteo Mantener un contador con el # de referencias que se han hecho a cada página Algoritmo LFU Reemplaza la página con el menor contador Algoritmo MFU (most freq. used) Basado en el argumento de que la página con el menor contador probablemente se acaba de cargar, y va a seguir siendo utilizada

Otras Decisiones ¿ Cuántos frames asignar a cada proceso? Un número igual por proceso Dependiendo de la prioridad del proceso Cuando se va a reemplazar una página, ¿escogemos una del propio proceso o de otro proceso? Alocación global Alocación local

Thrashing Si a un proceso no se le asignan “suficientes” frames, la tasa de page faults es muy alta Baja utilización del CPU S.O. piensa que debe aumentar el grado de multi-programación Se agrega otro proceso al sistema Thrashing  un proceso está ocupado haciendo swap in y swap out de páginas

Thrashing (cont.) Modelo de working-set puede ser utilizado por S.O. para determinar si hay thrashing.

Localidad patrones de referencia a memoria

Esquema de Frecuencias de Page-Faults Establecer una tasa de page-faults “aceptable” Si la tasa actual es muy baja, al proceso se le quita un frame Si la tasa actual es muy alta, al proceso se le otorga un frame

Asignando Memoria al Kernel Tratada de manera diferente que la memoria de usuario Frecuentemente asignadas de un pool de memoria libre Kernel solicita estructuras de memoria de tamaños variables En ocasiones, la memoria necesita ser contigua

Otros Aspectos: Prepaginación Pre-paginación Busca reducir el número de page faults que ocurren cuando un proceso se carga inicialmente Se puede prepaginar todas o algunas de las páginas que el proceso necesite, antes de que se referencien Pero, si las páginas pre-paginadas no se usan, hay desperdicio de E/S y memoria

Otros Aspectos Definir el tamaño de la página Muy grande: fragmentación Muy pequeña: Muchos page faults Tamaño del TLB Idealmente, capaz de contener el working set del proceso Estructura del programa (sgt. página)

Otros Aspectos: Estructura del Programa Estructura del programa int[128,128] data; Cada fila se almacena en una página Programa 1 for (j = 0; j <128; j++) for (i = 0; i < 128; i++) data[i,j] = 0; Programa 2 for (i = 0; i < 128; i++) for (j = 0; j < 128; j++) data[i,j] = 0;

Otros Aspectos: Estructura del Programa Estructura del programa int[128,128] data; Cada fila se almacena en una página Programa 1 for (j = 0; j <128; j++) for (i = 0; i < 128; i++) data[i,j] = 0; 128 x 128 = 16,384 page faults Programa 2 for (i = 0; i < 128; i++) for (j = 0; j < 128; j++) data[i,j] = 0;

Otros Aspectos: Estructura del Programa Estructura del programa int[128,128] data; Cada fila se almacena en una página Programa 1 for (j = 0; j <128; j++) for (i = 0; i < 128; i++) data[i,j] = 0; 128 x 128 = 16,384 page faults Programa 2 for (i = 0; i < 128; i++) for (j = 0; j < 128; j++) data[i,j] = 0; 128 page faults

Ejemplos de Sistemas Operativos Windows XP Solaris

Windows XP Uses demand paging with clustering . Clustering brings in pages surrounding the faulting page. Processes are assigned working set minimum and working set maximum Working set minimum is the minimum number of pages the process is guaranteed to have in memory A process may be assigned as many pages up to its working set maximum When the amount of free memory in the system falls below a threshold, automatic working set trimming is performed to restore the amount of free memory Working set trimming removes pages from processes that have pages in excess of their working set minimum

Solaris Maintains a list of free pages to assign faulting processes Lotsfree – threshold parameter (amount of free memory) to begin paging Desfree – threshold parameter to increasing paging Minfree – threshold parameter to being swapping Paging is performed by pageout process Pageout scans pages using modified clock algorithm Scanrate is the rate at which pages are scanned. This ranges from slowscan to fastscan Pageout is called more frequently depending upon the amount of free memory available

Capitulo 9 Memoria Virtual

Más contenido relacionado

La actualidad más candente (20)

Similar a Capitulo 9 Memoria Virtual (20)

Último (20)

Capitulo 9 Memoria Virtual