Capítulo 4 - Gestion de Memoria Virtual

Información de refuerzo- sistemas operativos
Capítulo 4. Memoria física y virtual .................................................................................................... 2

4.1. Patrones de acceso a almacenamiento ...................................................................................... 2
4.2. El espectro de almacenamiento ................................................................................................ 2
4.2.1. Registros de CPU .............................................................................................................. 3
4.2.2. Memoria caché .................................................................................................................. 3
4.2.2.1. Niveles de caché ............................................................................................................ 4
4.2.3. Memoria principal — RAM .............................................................................................. 4
4.2.4. Discos duros ...................................................................................................................... 5
4.2.5. Almacenamiento para respaldos fuera de línea ................................................................. 6
4.3. Conceptos básicos sobre Memoria Virtual ............................................................................... 6
4.3.1. La memoria virtual en términos sencillos ......................................................................... 7
4.3.2. Almacenamiento de respaldo — el Tenet central de la memoria virtual .......................... 7
4.4. La memoria virtual: los detalles ............................................................................................... 8
4.4.1. Fallos de página................................................................................................................. 9
4.4.2. El conjunto de direcciones de trabajo................................................................................ 9
4.4.3. Intercambio...................................................................................................................... 10
4.5. Implicaciones de rendimiento de la memoria virtual ............................................................. 10
4.5.1. Escenario de rendimiento del peor caso .......................................................................... 10
4.5.2. Escenario de rendimiento del mejor caso ........................................................................ 11
7 Reemplazo de Páginas.................................................................................................................... 11
7.4 Reemplazo de Páginas [SILB94] ........................................................................................... 11
7.4.1 Algoritmos de reemplazo [SILB94] [DEIT93] [STAL95] ............................................... 13
7.4.1.1 Reemplazo FIFO ....................................................................................................... 14
7.4.1.2 Reemplazo Optimo .................................................................................................... 15
7.4.1.3 Reemplazo Menos Recientemente Usado o LRU (Least Recently Used)................. 15
7.4.1.4 Aproximaciones a LRU. ............................................................................................ 17
Algoritmos de bits Adicionales de Referencia .............................................................. 17
El algoritmo de la Segunda Oportunidad ..................................................................... 18
El Algoritmo del Reloj .................................................................................................... 19
Algoritmo LFU (Last Frequently Used) ......................................................................... 19
El algoritmo MFU (Most Frequently Used) ................................................................... 19
Algoritmo de páginas de uso no reciente o NRU (Not Recently Used) ........................ 20
7.4.1.5 Asignación Global frente a Asignación Local [SILB94] .......................................... 21
Capítulo 4. Memoria física y virtual

Todas las computadoras de propósito general de hoy día, son del tipo conocido como
computadoras de almacenamiento de programas. Como su nombre lo implica, las
computadoras de programas almacenados cargan las instrucciones (los bloques de
construcción de programas) en algún tipo de almacenamiento interno, donde son
subsecuentemente ejecutadas.
Las computadoras de programas almacenados también utilizan el mismo almacenamiento

para los datos. Esto es en contraste con las computadoras que utilizan su configuración de
hardware para controlar sus operaciones (tales como las computadoras más antiguas
basadas en la conexión de tarjetas).
El lugar donde los programas eran almacenados en las primeras computadoras de

programas almacenados se llamó de varias formas y utilizó tecnologías diferentes, desde
manchas en un tubo de rayos catódicos, hasta pulsos de presión en columnas de mercurio.
Afortunadamente, los computadores de hoy en día utilizan tecnologías con mayores
capacidades de almacenamiento y de menor tamaño que antes.
4.1. Patrones de acceso a almacenamiento

Una cosa a recordar a lo largo de este capítulo es que los computadores tienden a acceder al
almacenamiento en formas particulares. De hecho, la mayoría del acceso a almacenamiento
tiende a exhibir uno (o ambos) de los siguientes atributos:
 El acceso tiende a ser secuencial

 El acceso tiende a ser localizado
El acceso secuencial significa que, si el CPU accede a la dirección N, es muy probable que
la dirección N+1 sea la próxima a acceder. Esto tiene sentido, ya que muchos programas
consisten de grandes secciones de instrucciones que ejecutan — en orden — una
instrucción tras la otra.
El acceso localizado significa que, si se accede a la dirección X, es muy probable que otras
direcciones alrededor de X también serán accedidas en el futuro.
Estos atributos son cruciales, debido a que permite que unidades de almacenamiento
pequeña y más rápida, coloque efectivamente en memoria temporal almacenamiento más
grande y lento. Esto es lo básico para implementar la memoria virtual. Pero antes de que
discutamos la memoria virtual, debemos examinar las diferentes tecnologías de
almacenamiento usadas actualmente.
4.2. El espectro de almacenamiento

Las computadoras de hoy utilizan una variedad de tecnologías de almacenamiento. Cada
tecnología está orientada hacia una función específica, con velocidades y capacidades en
combinación.
Estas tecnologías son:
 Registros de CPU
 Memoria caché
 RAM
 Discos duros
 Almacenamiento fuera de línea para respaldos (cintas, discos ópticos, etc.)
En términos de capacidades y costos, estas tecnologías forman un espectro. Por ejemplo,

los registros de CPU son:
 Muy rápidos (tiempos de acceso de unos pocos nanosegundos)
 Baja capacidad (usualmente menos de 200 bytes)
 Capacidades de expansión muy limitadas (se requiere un cambio en la arquitectura
del CPU)
 Costosas (más de un dólar/byte)
Sin embargo, en el otro lado del espectro, el almacenamiento fuera de línea es:
 Muy lento (tiempos de acceso se miden en días, si la media de respaldo debe ser
entregada sobre largas distancias)
 Capacidad muy alta (10s - 100s de gigabytes)
 Capacidades de expansión prácticamente ilimitadas (solamente limitadas por el
espacio físico requerido para hospedar la media de respaldo)
 Bajo costo (fracciones de céntimos/byte)
Usando diferentes tecnologías con diferentes capacidades, es posible afinar el diseño del
sistema para un máximo rendimiento al costo más bajo posible. Las secciones siguientes
exploran cada tecnología en el espectro del almacenamiento.
4.2.1. Registros de CPU

Todos los diseños de CPU de hoy día incluyen registros para una variedad de propósitos,
desde el almacenamiento de direcciones de la instrucción recientemente ejecutada, hasta
propósitos más generales de almacenamiento y manipulación de datos. Los registros de
CPU se ejecutan a la misma velocidad que el resto del CPU; de lo contrario habría un
cuello de botella grave sobre el rendimiento completo del sistema. La razón para esto es
que casi todas las operaciones realizadas por el CPU envuelven registros de una forma u
otra.
El número de registros de CPU (y sus usos) dependen estrictamente en el diseño

arquitectónico del CPU mismo. No hay forma de cambiar el número de registros de CPU,
solamente puede migrar a un CPU con una arquitectura diferente. Por estas razones, el
número de registros de CPU se puede considerar como una constante, ya que sólo pueden
cambiarse con mucho dolor y grandes costos.
4.2.2. Memoria caché

El propósito de la memoria caché es actuar como una memoria temporal entre los registros
de CPU, limitados y de gran velocidad y el sistema de memoria principal, mucho más
grande y lento — usualmente conocido como RAM[1]. La memoria caché tiene una
velocidad de operación similar a la del CPU mismo, por eso cuando el CPU accede a datos
en la caché, no tiene que quedarse esperando por los datos.
La memoria caché es configurada de forma tal que, cuando se leen datos desde la RAM, el
sistema de hardware verifica primero para determinar si los datos deseados están en caché.
Si los datos están en caché, estos son recuperados rápidamente y utilizados por el CPU. Sin
embargo, si los datos no están en caché, estos se leen desde la RAM y, mientras se
transfieren al CPU, también se colocan en caché (en caso de que se necesiten más tarde).
Desde la perspectiva del CPU, todo esto se hace de forma transparente, por lo que la única
diferencia entre el acceso de los datos en caché y desde la RAM es la cantidad de tiempo
que toma para que los datos sean recuperados.
En términos de la capacidad de almacenamiento, la caché es mucho más pequeña que la

RAM. Por lo tanto, no todos los bytes en la RAM tienen su ubicación única en caché.
Como tal, es necesario dividir la caché en secciones que se puedan utilizar para alojar
diferentes áreas de RAM y tener un mecanismo que permita que cada área de la caché haga
un "caché" de la RAM en diferentes momentos. Aúnque existe una diferencia en tamaño
entre la caché y la RAM, dada la naturaleza secuencial y localizada del acceso a
almacenamiento, una pequeña cantidad de caché puede efectivamente acelerar el acceso a
grandes cantidades de RAM.
Cuando se escriben datos desde el CPU, las cosas se complican un poco. Existen dos
enfoque que se pueden utilizar. En ambos casos, los datos son escritos primero a la caché.
Sin embargo, puesto que el propósito de la caché es funcionar como una copia muy rápida
de los contenidos de porciones seleccionadas de RAM, cada vez que una porción de datos
cambia su valor, ese nuevo valor debe ser escrito tanto a la caché como a la RAM. De lo
contrario, los datos en caché y los datos en la RAM ya no coincidirían.
Los dos enfoques se diferencian en cómo se logra hacer esto. En un enfoque, conocido
como write-through caching, los datos modificados se escriben inmediatamente a la RAM.
Sin embargo, en el write-back caching, se retrasa la escritura de los datos modificados a la
RAM. La razón para hacer esto es la de reducir el número de veces que una porción de
datos modificada frecuentemente debe ser escrita nuevamente a la RAM.
La caché "write-through" o inmediata es un poco más simple de implementar; por esta

razón es la más común. La caché "write-back" es un poco más complicada; además de
almacenar los datos, es necesario mantener cierto tipo de mecanismo que sea capaz de
notificar que los datos en caché están al día o "limpios" (los datos en caché son los mismos
que los datos en RAM), o que están "sucios" (los datos en caché han sido modificados, lo
que significa que los datos en RAM ya no están actualizados). También es necesario
implementar una forma de vaciar periódicamente entradas "sucias" en caché de vuelta en
RAM.
4.2.2.1. Niveles de caché
Los subsistemas de caché en los diseños de computadoras de hoy día pueden ser de niveles
múltiples; esto es, puede haber más de un conjunto de caché entre el CPU y la memoria
principal. Los niveles de caché a menudo están enumerados, con los números menores más
cercanos a la CPU. Muchos sistemas tienen dos niveles de caché:
 La caché L1 a menudo está ubicada en el chip del CPU mismo y se ejecuta a la

misma velocidad que el CPU.
 La caché L2 usualmente es parte del módulo de CPU, se ejecuta a las mismas
velocidades que el CPU (o casi) y normalmente es un poco más grande y lenta que
la caché L1
Algunos sistemas (normalmente servidores de alto rendimiento) también tienen caché L3,
que usualmente forma parte del sistema de la tarjeta madre. Como puede imaginarse, la
caché L3 es más grande (y casi con seguridad más lenta) que la caché L2.
En cualquier caso, el objetivo del todos los subsistemas de caché — bien sean simples o de
múltiples niveles — es el de reducir el tiempo de acceso promedio a la RAM.
4.2.3. Memoria principal — RAM

La RAM resuelve la mayoría del almacenamiento electrónico en las computadoras de hoy
en día. La RAM es utilizada tanto para almacenar datos como para almacenar los
programas en uso. La velocidad de la RAM en la mayoría de los sistemas actuales está
entre la velocidad de la memoria caché y la de los discos duros y está mucho más cercana a
la velocidad de la primera que a la segunda.
La operación básica de la RAM es en realidad bien sencilla. En el nivel más bajo, están los
chips de RAM — circuitos integrados que "recuerdan". Estos chips tienen cuatro tipos de
conexiones con el mundo externo:
 Conexiones de energía (para operar la circuitería dentro del chip)

 Conexiones de datos (para permitir la transferencia de datos hacia adentro y fuera
del chip)
 Conexiones de lectura/escritura (para controlar si los datos se almacenaran o se
recuperaran desde el chip)
 Conexiones de direcciones (para determinar si los datos en el chip serán
leídos/escritos)
He aquí los pasos requeridos para almacenar datos en RAM:
1. Los datos a almacenar se presentan a las conexiones de datos.

2. La dirección en la que los datos se almacenaran se presenta a las conexiones de
dirección.
3. La conexión de lectura/escritura se coloca en modo de escritura.
La recuperación de datos es también muy directa:
1. La dirección de los datos deseados se presenta a las conexiones de direcciones.

2. La conexión de lectura/escritura es colocada a modo de lectura.
3. Los datos deseados son leídos desde las conexiones de datos.
Mientras que estos pasos parecen bastante simples, estos toman lugar a grandes
velocidades, con el tiempo consumido en cada paso medido en nanosegundos.
Casi todos los chips de memoria creados hoy en día se venden como módulos. Cada
módulo consiste de un número individual de chips de RAM conectados a una pequeña
tarjeta de circuitos. La distribución mecánica y eléctrica del módulo sigue los estándares de
la industria, haciendo posible la compra de memorias desde diferentes fabricantes.
Nota
El beneficio principal de un sistema utilizando módulos RAM basados en estándares
de la industria, es que tienden a mantener bajos los costos de las RAM, debido a la
posibilidad de adquirir módulos a partir de diferentes fabricantes.
Aunque la mayoría de las computadoras utilizan módulos de RAM basados en

estándares de la industria, existen algunas excepciones. Las más notables de estas
excepciones son portátiles (e inclusive aquí se comienza a ver un poco más de
estandarización) y servidores de punta. Sin embargo, aún en estos ejemplos, es muy
probable que estén disponibles módulos de terceros, asumiendo que el sistema sea
relativamente popular y que no se trate de un diseño completamente nuevo.
4.2.4. Discos duros

Todas las tecnologías discutidas hasta ahora son volátiles por naturaleza. En otras palabras,
los datos contenidos en almacenamiento volátil se pierden cuando se desconecta el poder.
Por otro lado, los discos duros son no-volátiles — lo que significa que los datos se
mantienen allí, aún después que se ha desconectado la energía. Debido a esto, los discos
duros ocupan un lugar muy especial en el espectro del almacenamiento. Su naturaleza no-
volátil los hace ideal para el almacenamiento de programas y datos para su uso a largo
plazo. Otro aspecto único de los discos duros es que, a diferencia de la RAM y la memoria
caché, no es posible ejecutar los programas directamente cuando son almacenados en
discos duros; en vez de esto, ellos deben primero ser leídos a la RAM.
Otra diferencia de la caché y de la RAM es la velocidad del almacenamiento y recuperación

de los datos; los discos duros son de al menos un orden de magnitud más lento que todas
las tecnologías electrónicas utilizadas para caché y RAM. La diferencia en velocidad es
debida principalmente a su naturaleza electromecánica. Hay cuatro fases distintas que
toman lugar durante cada transferencia de datos desde o hacia un disco duro. La lista
siguiente ilustra estas fases, junto con el tiempo que en promedio tomaría una unidad de
alto rendimiento, para completar cada fase:
 Movimiento del brazo de acceso (5.5 milisegundos)

 Rotación del disco (.1 milisegundos)
 Lectura/escritura de datos de cabezales (.00014 milisegundos)
 Transferencia de datos hacia/desde la electrónica del disco (.003 Milisegundos)
De todas estas, solamente la última fase no es dependiente de ninguna operación mecánica.

Nota
Aunque hay mucho más por aprender sobre los discos duros, las tecnologías de
almacenamiento de disco son discutidas con más detalles en el Capítulo 5. Por los
momentos, solamente es necesario tener presente la gran diferencia de velocidad
entre la RAM y las tecnologías basadas en disco y que su capacidad de
almacenamiento usualmente excede la de la RAM por un factor de al menos 10 y a
menudo de 100 y hasta más.
4.2.5. Almacenamiento para respaldos fuera de línea

El almacenamiento de respaldo fuera de línea dá un paso más allá del almacenamiento de
disco duro en términos de la capacidad (mayor) y de la velocidad (más lento). Aquí, las
capacidades solamente están limitadas por su habilidad de conseguir y almacenar la media
removible.
Las tecnologías utilizadas en estos dispositivos varían ampliamente. He aquí los tipos más
populares:
 Cinta magnética
 Disco óptico
Por supuesto, el tener una media removible significa que los tiempos de acceso son aún más
largos, particularmente cuando los datos deseados están en un medio que aún no está
cargado en el dispositivo de almacenamiento. Esta situación es aliviada de alguna manera
por el uso de dispositivos robóticos capaces de montar y desmontar automáticamente la
media, pero las capacidades de almacenamiento de la media de tales dispositivos son
finitas. Hasta en el mejor de los casos, los tiempos de acceso son medidos en segundos, lo
cual está bastante lejos de los tiempos típicos de acceso de los ya relativamente lentos
multi-milisegundos de un disco duro.
Ahora que ha visto brevemente las diferentes tecnologías de almacenamiento utilizadas hoy
en día, vamos a explorar los conceptos básicos de la memoria virtual.
Notas
[1] Mientras que "RAM" es un acrónimo para "Random Access Memory," y un término
que podría ser fácilmente aplicable a cualquier tecnología de almacenamiento que
permita el acceso no secuencial de los datos almacenados, cuando los administradores
de sistemas hablan sobre RAM invariablemente se refieren al sistema de memoria
principal.
4.3. Conceptos básicos sobre Memoria

Virtual
Aún cuando la tecnología detrás de la construcción de las implementaciones modernas de
almacenamiento es realmente impresionante, el administrador de sistemas promedio no
necesita estar al tanto de los detalles. De hecho, solamente existe un factor que los
administradores de sistemas deberían tener en consideración:
Nunca hay suficiente RAM.
Mientras que esta frase puede sonar al principio un poco cómica, muchos diseñadores de
sistemas operativos han empleado una gran cantidad de tiempo tratando de reducir el
impacto de esta limitación. Esto lo han logrado mediante la implementación de la memoria
virtual — una forma de combinar RAM con un almacenamiento más lento para darle al
sistema la apariencia de tener más RAM de la que tiene instalada realmente.
4.3.1. La memoria virtual en términos sencillos

Vamos a comenzar con una aplicación hipotética. El código de máquina que conforma esta
aplicación tiene un tamaño de 10000 bytes. También requiere otros 5000 bytes para el
almacenamiento de datos y para la memoria intermedia de E/S. Esto significa que para
ejecutar la aplicación, deben haber más de 15000 bytes de RAM disponible; un byte menos
y la aplicación no será capaz de ejecutarse.
Este requerimiento de 15000 bytes se conoce como el espacio de direcciones de la

aplicación. Es el número de direcciones únicas necesarias para almacenar la aplicación y
sus datos. En las primeras computadoras, la cantidad de RAM disponible tenía que ser
mayor que el espacio de direcciones de la aplicación más grande a ejecutar; de lo contrario,
la aplicación fallaría con un error de "memoria insuficiente".
Un enfoque posterior conocido como solapamiento intentó aliviar el problema permitiendo

a los programadores dictar cuales partes de sus aplicaciones necesitaban estar residentes en
memoria en cualquier momento dado. De esta forma, el código requerido solamente para
propósitos de inicialización podía ser sobreescrito con código a utilizar posteriormente.
Mientras que el solapamiento facilitó las limitaciones de memoria, era un proceso muy
complejo y susceptible a errores. El solapamiento también fallaba en solucionar el
problema de las limitaciones de memoria globales al sistema en tiempo de ejecución. En
otras palabras, un programa con solapamiento requería menos memoria para ejecutarse que
un programa sin solapamiento, pero si el sistema no tiene suficiente memoria para el
programa solapado, el resultado final es el mismo — un error de falla de memoria.
Con la memoria virtual el concepto del espacio de direcciones de las aplicaciones toma un
significado diferente. En vez de concentrarse en cuanta memoria necesita una aplicación
para ejecutarse, un sistema operativo con memoria virtual continuamente trata de encontrar
una respuesta a la pregunta "qué tan poca memoria necesita la aplicación para ejecutarse?".
Aunque inicialmente pareciera que nuestra aplicación hipotética requiere de un total de

15000 bytes para ejecutarse, recuerde nuestra discusión anterior en la Sección 4.1 — el
acceso a memoria tiende a ser secuencial y localizado. Debido a esto, la cantidad de
memoria requerida para ejecutar la aplicación en un momento dado es menos que 15000
bytes — usualmente mucho menos. Considere los tipos de accesos de memoria requeridos
para ejecutar una instrucción de máquina sencilla:
 La instrucción es leída desde la memoria.

 Se leen desde memoria los datos requeridos por la instrucción.
 Después de completar la instrucción, los resultados de la instrucción son escritos
nuevamente en memoria.
El número real de bytes necesarios para cada acceso de memoria varían de acuerdo a la
arquitectura del CPU, la instrucción misma y el tipo de dato. Sin embargo, aún si una
instrucción requiere de 100 bytes de memoria por cada tipo de acceso de memoria, los 300
bytes requeridos son mucho menos que el espacio de direcciones total de la aplicación de
15000 bytes. Si hubiese una forma de hacer un seguimiento de los requerimientos de
memoria de la aplicación a medida que esta se ejecuta, sería posible mantener la aplicación
ejecutándose usando menos memoria que lo que indicaría su espacio de direcciones.
Pero esto genera una pregunta:
Si solamente una parte de la aplicación está en memoria en un momento dado, dónde esta el
resto?
4.3.2. Almacenamiento de respaldo — el Tenet central de

la memoria virtual
La respuesta corta a esta pregunta es que el resto de la aplicación se mantiene en disco. En
otras palabras, el disco actúa como un almacenamiento de respaldo para la RAM; un medio
más lento y también más grande que actúa como un "respaldo" para un almacenamiento
más rápido y más pequeño. Esto puede parecer al principio como un gran problema de
rendimiento en su creación — después de todo, las unidades de disco son mucho más lentas
que la RAM.
Aunque esto es cierto, es posible tomar ventaja del comportamiento de acceso secuencial y
localizado de las aplicaciones y eliminar la mayoría de las implicaciones de rendimiento en
el uso de unidades de disco como unidades de respaldo para la RAM. Esto se logra
estructurando el subsistema de memoria virtual para que este trate de asegurarse de que
esas partes de la aplicación que actualmente se necesitan — o que probablemente se
necesitaran en un futuro cercano — se mantengan en RAM solamente por el tiempo en que
son realmente requeridas.
En muchos aspectos, esto es similar a la situación entre la caché y la RAM: haciendo

parecer una poca cantidad de almacenamiento rápido con grandes cantidades de un
almacenamiento lento actuar como que si se tratase de grandes cantidades de
almacenamiento rápido.
Con esto en mente, exploremos el proceso en más detalle.
4.4. La memoria virtual: los detalles

Primero, debemos introducir un nuevo concepto: espacio de direcciones virtuales. El
espacio de direcciones virtuales es el espacio de direcciones máximo disponible para una
aplicación. El espacio de direcciones virtuales varia de acuerdo a la arquitectura del sistema
y del sistema operativo. El espacio de direcciones virtuales depende de la arquitectura
puesto que es la arquitectura la que define cuántos bits están disponibles para propósitos de
direccionamiento. El espacio de direcciones virtuales también depende del sistema
operativo puesto que la forma en que el sistema operativo fue implementado puede
introducir límites adicionales sobre aquellos impuestos por la arquitectura.
La palabra "virtual" en el espacio de direcciones virtuales, significa que este es el número

total de ubicaciones de memoria direccionables disponibles para una aplicación, pero no la
cantidad de memoria física instalada en el sistema, o dedicada a la aplicación en un
momento dado.
En el caso de nuestra aplicación de ejemplo, su espacio de direcciones virtuales es de 15000

bytes.
Para implementar la memoria virtual, para el sistema es necesario tener un hardware

especial de administración de memoria. Este hardware a menudo se conoce como un MMU
(Memory Management Unit). Sin un MMU, cuando el CPU accede a la RAM, las
ubicaciones reales de RAM nunca cambian — la dirección de memoria 123 siempre será la
misma dirección física dentro de la RAM.
Sin embargo, con un MMU, las direcciones de memoria pasan a través de un paso de
traducción antes de cada acceso de memoria. Esto significa que la dirección de memoria
123 puede ser redirigida a la dirección física 82043 en un momento dado y a la dirección
20468 en otro. Como resultado de esto, la sobrecarga relacionada con el seguimiento de las
traducciones de memoria virtual a física sería demasiado. En vez de esto, la MMU divide la
RAM en páginas — secciones contiguas de memoria de un tamaño fijo que son manejadas
por el MMU como unidades sencillas.
Mantener un seguimiento de estas páginas y sus direcciónes traducidas puede sonar como
un paso adicional confuso e innecesario, pero de hecho es crucial para la implementación
de la memoria virtual. Por tal razón, considere el punto siguiente:
Tomando nuestra aplicación hipotética con un espacio de direcciones virtuales de 15000

bytes, asuma que la primera instrucción de la aplicación accede a los datos almacenados en
la dirección 12374. Sin embargo, también asuma que nuestra computadora solamente tiene
12288 bytes de RAM física. ¿Qué pasa cuando el CPU intenta acceder a la dirección
12374?
Lo que ocurre se conoce como un fallo de página.
4.4.1. Fallos de página

Un fallo de página es la secuencia de eventos que ocurren cuando un programa intenta
acceder a datos (o código) que está en su espacio de direcciones, pero que no está
actualmente ubicado en la RAM del sistema. El sistema operativo debe manejar los fallos
de página haciendo residentes en memoria los datos accedidos, permitiendo de esta manera
que el programa continue la operación como que si el fallo de página nunca ocurrió.
En el caso de nuestra aplicación hipotética, el CPU primeramente presenta la dirección

deseada (12374) al MMU. Sin embargo, el MMU no tiene traducción para esta dirección.
Por tanto, interrumpe al CPU y causa que se ejecute un software, conocido como el
manejador de fallos de página. El manejador de fallos de página determina lo que se debe
hacer para resolver esta falla de página. El mismo puede:
 Encontrar dónde reside la página deseada en disco y la lee (este es usualmente el

caso si el fallo de página es por una página de código)
 Determina que la página deseada ya está en RAM (pero no está asignada al proceso
actual) y reconfigura el MMU para que apunte a el
 Apunta a una página especial que solamente contiene ceros y asigna una nueva
página para el proceso solamente si este intenta alguna vez escribir a la página
especial (esto se llama una página de copia en escritura y es utilizada a menudo por
páginas que contienen datos inicializados a cero)
 Obtener la página deseada desde otro lugar (lo que se discute en detalle más
adelante)
Mientras que las primeras tres acciones son relativamente sencillas, la última no lo es. Por
eso necesitamos cubrir algunos tópicos adicionales.
4.4.2. El conjunto de direcciones de trabajo

El grupo de páginas de memoria física actualmente dedicadas a un proceso específico se
conoce como conjunto de direcciones de trabajo para ese proceso. El número de páginas en
el conjunto de direcciones de trabajo puede crecer o reducirse, dependiendo de la
disponibilidad general de páginas del sistema.
El conjunto de direcciones de trabajo crece si un proceso tiene fallos de páginas. El

conjunto de direcciones de trabajo se reduce a medida que existen menos y menos páginas
libres. Para evitar que se acabe la memoria completamente, se deben eliminar las páginas
del conjunto de direcciones de trabajo y convertirlas en páginas libres, disponibles para un
uso posterior. El sistema operativo reduce el conjunto de direcciones de trabajo mediante:
 Escribiendo las páginas modificadas a un área dedicada en un dispositivo de

almacenamiento masivo (usualmente conocido como espacio de intercambio o de
paginado)
 Marcando las páginas sin modificar como libres (no hay necesidad de escribir estas
páginas fuera del disco pues no se han cambiado)
Para determinar los conjuntos de trabajo apropiados para todos los procesos, el sistema
operativo debe hacer un seguimiento de la información de uso de todas las páginas. De esta
manera, el sistema operativo determina cuales páginas son usadas activamente (y deben
mantenerse en memoria como residentes) y cuales no (y por lo tanto, se pueden eliminar de
memoria). En la mayoría de los casos, se utiliza un tipo de algoritmo de "menos usado
recientemente" para determinar cuales páginas son elegibles para eliminarse de los
conjuntos de trabajo de los procesos.
4.4.3. Intercambio
Mientras que el hacer intercambio de memoria (swapping, escribiendo páginas modificadas
al espacio swap del sistema) es una parte normal de la operación del sistema, es posible
experimentar demasiado intercambio. La razón por la que estar atentos ante el excesivo
intercambio es que la situación siguiente puede ocurrir fácilmente, y repetirse una y otra
vez:
 Las páginas de un proceso son intercambiadas (swapped)

 El proceso se vuelve ejecutable e intenta acceder a una página en el espacio de
intercambio
 La página es colocada en memoria (lo más probable forzando a otras páginas de
procesos a que sean extraídas de allí)
 Un momento después, la página es colocada nuevamente fuera de memoria
Si esta secuencia de eventos se extiende demasiado, esto se conoce como thrashing y es un

indicativo de insuficiente RAM para la carga de trabajo actual. "Trashing" es
extremadamente perjudicial para el rendimiento del sistema, pues las cargas de CPU y E/S
que se pueden generar en tal situación rápidamente sobrepasa la carga impuesta por el
trabajo real del sistema. En casos extremos, puede que el sistema no realice ningún trabajo
útil, consumiendo todos sus recursos moviendo páginas dentro y fuera de memoria.
4.5. Implicaciones de rendimiento de la

memoria virtual
Mientras que la memoria virtual hace posible que las computadoras manejen más
fácilmente aplicaciones más grandes y complejas, como con cualquier otra herramienta,
esto viene a un precio. El precio en este caso es el de rendimiento — la memoria virtual de
un sistema operativo tiene mucho más que hacer que un sistema operativo sin memoria
virtual. Esto significa que el rendimiento nunca es tan bueno con memoria virtual como lo
es cuando la misma aplicación esta 100% residente en memoria.
Sin embargo, esta no es razón suficiente para abandonar la idea. Los beneficios de la
memoria virtual son demasiados para hacer esto. Y, con un poco de esfuerzo, es posible
lograr un buen rendimiento. Lo que se debe hacer es examinar aquellos recursos de
sistemas impactados por el uso pesado del subsistema de memoria virtual.
4.5.1. Escenario de rendimiento del peor caso

Por un momento, utilice lo que ha leído en este capítulo y considere qué recursos del
sistema son utilizados extensivamente por fallos de páginas y actividad de intercambio:
 RAM — Obviamente la RAM disponible es poca (de lo contrario no habría

necesidad de fallos de páginas o de intercambio de páginas).
 Disco — Aunque el espacio en disco puede no ser impactado, el ancho de banda de
E/S (debido a mucho paginado e intercambio) si lo será.
 CPU — El CPU está utilizando ciclos haciendo el procesamiento necesario para
soportar la administración de memoria y estableciendo las operaciones necesarias de
E/S para el paginado e intercambio.
La naturaleza interrelacionada de estas cargas hace fácil entender cómo las limitaciones de
recursos pueden conducir a problemas graves de rendimiento.
Todo lo que se necesita es un sistema con poca RAM, alta actividad de fallos de páginas y
un sistema ejecutando casi en sus límites en términos de CPU o E/S de disco. En este
punto, el sistema está haciendo trashing, siendo el bajo rendimiento el resultado inevitable.
4.5.2. Escenario de rendimiento del mejor caso

En el mejor caso, la sobrecarga proveniente del soporte a la memoria virtual representa una
carga mínima para un sistema bien configurado:
 RAM — Suficiente RAM para todos los conjuntos de direcciones de trabajo con
suficiente exceso para manejar cualquier fallo de página[1]
 Disco — Debido a la actividad limitada de fallos de página, el ancho de banda de
E/S de disco será impactado de forma mínima.
 CPU — La mayoría de los ciclos de CPU realmente están dedicados a ejecutar
aplicaciones, en vez de ejecutar el código de manejo de memoria del sistema
El punto a tener en mente es que el impacto en el rendimiento de la memoria virtual es

mínimo cuando se utiliza tan poco como sea posible. Esto significa que el factor
determinante para un buen rendimiento del subsistema de memoria virtual es tener
suficiente RAM.
Lo siguiente (pero con mucho menos importancia) es suficiente capacidad de E/S de disco
y de CPU. Sin embargo, tenga en cuenta que estos recursos solamente ayudan a que el
rendimiento del sistema se degrade de una forma más limpia de intensivos fallos de página
y del intercambio; pero hacen poco para ayudar el rendimiento del subsistema de memoria
virtual (aunque obviamente pueden jugar un papel importante en el rendimiento global del
sistema).
Notas
[1] Un sistema razonablemente activo siempre experimenta algún nivel de actividad de

fallo de páginas, debido a los fallos de página en los que se incurre cuando las
aplicaciones lanzadas recientemente son traídas a memoria.
7 Reemplazo de Páginas
7.4 Reemplazo de Páginas [SILB94]
En nuestra presentación, la tasa de fallos no ha sido un problema serio, ya

que, como máximo, hay un fallo de página por cada página cuando se hace
referencia a ella por primera vez. Esto no es muy exacto. Considere que, si
un proceso de 10 páginas sólo emplea la mitad de ellas, entonces la
paginación por demanda ahorra la E/S necesaria para cinco páginas que
nunca se usarán. Podemos aumentar el nivel de multiprogramación
ejecutando el doble de procesos. Así, si tuviéramos 40 marcos, podríamos
ejecutar ocho procesos, en lugar de cuatro.
Si aumentamos nuestro nivel de multiprogramación, estamos

sobreasignando la memoria. Si ejecutamos seis procesos, cada uno con un
tamaño de 10 páginas, pero que sólo utilizan cinco, tenemos mayor
utilización de la CPU y productividad, con diez marcos de sobra. Sin
embargo, es posible que cada uno de estos procesos, para un conjunto de
datos en particular, requiera sus 10 páginas, lo que supondría una necesidad
de 60 marcos cuando tan sólo se dispone de 40. Aunque esta situación puede
ser poco probable, la posibilidad aumenta con el nivel de
multiprogramación. Puede, entonces, darse el caso de que produzcan
demanda de páginas para las que no hay marcos. El sistema operativo podría
abortar el proceso de usuario, pero la paginación dejaría de ser transparente,
ya que, por razones desconocidas para el usuario se ha acabado con la
ejecución de su proceso.
La solución está en reemplazar páginas. Si no hay ningún marco libre,

encontramos uno que no se esté utilizando en ese momento y lo liberamos.
Podemos liberar un marco escribiendo en disco todo su contenido y
modificando la tabla de páginas (y todas las demás tablas) para indicar que
la página ya no se encuentra en memoria (figura 7.3). El marco liberado
puede usarse ahora para contener la página por la que falló el proceso. Ahora
se modifica la rutina de servicio de fallo de página para incluir el reemplazo
de página:
Encontrar la ubicación en disco de la página deseada.
Buscar un marco libre:
Si hay un marco libre, utilizarlo.
De lo contrario, utilizar un algoritmo de reemplazo

de página con el fin de seleccionar un marco víctima.
Escribir la página víctima en disco; ajustar las

tablas de marcos y páginas.
Leer la página deseada en el nuevo marco libre; modificar

las tablas de páginas y marcos.
Reanudar el proceso de usuario.

Si no quedan marcos libres, se requieren dos transferencias de páginas (una
de entrada y otra de salida). Esta situación duplica el tiempo de servicio de
fallo de página y en consecuencia aumentará el tiempo efectivo de acceso.
Este tiempo de procesamiento adicional se puede reducir utilizando un bit de

modificación (dirty bit). Cada página o marco puede tener asociado un bit de
modificación en el hardware. El hardware pone a uno el bit de modificación
para una página cuando en ella se escribe una palabra o un byte, indicando
que ha sido modificada. Cuando seleccionamos una página para reemplazo,
examinamos su bit de modificación. Si está activo, sabemos que la página se
debe escribir en disco. Esta técnica también se aplica a páginas de sólo
lectura. Con esto se reduce a la mitad el tiempo de E/S, si la página no ha
sido modificada.
Para implantar la paginación por demanda debemos resolver dos grandes

problemas: desarrollar un algoritmo de asignación de marcos y un algoritmo
de reemplazo de páginas. Si tenemos varios procesos en memoria, debemos
decidir cuántos marcos asignar a cada uno. Además, cuando se requiere un
reemplazo de página es necesario seleccionar los marcos que se
reemplazarán. El diseño de algoritmos adecuados para resolver estos
problemas es una tarea importante, ya que la E/S de disco es muy costosa.
Un pequeña mejora en los métodos de paginación por demanda produce
amplias ganancias en el rendimiento del sistema.
7.4.1 Algoritmos de reemplazo [SILB94] [DEIT93] [STAL95]
Estamos buscando algoritmos que presenten la menor tasa de fallos de

página. Para ello, necesitamos evaluarlos para una serie determinada de
referencias a memoria y calcular el número de fallos de página. Podemos
generar las cadenas de referencias aleatoriamente o bien coger una muestra
del sistema. Esto producirá un gran número de datos (alrededor de un millón
de referencias por segundo). Se puede reducir este número, ya que tan sólo
hemos de considerar el número de páginas y no toda la dirección. Y además,
si tenemos una referencia a una página p, entonces ninguna referencia a la
página p que se presente inmediatamente después provocará fallo de página.
La página p, ya se encuentra en memoria y las siguiente referencias a ella no
provocan fallo de página.
Por ejemplo, si rastreamos un proceso, podemos anotar la siguiente

secuencia de direcciones: 0100, 0432, 0101, 0612, 0102, 0103, 0104, 0101,
0611, 0102, 0103, 0104, 0101, 0610, 0102, 0103, 0104, 0609, 0102, 0105, lo
cual, a 100 bytes por página, se reduce a la siguiente serie de referencias: 1,
4, 1, 6, 1, 6, 1, 6, 1, 6, 1.
Para determinar el número de fallos de página para una serie de referencias y

un algoritmo de reemplazo de página, necesitamos también el número de
marcos de página por proceso. Si aumenta el numero de marcos, se reducirá
el número de fallos de página. Para ilustrar los algoritmos de reemplazo de
páginas, usaremos la siguiente secuencia de referencias 7, 0, 1, 2, 0, 3, 0, 4,
2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1.
7.4.1.1 Reemplazo FIFO
El algoritmo de reemplazo más sencillo es el primero en entrar, primero en

salir. Este algoritmo asocia a cada página el instante en el que se trajo a
memoria. Cuando hay que reemplazar una página, se elige la más antigua.
Para la cadena de referencias de ejemplo, y suponiendo un total de tres
marcos, aplicamos este algoritmo con el resultado de 15 fallos de página.
ENLACE A LA ANIMACIÓN FIFO
El algoritmo FIFO es fácil de comprender y programar, pero su rendimiento

no siempre es bueno. La página reemplazada puede ser un módulo de
asignación de valores iniciales que se utilizó hace mucho tiempo y que ya no
se necesita. Pero también puede contener una variable cuyo valor inicial se
asignó hace tiempo pero que se utiliza constantemente. Además, este
algoritmo presenta una irregularidad denominada anomalía de Belady. Para
ilustrarlo suponga que ahora tenemos la siguiente serie de referencias 1, 2, 3,
4, 1, 2, 5, 1, 2, 3, 4, 5. La figura 7.5 muestra la curva de fallos de páginas
frente al número de marcos disponibles. Sorprendentemente el número de
fallos para cuatro marcos (diez) es mayor que para tres marcos (nueve).
Esto significa que con el algoritmo FIFO la tasa de fallos pueden aumentar
al incrementar el número de marcos asignados.
7.4.1.2 Reemplazo Optimo
ENLACE A LA ANIMACIÓN OPTIMO
Una consecuencia del descubrimiento de la anomalía de Belady fue la búsqueda de

un algoritmo de reemplazo de páginas óptimo. El algoritmo de reemplazo de
páginas óptimo sería aquel que eligiera la página de la memoria que vaya a ser
referenciada más tarde (con el ejemplo anterior vemos que se producen tan sólo 9
fallos de página). Si se elige otra, se producirá una falta de página antes, con lo que
baja el rendimiento del sistema. Por desgracia, este algoritmo es irrealizable, pues
no hay forma de predecir qué páginas referenciará un proceso en el futuro. Como
resultado de esto, el algoritmo óptimo se utiliza sobre todo para estudios
comparativos. Puede ser útil para saber que un nuevo algoritmo está dentro de
12.3% de lo óptimo en el peor de los casos y dentro del 4.7% en promedio.
7.4.1.3 Reemplazo Menos Recientemente Usado o LRU (Least Recently Used)
La principal diferencia entre los algoritmos FIFO y OPT es que el primero

utiliza el instante en que entró una página en memoria, y el segundo, utiliza
el tiempo en el que se usará la página. Una buena aproximación al algoritmo
óptimo se basa en el principio de localidad de referencia de los programas.
Las páginas de uso frecuente en las últimas instrucciones se utilizan con
cierta probabilidad en las siguientes instrucciones. De manera recíproca, es
probable que las páginas que no hayan sido utilizadas durante mucho tiempo
permanezcan sin ser utilizadas durante cierto tiempo. Es decir, estamos
utilizando el pasado reciente como aproximación de lo que sucederá en el
futuro. El algoritmo LRU explota esta idea: al ocurrir un fallo de página se
utiliza la página que no haya sido utilizada hace más tiempo. El resultado de
aplicar este algoritmo a nuestro ejemplo produce 12 fallos.
ENLACE A LA ANIMACIÓN LRU
Aunque LRU es realizable teóricamente, su implantación presenta problemas. Sería

necesario mantener una lista enlazada de todas las páginas en la memoria, en donde
la página de uso más reciente esté al principio de la lista y la de uso menos reciente
al final. La dificultad estriba en que la lista debe actualizarse en cada referencia a la
memoria. La búsqueda de una página en la lista, su eliminación y posterior traslado
al frente de la misma puede ser una operación que consuma mucho tiempo. Es
preciso un hardware especial (caro), o bien determinar una solución aproximada
mediante software.
La búsqueda y manipulación de una lista enlazada en cada instrucción es prohibitiva

por su lentitud, aún en hardware. Sin embargo, existen otras formas de implantar
LRU con un hardware especial. Consideremos primero el caso más sencillo. Este
método requiere un contador especial de 64 bits, C, en hardware, que se incrementa
de forma automática después de cada instrucción. Además, cada entrada de la tabla
de páginas debe tener un campo de tamaño adecuado como para contener al
contador. Después de cada referencia a la memoria, el valor actual de C se almacena
en la entrada de la tabla de páginas correspondiente a la página a la que se hizo
referencia. Al ocurrir un fallo de página, el sistema operativo examina todos los
contadores de la tabla de páginas y elige el mínimo. Esa página es la de utilizada
menos recientemente.
Analicemos ahora un segundo algoritmo LRU en hardware. En una máquina con n

marcos, el hardware LRU puede utilizar una matriz de nxn bits, cuyos datos
iniciales son todos cero. En una referencia al marco k, el hardware primero activa
todos los bits del renglón k y desactiva después todos los bits de la columna k. En
cualquier instante, la fila cuyo valor en binario es mínimo es el marco utilizado
menos recientemente, la fila con el siguiente valor más pequeño es el segundo
marco utilizado menos recientemente, etc. El funcionamiento de este algoritmo
aparece en la figura 6 para cuatro marcos con referencias a los marcos en el orden:
0123210323
Después de hacer referencia al marco 0 tenemos la situación de la figura 7.6 (a), etc.
Ni el reemplazo óptimo ni el reemplazo LRU padecen la anomalía de

Belady. Los algoritmos de reemplazo denominados algoritmos de
pila nunca presentan esta anomalía. Un algoritmo de pila es aquel
que para el cual se puede demostrar que el conjunto de páginas en
memoria para n marcos es siempre un subconjunto del conjunto de
las páginas que estarían en memoria con n + 1 marcos. Para el
reemplazo LRU, el conjunto de páginas en memoria sería las n
páginas más recientemente usadas. Si el numero de marcos
aumentara, estas n páginas seguirían siendo las de más reciente
referencia y, por tanto, seguirían en memoria.
7.4.1.4 Aproximaciones a LRU.
Pocos sistemas proporcionan suficiente ayuda del hardware para un

verdadero reemplazo de páginas LRU. Sin embargo, muchos
sistemas ofrecen cierta ayuda, en la forma de un bit de referencia. El
hardware coloca a uno el bit de referencia para una página cada vez
que se hace una referencia a ella. Los bits de referencia están
asociados a cada entrada de la tabla de páginas.
En principio, el sistema operativo borra todos los bits. Al ejecutarse

un proceso de usuario, el hardware activa (asignando 1) el bit
asociado a cada página referenciada. Después de cierto tiempo,
examinando los bits de referencia podemos determinar qué páginas
se han utilizado y cuáles no, aunque no sabemos el orden de uso.
Esta información parcial de la ordenación nos lleva a varios
algoritmos de reemplazo de páginas que se aproximan al LRU.
Algoritmos de bits Adicionales de Referencia
Podemos obtener información adicional de la ordenación anotando

los bits de referencia a intervalos regulares. En una tabla en memoria
podemos conservar ocho bits para cada página. A intervalos
regulares (cada 100 milisegundos), una interrupción del cronómetro
transfiere el control al SO. El sistema operativo desplaza el bit de
referencia de cada página al bit de orden superior de sus ocho bits,
desplazando los otros bits una posición a la derecha y descartando el
bit de orden inferior. Estos registros contienen la historia de la
utilización de la página durante los últimos ocho periodos. Si el
registro de desplazamiento contiene 00000000, entonces la página no
ha sido utilizado en ocho periodos; una página que se utiliza por lo
menos una vez cada periodo tendría un valor 11111111 en su
registro de desplazamiento.
Una página con valor 11000100 ha sido utilizada más recientemente

que una con valor 01110111. Interpretando estos bits como enteros
sin signo, la página con el menor número es la que se debe
reemplazar. El número de bits históricos puede variar. En el caso
extremo, el número puede reducirse a cero, dejando únicamente el bit
de referencia. A esta versión se le llama algoritmo de reemplazo de
la segunda oportunidad.
El algoritmo de la Segunda Oportunidad
Una modificación simple de FIFO, que evita deshacerse de una

página de uso frecuente, inspecciona el bit R de la página más
antigua. Si es 0, la página es antigua y no utilizada, por lo que se
reemplaza de manera inmediata. Si el bit es 1, R se pone a cero, la
página se coloca al final de la lista de páginas, como si hubiera
llegado en ese momento a la memoria. Después continúa la búsqueda
siguiendo la lista.
La operación de este algoritmo, llamado de la segunda oportunidad,

se muestra en la figura 7.7. En la figura 7.7 (a), vemos las páginas de
la A a la H, en una lista enlazada ordenada según el tiempo de
llegada a la memoria.
Supongamos que ocurre un fallo de página. La página más antigua

es A, si A tiene el bit R a cero, se saca de la memoria. Por contra, si R
vale 1, A se coloca al final de la lista, poniéndose a cero el bit R. La
búsqueda de una página adecuada prosigue con B.
Lo que hace el algoritmo de la segunda oportunidad es buscar una

página antigua sin referencias, si todas las páginas tienen alguna
referencia deviene en un simple FIFO. En efecto, supongamos que
todas las páginas de la figura 7.7 (a) tienen R a 1. Una a una, el
sistema operativo traslada las páginas al final de la lista y pone su bit
R a cero. Al final, se vuelve a la página A, la cual tiene R a cero. En
este momento, A se retira de la memoria. Por lo tanto, el algoritmo
siempre termina.
El Algoritmo del Reloj
Aunque la segunda oportunidad es un algoritmo razonable, es

ineficiente e innecesario, puesto que desplaza las páginas en una
lista. Un mejor diseño consiste en mantener las páginas en una lista
circular, con la forma de un reloj, como se muestra en la figura 7.8.
Una manecilla apunta hacia la página más antigua.
Al ocurrir un fallo de página, se inspecciona la página a la que

apunta la manecilla. Si su bit R vale 0, la página se retira de la
memoria, se inserta la nueva página en su lugar en el reloj, y la
manecilla avanza una posición. Si R vale 1, este bit se pone a 0 y la
manecilla avanza a la página siguiente. Este proceso continúa hasta
encontrar una página con R a cero. Este algoritmo sólo difiere del
anterior en su implementación.
Algoritmo LFU (Last Frequently Used)
Un algoritmo de reemplazo de página menos frecuentemente usada

(Least Frequently Used) mantiene un contador del número de
referencias que se han hecho para cada página. Se reemplaza la
página con el menor recuento. La razón para esta selección es que
una página que se usa activamente debe tener un alto número de
referencias. Este algoritmo tiene problemas cuando una página se usa
mucho en la fase inicial de un proceso, pero después ya no se utiliza.
Como se usó bastantes veces, tiene un recuento alto y permanece en
memoria aunque ya no se necesite. Una solución consiste en
desplazar los recuentos un bit a la derecha a intervalos regulares,
formando un recuento promedio de utilización que disminuye
exponencialmente.
El algoritmo MFU (Most Frequently Used)
Otro algoritmo de reemplazo de páginas es el reemplazo más

frecuentemente usado, que se basa en el argumento de que la página
con el menor recuento probablemente acaba de llegar y aún tiene que
usarse. Como se podría esperar, no es común ni el reemplazo MFU
ni el LFU porque son costosos y se alejan mucho del reemplazo
OPT.
Algoritmo de páginas de uso no reciente o NRU (Not Recently Used)
La mayoría de los ordenadores presentan los bits R (de referencia) y

M (de modificación) en las entradas de la tabla de páginas, siendo
estos bits actualizados vía hardware. Si el hardware no proporciona
dichos bits, éstos pueden ser simulados mediante el software. Para
ello, cuando se inicia un proceso se señalan todas sus entradas en la
tabla de páginas como si no estuvieran dentro de la memoria. Si se
hace referencia a cualquier página, ocurre un fallo de página. El
sistema operativo activa entonces el bit R (en sus propias tablas) y
cambia la entrada de la tabla de páginas para que apunte hacia la
página correcta, poniendo dicha entrada en modo sólo lectura
(recordar los bits de permisos). El proceso retoma su ejecución; si se
escribe en la página, ocurre otra interrupción por violación de
permisos, lo que permite al sistema operativo activar el bit M en sus
tablas, cambiando los permisos de la página a lectura y escritura.
Disponiendo de los citados bits R y M se puede construir el siguiente

algoritmo: al iniciar un proceso, el sistema operativo asigna un valor
0 a los bits R y M de todas sus páginas. De manera periódica (cada
interrupción del reloj) se pone a cero el bit R, para distinguir las
páginas que no tienen referencias recientes de las que sí.
Ante un fallo de página, el sistema operativo inspecciona todas las

páginas y las divide en cuatro categorías, según los valores actuales
de los bits R y M:
Clase 0:no referenciada, ni modificada (0,0).
Clase 1:no referenciada, pero modificada (0,1).
Clase 2:referenciada, pero no modificada (1,0).
Clase 3:referenciada y modificada (1,1).
Aunque parece imposible la existencia de las páginas de la clase 1,

este caso aparece cuando en una página de clase 3, una interrupción
del reloj pone a cero su bit R. Las interrupciones del reloj no
provocan el poner a cero el bit M, puesto que esta información es
necesaria para saber si hay que volver a escribir la página en el disco
o no.
El algoritmo NRU elimina una página de manera aleatoria de la

primera clase no vacía con el número más pequeño. Una hipótesis
implícita de este algoritmo es que es mejor eliminar una página
modificada sin referencias en al menos un intervalo del reloj (por lo
general, de 20 mseg) que una página sin modificar de uso frecuente.
Este algoritmo es fácil de comprender, tiene una implementación
eficiente y un rendimiento aceptable.
7.4.1.5 Asignación Global frente a Asignación Local [SILB94]
Cuando varios procesos compiten por marcos podemos clasificar los

algoritmos de reemplazo de páginas en dos categorías: reemplazo
global y reemplazo local. El reemplazo global permite que un
proceso seleccione un marco para reemplazar de entre todo el
conjunto de marcos, incluso si ese marco está asignado a otro
proceso; un proceso puede quitar un marco a otro. El reemplazo local
requiere que cada proceso selecciones sólo de su propio conjunto de
marcos asignados.
Con una estrategia de reemplazo local, el número de marcos

asignados a un proceso no cambia. Con el reemplazo global es
posible que un proceso sólo seleccione marcos que pertenezcan a
otros procesos, incrementando su número de marcos asignados
(suponiendo que otros procesos no elijan sus marcos para
reemplazo).
Un problema del algoritmo de reemplazo global es que un proceso

no puede controlar su propia tasa de fallos de página. El conjunto de
páginas en memoria para un proceso no sólo depende del
comportamiento de paginación de ese proceso, sino también del de
los otros. Por tanto, puede variar la forma en que se ejecuta un
proceso debido a circunstancias totalmente ajenas. Esto no ocurre
con un algoritmo de reemplazo local. Con este esquema, el conjunto
de páginas en memoria para ese proceso sólo depende de su
comportamiento en cuanto a paginación. Ahora bien, el reemplazo
local impide a un proceso tener acceso a otras páginas de memoria
menos usadas. Por esta razón, el reemplazo global generalmente
brinda una mayor productividad.

Capítulo 4 - Gestion de Memoria Virtual

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Capítulo 4 - Gestion de Memoria Virtual

Încărcat de

Drepturi de autor:

Formate disponibile

Información de refuerzo- sistemas operativos

Capítulo 4. Memoria física y virtual .................................................................................................... 2

Capítulo 4. Memoria física y virtual

Las computadoras de programas almacenados también utilizan el mismo almacenamiento

El lugar donde los programas eran almacenados en las primeras computadoras de

4.1. Patrones de acceso a almacenamiento

 El acceso tiende a ser secuencial

4.2. El espectro de almacenamiento

Estas tecnologías son:

En términos de capacidades y costos, estas tecnologías forman un espectro. Por ejemplo,

4.2.1. Registros de CPU

El número de registros de CPU (y sus usos) dependen estrictamente en el diseño

4.2.2. Memoria caché

En términos de la capacidad de almacenamiento, la caché es mucho más pequeña que la

La caché "write-through" o inmediata es un poco más simple de implementar; por esta

4.2.2.1. Niveles de caché

 La caché L1 a menudo está ubicada en el chip del CPU mismo y se ejecuta a la

4.2.3. Memoria principal — RAM

 Conexiones de energía (para operar la circuitería dentro del chip)

1. Los datos a almacenar se presentan a las conexiones de datos.

La recuperación de datos es también muy directa:

1. La dirección de los datos deseados se presenta a las conexiones de direcciones.

Aunque la mayoría de las computadoras utilizan módulos de RAM basados en

4.2.4. Discos duros

Otra diferencia de la caché y de la RAM es la velocidad del almacenamiento y recuperación

 Movimiento del brazo de acceso (5.5 milisegundos)

De todas estas, solamente la última fase no es dependiente de ninguna operación mecánica.

4.2.5. Almacenamiento para respaldos fuera de línea

4.3. Conceptos básicos sobre Memoria

Nunca hay suficiente RAM.

4.3.1. La memoria virtual en términos sencillos

Este requerimiento de 15000 bytes se conoce como el espacio de direcciones de la

Un enfoque posterior conocido como solapamiento intentó aliviar el problema permitiendo

Aunque inicialmente pareciera que nuestra aplicación hipotética requiere de un total de

 La instrucción es leída desde la memoria.

Pero esto genera una pregunta:

4.3.2. Almacenamiento de respaldo — el Tenet central de

En muchos aspectos, esto es similar a la situación entre la caché y la RAM: haciendo

Con esto en mente, exploremos el proceso en más detalle.

4.4. La memoria virtual: los detalles

La palabra "virtual" en el espacio de direcciones virtuales, significa que este es el número

En el caso de nuestra aplicación de ejemplo, su espacio de direcciones virtuales es de 15000

Para implementar la memoria virtual, para el sistema es necesario tener un hardware

Tomando nuestra aplicación hipotética con un espacio de direcciones virtuales de 15000

Lo que ocurre se conoce como un fallo de página.

4.4.1. Fallos de página

En el caso de nuestra aplicación hipotética, el CPU primeramente presenta la dirección

 Encontrar dónde reside la página deseada en disco y la lee (este es usualmente el

4.4.2. El conjunto de direcciones de trabajo

El conjunto de direcciones de trabajo crece si un proceso tiene fallos de páginas. El

 Escribiendo las páginas modificadas a un área dedicada en un dispositivo de

 Las páginas de un proceso son intercambiadas (swapped)

Si esta secuencia de eventos se extiende demasiado, esto se conoce como thrashing y es un

4.5. Implicaciones de rendimiento de la

4.5.1. Escenario de rendimiento del peor caso

 RAM — Obviamente la RAM disponible es poca (de lo contrario no habría

4.5.2. Escenario de rendimiento del mejor caso

El punto a tener en mente es que el impacto en el rendimiento de la memoria virtual es

[1] Un sistema razonablemente activo siempre experimenta algún nivel de actividad de

7.4 Reemplazo de Páginas [SILB94]

En nuestra presentación, la tasa de fallos no ha sido un problema serio, ya

Si aumentamos nuestro nivel de multiprogramación, estamos

La solución está en reemplazar páginas. Si no hay ningún marco libre,