Memoria Virtual

SISTEMAS OPERATIVOS REF.
: Memoria Virtual
MEMORIA VIRTUAL
AUTOR: Ing. NICANOR CASAS EDICIÓN: BUENOS AIRES, JULIO 2006
INTRODUCCION.
Ya conocemos varias estrategias de administración de memoria, todas con el

mismo objetivo: mantener varios procesos en memoria simultáneamente para
permitir la multiprogramación. Como condición básica, se requería que estos
procesos en su totalidad se encontrasen en memoria antes de ser
ejecutados. La técnica de administración de memoria que cambia ese
concepto es el de Memoria Virtual., que es una solución para las
limitaciones físicas impuestas por los sistemas de cómputos. Este trabajo
apunta a profundizar las técnicas y cómo su implementación afecta la
performance de los sistemas, por tanto debe realizarse un seguimiento
medido de la actividad del sistema siguiendo diferentes técnicas de
medición..
El término memoria virtual se refiere a la abstracción de memoria

lógica, como es vista por el proceso y memoria física, la que ve el
procesador.
La técnica de memoria virtual permite que se ejecuten procesos que

no estén completamente alojados en memoria. La ventaja más notable es
que los programas pueden ser más grandes que la memoria física, es decir,
se separa la memoria física de la lógica, siendo ésta última, la que finalmente
ve el usuario. Esto permite a los programadores despreocuparse de esas
limitaciones. Este tipo de memoria no es fácil de implementar, y debe ser
tratada cuidadosamente para no disminuir la performance del sistema,
además de ser más lenta que los otros administradores de memoria que ya
hemos visto.
Un requerimiento básico para ejecutar una instrucción, es que ésta se

encuentre en la memoria física, un primer acercamiento es ubicar la totalidad
del espacio de direcciones lógicas en la memoria física. Esta restricción se
puede resolver mediante: los solapamientos de memoria (overlays)1 y la
carga dinámica, pero esto requiere precauciones especiales y un costo extra
a los programadores. Esta restricción limita el tamaño de un programa al
tamaño de la memoria física.
De hecho, observando varios programas reales, en muchos casos no

se necesita que todo el programa este cargado en memoria principal o física,
por ejemplo:
• Rutinas para manejar errores que rara vez ocurren, este código
se ejecuta muy pocas veces, o nunca.
• Vectores, listas y tablas que tienen asignada más memoria que

la que realmente necesitan.
• Ciertas opciones de un programa que pocas veces se usan.

1
Muy utlizada por la planilla de cálculo Lotus-1-2-3
Versión 2.0 1
SISTEMAS OPERATIVOS REF.: Memoria Virtual
MEMORIA VIRTUAL
Puede darse que se necesite todo el código de un programa, pero

quizás no se necesite al mismo tiempo. La habilidad de poder ejecutar
programas que están parcialmente en memoria tiene sus beneficios:
• Un programa no está limitado por la cantidad de memoria física

que está disponible, se pueden escribir programas para grandes espacios
de direcciones virtuales, facilitando la tarea de programación.
• Cada programa puede ocupar menos memoria física y más

programas pueden ser corridos a la vez, haciendo más eficiente el uso de
la CPU.
• Es implementada usando una memoria secundaria como

aumento de la memoria física del procesador
Memoria virtual es la separación de la memoria lógica de la memoria

física. Esto permite obtener una gran memoria para ser utilizada cuando sólo
se dispone de una pequeña memoria física, entonces el programador, sólo
debe preocuparse del problema de programación y no de la disponibilidad de
memoria. La memoria virtual ha ido desplazando el solapamiento de
memoria.
La memoria virtual se implementa generalmente sobre discos rígidos

(el área dedicada al intercambio se llama swapp space o área de intercambio
y por ejemplo es obligatorio definirla cuando instalamos Linux), es decir que
el espacio de direcciones lógicas puede ser tan grande como la capacidad de
éste. Si el intercambio entre la memoria secundaria y la memoria principal
está determinado por tamaños fijos es llamado paginación; en cambio si
tamaños variables son permitidos y el dato se puede partir en rutinas,
corrutinas o matrices se le llama segmentación. Algunos sistemas
operativos combinan ambos procedimientos a los que se le llama
segmentación paginada.
El proceso es básicamente dividir la totalidad del programa en páginas

o segmentos, de acuerdo al tipo de implementación, de los cuales solamente
estarán en memoria principal los que se precisen en ese momento,
manteniendo los demás en el disco.
Existen además algoritmos de reemplazo de estos segmentos que

deberán responder a las necesidades del programa en cada momento.
Referido a la dificultad de implementación, los algoritmos de reemplazo de
segmentos son más complejos debido a sus tamaños variables.
Los datos son transferidos, desde la memoria secundaria a la memoria

principal, cada vez que son necesarios siguiendo el método estipulado por el
algoritmo de reemplazo de páginas que se ha seleccionado de acuerdo a la
política elegida por el centro de cómputos.
2 Versión 2.0
MEMORIA VIRTUAL
¿POR QUÉ ES NECESARIA LA MEMORIA VIRTUAL?
Siempre se ha presentado un problema de relación entre el alto costo

de la memoria principal y el bajo costo de los almacenamientos secundarios.
El código del programa, los datos más la pila y la PCB, requieren estar en
memoria (de acuerdo al principio fundamental de los procesos) para ser
ejecutados, pero ésta puede no ser lo suficientemente grande para albergar
enteramente un proceso.
Para los primeros computadores, los programadores dividían los

programas en secciones para luego ser transferidos a memoria por un
período de tiempo. Cada vez que el programa lo necesitaba nuevas
secciones eran transferidas a memoria, siendo responsabilidad del
programador el manejo del intercambio (overlays). La eficiencia, entonces, de
los lenguajes de alto nivel, que permitían realizar más fácilmente programas
complejos, se veía disminuida por la problemática de los overlays.
Emergieron de este problema 2 teorías para resolver la ineficiencia del
manejo de la memoria:
• la ubicación estática
• la ubicación dinámica
La estática: asume que la relación entre la disponibilidad de memoria

y la porción del programa que la necesita puede ser predeterminada. Aplicar
esto fue muy dificultoso cuando no imposible.
La dinámica: determina que el uso de la memoria principal crece o
decrece de acuerdo a las necesidades que el programa tienen el momento de
su ejecución. Para esto hubo dos posturas: una que pugnaba por ampliar la
memoria para solucionar las necesidades del los programas, la cual no
prosperó por el alto costo de la memoria y la otra propuso la memoria
virtual.
FUNCIONAMIENTO GENERAL DE LA MEMORIA VIRTUAL

Supongamos que es tiempo de cargar un nuevo proceso en memoria
principal, el sistema operativo carga solamente algunas porciones (páginas o
segmentos), que conformarán a partir de ese momento un set residente de
porciones. El proceso se ejecuta mientras todas las referencias de memoria
pertenezcan a este set residente, el procesador mediante una tabla de
páginas o segmentos es capaz de determinar esta situación. Si éste se
encuentra con una dirección lógica que no está en memoria principal, genera
una interrupción indicando una falla de acceso a memoria. Entonces, el
sistema operativo pone el proceso interrumpido en estado de bloqueo y carga
en memoria principal la porción de proceso en la que se encuentra la
dirección lógica que causó la interrupción, para esto hace un pedido de I/O
para lectura, mientras se realiza la I/O el sistema operativo puede enviar otro
proceso a ejecutarse. Luego que la porción pedida es cargada en memoria
principal, el sistema operativo toma control otra vez de la situación poniendo
al proceso afectado en estado de listo (ready). Aquí se puede apreciar
Versión 2.0 3
MEMORIA VIRTUAL
claramente la posibilidad de la multiprogramación mediante la memoria

virtual.
Se puede ver además, que así como se cargan porciones en memoria
principal trayéndolas desde el disco, llegará un momento en que será
necesario desalojar alguna porción para permitir a alguna otra que sea
cargada. Para resolver este problema existen varios algoritmos que serán
desarrollados más adelante.
LA ESTRUCTURA DE LOS PROCESOS Y SU COMPORTAMIENTO:

El comportamiento de los procesos impacta fuertemente en los
sistemas de memoria virtual. Simulaciones realizadas muestran que durante
el tiempo de procesamiento, un proceso mostrará fases (o períodos de
pequeños cambios en el contenido de la memoria principal) alternando con
transiciones (o períodos de grandes cambios en la memoria principal). El
gráfico adjunto demuestra los efectos de un proceso durante su ejecución:
La mayor cantidad de fallos de página ocurren durante el período de

transición, siendo estos de un alto costo para el sistema. Las fases tienen un
comportamiento opuesto dado que el sistema extiende el tiempo de
procesamiento.
Paginación por Demanda:

Un sistema de paginación por demanda es similar a un sistema de
paginación con swapping. Los procesos residen en memoria secundaria (que
generalmente es un disco). Cuando se ejecuta un proceso, lo cargamos en
memoria. En lugar de traer todo el proceso, usamos un lazy swapper
(cambiador lento) el cual nunca trae una página a memoria a menos que se
la necesite. Dado que ahora estamos visualizando un proceso como una
4 Versión 2.0
MEMORIA VIRTUAL
secuencia de páginas en lugar de un gran espacio de direcciones contiguas,

el uso del término swap es técnicamente incorrecto. Un swapper manipula
procesos enteros, mientras que un paginador (pager o mapper) está
relacionado con las páginas individuales de un proceso. Usaremos, por lo
tanto, los términos pager o mapper (indistintamente), en lugar de swapper, en
conexión con la paginación por demanda.
En vez de cargar un proceso completo, el pager trae a memoria
solamente aquellas páginas necesarias. De esta forma, se evita llevar a
memoria páginas que no se usarán, reduciendo el swap time y la cantidad de
memoria física necesaria.
El mapper es la parte del sistema operativo que traduce el número de

página lógica generada por el proceso a un número de frame que se
encuentra en memoria.
Esta traducción se realiza usando una tabla indexada llamada tabla de
páginas que identifica a todas aquellas que realmente se encuentran en
memoria. Si la página no se encuentra en memoria el mapper o pager utiliza
la rutina del sistema operativo de page fault y la ejecución es suspendida
hasta que la página sea colocada en memoria.
Como se ve la función es sumamente pesada e incrementa
substancialmente el tiempo de ejecución del proceso. Con miras a la
eficiencia es necesario saber: ¿dónde está almacenada la tabla de páginas y
como es accedida?. La respuesta está en las memorias asociativas tema que
trataremos más adelante.
Versión 2.0 5
MEMORIA VIRTUAL
Con este esquema, necesitamos alguna forma de apoyo al hardware

que permita distinguir entre aquellas páginas que están memoria y aquellas
que están en disco. El esquema del bit de valid-invalid (válido - inválido) se
puede usar para este propósito. Cuando se encuentra en ‘valid’, indica que la
página asociada es legal así como también que se encuentra en memoria.
Si el bit se encuentra en ‘invalid’, este valor indica que la página no es válida
(no está en el espacio de direcciones lógicas del proceso), o es válida pero
está actualmente en disco. La entrada de la tabla de página para un página
que se trae a memoria se activa de la manera habitual, pero la entrada de la
tabla de páginas para una página que no está en memoria, se marca
simplemente como ‘invalid’, o contiene la dirección de la página en disco.
Téngase en cuenta que marcar una página como ‘invalid’ no tendría

efecto si el proceso nunca intenta acceder a esa página. Por lo tanto, si
“acertamos” y se cargan todas y solamente aquellas páginas que son
realmente necesarias, el proceso se ejecutará exactamente como si se
hubiera cargado totalmente en memoria. Mientras el proceso ejecuta una y
accede a las páginas que están residentes en memoria, la ejecución
prosigue normalmente. Pero qué sucede si el proceso trata de usar una
página que no estaba cargada en memoria? El acceso a una página
marcada como ‘invalid’ provoca un trap por error de página ( page fault ). El
hardware de paginación, al traducir la dirección a través de la tabla de
páginas, notará que el bit esta como ‘invalid’, provocando un trap al Sistema
Operativo.
Este trap es el resultado de que el Sistema Operativo no puede traer a

memoria la página deseada ( en un intento de minimizar el tiempo de
transferencia de disco y requerimientos de memoria ) en vez de un error por
dirección inválida como resultado de un intento de usar una dirección de
memoria ilegal ( como un subíndice incorrecto en un array ). Debemos
corregir este inconveniente; el procedimiento para manipular este error de
página es simple:
1) Se controla una tabla interna (generalmente almacenada con la

PCB) para este proceso, con el fin de determinar si la referencia fue un
acceso a memoria válido o inválido.
2) Si la referencia fue inválida, se termina el proceso. Si fue válida,

pero no se ha cargado esa página, se carga esta última.
3) Encontramos un marco (frame) libre (tomando uno de la lista de

marcos libres)
4) Planificamos una operación de disco para leer la página deseada

en el nuevo marco.
5) Cuando se completa la lectura, modificamos la tabla interna

almacenada con la PCB y la tabla de páginas para indicar que la página está
ahora en memoria.
6 Versión 2.0
MEMORIA VIRTUAL
6) Se recomienza la instrucción que fue interrumpida por el trap por

dirección ilegal. El proceso puede ahora acceder a la página como si siempre
hubiera estado en memoria.
Es importante darse cuenta que, debido a que se salva el estado

(registros, código de condición, contador de instrucciones) del proceso
interrumpido, cuando se produce el page fault, se puede volver a comenzar el
proceso exactamente en el mismo lugar y estado, excepto que la página
deseada está en memoria y se la puede acceder.
En el caso extremo, podríamos comenzar a ejecutar un proceso sin

páginas en memoria. Cuando el Sistema Operativo coloca el puntero de
instrucciones en la primera instrucción del proceso que es una página no
residente en memoria, el proceso inmediatamente carga la página. Después
de esto, el proceso sigue ejecutándose, realizando los traps necesarios hasta
que todas las páginas que el mismo necesita estén en memoria. En ese
punto, se puede continuar ejecutando sin más faults. Este esquema es
paginación por demanda pura: nunca traigas a memoria una página a
menos que se la requiera.
Teóricamente, algunos programas pueden acceder a varias páginas

nuevas de memoria con cada ejecución de una instrucción (una página para
la instrucción y muchas para datos) causando posiblemente muchos page
faults por instrucción. Esta situación daría como resultado un rendimiento
inaceptable del sistema. Afortunadamente, el análisis de los procesos en
ejecución muestra que este comportamiento es muy poco probable. Los
programas tienden a tener localidad de referencia, que resulta en una
performance razonable para la paginación por demanda.
El hardware para soportar la paginación por demanda es el mismo que

para paginación y swapping.
* Tabla de Páginas (PAGE TABLE): esta tabla tiene la habilidad de

marcar a una entrada como inválida, a través del bit de valid-invalid o el valor
especial de bits de protección.
* Memoria Secundaria: esta memoria almacena todas las páginas del

proceso, aún aquellas páginas que están en memoria principal. La memoria
secundaria es generalmente un disco de alta velocidad. Se la conoce como
‘swap device’ y a la sección del disco utilizada con este propósito se la
conoce como ‘SWAP SPACE’ o ‘BACKING STORE’.
Algunas limitaciones adicionales se deben imponer. Algo crucial es la

necesidad de poder recomenzar cualquier instrucción después de un page
fault. En la mayoría de los casos, este requerimiento se satisface fácilmente.
Un page fault podría ocurrir en cualquier referencia de memoria. Si ocurre en
la búsqueda de la instrucción, podemos recomenzar buscando la instrucción
nuevamente. Si ocurre mientras estamos buscando un operando, debemos
Versión 2.0 7
MEMORIA VIRTUAL
volver a buscar la instrucción, decodificarla de nuevo, y luego buscar el

operando.
Como el caso más grave, considérese una instrucción de tres

direcciones, como sumar (ADD) el contenido de A y B, colocando el
resultado en C. Los pasos para ejecutar esta instrucción serían :
1) buscar y decodificar la instrucción (ADD)
2) Buscar A
3) Buscar B
4) Sumar A y B
5) Almacenar la suma en C
Si el trap ocurre cuando tratamos de almacenar en C (porque C se

encuentra en una página que no está actualmente en memoria), tendríamos
que obtener la página deseada, traerla, corregir la tabla de páginas y
recomenzar la instrucción. Volver a empezar requeriría buscar la instrucción,
decodificarla, buscar los dos operandos y realizar la suma de nuevo. Sin
embargo, no hay realmente mucho trabajo repetido (menos de una
instrucción completa), y la repetición solamente es necesaria cuando se
produce un page fault.
El principal problema se da cuando una instrucción puede modificar

varias ubicaciones diferentes. Por ejemplo, considérese la instrucción MVC
(mover carácter) del sistema 360/370 de IBM, que puede mover hasta 256
bytes de una locación a otra (posiblemente solapeada). Si cada bloque
(fuente y destino) se encuadra en un límite de página, un page fault podría
ocurrir después de que el movimiento esté realizado parcialmente. Además si
los bloques fuente y destino solapean, el bloque fuente puede haber sido
modificado, en cuyo caso no podemos simplemente recomenzar la
instrucción.
El problema se puede solucionar de dos maneras diferentes. En una

solución, el microcódigo calcula e intenta acceder a los fines de ambos
bloques. Si fuera a ocurrir un page fault, tendrá lugar en este paso, antes de
que cualquier cosa se modifique. El movimiento puede tener lugar, dado que
sabemos que ningún page fault puede ocurrir, ya que todas las páginas
relevantes están en memoria. La otra solución usa registros temporarios
para almacenar los valores de las locaciones sobrescritas. Si hay un page
fault, los ‘viejos’ valores se vuelven a escribir en memoria antes que se
produzca el trap. Esta acción restaura a la memoria con el estado que tenía
antes de que la instrucción comenzara, para que la misma se pueda repetir.
Un problema similar tiene lugar en las máquinas que usan modos
especiales de direccionamiento, incluyendo los modos de autoincremento y
autodecremento (por ejemplo, el PDP-11). Estos modos de direccionamiento
8 Versión 2.0
MEMORIA VIRTUAL
utilizan un registro como puntero y automáticamente decrementan o

incrementan el registro. Se decrementa el registro antes de usar su contenido
como la dirección del operando. Se incrementa al registro después de usar su
contenido como la dirección del operando. Esto lo podemos realacionar,
como ejemplo al registro CX que se auodecrementa cuando lo utilizamos con
la sentencia LOOP.
De esta manera, la instrucción MOV (R2), (R3), copia el contenido de
la ubicación apuntada por el registro 2 en la ubicación apuntada por el
registro 3. El registro 2 se incrementa (en 2 para una palabra, dado que el
PDP-11 es una computadora direccionable de a un byte) después que se usa
como puntero; el registro 3 se decrementa en dos antes de ser utilizado como
puntero. Ahora, considérese que sucedería si se produce un page fault al
tratar de almacenar en la ubicación apuntada por el registro 3. Para
recomenzar la instrucción, debemos resetear los dos registros con los valores
que tenían antes de que comenzara la ejecución de la instrucción. Una
solución es crear un nuevo registro de estado especial para guardar el
número de registro y la cantidad modificada para cualquier registro que se
haya cambiado durante la ejecución de una instrucción. Este registro de
estado le permite al Sistema Operativo ‘deshacer’ los efectos de una
instrucción parcialmente ejecutada que produce un page fault.
Estas no son de ninguna manera los únicos problemas que resultan de
agregar la paginación a una arquitectura existente, para poder permitir la
paginación por demanda. La paginación se agrega entre la CPU y la memoria
en un sistema de computación. Debería ser totalmente transparente para el
proceso del usuario. De esta manera, la gente asume que la paginación se
podría agregar a cualquier sistema. Aunque esta suposición es verdadera
para un ambiente de paginación que no sea por demanda, donde un page
fault representa un error fatal, no es verdad en el caso en que un page fault
signifique solamente que una página adicional se deba cargar en memoria y
se deba recomenzar el proceso.
LA CONVERSION DE DIRECCION LOGICA A FISICA.

Si queremos hacer ejecutar la siguiente instrucción:
MOVER REGISTRO,100 (Copia el contenido de la dirección
100 al registro) es necesario que la CPU genere las direcciones
correspondientes las que se pueden realizar mediante: índices, registros
base, registros segmentos, otras formas.
En las computadoras que no tienen Memoria Virtual las direcciones se
conectan en forma directa dentro del bus de direcciones, lo que permite que
se pueda leer/escribir en la palabra de la memoria física que tenga la misma
dirección. Al usarse Memoria Virtual las direcciones pasan a una unidad de
administración de memoria (MMU - MEMORY MANAGMENT UNIT) que está
formada por un chip o un conjunto de chips que asocian las direcciones
virtuales con las direcciones de memoria física.
Versión 2.0 9
MEMORIA VIRTUAL
Veamos como funciona:

EJERCICIO: Tenemos una PC que puede generar direcciones de 16
bits. Sin embargo nuestra computadora tiene sólo 32k de memoria física. Si
tenemos un programa de 64k este no se podría ejecutar en esta PC si se
quisiera cargarlo completamente. Por tanto, debemos tener una copia
completa del programa de 64k en el disco. Como las páginas y los frames
deben tener exactamente el mismo tamaño vamos a suponer que en este
ejercicio tienen 4k. (TAN92).
SOLUCION:
Si el programa tiene 64k y las páginas 4k habrá 64k / 4k = 16 páginas.
Si la memoria tiene 32k y los frames 4k habrá 32k / 4k = 8 frames.
Si queremos realizar la siguiente instrucción MOVER REGISTRO, 01 la
dirección virtual 01 se envía a la MMU la cual detecta que se encuentra en la
pagina 0 de nuestro programa. Veamos el gráfico correspondiente.
P ro ce so M e m o ria C e n tral
D ire c. D ire c.
L ógica F ram e P /A F ram e F ísic a
00-04 2 1 3 00-04
04-08 1 1 1 04-08
08-12 6 1 0 08-12
12-16 0 1 5 12-16
16-20 4 1 4 16-20
20-24 3 1 4 20-24
24-28 0 0 2 24-28
28-32 0 0 1 28-32
32-36 0 0
36-40 5 1
40-44 0 0
44-48 7 1
48-52 0 0
52-56 0 0
56-60 0 0
60-64 0 0
10 Versión 2.0
MEMORIA VIRTUAL
P ág in a O ffse t
D ir. V irtu al d e
0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0
e n trad a 8 1 9 6
2 1
1 1
6 1 110
0 1
4 1
3 1
0 0
0 0
0 0
5 1
0 0
7 1
0 0
0 0
0 0
0 0
D ir. V irtu al d e
1 1 0 0 0 0 0 0 0 0 0 0 1 0 0
salid a 2 4 5 8 0
LA MEMORIA ASOCIATIVA Y LA TABLA DE PAGINAS.

Como se implementa la tabla de páginas es vital para la eficiencia de
la técnica de Memoria Virtual porque para cada referencia se debe incluir la
misma en la tabla de páginas. El mecanismo de traducción es bastante lento
porque se necesitan 3 tres accesos:
1. Al directorio de páginas.
2. A la tabla de páginas.
3. Efectuar la lectura o escritura solicitada.
Por otra parte se debe sumar la base más el desplazamiento para
realizar la conversión de una dirección lineal a física.
La mejor solución es un juego de registros dedicados para analizar los
agujeros que se encuentran en las páginas, pero el método es impracticable
para tablas grandes por ser sumamente caro.
Pero guardar una página en la memoria principal causaría insufribles
demoras porque tan solo un acceso realiza una depresión del 100 % y una
tabla grande realiza más de un acceso. La solución es utilizar memorias
rápidas formadas por registros asociativos o TLB (TRANSLATION
LOOKASIDE BUFFERS) las cuales son llamadas también memorias
asociativas.
Cada uno contiene una clave y un valor. Las claves pueden ser
comparadas simultáneamente. Si es encontrada, el valor correspondiente
representa la dirección física de la página lógica y el código de acceso que
indica la presencia en memoria. Esto explicado de manera simple, ahora
veremos el funcionamiento con más detalle.
La TLB guarda las direcciones lineales de las últimas 32 entradas.
La CPU consulta a la TLB cada vez que necesita un acceso a
memoria. Si la dirección fue utilizada se tardarán alrededor de 2
Versión 2.0 11
MEMORIA VIRTUAL
nanosegundos (tal vez menos) para realizar la operación de transferencia,

pero si no se encuentra debemos realizar los tres pasos indicados
anteriormente más los siguientes:
1. Carga de la nueva dirección obtenida en la TLB.
2. Consulta nuevamente de la TLB.
Estructura y funcionamiento
Cada entrada a la TLB corresponde a una página del proceso
accedida, por lo tanto tendremos direcciones a 32 páginas de 4KB cada una
lo que nos da 128KB de memoria, lo que se supone que es suficiente para
contener el área de trabajo de un proceso, sin tener que modificar la TLB.
Las 32 entradas están organizadas en 4 grupos de 8 entradas cada
una que operan en paralelo. La gran velocidad que alcanza por el método de
acceso, que es por contenido. Estas memorias se llaman CAM (CONTENT
ACCESS MEMORY – Memoria de acceso por contenido). Cada entrada en
una CAM se compone de una etiqueta y un dato asociado.
Para encontrar un valor, este se compara con los campos de etiqueta
de todas las posiciones. En caso que el circuito detecte el dato, ÉXITO (HIT),
el dato asociado se coloca en la salida. La entrada es la dirección lineal y la
salida es la dirección física correspondiente.
Los bits 12, 13 y 14 de la dirección lineal se selecciona permiten
seleccionar uno de los cuatro grupos de la TLB.
Estas entradas constan de 20 bits definidas de la siguiente manera:
a. 13 bits de más peso de la dirección lineal
b. 1 bit de validez. Si contiene un 1 lógico la entrada es válida,
en caso contrario los valores que se encuentran en la
entrada no nos sirven.
c. 1 bit D (DIRTY – sucio) Indica que la página fue modificada
d. 1 bit U (USED – usada) Indica que es una página usada y
que puede ser accedida por el nivel 3. De otro modo es una
página accedida sólo por el supervisor.
e. 1 bit W (WRITABLE – escribible – modificable) Si el bit
tiene un 1 lógico indica que la página permite realizar
escrituras o modificaciones.
Bien, una vez seleccionadas las mismas se comparan con los bits 15 a
31 de la dirección lineal. Si alguno de los 4 comparadores grita “BINGO” la
CPU toma los 20 bits de más peso de la dirección física se carga en las
líneas 12 a 31 del bus de direcciones. Posteriormente agrega los 12 bits de
menor peso (desplazamiento) de la dirección lineal y los coloca en los bits 0 a
11 del mismo bus con lo que logramos la dirección física completa.
Ahora se nos presenta un problema. El 386 no chequea el cambio de
contexto por lo tanto hay que borrarla, previo guardarla en algún lado y cargar
las otras.
Otro problema es que INTEL delega toda la responsabilidad al que
confecciona el sistema operativo, ya que en los futuros procesadores el
método puede ser cambiado totalmente y sin previo aviso.
12 Versión 2.0
MEMORIA VIRTUAL
El uso de la TLB es transparente para los programadores, aunque si

queremos saber que es lo que contiene podemos utilizar los registros TR6 y
TR7 podemos realizar un debug del contenido de la TLB.
La figura muestra el trabajo del mapper con las memorias asociativas:
CPU M E M O R IA PR IN C IP AL
f ram e s
f ra
m
e
+
x
c ó d ig o
acc e so
p ag. p ag .
ló g ic a física
clav e v alo r
T ab la d e p ág in as
LA TABLA DE PÁGINAS
En ella se encuentran una serie de campos que tiene real importancia
y que son tomados por los diferentes algoritmos para poder llevar a cabo su
función.
Cada dirección en el sistema está asociado con la tabla de paginas y
el mapa del disco. Cada una de ellas describe un espacio entero de
direcciones.
Vamos a especificar cuales son las funciones de los campos que
presentamos. Aclaremos que hay otros campos pero que no son relevantes
para nosotros.
• FRAME: Indica la dirección en la cual esta almacenada la
página en la memoria principal.
• BIT de PRESENCIA/AUSENCIA: Es también llamado valid-
invalid. Indica si la página se encuentra en memoria. En caso de que no esté
se producirá un page fault.
• BIT de MODIFICACION: Indica si la página a sido modificada o
no. Tengamos en consideración de que la pagina puede contener variables
que pueden ser modificadas a lo largo del proceso. Si ello ocurriera y esa
página fue seleccionada como víctima entonces el primer paso será grabar
en el disco la página víctima y luego traer la solicitada por el proceso.
• BIT de REFERENCIA: Indica si la página fue usada o llamada

más de una vez. Cuando la página es llevada a memoria el bit se pone en
uno. Cada algoritmo realiza un tratamiento diferente con este bit. Algunos no
lo toman en cuenta.
Versión 2.0 13
MEMORIA VIRTUAL
• BIT de PROTECCION: También llamado bit de permisos.

Indica si la página puede ser leída solamente o leída y escrita. Si fuese
escrita esto llevaría a que el bit de modificación se pusiera en ON.
• CACHING: Indica la ubicación de esa página en el disco. En

los grandes computadores pueden utilizarse mas de una unidad de disco
para administrar la Memoria Virtual.
• DATE TIME STAMP: Indica la fecha y hora en que la página

fue cargada a memoria.
• BIT de COPIA por ESCRITURA: Destinado a marcar páginas

que son utilizadas por más de un proceso
14 Versión 2.0
MEMORIA VIRTUAL
PERFORMANCE DE LA PÁGINACIÓN POR DEMANDA

La paginación por demanda puede tener un efecto significativo en el
rendimiento de un sistema de computación. Para ver por qué, calculemos el
tiempo de acceso efectivo (EFFECTIVE ACCESS TIME ) para una memoria
paginada por demanda. El tiempo de acceso a memoria, para la mayoría de
las computadoras varía de 10 a 200 nanosegundos. Siempre que no
tengamos page faults, el tiempo de acceso efectivo es igual al de
acceso a memoria. Si, por el contrario, se produce un page fault, debemos
leer primero la página relevante del disco y luego acceder a la palabra
deseada.
Sea p la probabilidad de un page fault (0 <= p <= 1). Desearíamos que

p sea cercana a cero; es decir, que haya unos pocos page faults. El tiempo
de acceso efectivo es entonces:
Tiempo de Acceso Efectivo = ( 1 - p ) . ma + p . tiempo de page fault
Siendo ma = Tiempo de acceso a memoria.
Para calcular el tiempo de acceso efectivo, debemos conocer cuanto

tiempo se necesita para un page fault. Un page fault produce la siguiente
secuencia:
1) Un trap al Sistema Operativo
2) Salvar los registros del usuario y el estado del proceso. (context

switch)
3) Determinar que la interrupción fue un page fault.
4) Controlar que la referencia de página haya sido legal y determinar la

ubicación de la página en el disco.
5) Hacer una lectura desde disco hacia el marco libre.
a) Esperar en la cola de este dispositivo hasta que se le de servicio al

pedido de lectura.
b) Esperar el tiempo de búsqueda y/o latencia del dispositivo.
c) Comenzar la transferencia de la página hacia un marco libre.
6) Mientras se espera, asignarle a la CPU algún otro usuario (CPU

SCHEDULING; opcional)
(CONTEXT SWITCH)
7) Interrupción de disco (E/S completada)
Versión 2.0 15
MEMORIA VIRTUAL
8) Salvar los registros y el estado del proceso para el otro usuario. (si
el paso seis se ejecutó)
9) Determinar que la interrupción fue del disco
10) Corregir la tabla de páginas y otras tablas para mostrar que la

página deseada está ahora en memoria.
11) Esperar se le asigne de nuevo a este proceso la CPU.
12) Restaurar los registros de usuario, estado del proceso, la nueva

tabla de páginas, convertir la dirección de memoria lógica en dirección de
memoria física y luego volver a la instrucción interrumpida.
No todos estos pasos pueden ser necesarios en todos los casos. Por
ejemplo estamos asumiendo que, en el paso 6, se le asigna otro proceso a la
CPU, mientras se produce la E/S. Este arreglo permite la multiprogramación
para mantener la utilización de la CPU, pero requiere tiempo adicional para
reanudar la rutina de servicio al page fault cuando la transferencia de E/S se
completa.
En cualquier caso, nos encontramos con los tres componentes
principales del tiempo de servicio al page fault.
1) Dar servicio a la interrupción por page fault
2) Leer la página.
3) Recomenzar el proceso.
La primera y tercera tarea se pueden reducir con una codificación

cuidadosa a varios cientos de instrucciones. Estas tareas pueden llevar de 1
a 100 microsegundos cada una. El tiempo de cambio de página, por otra
parte, estará probablemente cerca de los 24 milisegundos. Un disco rígido
típico tiene una latencia promedio de 8 milisegundos, tiempo de búsqueda de
15 milisegundos y un tiempo de transferencia de 1 milisegundo. Así, el tiempo
total de paginación estaría alrededor de los 25 milisegundos, incluyendo el
tiempo del hardware y del software. Recuérdese también que estamos
mirando solamente el tiempo de servicio del dispositivo. Si una cola de
procesos está esperando al dispositivo (otros procesos que han producido
page faults) tenemos que sumar el device QUEUEING TIME mientras
esperamos que el dispositivo de paginación se libere para dar servicio a
nuestro pedido, aumentando el swap time aún más. Si tomamos un tiempo de
servicio al page fault promedio de 25 milisegundos y un tiempo de acceso a
memoria de 100 nanosegundos, entonces el tiempo de acceso efectivo será :
Tiempo de Acceso Efectivo = (1 - p ) . 100 nanosegundos + p . ( 25

MS ) =
= (1 - p ) . 100 + p . 25000000 nanosegundos =
16 Versión 2.0
MEMORIA VIRTUAL
= 100 - 100 p + 25000000 p
= 100 + 24999900 p
Podemos ver entonces que el tiempo de acceso efectivo es

directamente proporcional a la tasa de page fault (p). Si un acceso de 1000
produce un page fault , el tiempo de acceso efectivo es de 25 microsegundos.
La computadora se vería demorada por un factor de 250 debido a la
paginación por demanda. Si queremos una degradación menor al 10 por
ciento, necesitamos :
110 > 100 + 25000000 . p
10 > 25000000 . p
p < 0.0000004
Es decir, para mantener la demora debida a la paginación por

demanda en un nivel razonable, podemos permitir un acceso de 2500000
para page fault. Es importante mantener la tasa de page fault baja en un
sistema con paginación por demanda. Caso contrario, el tiempo de acceso
efectivo aumenta, demorando dramáticamente la ejecución de los procesos.
Un aspecto adicional de la paginación por demanda es la manipulación

y el uso general del swap space. La E/S de disco en el swap space es
generalmente más rápida que las del File System. Es más rápida porque el
swap space se ubica en bloques muchos más grandes y las consultas de
archivos (FILE LOOKUPS) y los métodos de asignación indirecta no se
usan. Es posible, por lo tanto, que el sistema obtenga una mejor respuesta de
paginación copiando una imagen del archivo entero en el swap space cuando
el proceso comienza, y luego realizar la paginación por demanda desde el
swap space. Los sistemas con swap space limitado pueden emplear un
esquema diferente cuando se utilizan archivos binarios. Las páginas de
demanda para tales archivos se cargan directamente del file system. Sin
embargo, cuando se efectúa el reemplazo de la página, las mismas se
pueden sobrescribir (porque nunca se modifican) y pueden volver a ser
cargadas por el sistema nuevamente si es necesario. Sin embargo, otra
opción es inicialmente demandar páginas del file system, pero escribirlas en
el swap space cuando son reemplazadas. Este enfoque asegurará que
solamente las páginas necesarias se leerán del file system, pero toda la
paginación subsecuente se hace desde el swap space. Este método parece
ser un buen compromiso; se usa en el BSD UNIX.
REEMPLAZO DE PÁGINAS
En la presentación anterior, la tasa de ocurrencia de fallos de página
no representa un problema serio, puesto que se falla cada página como
máximo una vez, cuando ésta se referencia por primera vez. Esta
representación no es tan exacta. Considere que si un proceso de 10 páginas
solo usa la mitad de ellas, la paginación por demanda realiza la E/S
Versión 2.0 17
MEMORIA VIRTUAL
necesaria para cargar las cinco páginas que nunca se usarán. De esta forma,
si tenemos 40 frames, ejecutaríamos ocho procesos, en lugar de los cuatro
que se ejecutarían si cada uno requiriese 10 frames (cinco de los cuales
nunca se usarán).
Si aumentamos el grado de multiprogramación, estamos sobre-

asignando memoria. Si ejecutamos seis procesos, cada uno de un tamaño de
10 páginas, pero que solo usan cinco, tenemos utilización de CPU y
rendimiento más altos, con 10 frames para ahorrar. Sin embargo, es posible
que cada uno de estos procesos, para un grupo de datos particular, intenten
usar sus 10 páginas, para lo que se necesitarían 60 frames, cuando solo hay
40 disponibles. Si bien esta situación puede resultar desagradable, deja de
serlo a medida que incrementamos el nivel de multiprogramación, de modo
que el uso de memoria intermedia se acerque al de la memoria física
disponible. (En el ejemplo, ¿por qué detenernos en un nivel de
multiprogramación 6, si podemos alcanzar un nivel 7 u 8?).
La sobre-asignación aparecerá de la siguiente manera. Mientras se
ejecuta un proceso de usuario, ocurre un fallo de página. El hardware deriva
al sistema operativo, el cual chequea sus tablas internas para verificar que se
trata de un fallo de página y no de un acceso ilegal de memoria. El sistema
operativo determina en que parte del disco está la página deseada, pero si
descubre que no hay frames libres en la lista de frames libres; toda la
memoria está ocupada.
En este punto, el sistema operativo tiene varias opciones. Podría
terminar el proceso de usuario. Sin embargo, la paginación por demanda es
algo que el sistema operativo hace para mejorar la utilización del sistema y el
rendimiento. Los usuarios pueden no estar enterados de que sus procesos se
ejecutan en un sistema de páginas. La paginación sería lógicamente
transparente para el usuario. Por esto, esta no es la mejor opción.
Podríamos sacar de memoria un proceso, dejando libres sus frames,
reduciendo el nivel de multiprogramación. Algunas veces esta opción es
buena, pero primero discutiremos una posibilidad más concreta: el reemplazo
de páginas.
El reemplazo de páginas toma el siguiente enfoque. Si no hay frames
libres, buscamos uno fuera de uso y lo liberamos. Podemos liberar un frame
copiando su contenido al espacio de intercambio (swap space) y modificando
la tabla de páginas (y las demás tablas) para indicar que la página ya no está
en memoria. El frame que liberamos puede contener ahora la página
solicitada por el proceso que originó el fallo. La rutina del servicio de fallo de
página es la siguiente:
1. Encontrar la ubicación de la página deseada en el disco.

2. Encontrar un frame libre
a. Si hay un frame libre, usarlo.
b. Por el contrario, usar un algoritmo de reemplazo de páginas para
elegir un frame a liberar.
c. Copiar la página a sacar de la memoria en el disco y modificar las
tablas de páginas y de frames.
18 Versión 2.0
MEMORIA VIRTUAL
3. Asignar la página deseada al frame libre y modificar las tablas de

páginas y de frames.
4. Recomenzar el proceso de usuario.
Nótese que, si no hay frame libre, pueda ser que se requieran dos
transferencias de página (una hacia afuera y una hacia adentro). Esta
situación duplica el tiempo del servicio de fallo de página e incrementa el
tiempo efectivo de acceso.
Esto puede reducirse con el uso de un bit de modificación. Cada
página o frame puede tener un bit de modificación asociado con él en el
hardware. El bit de modificación se pone en 1 siempre y cuando se escriba
una palabra o byte dentro de la página asociada al bit, indicando que esta se
modificó. Cuando elegimos una página para reemplazar, examinamos su bit
de modificación. Si el bit está en 1, sabemos que se modificó la página desde
que se la leyó del disco. En este caso, debemos copiar esta página en el
disco. Sin embargo, si el bit de modificación no está en 1, no se modificó la
página desde que se la atribuyó a la memoria no es necesario copiarla al
disco porque es igual a la que está allí. También se aplica esta técnica para
las páginas de solo lectura (por ejemplo, páginas de código binario). Estas
páginas no se pueden modificar; de esta manera, deben descartarse cuando
así se desea. Este esquema puede reducir significativamente el tiempo para
atender un fallo de página, dado que disminuye el tiempo de E/S en la mitad
si no se modificó la página.
El reemplazo de páginas es fundamental para la paginación por
demanda. Completa la separación entre memoria lógica y memoria física.
Con este mecanismo, se provee de una gran memoria virtual a
programadores con una pequeña memoria física. Con la paginación que no
es por demanda, las direcciones del usuario se transforman en direcciones
físicas, lo que permite que los dos grupos de direcciones sean bastante
diferentes. Sin embargo, todas las páginas de un proceso deben residir en la
memoria física. Con la paginación por demanda, el tamaño del rango de
direcciones lógicas ya no depende de la memoria física. Si tenemos un
proceso de usuario de 20 páginas, podemos ejecutarlo en una cantidad
menor de frames usando simplemente paginación por demanda y un
algoritmo de reemplazo de páginas para buscar un frame libre cuando sea
necesario. Si se debe reemplazar la página que se modificó, su contenido se
copia al disco. Una posterior referencia a esa página puede causar un fallo de
página. En este momento, la página volverá a la memoria, quizás
reemplazando alguna otra página en el proceso.
Para implementar paginación por demanda debemos resolver dos
problemas fundamentales: debemos desarrollar un algoritmo de asignación
de frames y un algoritmo de reemplazo de páginas. Si tenemos múltiples
procesos en memoria, debemos decidir cuántos frames se asignan a cada
proceso. Además, cuando se requiere un reemplazo de página, debemos
elegir los frames a reemplazar. Diseñar algoritmos apropiados para resolver
estos problemas es una tarea importante, dado el alto costo de las E/S de
disco. Aún sutiles mejoras en los métodos de paginación por demanda
derivan en grandes beneficios en el rendimiento del sistema.
Versión 2.0 19
MEMORIA VIRTUAL
ALGORITMOS DE REEMPLAZO DE PÁGINAS

Hay muchos algoritmos diferentes para el reemplazo de páginas.
Probablemente cada sistema operativo tenga su propio esquema único de
reemplazo de páginas. ¿Cómo elegimos un algoritmo particular? En general,
deseamos el que tenga menor tasa de probabilidad de ocurrencia de fallos de
página.
Evaluamos un algoritmo ejecutándolo en un flujo particular de
referencias de memoria y calculando el número de fallos. El flujo o cadena de
referencias a memoria se llama “Cadena de referencia”. Podemos generar
cadenas de referencias artificialmente (por ejemplo, con un generador de
números al azar) o siguiendo un sistema dado y registrando la dirección de
cada referencia a memoria. La última opción produce una gran cantidad de
datos ( En el orden de 1 millón de direcciones por segundo). Para reducir la
cantidad de datos, tenemos en cuenta dos cosas.
Primero, para un determinado tamaño de página (y el tamaño de

página lo fija generalmente el hardware), debemos considerar solo el número
de página, no la dirección completa.
Segundo, si tenemos una referencia a la página p, cualquier
referencia inmediatamente posterior a la misma página no causará un fallo.
La página p estará en memoria después de la primera referencia; las
referencias inmediatas siguientes no fallarán.
Por ejemplo, si seguimos un proceso particular, podríamos registrar la
siguiente secuencia de direcciones:,
0100, 0432, 0101, 0612, 0102, 0103, 0104, 0101, 0611, 0102, 0103,
0104, 0101, 0610, 0102, 0103, 0104, 0101, 0609, 0102, 0105, la cual, a 100
bytes por página, se reduce a la siguiente cadena de referencias: (debemos
dividir cada petición por 100 lo que nos dará el número de página siendo el
resto el offset -desplazamiento- dentro de esa página)
1, 4, 1, 6, 1, 6, 1, 6, 1, 6, 1.
Para determinar el número de fallos de página para una cadena de

referencias particular y el algoritmo de reemplazo de páginas, también
necesitamos saber el número de frames disponibles. Obviamente, a medida
que el número de frames disponibles aumenta, el número de fallos
disminuirá. Para la cadena de referencias expuesta anteriormente, por
ejemplo, si tenemos 3 o más frames, tendríamos solo 3 fallos, una falla por
cada primera referencia a cada página. Por otro lado, con un solo frame
disponible, tendríamos un reemplazo. A medida que el número de frames
aumenta, el número de fallos de página desciende a un mínimo nivel. Por
supuesto, agregar memoria física incrementa el número de frames.
Para ilustrar los algoritmos de reemplazo de páginas, usaremos la
cadena de referencia:
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1, para una memoria
con 3 frames libres.
20 Versión 2.0
MEMORIA VIRTUAL
Algoritmo FIFO
El algoritmo más simple de reemplazo de página es el FIFO (primero
entrado, primero salido). El algoritmo FIFO asocia a cada página la hora en
que se la introdujo en la memoria. Cuando se debe sacar una página, se
elige la más “vieja”. Nótese que no es sumamente necesario registrar la hora
en que la página se introdujo en la memoria. Podemos crear una cola FIFO
para mantener todas las páginas en memoria. Reemplazamos la página que
está en la cabecera de la cola. Cuando la página se lleva a la memoria, la
insertamos en el fondo de la cola.
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 0 1 2 2 3 0 4 2 3 0 0 0 1 2 2 2 7 0 1
7 0 1 1 2 3 0 4 2 3 3 3 0 1 1 1 2 7 0
7 0 0 1 2 3 0 4 2 2 2 3 0 0 0 1 2 7
P P P P P P P P P P P P P P P
F F F F F F F F F F F F F F F
En la cadena de referencias del ejemplo, los 3 frames están

inicialmente vacíos. Las 3 primeras referencias (7, 0, 1) causan fallos de
página y se introducen en estos 3 frames. La próxima referencia (2)
reemplaza la página 7, porque ésta fue la primera en entrar lo que produce
un nuevo page fault. Como 0 es la próxima referencia y ya está en memoria,
no hay fallo. La primera referencia a 3 produce el reemplazo de las página
que están en memoria (0, 1, y 2). Este reemplazo indica que la próxima
referencia, a 0, fallará. Entonces, se reemplaza la página 1 por la 0; y así
continúa el proceso. Lo que determina 15 fallos.
Otra forma de presentar el cuadro es a través de su posición en
memoria, es decir, el lugar que ocupa en la memoria cuando la página es
ingresada.
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7 2 2 2 2 4 4 4 0 0 0 0 0 0 0 7 7 7
0 0 0 0 3 3 3 2 2 2 2 2 1 1 1 1 1 0 0
1 1 1 1 0 0 0 3 3 3 3 3 2 2 2 2 2 1
PF PF PF PF PF PF PF PF PF PF PF PF PF PF PF
El algoritmo FIFO es fácil de entender y de programar. Sin embargo,

su rendimiento no siempre es bueno. La página a reemplazar puede estar en
un módulo de inicialización que se usó hace mucho tiempo y ya no es
necesaria. Por otro lado, podría contener una variable de uso importante que
se inicializó prematuramente y está en uso constante.
Nótese que, aún si elegimos para reemplazar una página que se usa
activamente, todo continúa trabajando correctamente. Después de sacar esa
página activa e insertar otra en su lugar, un fallo ocurrirá inmediatamente
para recuperar la página activa. Se sacará alguna otra página para llevar la
activa a la memoria. Así, una mala elección de reemplazo aumenta la
probabilidad de ocurrencia de fallos de página y demora la ejecución del
proceso, pero no ocasiona una ejecución incorrecta.
Versión 2.0 21
MEMORIA VIRTUAL
Para ilustrar el posible problema con el algoritmo FIFO, consideremos

la cadena de referencias:
11 02 66 21 11 02 09 11 02 66 21 09 total
11 02 66 21 11 02 09 09 09 66 21 21
11 02 66 21 11 02 02 02 09 66 66
11 02 66 21 11 11 11 02 09 09
PF PF PF PF PF PF PF PF PF 9
11 02 66 21 11 02 09 11 02 66 21 09 total
11 02 66 21 21 21 09 11 02 66 21 09
11 02 66 66 66 21 09 11 02 66 21
11 02 02 02 66 21 09 11 02 66
11 11 11 02 66 21 09 11 02
PF PF PF PF PF PF PF PF PF PF 10
Los cuadros muestran la relación entre los fallos de páginas versus el

número de frames disponibles. Nótese que el número de fallos para 4 frames
(10) es mayor que el de para 3 frames (9). Este resultado es por mucho
inesperado y se conoce como ANOMALÍA de BELADY. La Anomalía de
Belady refleja que, para algunos algoritmos de reemplazo de páginas, la
probabilidad de ocurrencia de fallos aumenta a medida que aumenta el
número de frames disponibles. Se creía que dando más memoria a un
proceso se mejoraría su rendimiento. En algunas recientes investigaciones,
los investigadores notaron que esta suposición no siempre es verdad.
Algoritmo óptimo (OPT ó MIN)

Un resultado del descubrimiento de la anomalía de Belady fue la
búsqueda de un algoritmo de reemplazo de páginas óptimo. Un algoritmo
óptimo tiene la menor probabilidad de ocurrencia de fallos de página entre
todos los algoritmos. Un algoritmo óptimo nunca padecerá la anomalía de
Belady. Un algoritmo óptimo de reemplazo de páginas existe, y se denomina
OPT o MIN.
Es sencillo. Reemplazar la página que no se usará por el mayor
período de tiempo. El uso de este algoritmo garantiza la menor tasa de
ocurrencia de fallos de página para un número determinado de frames.
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 0 1 2 2 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 0 1 1 2 3 3 4 2 3 0 3 2 1 2 0 0 7 0
7 0 0 0 2 2 3 4 2 2 0 0 0 1 2 1 2 7
PF PF PF PF PF PF PF PF PF
Por ejemplo, en nuestro modelo de cadena de referencias el algoritmo

óptimo produciría nueve fallos. Las primeras tres referencias causan fallos
que llenan los tres frames vacíos. La referencia a la página 2 reemplaza a la
7, porque ésta no se usará hasta la referencia 18, y en cambio la página se
usará en la referencia 5, y la 1 en la referencia 14. La referencia a la página 3
22 Versión 2.0
MEMORIA VIRTUAL
reemplaza a la 1, porque la 1 será la última de las tres páginas que están en

memoria en ser referenciadas nuevamente por la cadena. Con sólo 9 fallos,
el algoritmo óptimo es mucho mejor que el FIFO, que ocasionaba 15. (Si
ignoramos los primeros tres fallos, que todos los algoritmos tendrán, el
reemplazo óptimo es doblemente mejor que el FIFO. En efecto, ningún
algoritmo de reemplazo de páginas puede ejecutar esta cadena de
referencias con tres frames con menos de 9 fallos.
Lamentablemente, el algoritmo óptimo de reemplazo de páginas es
difícil de implementar, porque requiere un conocimiento futuro de la cadena
de referencias. (Algo similar ocurre con el algoritmo de planificación SJF). Por
esto, el algoritmo óptimo se usa principalmente para estudios comparativos.
por ejemplo, puede ser muy provechoso saber que, aunque un nuevo
algoritmo no sea óptimo, está al menos dentro del 12.3% de lo óptimo y
dentro del 4.7% del término medio.
Algoritmo LRU (Least Recently Used)

Si el algoritmo óptimo no es posible, tal vez lo sea una aproximación.
La clave distintiva entre los algoritmos FIFO y OPT, es que el algoritmo FIFO
usa el tiempo de cuando se trae una página a la memoria; el algoritmo OPT
usa el tiempo de cuando una página se va a usar. Si usamos el pasado
reciente como una aproximación del futuro cercano, entonces
reemplazaremos la página que no se ha usado por el período de tiempo más
largo. Este acercamiento es el algoritmo de la página usada menos
recientemente (LRU).
El reemplazo LRU asocia a cada página el tiempo de su última
utilización. Cuando se debe reemplazar una página , el LRU elige aquella que
no ha sido usada por el período de tiempo más largo. Esta estrategia es el
algoritmo óptimo de reemplazo de página mirando hacia atrás en el tiempo en
vez de prever.
El resultado de aplicar el algoritmo LRU al string de referencia es el
siguiente:
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0
7 0 1 2 2 3 0 4 2 2 0 3 3 1 2 0 1 7
PF PF PF PF PF PF PF PF PF PF PF PF
El algoritmo produce 12 fallos, las primeras 5 son las mismas que con
el reemplazo óptimo. Cuando ocurre la llamada a la página 4 , sin embargo,
el LRU ve que ,de los tres marcos en memoria ,la página 2 fue usada menos
recientemente. La más recientemente usada es la 0 y justo después la página
3. De esta manera el LRU reemplaza la página 2 sin saber que va a ser
usada después. Cuando falla por la página 2, el LRU reemplaza la página 3 ,
porque de las tres página en memoria {0 3 4} la 3 e la usada menos
recientemente.
Versión 2.0 23
MEMORIA VIRTUAL
A pesar de estos problemas el reemplazo LRU con 12 fallos es

todavía mucho mejor que el FIFO con 15.
• La política LRU se usa generalmente como un algoritmo de

reemplazo de página y es considerada bastante buena. El mayor problema
es cómo implementarlo. Puede requerir asistencia de hardware. El
problema es determinar un orden para los marcos definidos para el tiempo
de su último uso. Hay dos implementaciones posibles:
• Contadores: En el caso más simple, asociamos con cada

entrada a la tabla de páginas un campo de tiempo de uso y se agrega a la
CPU un reloj lógico o contador. El reloj se incrementa con cada referencia
a memoria. Cuando se hace referencia a una página los contenidos del
registro reloj se copian al campo de tiempo de uso en la tabla de páginas
para esa página. De esta forma siempre se tiene el tiempo de la última
referencia a cada página. Se reemplaza la página con el menor valor de
tiempo. Esto necesita una búsqueda en la tabla de páginas para encontrar
la LRU y una escritura de memoria (del campo de tiempo en la tabla)para
cada acceso a memoria. Los tiempos se deben mantener cuando se
cambian las tablas de páginas. Se debe considerar el overflow del reloj.
• Pilas: Otro acercamiento para implementar el algoritmo LRU e
mantener una pila con los números de página. Cuando se necesita una
página, se remueve de la pila y se coloca en el tope. Así el tope de la pila
es la página usada más recientemente y el final es la LRU. Como las
entradas se deben remover de la mitad de la pila, se implementa mejor con
una lista doblemente enlazada, con un puntero al principio y al final.
Entonces para remover una página y colocarla en el tope de la pila se
necesitan cambiar seis punteros como mucho. Cada renovación es un
poco más costosa, pero no hay búsqueda para un reemplazo, el puntero
cola apunta al final donde está la página LRU. Este acercamiento es
particularmente importante para implementaciones de software o e
microcódigo de LRU.
Ni el reemplazo OPT ni el LRU sufren de la anomalía de Belady. Hay
una clase de algoritmos de reemplazo de página, llamados algoritmos de pila
que nunca la pueden padecer. Un algoritmo de pila es aquel por el cual se
puede mostrar que el conjunto de páginas en memoria para n marcos
siempre es un subconjunto de las páginas que habría en memoria con n+1
marcos. Para el reemplazo LRU , el conjunto de páginas en memoria hubiera
sido las n páginas más recientemente referenciadas. Si se incrementa el
número de marcos, estas n páginas seguirían siendo las referenciadas más
recientemente y por lo tanto seguirían en memoria.
Ninguna implementación de los LRU podrá ser posible sin la asistencia

de hardware bajo los registros TLB estándar. La actualización del campo de
reloj o la pila se debe hacer para cada referencia a memoria. Si se usara una
interrupción para cada una para permitirle al software renovar tales
estructuras de datos, reduciría la rapidez de cada referencia a memoria en un
factor de por lo menos 10, y por lo tanto cada proceso de usuario en 10
.Pocos sistemas pueden tolerar tal nivel de overhead de manejo de memoria.
24 Versión 2.0
MEMORIA VIRTUAL
Algoritmos de aproximación a LRU

Pocos sistemas tienen el hardware suficiente para el verdadero
reemplazo LRU .Algunos sistemas proveen alguna ayuda en la forma de un
bit de referencia. Este bit es encendido por el hardware, para una página
cuando ésta es referenciada (tanto una lectura como una escritura de sus
bytes) Los bits de referencia están asociados a cada entrada en la tabla de
páginas.
Inicialmente todos los bits se ponen en 0 por el sistema operativo.
Cuando se ejecuta un proceso de usuario, el bit asociado con cada página
referenciada se cambia a 1 por el hardware. Luego de un tiempo, se pude
determinar qué páginas se han usado y cuales no examinando los bits de
referencia; pero no se sabe el orden de uso . Este ordenamiento parcial nos
lleva a varios algoritmos de reemplazo de página que se aproximan al LRU.
Algoritmo de bit de referencia adicional

Se puede ganar información de orden adicional al grabar los bits de
referencia en intervalos regulares. Se pude tener un byte de 8 bits para cada
página en una tabla en memoria. A intervalos regulares (cada 100
milisegundos por ejemplo) una interrupción de tiempo le transfiere el control
al sistema operativo. Este cambia el bit de referencia para cada página en el
orden alto del byte, cambiando los restantes bits en uno, descartando los bits
de bajo orden. Estos cambios de registros de 8 bits contienen la historia del
uso de la página para los últimos 8 períodos de tiempo. Si el registro de
cambio contiene 00000000, entonces la página no fue usada por 8 períodos
de tiempo; una página que se usa por lo menos una vez cada período tendrá
un registro como 11111111.
Una página con un registro histórico de 11000100 se ha usado más
recientemente que una con 01110111. Si se interpreta el byte como un entero
sin signo, la página con el número más bajo será la elegida como víctima y se
podrá reemplazar. Los números pueden no ser únicos ; se puede reemplazar
(swap out) todas las páginas con el menor valor o usar una selección entre
ellas.
El número de bits de historia puede variar, por supuesto , y será
seleccionado dependiendo del hardware disponible , para hacer la
actualización lo más rápido posible . En el caso extremo, el número se puede
reducir a cero, dejando sólo el bit de referencia. Este algoritmo se llama de
reemplazo de segunda oportunidad.
Algoritmo de segunda oportunidad

El algoritmo de segunda oportunidad básico es el algoritmo FIFO. Sin
embargo, cuando se ha seleccionado una página, se inspecciona su bit de
referencia. Si el valor es 0 se procede a reemplazarla; si el bit de referencia
es 1 se le da a la página una segunda oportunidad y se busca la FIFO
siguiente. Cuando la página obtiene la segunda oportunidad, su bit de
referencia pasa a valer 0 y su tiempo de llegada se actualiza con el tiempo
actual. de esta manera a una página que se le dio una segunda oportunidad
Versión 2.0 25
MEMORIA VIRTUAL
no se la reemplaza hasta que las demás lo hayan sido (o se les diera

segunda oportunidad) .Además si la página fue usada lo suficiente como para
tener encendido su bit de referencia, nunca será reemplazada.
Una manera de implementar este algoritmo es a través de una cola
circular, por eso recibe también el nombre de Algoritmo de Reloj. Un
puntero indica qué página será reemplazada luego. Cuando se necesita un
marco el puntero avanza hasta que encuentra una página con su bit de
referencia en 0 .Mientras avanza, pone en cero a los demás bits de
referencia. Una vez que se encuentra la página víctima, se reemplaza, y se
inserta la nueva en la cola circular en tal posición. En el peor de los casos si
todos los bits están en 1, el puntero circula por toda la cola, dándole a cada
página una segunda oportunidad. Testea todos los bits de referencia antes de
encontrar la próxima página para reemplazar En este caso se degenera hacia
un algoritmo FIFO.
Algoritmo de segunda oportunidad mejorado

El algoritmo de segunda oportunidad se puede mejorar considerando
tanto el bit de referencia como el modificado. Con ellos se puede formar:
(00) no recientemente usado ni modificado, la mejor página para
reemplazar;
(01) no recientemente usado pero modificado, no tan buena, porque la
página puede necesitar escribirse antes de reemplazarla;
(10) recientemente usada pero limpia, probablemente se la usará
rápido otra vez;
(11) recientemente usada y modificada, probablemente se usará otra
vez y se necesitará escribirla antes de usarla.
Cuando se llama a un reemplazo de página, cada una está en uno de

los cuatro estados. Se hace lo misma que en el algoritmo de reloj, pero en
vez de fijarse si a la página apuntada tiene el bit de referencia en 1 , se
examina la clase a la que pertenece . Se reemplaza la que se encuentre
primero en la clase no vacía más baja. Se puede llegar a revisar la cola
circular varias veces antes de encontrar una página para reemplazar.
Este algoritmo se usa en el manejo de memoria virtual de Macintosh.
La mayor diferencia entre este algoritmo y el de reloj es que en éste se les da
preferencia a aquellas páginas que han sido modificadas para reducir el
número de I/O necesitadas.
Algoritmos contadores
Hay muchos otros algoritmos que se pueden usar para reemplazar
páginas. Por ejemplo se puede llevar un contador con el número de
referencias que se hicieron a cada página y desarrollar lo siguiente:
• ALGORITMO LFU: El algoritmo de reemplazo de la página usada
menos frecuentemente (LFU) requiere que se reemplace aquella
con el contador más pequeño. La razón de esta selección es que
una página usada activamente debería tener un contador de
referencias grande. Este algoritmo sufre de la situación en que una
página se usa mucho en la fase inicial de un proceso pero luego no
se usa nunca más. Como se la usó mucho tiene un gran contador y
26 Versión 2.0
MEMORIA VIRTUAL
permanece en memoria aunque no se la necesite más. Una

solución es cambiar los contadores en un bit a intervalos regulares,
formando un porcentaje exponencial decreciente el uso del
contador.
• ALGORITMO MFU: E l algoritmo de reemplazo de la página usada
más frecuentemente, se basa en el argumento de que la página con
el contador más pequeño fue probablemente recién traída y todavía
debe ser usada.
Ni el reemplazo LFU ni el MFU son comunes. La implementación de
estos algoritmos es bastante costosa y no se aproximan muy bien al
reemplazo OPT.
Algoritmo de página de buffer

Generalmente se usa otros procedimientos, además de los algoritmos
específicos de reemplazo de página. Por ejemplo, los sistemas tienen
generalmente un conjunto de marcos libres. Cuando ocurre un fallo de página
se elige un marco víctima como antes. Sin embargo la página deseada se la
lee en un marco libre del conjunto antes de que la víctima sea sobrescrita.
Esto le permite al proceso recomenzar tan pronto como sea posible, sin
esperar que sea sacada la página víctima. Cuando más tarde se hace esto,
su marco se agrega al conjunto de marcos libres.
Una expansión de esta idea es mantener una lista de las páginas
modificadas. Cuando el dispositivo de página está inactivo, se selecciona una
página modificada y se la escribe en disco, se resetea su bit modificado. Esto
incrementa la posibilidad de que una página esté limpia cuando se la
selecciona para remplazarla y no necesite ser sacada.
Otra modificación es mantener un conjunto de marcos libres, pero
recordando qué página estaba en cada uno. Como los contenidos de los
marcos no se modifican cuando se escribe un marco en el disco, la página
vieja puede ser reusada directamente del conjunto de marcos libres si se la
necesita antes de que se reúse el marco. No necesita I/O en ese caso
Cuando ocurre un fallo de página, primero se fija si la página deseada está
en el conjunto de marcos libres; si no está, se debe seleccionar un marco
libre y leerla allí.
Esta técnica se usa en el sistema VAX/VMS, con un algoritmo FIFO de
reemplazo. Cuando el algoritmo FIFO reemplaza equivocadamente una
página que todavía está en uso activo, se la puede recuperar rápidamente
del marco libre del buffer y no se necesita I/O. El marco libre del buffer provee
protección contra el relativamente pobre, pero simple, algoritmo FIFO. Este
método es necesario porque las primeras versiones de VAX no
implementaban correctamente el bit de referencia.
Versión 2.0 27
MEMORIA VIRTUAL
ASIGNACION DE LOS MARCOS (ESTRUCTURAS)

¿Como podemos asignar una cantidad fija de memoria libre entre
varios procesos?
Si tenemos 93 marcos y 2 procesos, cuantos marcos obtendrá cada
proceso?
El sistema más simple de memoria virtual es un sistema monousuario.
Considere una microcomputadora monousuario con 128 k de memoria
compuesta de páginas de 1k. Así, hay 128 marcos. El sistema operativo
debe tomar 309 k dejando 93 marcos para los procesos de usuario. Bajo una
paginación por demanda pura, los 93 marcos deberían ser puestos a la lista
de marcos libres. Cuando un proceso de usuario comienza a ejecutarse, este
genera una secuencia de fallos de página.
Los primeros 93 fallos de página conseguirán marcos libres de la lista
de marcos libres. Cuando se agote la lista de marcos libres, se debe usar un
algoritmo de reemplazo de página para reemplazarla con la número 94 y así
sucesivamente. Cuando el proceso termina, los 93 marcos deben ser
devueltos en la lista de marcos libres.
Hay muchas variantes de esta simple estrategia, podemos requerir que
el sistema operativo asigne todos sus buffer y su tabla de espacio desde la
lista de marcos libres. Cuando ese espacio no esta usado por el sistema
operativo, este puede ser usado para ayudar a la paginación del usuario.
Podemos mantener 3 marcos libres reservados en la lista de marcos libres en
todo momento. Así cuando ocurre un fallo de página hay un marco libre
disponible para paginar en el. Mientras el intercambio de páginas esta
tomando lugar, puede seleccionarse un reemplazo, el cual es entonces
escrito al disco y el programa de usuario continua la ejecución.
También son posibles otras variantes, pero la estrategia básica es
clara. El proceso de usuario es asignado a todos los marcos libres.
Un problema diferente aparece cuando la demanda paginada se
combina con la multiprogramación. La multiprogramación coloca dos (o más)
procesos en la memoria al mismo tiempo.
Número mínimo de marcos.

Seguramente hay varias restricciones en nuestras estrategias para la
asignación de marcos. No podemos asignar más del número total de marcos
disponibles (al menos aquí se comparten las páginas).
Hay también un mínimo número de marcos que se pueden asignar.
Obviamente, como el número de marcos asignados a cada proceso decrece,
la tasa de fallo de página se incrementa, lentificando la ejecución del proceso.
Además de la indeseable performance por asignar pocos marcos, hay
un mínimo número de marcos que deben estar asignados. Este número
mínimo esta definido por la arquitectura del set de instrucciones. Recuerde
que, cuando ocurre un fallo de página antes que se complete una instrucción
que se estaba ejecutando, la instrucción debe ser recomenzada.
Consecuentemente debemos tener suficientes marcos para mantener todas
las diferentes páginas a las que cualquier instrucción pueda referenciar.
Por ejemplo, considere una máquina en la cual todas las instrucciones
de referencia a memoria tienen solo una dirección de memoria. Así, podemos
necesitar por lo menos un marco para la instrucción y un marco para la
referencia a memoria. Además si se permite un direccionamiento indirecto de
un nivel (por ejemplo una instrucción de carga en la página 16 puede referirse
a una dirección en la página 0, la cual es una referencia indirecta a la página
23), entonces la paginación requiere por lo menos tres marcos por proceso.
El número mínimo de marcos esta definido por la arquitectura de la
computadora. por ejemplo la instrucción MOVE para la PDP-11 necesita más
28 Versión 2.0
MEMORIA VIRTUAL
de una palabra para algunos modos de direccionamiento, y así la instrucción

en si misma puede necesitar o no dos páginas. Además cada uno de los
dos operandos deben tener referencias indirectas, para un total de 6 marcos.
El peor caso para el IBM 370 es probablemente la instrucción MVC. Ya que la
instrucción es almacenamiento a almacenamiento, toma 6 bytes y puede
montar dos páginas. El bloque de caracteres a mover y el área a donde
serán movidas pueden tomar también 2 páginas. Esta situación puede tomar
6 marcos. (Actualmente el peor caso es si MVC es operando de una
instrucción execute, que toma una página límite, en este caso necesitaremos
8 marcos).
El escenario del peor caso ocurre en arquitecturas que permiten
múltiples niveles de indirección (por ejemplo cada palabra de 16 bits pueden
tener una dirección de 15 bits y un bit de indicación de indirección)
Teóricamente una instrucción de carga simple puede referenciar a una
dirección indirecta que puede referenciar a una dirección indirecta (en otra
página) que puede también referenciar a una dirección indirecta (en otra
página), y así sucesivamente hasta que todas las páginas en la memoria
virtual hayan sido tocadas. Así en el peor caso, el total de la memoria virtual
estará en memoria física. Para paliar esta dificultad, debemos poner un limite
en los niveles de indirección (por ejemplo, limitar a una instrucción a tener
como máximo 16 niveles de indirección). Cuando ocurre la primera
indirección, un contador se pone a 16 el contador es entonces decrementado
para cada sucesiva indirección de esta instrucción. si el contador es
decrementado a 0, ocurre un trap (indirección excesiva). Esta limitación
reduce el máximo número de marcos.
El mínimo número de marcos por proceso es definido por la
arquitectura, donde el máximo número esta definido por la cantidad de
memoria física disponible. En cambio, tenemos todavía una opción
significante en la asignación de marcos.
Algoritmos de Asignación
El camino más fácil para separar los m marcos entre los n procesos,
es para dejar a cada uno una porción forma igual, m/n marcos. Por ejemplo
Si hay 93 marcos y 09 procesos, cada proceso obtendrá 10 marcos. Los tres
marcos restantes pueden usarse como un contenedor de marcos libres. Este
esquema se denomina asignación equivalente o pareja. Una alternativa es
reconocer que varios procesos pueden necesitar cantidades diferentes de
memoria. Si un pequeño proceso de un estudiante de 10k y un base de datos
interactiva de 127k son los únicos procesos corriente en un sistema con 62
marcos libres, no tiene sentido asignar a cada proceso 31 marcos. El proceso
del estudiante no necesitara más de 10 marcos, así que los otros 21 son
desperdiciados. Para resolver este problema, podemos usar la asignación
proporcional. Asignaremos la memoria disponible a cada proceso de
acuerdo a su tamaño. Dejar que el tamaño de la memoria virtual para el
proceso Pi sea Si, y definir S= E Si.
Entonces, si el número total de marcos disponibles es m asignaremos
Ai marcos a proceso Pi, donde Ai es aproximadamente Ai= Si/S x m.
Podemos ajustar cada Ai para ser un entero, el cual es más grande
que el mínimo número de marcos requeridos por el set de instrucciones. con
una suma que no exceda m.
Para una asignación proporcional, debemos separar los 621 marcos
entre 2 procesos uno de 10 páginas y uno de 127 páginas, asignando cuatro
marcos y 097 marcos respectivamente así 10/137 * 62 = 4 y 127/137 * 62 =
097.
Versión 2.0 29
MEMORIA VIRTUAL
En este caso, ambos procesos comparten los marcos disponibles de

acuerdo a sus necesidades en igualdad.
En ambos la Asignación equivalente y la Asignación proporcional la
asignación a cada proceso puede variar de acuerdo a el nivel de
multiprogramación. Si el nivel de multiprogramación se incremente, cada
proceso perderá algunos marcos para proveerlo a las necesidades del nuevo
proceso. Por otro lado si la multiprogramación disminuye los marcos que
fueron asignados a los procesos que terminaron puede ser nuevamente
repartida entre los procesos que quedaron.
Note que con cualquiera de las dos, la asignación equivalente o
proporcional un proceso de alta prioridad es tratado igual que un
proceso de baja prioridad.
Un acercamiento es usar un esquema de asignación proporcional
donde la tasa de marcos dependa no solo del tamaño relativo del proceso,
pero si en las prioridades de los procesos, o una combinación del tamaño y la
prioridad.
Reemplazo Local y Reemplazo Global

Otro factor importante en la manera en que son asignados los marcos
a los diferentes procesos es el reemplazo de página. Con múltiples procesos
compitiendo por los marcos, podemos clasificar los algoritmos de reemplazo
de página en 2 categorías, los Reemplazos globales y los Reemplazos
locales.
El reemplazo global permite a un proceso seleccionar un marco para
reemplazar de la lista de todos los marcos aun si este marco esta asignado a
otro proceso, el reemplazo local en cambio solo puede seleccionar los
marcos que se encuentran en su propio set de marcos asignados.
Por ejemplo, considere un esquema de asignación donde permitamos
a los procesos de alta prioridad seleccionar marcos de otros con menor
prioridad, este acercamiento permite que los procesos con alta prioridad
aumenten el número de marcos a expensas de procesos con menor
prioridad.
Con una estrategia de reemplazo local, el número de marcos
asignados a un proceso no cambia. Con la global puede suceder que un
proceso seleccione marcos asignados solo a otros procesos aumentando así
su número de marcos.
Un problema con el algoritmo de reemplazo global es que un proceso
no puede controlar su propia tasa de fallos de página.
El set de páginas en memoria para un proceso depende no solo de la
paginación de este proceso, sino también en la paginación de otros procesos.
Así el mismo proceso puede ejecutar en forma diferente (tomándose 0,09
segundos para una ejecución y 10,3 segundos para la próxima ejecución)
según las circunstancias externas. Así no ocurre con el algoritmo de
emplazamiento local, donde el set de páginas, en memoria para un proceso,
son afectadas solo por la paginación de ese proceso. Así el reemplazo local
puede estorbar a un proceso no haciendo disponible a otro sus páginas no
utilizadas resultando así el de reemplazo global el de mayor rendimiento.
TRASHING
Si el la cantidad de marcos asignados a un proceso de baja prioridad
cae hasta ser menor que el número mínimo requerido por la arquitectura de
la computadora, debemos suspender la ejecución del mismo. Podríamos
quitar sus restantes páginas, liberando así todos sus marcos asignados. Esta
30 Versión 2.0
MEMORIA VIRTUAL
condición introduce un nivel de swap in-swap out del planificador intermedio

de la CPU.
De hecho, pensemos en un proceso que no posee los “suficientes”
marcos (frames). A pesar de que técnicamente es posible reducir al mínimo
la cantidad de marcos asignados, hay cierto gran número de páginas que
están en uso activo. Si el proceso no tiene ese número de frames,
rápidamente producirá un page fault o fallo de página. Hasta este punto, se
debe reemplazar alguna página. De todos modos, dado que todas sus
páginas están en uso activo, debe reemplazar una página que se necesitará
más tarde. Por lo tanto, volverá a producir fallos de página una y otra vez
Esta gran actividad de paginación es denominada trashing. Un proceso
está en trashing cuando pasa más tiempo en la paginación que en la
ejecución.
CAUSAS DE TRASHING
El Trashing trae como consecuencia muchos problemas graves de
performance. Vamos a considerar el siguiente caso, basado en la conducta
real de los primeros sistemas de paginación.
El sistema operativo monitorea la utilización de la CPU. Si ésta es
demasiado baja, incrementaremos el grado de multiprogramación
introduciendo un nuevo proceso al sistema. Se utiliza un algoritmo de
reemplazo de página global, que reemplaza páginas sin dar importancia al
proceso al cual pertenecen. Supongamos ahora que un proceso entra una
nueva fase en su ejecución y necesita más frames. Comienza fallando y
tomando páginas de otros procesos, los cuales necesitan esas páginas y por
lo tanto, también fallan tomando páginas de otros procesos. Estos procesos
necesitan el dispositivo de paginación (llamémosle paginador) para mutar sus
páginas (swap in- swap out). A medida que la cola para el paginador se
incrementa, la cola de listos decrece; decreciendo obviamente la utilización
de la CPU.
El planificador de la CPU ve este decrecimiento y aumenta el grado de
multiprogramación. El nuevo proceso intentará comenzar tomando páginas
de procesos corrientes, causando más fallos de página y una cola aún mayor
para el paginador. Como resultado la utilización de la CPU cae aún más. Se
ha producido un Trashing y el rendimiento del sistema cae bruscamente. El
grado de page-fault crece. Como resultado, crece también el tiempo efectivo
de acceso a memoria. No se realiza ningún trabajo, dado que todos los
procesos están perdiendo su tiempo paginando.
Para incrementar la utilización de la CPU y detener el trashing,
debemos decrementar el grado de multiprogramación.
Los efectos del trashing pueden ser limitados utilizando un algoritmo
de reemplazo local o de prioridades. Con éste, si un proceso entra en
trashing, no puede tomar frames de otro proceso y provocar que los
siguientes entren también en trashing. Las páginas son reemplazadas sin
darle importancia al proceso al que pertenecen. De cualquier modo, si los
procesos entran en trashing, estarán la mayoría del tiempo en la cola para el
paginado. El tiempo promedio de servicio para los fallos de página crecerá,
Versión 2.0 31
MEMORIA VIRTUAL
debido al mayor promedio en la cola del paginador. De esta manera, crecerá

el tiempo de acceso efectivo aún para un proceso que no esté en trashing.
Para evitar el trashing, debemos dar a un proceso los frames que
necesita. Hay diversas técnicas para conocer esta cantidad. Uno de ellos es
la estrategia de conjunto de trabajo (working-set), que comienza mirando
cuántos marcos está utilizando realmente un proceso. Este planteamiento
define el modelo de localización de ejecución de los procesos.
El modelo de localización establece que, mientras se ejecuta el
proceso, éste se mueve de una a otra localización. Una localización es un
grupo de páginas que son usadas activamente juntas. Un programa
generalmente está compuesto de diferentes localizaciones, las cuales
pueden solaparse.
Por ejemplo, cuando se llama a una subrutina, ésta define una nueva
localidad, en la cual se hacen referencias a memoria para sus instrucciones,
variables locales, y un subgrupo de variables globales. Cuando una subrutina
sale, el proceso deja su localidad, dado que las variables locales e
instrucciones de las subrutinas no están más en uso activo. Podríamos
regresarlo a su localización anterior. Hemos visto, que las localizaciones son
definidas por el las estructuras del programa y sus datos. Este modelo
establece que todos los programas presentarán esta estructura básica de
referencia a memoria.
Supongamos ahora que hemos asignado los suficientes frames a un
proceso para ajustar sus actuales localizaciones. Éste entrará en fallo por las
páginas en su localización hasta que estén todas en memoria; así, no volverá
a fallar nuevamente hasta que cambie sus localizaciones. Si asignamos
menos frames que el tamaño de la actual localización, el proceso entrará en
trashing, dado que no puede mantener en memoria todas las páginas que
están en uso activo.
MODELO DE CONJUNTO DE TRABAJO (WORKING-SET MODEL)

Este modelo está basado en la hipótesis de localización. Utiliza un
parámetro ,∆ , para definir la ventana de fijación de trabajo.
La idea, es examinar las ∆ referencias de páginas más recientes. El
grupo de páginas en estas referencias son el conjunto de trabajo (llamémosle
working set). Si una página está en uso activo, estará en el working set. De lo
contrario, se moverá desde aquí ∆ unidades de tiempo luego de su última
referencia. Así, el working set es una aproximación de la localización del
programa y definimos como localización al conjunto de páginas usadas por
un proceso en un momento del tiempo.
Daremos la siguiente figura como ejemplo:
Tabla de Referencia de página

…261097777091623412344434344413234443444…
∆ ∆
t1 t2
WS(t1)= {1,2,0,9,6,7} WS(t2)={3,4}
32 Versión 2.0
MEMORIA VIRTUAL
Dada esta secuencia de memoria, si ∆ =10 referencias de memoria, el

Working Set en el tiempo t1 es {1,2,09,6,7}, y en el tiempo t2 es {3,4}
La exactitud del working set depende de la elección de ∆ . Si es muy
pequeño, no abarcará toda la localización; mientras que si es muy grande,
podría solapar varias localidades.
La propiedad más importante del working set es su tamaño. Si

calculamos este tamaño, llamémoslo wssi para cada proceso en el sistema,
podemos considerar
D=Σ WSSi
siendo D la demanda total de marcos.
Cada proceso usa activamente las páginas en su working set. Así, un

proceso i necesita WSSi frames. Si D es mayor que el total de frames
disponibles, se produce trashing.
El sistema operativo revisa el WS de cada proceso y le asigna los
marcos suficientes para su tamaño. De haber suficientes frames extras,
puede iniciarse otro proceso. Si la suma de los tamaños de los WS crece,
excediendo el total de frames disponibles, el sistema operativo selecciona
un proceso y lo suspende.
La estrategia de Working-Set evita el trashing a la vez que mantiene el
grado de multiprogramación lo más alto posible, optimizando así el uso de la
CPU. La dificultad de este modelo es manejar el recorrido del WS, dado que
su ventana es movible. En cada referencia a memoria, aparece una nueva
referencia en un final y la referencia más antigua decrece al otro final.
Una página está en el WS si se le referencia en cualquier parte de la
ventana de WS. Podríamos aproximar el modelo de WS con un interruptor de
tiempo de intervalo fijo y un bit de referencia.
Por ejemplo, sea ∆ =10.000 referencias y un interrupción cada 09.000.
Cuando se produce una interrupción, se copia y vacía el valor del bit de
referencia para cada página. Así, si ocurre un fallo de página, podremos
revisar el actual bit de referencia y 2 bits en memoria para determinar qué
página fue usada en las últimas 10.000 o 109.000 referencias. Si fueron
usadas al menos uno de estos bits estarán en on, y se considera que están
en el WS. Este arreglo no es absolutamente exacto debido a que no
podemos definir cuando, dentro de un intervalo de 09.000, ha ocurrido una
referencia.
Frecuencia de fallos de página.

El modelo de Working Set es exitoso, pero puede resultar un modo
torpe para controlar el trashing. La estrategia de Frecuencia de Fallos de
Página (FFP) es un modo más directo.
El trashing tiene un alto grado de fallo de página. Cuando este rango
es muy alto, sabemos que el proceso necesita más marcos, mientras que si
es muy bajo es porque tiene demasiados. Pueden establecerse límites
mayores y menores en algún rango de fallo de página . Si el actual fallo
Versión 2.0 33
MEMORIA VIRTUAL
excede el límite superior, asignamos al proceso otro marco, de lo contrario,

quitamos marcos de ese proceso. Así podemos directamente controlar y
medir el rango de fallos de página y evitar el trashing.
Como en la estrategia de WS, podríamos tener que suspender un

proceso. Si el rango de fallos crece y no hay marcos libres disponibles,
debemos seleccionar algún proceso y suspenderlo. Los marcos liberados se
distribuyen a los procesos con mayor grado de fallo de página.
34 Versión 2.0
MEMORIA VIRTUAL
OTRAS CONSIDERACIONES.
Existen varios aspectos a tener en cuenta para implementar un
sistema paginado, algoritmos de reemplazo y políticas de asignación de
memoria son los más importantes. Es bueno considerar otros aspectos
también importantes a saber:
Prepaginación.
Como ya hemos visto en la paginación por demanda, las páginas son
cargadas a memoria sólo cuando se hace una referencia a una dirección de
esta página. Cuando un proceso comienza es muy probable que ocurran
numerosos fallos de página que producirán varias interrupciones y accesos a
disco para traer las páginas solicitadas. Luego cuando el proceso avanza
este nivel de fallas de página se ira decrementando hasta hacerse muy
pequeño. Para resolver el primer problema, el del comienzo del proceso
existe una estrategia llamada prepaginación, que consiste en traer a memoria
principal otras páginas aunque no sean pedidas por una falla de página. Esta
estrategia se basa en que la mayoría de los dispositivos de memoria
secundaria tienen un tiempo de búsqueda importante. Si ubicamos en la
memoria secundaria en forma contigua las páginas que se referencian, es
más conveniente en cada acceso a esta memoria traer además de la página
solicitada algunas más que están contiguas a estas, de esta manera se
ganaría algún tiempo evitando las varias búsquedas que tendría la
paginación por demanda, y además se reduciría la frecuencia de las fallas de
página. Por otro lado, este proceso sería ineficiente si las páginas extras
cargadas en memoria principal no son referenciadas.
Esta política de prepaginación puede ser utilizada en el comienzo de
un proceso o cada vez que ocurra una falla de página, en el primer caso el
programador debe de alguna manera designar las páginas a cargar.
Tamaño de la página.
No existe un mejor tamaño de página, por el contrario, hay varios
factores que permiten utilizar distintos tamaños. Veremos en los casos
siguientes como los diversos factores hacen, en algunos casos más
convenientes las páginas de gran tamaño, y en otros la páginas de pequeño
tamaño.
Un factor es el tamaño de la tabla de páginas, ya que cada proceso
activo debe tener una copia de la tabla de páginas es beneficioso que esta
sea del menor tamaño posible, esto se consigue con páginas de gran
tamaño.
Por otro lado, la memoria se utiliza mejor con tamaños pequeños de
página. Seguramente, la ultima página de un proceso no estará ocupada en
su totalidad, por lo tanto habrá una porción de memoria no utilizada
generando fragmentación interna, como la página es la unidad de asignación
de memoria no se podrá utilizar este remanente de memoria para otro
proceso, entonces si el tamaño de la página es grande esta fragmentación
Versión 2.0 35
MEMORIA VIRTUAL
puede ser importante, para reducirla es conveniente utilizar páginas

pequeñas.
Otro aspecto es el tiempo requerido para leer o escribir una página, es
decir el tiempo de I/O (búsqueda, latencia y transferencia), sabemos que el
tiempo de trasferencia es mínimo ante el tiempo de búsqueda y latencia( a
razón del 1 %), si tenemos grandes páginas el tiempo de transferencia no
afectara demasiado, en cambio el hecho de hacer solo una búsqueda
disminuye considerablemente el tiempo perdido en cada I/O para cargar una
página. Para este aspecto es conveniente un gran tamaño de página.
En contrapartida con el punto anterior, un tamaño de página pequeño
permite tener mayor “resolución”, es decir que la memoria cargada sea
realmente la que se necesita. Si podemos ubicar en forma contigua las
páginas que se referencian se disminuiría el tiempo de búsqueda, que es el
mayor en una I/O y así el total de tiempo de las diversas I/O, y aprovechando
el menor tamaño de página se ocuparía menor cantidad de memoria.
Si el tamaño de página es muy pequeño, y no se consiguió cierta
contigüidad en el almacenamiento se producirán numerosas fallas de páginas
con las consiguientes pérdidas de tiempo en todo el proceso de reemplazo de
páginas (procesar la interrupción, salvar registros, reemplazar la página,
actualizar la tabla de páginas). Entonces para minimizar las fallas de página
se necesitan grandes tamaños de página.
Finalmente, la tendencia histórica es hacia las grandes páginas. Esto
es debido a que la velocidad de la CPU y la capacidad de memoria principal
ha crecido mucho más que la velocidad de los discos. Las fallas de página
son aun muy costosas, es por esto que se trata de disminuir su frecuencia a
través de grandes tamaños de página, aunque haya mayor fragmentación
interna.
Estructura de programa.
Para interpretar este aspecto supongamos el siguiente ejemplo,
tenemos: páginas de 128 palabras, un programa que inicializa a cero una
matriz de 128 x 128, cuyos elementos ocupan 1 palabra. Si almacenamos la
matriz por fila, cada fila ocupara una página, si el programa recorre la matriz
por filas e inicializa y si el sistema operativo aloja menos de 128 páginas para
el programa entero habrá con seguridad 128 x 128 = 16.384 fallos de
páginas. Si se cambia el programa inicializando la matriz por filas, es decir en
el sentido en que fue almacenada, se reduce el número de fallos de página a
128.
Con este ejemplo se puede ver que mucho tiene que ver la
programación en una buena performance de la memoria virtual. Eligiendo
cuidadosamente las estructuras de datos y su programación se pueden
reducir las fallas de páginas y aumentar la vecindad de páginas
referenciadas.
Interlock.
Supongamos que un proceso hace un pedido de I/O, entonces es
puesto en la cola del dispositivo de I/O. Mientras tanto, la CPU ejecuta otros
procesos, estos causan fallos de página, y usando un algoritmo global de
36 Versión 2.0
MEMORIA VIRTUAL
reemplazo, uno de estos reemplaza la página que contiene la memoria a ser

transferida por el proceso en espera de I/O. Luego una vez que la I/O tiene
lugar ocurre sobre las direcciones especificadas, pero este marco esta siendo
usado por otra página perteneciente a otro proceso.
Una solución para este problema es permitir que se puedan bloquear páginas, en cada marco
debe haber un bit que indique el estado de bloqueo. Si un marco esta bloqueado no puede
seleccionarse para ser reemplazado.
Versión 2.0 37
MEMORIA VIRTUAL
SEGMENTACIÓN por Demanda

Aunque la paginación por demanda es generalmente considerada el
sistema de memoria virtual más eficiente, se necesita una gran cantidad de
hardware para poder implementarlo. Cuando falta este hardware hay
maneras menos eficientes de proveer memoria virtual. Un caso es la
segmentación por demanda. El Intel 80286 no incluye aspectos para la
paginación pero si para segmentación, es más, la segmentación es la forma
nativa de INTEL. El OS/2 que ejecuta en este CPU utiliza el hardware de
segmentación como la única aproximación posible de la paginación por
demanda.
El OS/2 asigna segmentos en memoria, en vez de páginas. Realiza un
seguimiento de esos segmentos a través de los Descriptores de Segmentos,
los cuales incluyen información sobre el tamaño del segmento, protección y
localización. Un proceso no necesita tener todos sus segmentos en memoria
para ejecutarse, en lugar de esto el descriptor de segmentos posee un bit de
validación para cada segmento para indicar si el segmento se encuentra en
memoria. Cuando un proceso direcciona a un segmento que contiene código
o datos, el hardware chequea este bit de validación, si el segmento esta en
memoria principal, el acceso continúa sin problemas, si el segmento no esta
en memoria, ocurre un trap al sistema operativo (Fallo de Segmento) tal
como en la paginación por demanda. Entonces el OS/2 intercambia un
segmento al almacenamiento secundario e introduce todo el segmento
pedido, luego de esto continua la instrucción interrumpida.
Para determinar que segmento reemplazar en caso de un fallo de
segmento, el OS/2 utiliza otro bit en el descriptor de segmentos llamado Bit
de acceso. El bit de acceso tiene el mismo propósito que el bit de referencia
en la paginación por demanda. Esta activado cuando se lee o escribe un byte
de dicho segmento. Se mantiene una cola con una entrada por cada
segmento en la memoria. Después de cada ciclo de tiempo, el SO pone en el
principio de la cola cualquier segmento que posee el bit activado, luego limpia
el bit de acceso. De esta manera la cola se mantiene ordenada con el
segmento más recientemente usado en el principio. Además el OS/2 provee
de llamadas al sistema que los procesos pueden utilizar para informar al
sistema de aquellos segmentos que se pueden descartar, o deben
permanecer en memoria. Esta información se utiliza para reordenar la
información en la cola. Cuando ocurre un fallo de segmento invalido, las
rutinas de administración de memoria deben determinar donde hay suficiente
espacio para acomodar el segmento. La compactación de memoria debe
liberar a esta de la fragmentación externa. Si, luego de la compactación, no
hay suficiente memoria libre, se ejecuta un reemplazo de segmento. El
segmento al final de la cola es reemplazado y escrito al espacio de
intercambio. Si el nuevo espacio liberado es suficientemente grande para
acomodar el segmento pedido entonces el descriptor de segmentos es
actualizado y el segmento es colocado al principio de la cola. En otro caso, se
ejecuta la compactación de memoria y se repite la operación.
Esta claro que la segmentación por demanda requiere de una
considerable sobrecarga. Así la segmentación por demanda no es una
manera óptima para hacer un buen uso del sistema.
La alternativa en hardware menos sofisticado es no utilizar memoria
virtual. Dados los problemas vinculados a la falta de memoria virtual, esta
solución es también pobre. La segmentación por demanda es una solución
razonable para aquellos sistemas en los que las restricciones hacen la
paginación por demanda imposible.
38 Versión 2.0
MEMORIA VIRTUAL
Versión 2.0 39
MEMORIA VIRTUAL
RESUMEN
PÁGINACIÓN POR DEMANDA :
Cuando se tiene que cargar un proceso, el paginador deduce que

páginas se usarán antes de que el proceso sea sacado de la memoria
nuevamente. En vez de cargar un proceso completo, el pager trae a memoria
solamente aquellas páginas necesarias. De esta forma, se evita llevar a
memoria páginas que no se usarán, reduciendo el swap time y la cantidad de
memoria física necesaria.
El esquema del bit de valid-invalid ( válido-inválido ) se puede usar
para este propósito. Cuando dicho bit se encuentra en ‘valid’, este valor
indica que la página asociada es legal así como también que se encuentra en
memoria. Si el bit se encuentra en ‘invalid’, este valor indica que la página no
es válida ( es decir, que no está en el espacio de direcciones lógicas del
proceso ), o es válida pero está actualmente en disco.
Mientras el proceso ejecuta una y accede a las páginas que están
residentes en memoria, la ejecución prosigue normalmente. Pero qué sucede
si el proceso trata de usar una página que no está cargada en memoria ? El
acceso a una página marcada como ‘invalid’ provoca un trap por error de
página ( page fault ). El hardware de paginación, al traducir la dirección a
través de la tabla de páginas, notará que el bit está como ‘invalid’,
provocando un trap al Sistema Operativo. El procedimiento para manipular
este error de página es simple :
1) Se controla una tabla interna (generalmente almacenada con la

PCB) para este proceso, con el fin de determinar si la referencia fue un
acceso a memoria válido o inválido.
2) Si la referencia fue inválida, se termina el proceso. Si fue válida,
pero no se ha cargado esa página, se carga esta última.
3) Encontramos un marco (frame) libre (tomando uno de las lista de
marcos libres).
4) Planificamos una operación de disco para leer la página deseada en
el nuevo marco.
09) Cuando se completa la lectura, modificamos la tabla interna
almacenada con la PCB y la tabla de páginas para indicar que la página está
ahora en memoria.
6) Se recomienza la instrucción que fue interrumpida por el trap por
dirección ilegal. El proceso puede ahora acceder a la página como si siempre
hubiera estado en memoria.
Por último, es necesario saber que un page fault produce lo siguiente:
1) Un trap al Sistema Operativo

2) Salvar los registros del usuario y estado del proceso.
3) Determinar que la interrupción fue un page fault.
40 Versión 2.0
MEMORIA VIRTUAL
4) Controlar que la referencia de página haya sido legal y determinar la

ubicación de la página en el disco.
09) Hacer una lectura desde disco hacia el marco libre.
a) Esperar en la cola de este dispositivo hasta que se le de servicio al
pedido de lectura.
b) Esperar el tiempo de búsqueda y/o latencia del dispositivo.
c) Comenzar la transferencia de la página hacia un marco libre.
6) Mientras se espera, asignarle a la CPU algún otro usuario ( CPU
Scheduling; opcional )
7) Interrupción de disco ( E/S completada )
8) Salvar los registros y el estado del proceso para el otro usuario ( si
el paso seis se ejecutó )
9) Determinar que la interrupción fue de disco.
10) Corregir la tabla de páginas y otras tablas para mostrar que la
página deseada está ahora en memoria.
11) Esperar se le asigne de nuevo este proceso a la CPU.
12) Restaurar los registros de usuario, estado del proceso, y la nueva
tabla de páginas y luego volver a la instrucción interrumpida.
ALGORITMOS DE REEMPLAZO DE PÁGINA
• Algoritmo LRU: El reemplazo LRU asocia a cada página el tiempo de su

última utilización. Cuando se debe reemplazar una página, el LRU elige
aquella que no ha sido usada por el período de tiempo más largo, es decir,
la página usada menos recientemente. Se puede implementar con
contadores o con pilas.
Un algoritmo de pila es aquel por el cual se puede mostrar que el
conjunto de páginas en memoria para n marcos es un subconjunto del de las
páginas que habría en memoria con n+1 marcos. Por este motivo ni el
reemplazo de página OPT ni el LRU sufren de la anomalía de Belady.
Algoritmos de aproximación al LRU: Se utiliza un bit de referencia
asociado con cada entrada a la tabla de páginas, el cual valdrá 1 si la página
fue referenciada. De esta manera se conoce si la página se ha utilizado o no;
pero no se conoce el orden.
• Algoritmo de bit de referencia adicional: Se tiene un byte de 8 bits; a
intervalos regulares de tiempo se pasa el control al sistema operativo quien
cambia el bit de referencia para cada página en el orden alto del bit,
descartando los bits de bajo orden. Estos cambios de registros de 8 bits
contienen la historia del uso de la página para los 8 últimos tiempos. Si se
interpretan los ocho bits del byte como un entero sin signo, la página con el
número más bajo será la LRU y se podrá reemplazar.
• Algoritmo de segunda oportunidad (reloj): Es un algoritmo FIFO.
Cuando se ha seleccionado una página para reemplazar, sin embargo, se
inspecciona su bit de referencia. Si el valor es cero se la reemplaza. Si el
bit de referencia es 1 se le da a la página una segunda oportunidad y se
busca la página FIFO siguiente. Cuando se otorga la segunda oportunidad
el bit de referencia pasa a valer 1 y se actualiza el tiempo con el actual.
Versión 2.0 41
MEMORIA VIRTUAL
Una página no es reemplazada hasta que las demás lo hayan sido o se les
haya dado una segunda oportunidad. Se implementa con una cola circular.
• Algoritmo de segunda oportunidad mejorado: Se considera tanto el bit
de referencia como el bit modificado, se forman los pares ordenados :
1. (00) ni recientemente usado ni modificado, la mejor para
reemplazar;
2. (01) no usado recientemente pero modificado, la página puede
necesitar escribirse;
3. (10) recientemente usada pero limpia, se la podría usar otra vez
rápido;
4. (11) usada recientemente y modificada, probablemente se la
usará otra vez.
Cuando se va a reemplazar la página se examina a qué clase
pertenece, se reemplaza la primera página que se encuentre en la clase no
vacía más baja.
Algoritmos contadores: Se puede levar un contador con el número
de referencias hechas a cada página:
• Algoritmo LFU: El algoritmo de la página usada menos
frecuentemente requiere que se reemplace aquella con el contador más
pequeño.
• Algoritmo MFU: El algoritmo de la página más frecuentemente
usada, se basa en el argumento de que la página con el contador más
pequeño fue probablemente traída recién y necesitará ser usada
nuevamente.
Algoritmo de página de buffer: Se conserva un conjunto de marcos
libres. Cuando ocurre un fallo de página se elige un marco víctima pero la
página se lee en uno de los marcos libres antes de que la víctima se
sobrescriba. Esto le permite al proceso recomenzar tan pronto como sea
posible, sin esperar que la página víctima se saque; cuando esto último
ocurre el marco se agrega al conjunto de marcos libres.
Una expansión es mantener una lista de las páginas modificadas,
cuando el dispositivo de página está inactivo se selecciona una página
modificada y se la escribe en disco, reseteando su bit modificado.
Otra modificación es mantener un conjunto de marcos libres, pero
recordando qué página estaba en cada uno. De esta manera la página vieja
puede ser rehusada directamente del conjunto de marcos libres si se la
necesitase antes de rescribir el marco.
ASIGNACIÓN DE MARCOS
La asignación de marcos de memoria a los procesos puede realizarse
de diferentes maneras dependiendo de si la maquina en cuestión realiza o no
multiprogramación. En el caso de tratarse de una microcomputadora personal
monoprogramada hay varias estrategias a llevar a cabo, pero todas ellas
apuntan a lo mismo; todos los marcos libres son asignados al proceso
usuario.
En el caso de multiprogramación aparecen nuevos problemas.
El número de marcos que se asignan a un proceso no debe ser tan
poco que lo obligue a realizar constantemente fallos y así no realice un
avance en su ejecución y tampoco tan grande que solo unos pocos procesos
puedan ejecutarse dentro de la computadora. Además hay un número
42 Versión 2.0
MEMORIA VIRTUAL
mínimo de marcos que se deben asignar a los procesos, que esta dada por la
arquitectura del set de instrucciones. Consecuentemente debemos tener
suficientes marcos para mantener todas las diferentes páginas a las que
cualquier instrucción pueda referenciar. Además el grado de indirección de
las instrucciones puede consumir muchos marcos por ello deberemos
restringir la cantidad de indirecciones de las instrucciones (esto es una
instrucción de carga en la página 16 puede referirse a una dirección de la
página 0 que es a su vez una referencia indirecta de la página 23).
Los algoritmos de asignación de marcos pueden ser diversos, así el
más simple seria el de separar el total m de marcos entre los n procesos,
dándole a cada uno una cantidad equivalente, llamado este de Asignación
equivalente, pero esto resulta poco practico si tenemos procesos con mayor
carga que otros por esto se utilizan los algoritmos de Asignación Proporcional
que pueden tener en cuenta o el tamaño de los programas, o su prioridad o
ambos.
SEGMENTACIÓN POR DEMANDA

La paginación por demanda es seguramente el sistema de memoria
virtual más eficiente pero necesita de una cantidad de hardware considerable.
Algunos equipos, como el 80286, no posee este hardware y por ello el
sistema operativo OS/2 utiliza sus mecanismos de segmentación para utilizar
memoria virtual. Hay varios mecanismos que permiten implementar la
segmentación por demanda pero todos ellos son poco óptimos, algunas
veces conviene no implementar ningún mecanismo de memoria virtual antes
que utilizar segmentación por demanda. Lo cierto es que la segmentación por
demanda es una solución razonable cuando el hardware para paginación no
es suficiente.
Versión 2.0 43
MEMORIA VIRTUAL
Ejercicios: Memoria Virtual
1) ¿Cuándo se producen los page faults? Describa las acciones llevadas a

cabo por el Sistema Operativo cuando se produce un page fault.
2) ¿Cuáles de las siguientes técnicas de programación y estructuras son

‘buenas’ para un ambiente de paginación por demanda? ¿Cuáles no son
buenas? Explique sus respuestas.
a) Pila
b) Tabla de símbolos de Hashing (hashed symbol table)
c) Búsqueda secuencial
d) Búsqueda binaria
e) Código puro
f) Operaciones de Vectores
g) Indirección
3) Considere un sistema con paginación con las siguientes características:
Utilización de la CPU 20 %
Disco de Paginación 97.7 %
Otros dispositivos de E/S 9 %
¿Cuáles (si hay alguno) de los siguientes puntos (probablemente)

mejorará la utilización de la CPU?
a) Instalar una CPU más rápida

b) Instalar un disco de paginación más grande
c) Aumentar el grado de Multiprogramación
d) Reducir el grado de Multiprogramación
e) Instalar más Memoria Principal
f) Instalar un disco rígido más rápido, o múltiples controladores
con múltiples discos rígidos.
g) Agregar preparing a los algoritmos de búsqueda de página
h) Aumentar el tamaño de página.
4) ¿Cuál es la causa de Thrashing? ¿Cómo lo detecta el sistema operativo?

¿Una vez detectado, qué puede hacer el sistema para eliminarlo?
5) Qué efecto permite que dos entradas de la tabla de páginas apunten al

mismo frame en memoria? Explique cómo este efecto puede aplicarse para
reducir la cantidad de tiempo necesaria para copiar una gran cantidad de
memoria de un lugar a otro. ¿Cuál sería el efecto de actualizar un byte de
una página a la otra?
6) ¿Por qué el algoritmo LRU no sufre la anomalía de Belady? ¿Qué

características tienen los algoritmos que sí la padecen?
44 Versión 2.0
MEMORIA VIRTUAL
7) Dada la secuencia de referencia en memoria virtual
…2,6,1,9,7,7,7,7,9,1,6,2,3,4,1,2,3,4,4,4,3,4,3,4,4,4,1,3,2,3,4,4,4,3,4,4,4,...
|---------t1--------- |---------------t2--------------------|----------t3------------|
Determine el Working Set para los tiempos t1, t2 y t3.
8) Suponga un esquema de memoria paginada con memoria virtual.

Se están ejecutando tres programas A, B y C con longitudes 2K,
1.5K, y 3K respectivamente. La longitud de la página es de 0.5K.
a) Cuál es la cantidad máxima de páginas que puede tener un

programa si las instrucciones tienen direcciones de 16 bits.
b) Diseñe las tablas necesarias para el sistema suponiendo que
el tamaño de la memoria es 64K.
c) Determinar el contenido de las tablas para los programas A, B
y C. Los bloques de memoria contienen: A-0, B-0, C-5, A-1, A-2, C-3, C-1, B-
2, C-4.
d) En la dirección 0280B de A hay una instrucción de bifurcación
incondicional. Usando las tablas del punto c), determinar la dirección de
memoria donde está la instrucción. Indique cómo actúa el sistema, si la
instrucción bifurcara a 029AH, 00BAH, y 0708H.
9) Considérese la siguiente cadena de referencia de páginas :
1,2,3,4,2,1,09,6,2,1,2,3,7,6,3,2,1,2,3,6
Cuántos page faults ocurrirían para los siguientes algoritmos de

reemplazo, asumiendo uno, dos, tres, cuatro, cinco, seis o siete marcos ?
Recuérdese que todos los marcos están inicialmente vacíos, por lo que cada
una de sus primeras páginas provocarán un page fault.
a) LRU
b) FIFO
c) Reemplazo Optimo (Optimal Replacement)
Versión 2.0 45
MEMORIA VIRTUAL
Bibliografía
Ang98 – Angulo José María y Funke Enrique M. – Microprocesadores
Avanzados 386 y 486 – Editorial Paraninfo – Cuarta Edición - 1998
Bre01 - Brey Barry B. – Los Microprocesadores Intel – Prentice Hall – Quinta
Edición - 2001
Dei90 – Deitel H. M. – Sistemas Operativos – Addison Wesley – Segunda
Edición - 1990
Gro53 – Groves Jim – Windows NT Answer Book - Microsoft Press – First
Edition - 1953
Mic98 – Microsoft Corporation – Windows Architecture Training – Microsoft
Press – First Edition - 1998
Mil92 – Milencovick Milan – Sistemas Operativos Conceptos y Diseños – Mc
Graw Hill -Segunda Edición
Mur00 – Murdocca, Miles J. y Heuring Vincent P. – Principios de Arquitectura
de Computadoras – Prentice Hall – Primera Edición – 2000
Sil98 – Silverschatz Abraham y Galván Peter Baer – Operating Systems
Concepts – Addison Wesley – Fifth Edition – 1998
Sil02 – Silverschatz Abraham, Galvin Peter Baer y Gagne Grez – Sistemas
Operativos – Limusa Wiley – Sexta Edición – 2002
Sta01 – Stallings Willams – Sistemas Operativos – Prentice Hall – Cuarta
Edición – 2001
Sta00 – Stallings Willams – Organización y Arquitectura de Computadores –
Prentice Hall – Quinta Edición – 2000
Sta98 – Stallings Willams – Operating Systems Internals and Design
Principles – Prentice Hall – Third Edition – 1998
Tan92 - Tanembaum Andrews – Organización de computadoras un enfoque
estructurado – Prentice Hall – Tercera Edición – 1992
Tan97 – Tanembaum Adrews y Woodhull Albert. S – Operating Systems
Design and Implementation – Prentice Hall – Second Edition - 1997
Tan03 - Tanenaum Andrews – Sistemas Operativos Modernos – Pearson
Educación – Segunda Edición – 2003
Tur98 – Turley James L. – Advanced 80386 Programming Techniques –
Osborne Mc Graw Hill – First Edition - 1998
CAR01 – Jesús Carretero Pérez, Fekix García Carballeira, Pedro de Miguel
Anasagasti Fernando Perez Costoya – Sistemas Operativos Una visión
aplicada – Mc Graw Hill – Primera Edición - 2001
46 Versión 2.0

Memoria Virtual

Încărcat de

Informații document

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

Memoria Virtual

Încărcat de

Drepturi de autor:

Formate disponibile

SISTEMAS OPERATIVOS REF.

Ya conocemos varias estrategias de administración de memoria, todas con el

El término memoria virtual se refiere a la abstracción de memoria

La técnica de memoria virtual permite que se ejecuten procesos que

Un requerimiento básico para ejecutar una instrucción, es que ésta se

De hecho, observando varios programas reales, en muchos casos no

• Vectores, listas y tablas que tienen asignada más memoria que

• Ciertas opciones de un programa que pocas veces se usan.

Puede darse que se necesite todo el código de un programa, pero

• Un programa no está limitado por la cantidad de memoria física

• Cada programa puede ocupar menos memoria física y más

• Es implementada usando una memoria secundaria como

Memoria virtual es la separación de la memoria lógica de la memoria

La memoria virtual se implementa generalmente sobre discos rígidos

El proceso es básicamente dividir la totalidad del programa en páginas

Existen además algoritmos de reemplazo de estos segmentos que

Los datos son transferidos, desde la memoria secundaria a la memoria

¿POR QUÉ ES NECESARIA LA MEMORIA VIRTUAL?

Siempre se ha presentado un problema de relación entre el alto costo

Para los primeros computadores, los programadores dividían los

La estática: asume que la relación entre la disponibilidad de memoria

FUNCIONAMIENTO GENERAL DE LA MEMORIA VIRTUAL

claramente la posibilidad de la multiprogramación mediante la memoria

LA ESTRUCTURA DE LOS PROCESOS Y SU COMPORTAMIENTO:

La mayor cantidad de fallos de página ocurren durante el período de

Paginación por Demanda:

secuencia de páginas en lugar de un gran espacio de direcciones contiguas,

El mapper es la parte del sistema operativo que traduce el número de

Con este esquema, necesitamos alguna forma de apoyo al hardware

Téngase en cuenta que marcar una página como ‘invalid’ no tendría

Este trap es el resultado de que el Sistema Operativo no puede traer a

1) Se controla una tabla interna (generalmente almacenada con la

2) Si la referencia fue inválida, se termina el proceso. Si fue válida,

3) Encontramos un marco (frame) libre (tomando uno de la lista de

4) Planificamos una operación de disco para leer la página deseada

5) Cuando se completa la lectura, modificamos la tabla interna

6) Se recomienza la instrucción que fue interrumpida por el trap por

Es importante darse cuenta que, debido a que se salva el estado

En el caso extremo, podríamos comenzar a ejecutar un proceso sin

Teóricamente, algunos programas pueden acceder a varias páginas

El hardware para soportar la paginación por demanda es el mismo que

* Tabla de Páginas (PAGE TABLE): esta tabla tiene la habilidad de

* Memoria Secundaria: esta memoria almacena todas las páginas del

Algunas limitaciones adicionales se deben imponer. Algo crucial es la

volver a buscar la instrucción, decodificarla de nuevo, y luego buscar el

Como el caso más grave, considérese una instrucción de tres

1) buscar y decodificar la instrucción (ADD)

Si el trap ocurre cuando tratamos de almacenar en C (porque C se

El principal problema se da cuando una instrucción puede modificar

El problema se puede solucionar de dos maneras diferentes. En una

utilizan un registro como puntero y automáticamente decrementan o

LA CONVERSION DE DIRECCION LOGICA A FISICA.

Veamos como funciona:

LA MEMORIA ASOCIATIVA Y LA TABLA DE PAGINAS.

nanosegundos (tal vez menos) para realizar la operación de transferencia,

El uso de la TLB es transparente para los programadores, aunque si

• BIT de REFERENCIA: Indica si la página fue usada o llamada

• BIT de PROTECCION: También llamado bit de permisos.

• CACHING: Indica la ubicación de esa página en el disco. En

• DATE TIME STAMP: Indica la fecha y hora en que la página

• BIT de COPIA por ESCRITURA: Destinado a marcar páginas

PERFORMANCE DE LA PÁGINACIÓN POR DEMANDA

Sea p la probabilidad de un page fault (0 <= p <= 1). Desearíamos que

Tiempo de Acceso Efectivo = ( 1 - p ) . ma + p . tiempo de page fault