Walter Gaibor N.

GESTIÓN DE MEMORIA
El objetivo es estudiar como el sistema operativo gestiona
la memoria. La parte del sistema operativo que se encarga
de esta gestión se llama gestor de memoria.

Con el transcurso del tiempo y la tecnología, los gestores

han ido evolucionando a medida que los sistemas
operativos se han ido desarrollando.

La memoria es un recurso utilizado tanto por el sistema

operativo como por los programas en ejecución. Es un recurso
que debe ser compartido por los procesos que están cargados
en el sistema y, por lo tanto, debe ser gestionado de forma
eficiente.

El gestor de memoria, asigna memoria a los Procesos que llegan

al sistema, libera la memoria de los procesos que abandonan el
sistema, garantiza la utilización segura de memoria, etc.
La memoria se puede asemejar a una tabla divida en celdas de igual
tamaño.

En cada una de las celdas se alberga un dato y cada dato tiene su propia
dirección. El tamaño de la tabla y de las celdas pueden variar de un
sistema a otro, es dependiente de la arquitectura de la máquina. El
tamaño de la celda, por ejemplo, pueden ser bit, byte, palabra, etc.

El tamaño de la memoria varía mucho de un sistema a otro. En las PC

que se utilizan es normal que tenga un tamaño de 512 K o 1024 K.

La memoria, normalmente se divide en dos partes: la que utiliza el sistema

operativo y la que utilizan el o los programas que están ejecutando en el
sistema.

Debido a esta convivencia de procesos es necesario proteger al S.O. de los otros

procesos y a los procesos, entre ellos, de accesos inadecuados.
Fragmentación.

La fragmentación es el desaprovechamiento de la memoria, y puede ser de dos

tipos: interna y externa.

La fragmentación interna se produce cuando la memoria se divide en

particiones de tamaño fijo. Es la diferencia de tamaño que hay entre la
partición y el proceso albergado en ella. Por ejemplo, tenemos una partición
de 100K y un proceso de 90K, si el proceso se carga en esa partición se
produce Una fragmentación interna de 10K.

La fragmentación externa se produce cuando la memoria se divide en

particiones de tamaño variable. Es el desaprovechamiento de espacio entre
particiones. Por ejemplo, supongamos dos particiones de memoria no
contiguas que tienen un tamaño de 20K cada una. Si queremos cargar un
proceso de 30K se produce una fragmentación externa de 40K. El proceso no
se puede cargar en memoria, a pesar de que hay espacio libre suficiente,
Porque el sitio disponible para albergarlo no está contiguo.
Reubicación.

Para ejecutar un programa, éste debe cargarse en memoria. Cada vez que se
carga se puede ubicar en diferentes zonas de memoria. Esta variación en la
ubicación se debe, por un lado, que en los sistemas multiprogramados el
estado de la memoria varia de un instante a otro. Por otro lado, para maximizar
el uso del procesador a veces se descargan y/o cargan los procesos activos
de/en memoria. Por estos motivos no es eficiente que un proceso se deba
situar siempre en la misma zona de memoria. La posibilidad de ubicar el
proceso en diferentes particiones de memoria se denomina reubicación.

Una consecuencia de la variación en la ubicación de los procesos es que las

direcciones que genera un proceso varían cada vez que se carga. Existen dos
tipos de reubicación: La estadística y la dinámica.

La reubicación estadística se lleva a cabo durante la carga del programa. Todas

las direcciones generadas son relativas a la dirección a partir de la cual se carga
el programa. Una vez que el programa ha sido cargado, este no puede ser
movido a otra dirección de memoria.
 La reubicación dinámica se lleva a cabo durante la ejecución del programa; En
vez de generar las direcciones en la carga, se genera dinámicamente a medida
que se van referenciando. El programa puede ser trasladado a otra zona de
memoria sin que ello tenga consecuencias falsas.

Una consecuencia de la reubicación dinámica es que se tienen dos visiones

diferentes: la del programador y la del sistema operativo.

Para un programador, un programa siempre comienza en la misma dirección.

Para el sistema operativo, el programa comienza a partir de la dirección que

realmente a sido cargado en memoria.

La ventaja de este tipo de reubicación frente a la estadística es que Los

programas pueden ser cambiados de sitio en tiempo de ejecución.
Protección
Tanto en los sistemas monoprogramados como en los multiprogramados
es necesario establecer mecanismos de protección.

La parte del sistema operativo que se encarga de establecer la protección, debe

evitar que los Procesos accedan a diferentes direcciones de memoria no
incluidas en su espacio de direccionamiento.

En los sistemas monoprogramados los mecanismos de protección deben evitar

que el proceso albergado en memoria acceda a las direcciones de memoria
pertenecientes al sistema operativo.

En los sistemas multiprogramados se debe evitar que los procesos accedan a la

zona de memoria del sistema operativo y a las zonas de memoria de otros
procesos.

Compartición.
En los sistemas multiprogramados, en numerosas ocasiones, los procesos que
conviven en el necesitan compartir datos. En este compartimiento de datos se
realiza a través de zonas de memoria a las que se pueden acceder los procesos
que comparten la información. El sistema operativo, concretamente el gestor de
memoria, debe encargarse de controlar el uso adecuado de estas zonas de
memoria.
 GESTOR DE MEMORIA.

El gestor de memoria es la parte del sistema operativo encargada de administrar

la memoria. Se ocupa de gestionar la memoria asignándola a los procesos,
liberándola de los procesos cuando estos finalizan, contabilizando la
cantidad de memoria ocupada y libre, de gestionando el intercambio
entre disco y memoria.

Los gestores de memoria han ido evolucionando, desde los de los sistemas mono
programados, que eran sencillos, a los que se utilizan en los actuales
sistemas multiprogramados modernos que emplea un sistema de gestión
de memoria llamado memoria virtual.
 ESQUEMAS DE GESTION DE MEMORIA

Existen sistemas en los que no se coloca ningún gestor de memoria. El

programador tiene acceso total a todo el espacio de memoria y no recibe
ningún servicio por parte del sistema operativo.

Otro esquema de gestión de memoria es el que se utilizo en los primeros

sistemas monoprogramados:
se reservaba una zona de memoria para el sistema operativo y el resto de
la memoria era para el proceso de usuario. En este tipo de sistema se
protege la zona de memoria asignada al sistema operativo, con la
finalidad de evitar accesos indebidos por parte del proceso cargado de
memoria.

Con la aparición de la multiprogramación el gestor de memoria también

evoluciona. A continuación vamos a ir examinando diferentes métodos de gestión
de memoria que se han ido utilizando en los sistemas en los que conviven
varios procesos.
Memoria Particionada.
En este esquema de gestión de memoria, el sistema operativo ocupa siempre una
zona de memoria, mientras que el resto está disponible para los procesos que
van llegando al sistema. La zona de memoria que está a disposición de los
procesos se puede dividir en un número fijo o variable de particiones. Cuando el
numero de particiones es fijo, hablamos de un sistema de gestión de memoria
con número fijo de particiones o MFT (Multiprogramación con número fijo de
tares).Si el numero de particiones es variable, el esquema de gestión de
memoria se denomina MVT (Multiprogramación con número variable de tareas).

MFT La zona de memoria reservada para los procesos se divide en un número fijo
de particiones; el tamaño de cada partición es invariable una vez que se ha
establecido. El número de particiones y el tamaño de cada una se define en el
momento de arrancar la maquina. El resultado es un sistema multiprogramado
con número fijo de tareas. Las particiones pueden ser todas del mismo tamaño o
de diferente tamaño.

El algoritmo de ubicación debe decidir en qué partición debe albergar al nuevo

proceso en memoria es trivial si todas las particiones tienen el mismo tamaño.
Es indiferente en que partición se ubique un proceso mientras haya particiones
libres. Si no hay particiones libres, el/los proceso/s que deba/n cargarse en
memoria tendrán que esperar a que se libere una partición.
Cuando las particiones de memoria son de diferente tamaño se pueden aplicar
varios algoritmos de ubicación. Una política de ubicación es asignar la primera
partición disponible en la que quepa el proceso. Otra política consiste en
asignar al proceso la partición libre más pequeña en la que quepa. En el primer
caso, se utilizara una única cola. En el segundo caso se empleara una cola para
cada partición. Si existen varias particiones de igual tamaño, se asigna una cola
a todas las particiones de igual tamaño.

En particiones de la memoria en zonas estáticas de igual tamaño hay dos

problemas:
(1)Se produce fragmentación interna.
(2)Un Programa puede ser demasiado grande y no cabe en ninguna de las
particiones.

MVT La zona de memoria reservada para los procesos se divide en un número

variable de particiones; el tamaño de cada partición también es variable. A
medida de que van llegando los procesos al sistema, se les va asignando
particiones del espacio libre de memoria. El tamaño de memoria coincide con
la cantidad de memoria que necesita el proceso.
Cuando un proceso finaliza, se libera la zona de memoria que tiene asignada. Al
principio toda la memoria, excepto la zona asignada al sistema operativo, está
libre. Se van asignando particiones al proceso. Después de pasar un tiempo,
se van a generar huecos en memoria. Llega un momento en que los huecos
libres disponibles son pequeños para albergar procesos y existe el peligro de
que se produzca fragmentación externa.

El algoritmo de ubicación debe elegir en que hueco, de los que hay libres, se
alberga al nuevo proceso que ha llegado al sistema. Hay diversas
posibilidades, las dos más conocidas son:
(1) el mejor ajuste: elige de entre todos los bloques que hay libres y son de
igual o mayor tamaño que el proceso, el que se aproxime más al tamaño del
proceso;

(2) el primer ajuste: Selecciona el bloque libre de igual o mayor tamaño que
primero encuentre; la búsqueda comienza por la primera dirección de
memoria.
El particionamiento de la memoria en zonas dinámicas genera
fragmentación externa a pesar de eliminar la fragmentación
interna. La fragmentación externa se puede eliminar
compactando la memoria. Cada cierto tiempo, el sistema
operativo desplaza los procesos para que toda la memoria libre
esta contigua en el bloque. Esta técnica resuelve el problema de
la fragmentación externa pero consume mucho tiempo.
EJERCICIOS
• Considérese un sistema de gestión de memoria con particiones estáticas o MFT
(Multiprogramación con un número Fijo de Tareas). El sistema operativo ocupa la
primera partición que tiene un tamaño de 10 K: el resto de la memoria está dividida
en cuatro particiones cuyas características se muestran en la Tabla 2.1. El algoritmo
de ubicación asigna a cada proceso la partición más pequeña en la que quepa: por
lo tanto se empleará una cola de planificación para cada partición. En la Tabla 2.2
podemos ver la cantidad de memoria que requiere cada proceso. Se pide mostrar
cómo el algoritmo de ubicación va albergando los distintos procesos en memoria.
• SOLUCIÓN
• El algoritmo de ubicación alberga cada proceso en la partición más pequeña en la que quepa. Tendremos tantas
colas de planificación como particiones, ya que todas son de distinto tamaño. El proceso A entrará en la cola 3. el
proceso B en la 4, el C en la 1, el D en la 3 y el proceso E se ubicará en la cola 4.
• En la Figura 2.3 se muestra el contenido de las colas asignadas a cada una de las particiones de memoria. Los
procesos D y E quedan a la espera de que se desocupen las particiones de 8 y16 k respectivamente.

Sistema operativo
10k
C 18k

12k

8k
D A 16k

E B

Comentario: La partición de 12 K no se usa. Esta partición se podría haber asignado al proceso D o al A.

ya que ambos entran en ella, pero la política de ubicación priorizada el hecho de minimizar la
fragmentación interna
• Considérese el mismo sistema que en el ejercicio anterior con la
salvedad de que en este caso se emplea una única cola de procesos. Los procesos que llegan al sistema y sus
características son los misa que los del ejemplo anterior. El algoritmo de ubicación carga los procesos en la partición
disponible libre) mas pequeña en la que quepan.
• Resolución
• Al igual que en el ejercicio anterior. la memoria sigue dividida en cinco particiones estáticas tal y como hemos
representado en la Figura 2.2. pero el algoritmo de ubicación emplea una sola cola de procesos Éste alberga a cada
proceso en la partición libre mis pequeña en la que quepa el proceso. Siguiendo die algoritmo de ubicación. con la Figura
2.4 se representa gráficamente cómo se lleva a cabo la asignación de memoria.
• Comentario
• La partición de 12 K si se utiliza. ahora el proceso D no espera a que quede libre la partición de 8 K. proceso E es el único
que se queda esperando en la cola. Esta espera es debida a que todas las particiones de memoria están ocupadas.

Sistema operativo
10k

18k

E D C B A
12k

8k

16k
Tenemos un sistema con gestión de memoria MFT compuesto por cuatro particiones cuyas características se muestran en la
Tabla 2.3. El tamaño, el instante de llegada y la duración de los procesos que llegan al sistema están en la Tabla 2.4.
Se pide determinar cómo se realiza la asignación de particiones y el tipo y tamaño de la fragmentación que se produce para
los siguientes casos:
a) Se emplea una cola de procesos por partición. El algoritmo de ubicación asigna al proceso la partición más pequeña
en la que quepa.
b) b) Se emplea una cola única de procesos. El algoritmo de ubicación asigna la primera partición disponible en la que
quepa el proceso.
Nota: Los tiempos de carga y desalojo en/de memoria se consideran despreciables.

BASE DE LA PARTTICION TAMAÑO DE LA ESTADO

PARTICION
0K 150K ASIGNADA AL S.O.
150K 100K LIBRE
250K 150K LIBRE
400K 100K LIBRE
TABLA 2.3 características de las particiones

PROCESO INSTANTE DE DURACION TAMAÑO

LLEGADA
A 0 3 130K
B 1 3 90K
C 2 2 80K
D 3 2 70K
E 5 4 110K

TABLA 2.4 característica de los procesos

• SO (a) SO
instante 2
B

instante 3 instante 5
SO SO
SO
• instante 0 B D

E
A
C

SO
instante 4
SO

B D
• instante 1
A
El gestor de memoria ubicará los procesos en memoria a través de dos colas: una para la partid de 150 K y otra para las dos
particiones de 100 K. La carga de los procesos en memoria, que hemos representado en la Figura 2.5, se lleva a cabo de la
siguiente manera:
■ Instante O, el proceso A llega al sistema y entra en la partición de tamaño 150 K. Se produce una fragmentación interna de
20 K.
■ Instante 1, el proceso B se carga en la primera partición de tamaño 100 K. Hay fragmentacion interna igual a 10 K.
■ Instante 2, el gestor de memoria carga el proceso C en la segunda partición de tamaño 100 K. Esta operación produce una
fragmentación interna de 20 K.
■ Instante 3, en este punto ocurren dos hechos importantes: el proceso A deja libre la partición de 150 K y el proceso D
entra en la cola correspondiente. No se carga el proceso D porque la partición libre es de 150 K y este proceso se debe
ubicar, siguiendo el algoritmo de asignación de particiones, en una de las particiones de 100 K. En este instante tenemos
una fragmentación interna de 30 K, la fragmentación que produce la carga del proceso B más la que produce la carga del
proceso C.
■ Instante 4, en este momento ocurren los siguientes acontecimientos: los procesos B y C libe-ran las dos particiones de 100
K; el proceso D entra en la primera partición de 100 K. La carga del proceso D genera una fragmentación interna de 30 K.
■ Instante 5, la partición de 150 K es ocupada por el proceso E, lo cual produce una fragmentación interna de 40 K.
Ahora empleemos una sola cola para gestionar las tres particiones estáticas en las que se divide la memoria
dedicada a los procesos de usuario. En este caso, la carga de los procesos la representamos en la Figura 2.6 y
se realiza de la siguiente forma:
■ Instante O, el proceso A llega al sistema y se carga en la partición de 150 K. Fragmentación interna de 20
K.
■ Instante 1, en la primera partición de 100 K se alberga el proceso B. Fragmentación interna de 10 K.
■ Instante 2, en la segunda partición de 100 K se carga el proceso C. Fragmentación interna igual a 20 K.
■ Instante 3, ocurren dos hechos: el proceso A deja libre la partición que ocupaba, el proceso D llega al
sistema. Este proceso se cargará en la partición de 150 K, lo cual provoca una fragmentación interna de 80 K.
■ Instante 4, los procesos B y C abandonan las particiones de memoria que ocupaban.
■ Instante 5, el proceso D abandona la partición de 150 K que es ocupada por el proceso E. La carga de este
proceso genera una fragmentación interna de 40 K.
• MULTIPROGRAMACIÓN CON NUMERO VARIABLE DE TAREAS

• Nuestro sistema operativo sigue un esquema de gestión de memoria con

particiones dinámicas o MVT (Multiprogramación con número Variable de
Tareas). La memoria tiene un tamaño de 64 K de los cuales las 10 K primeras
posiciones están ocupadas por el sistema operativo. Al sistema llegan cinco .
trabajos cuyo tamaño, instante de llegada y duración se muestran en la Tabla 2.5.
Se pide representar gráficamente cómo se van cargando los procesos en
memoria principal.
PROCESO TAMAÑO INSTANTE DE DURACION
LLEGADA
A 8K 1 7

B 14K 2 7

C 18K 3 4

D 6K 4 6

E 14K 5 5

TABLA 2.5 tamaño de instante de llegada y duración de los procesos

• El proceso E llega al sistema en el instante 5, en este momento permanece libre el " hueco" que está al final de la
memoria. Esta partición de 8 K es demasiado pequeña para albergar al proceso E. Tendremos que esperar a que algún
proceso libere memoria para que el proceso E se pueda cargar. En el instante 7, cuando el proceso C termina su
ejecución, se libera memoria. En este instante tendremos libres dos particiones una de 18 K y otra de 8 K. El proceso E
será albergado en la partición de 18 K generando un nuevo "hueco" de 4 K. En la Figura 2.8 hemos representado
gráficamente la carga del proceso E una vez que el proceso C ha salido de memoria.
S.O
10K
PROCESO A
8K
PROCESO B
10K
PROCESO E
14K

PROCESO D
6K

Comentario:
Se puede observar que a medida que van entrando y saliendo procesos de memoria se van generando
"huecos" en ésta. Llegará un momento en el que, a pesar de que haya espacio libre en memoria, no se
Podrán albergar procesos por que ele espacio libre no es suficiente grande. Para solucionar este problema lo
que se hace es compactar la memoria juntando todo el espacio libre .Esta operación es efectiva pero muy
costosa
 Paginación.
Los dos esquemas de gestión de memoria particionada que hemos visto tienen problemas.
Con MFT se produce fragmentación interna y MVT provoca fragmentación externa. La
paginación resuelve total o parcialmente estos problemas. Con un sistema de gestión de
memoria paginada, la memoria y los procesos se dividen en pequeños trozos de tamaño
fijo e igual. Cada trozo perteneciente al proceso se llama página y cada trozo de memoria
se denomina marco.

El tamaño de la página viene fijado por el hardware: 2K o 4K son ejemplos de tamaños de

página o marco, cuando un proceso debe cagarse en memoria, sus páginas serán
asignadas a marcos libres de memoria, no siendo necesario que los marcos asignados
estén situados de forma contigua. De esta manera, el espacio desaprovechado en
memoria por cada proceso es una fracción de último marco asignado al proceso. Por lo
tanto, con este esquema de gestión de memoria, se produce solamente fragmentación
interna, cuyo valor máximo será un poco menos que el tamaño de la página.
La dirección lógica, generada por el proceso, está formada por el número de página y el
desplazamiento dentro de esta. La dirección física la constituyen el número de marco y el
desplazamiento. El sistema operativo mantiene la tabla de páginas para relacionar cada página
con el marco en el que está cargada. Existe una tabla de páginas por cada proceso y está tiene
tantas entradas como páginas forman el proceso. En la tabla de páginas se almacena la
dirección de memoria del marco correspondiente a cada página. La MMU traduce la dirección
lógica a dirección física utilizando la información de la tabla de páginas del proceso. Cuando se
carga un proceso en memoria, se asignan todas las páginas a marcos libres y se rellena la tabla
de páginas.

En paginación, la protección se establece a través de la tabla de páginas. Cada una de las

entradas contiene los bits de acceso utilizados para restringir los accesos a la página.
Compartir el contenido de una página es muy sencillo, basta con referenciar al mismo marco
desde las tablas de páginas de los procesos que deben compartir la información.

En paginación es necesario saber qué marcos de la memoria principal están libres y cuales
ocupados. Para lograr este objetivo se conocen dos mecanismos: mapa de bits tiene una
entrada por marco; cada entrada puede tener dos valores 0 o 1 para indicar si el bloque está
ocupado o no. En la lista enlazada se guardan únicamente los marcos libres.
• Estamos trabajando con un sistema operativo que emplea una gestión de
memoria paginada. Cada página tiene un tamaño de 2.048 posiciones (o bytes.
La memoria física disponible para los procesos es 8 M. Primero llega un proceso
que necesita 31.566 posiciones de memoria y. después. llega otro proceso que
consume 18.432 posiciones cuando se carga en memoria. Se pide:
• 1. ¿Qué fragmentación interna provoca cada proceso?
• 2. ¿Qué fragmentación externa provoca cada proceso?
• Para saber si existe fragmentación interna se debe calcular el número de páginas que necesita
el proceso para ejecutarse, y ver si de la última página se utilizan todas las posiciones.
Si se utilizan todas las posiciones de la última página no se produce fragmentación interna, en
caso contrario si se produce.

1) Parte a): Calcular las páginas que necesita el programa para ejecutarse, dividiendo el tamaño
del programa entre el tamaño de la página.
• Número de páginas = 31566 bytes/2048 bytes = 15,4 páginas
• El programa necesita 16 páginas
• Ahora debemos determinar si el proceso entra en la memoria, calculando las páginas
disponibles que hay en el almacenamiento primario.
• Número de páginas en memoria =
• 8M (1024 * 1024 *8 ) / 2048 =4096 pág
• El proceso entra en memoria en vista que hay 4096 páginas libres y el proceso
ocupa 16.
• Sabemos que se usa fragmentación interna en vista que se utiliza 15.4
páginas:
• 31566-(15 páginas * 2048 posiciones/pagina) = 846 posiciones ocupadas
• La cantidad de fragmentación interna es 2048 – 846 = 1202 bytes

Parte b):
Páginas que ocupa el segundo programa: 18432/2048 = 9 páginas

En memoria todavía existe espacio: Total 4096 páginas

- 16 proceso 1
- 9 proceso 2 sin frag. Interna
4071 libre

2) La gestión de memoria paginada evita la fragmentación externa.

Estamos trabajando con un sistema operativo que emplea una gestión de memoria paginada. Cada libpágina tiene un
tamaño de 2.048 posiciones (o bytes). La memoria física disponible para los procesos es 8 M. Primero llega un proceso que
necesita 31.566 posiciones de memoria y, después, llega otro proceso que consume 18.432 posiciones cuando se carga en
memoria. Se pide:
1. ¿Qué fragmentación interna provoca cada proceso?
2. ¿Qué fragmentación externa provoca cada proceso?
Resolución I.
a) Para saber si existe fragmentación interna tenemos que calcular cuántas páginas necesita el proceso para ejecutarse y
ver si de la última página se utilizan todas las posiciones. Si se utilizan todas las posiciones de la última página, no se
produce fragmentación interna, en caso contrario sí se produce este tipo de fragmentación. Primero calcularemos las
páginas que necesita el programa para ejecutarse, dividiendo el tamaño del programa entre el tamaño de la página. número
de páginas del programa = 31.566 bytes/ 2.048 bytes = 15, 4 páginas.
El programa necesita para ejecutarse 16 páginas. Ahora vamos a averiguar si el proceso entra en memoria, calculando las
páginas disponibles que hay en almacenamiento primario. Para hacer este cálculo dividiremos el tamaño de la memoria
entre el tamaño de la página.
número de páginas de la memoria = 8M(1.024 x 8K)/ 2.048(2K) = 4.096 páginas.
De este cálculo deducimos que el proceso entra en memoria, ya que hay 4096 páginas libres y el proceso ocupa 16 páginas.
De este cálculo deducimos que el proceso entra en memoria, ya que hay 4096 páginas libres y el proceso
ocupa 16 páginas. Sabemos que se produce fragmentación interna, concretamente de la última página sólo
se ocupan 846 posiciones. Para calcular la fragmentación interna primero averiguamos las posiciones
ocupadas en la última página y después restamos esta cantidad al tamaño de la misma. Las posiciones
ocupadas en la ultima página son:
31.566 — (15páginas x 2.048 posiciones/página) = 846 posiciones ocupadas
La cantidad de fragmentación interna que se produce es:
2.048 — 846 = 1.202 bytes
b) Ahora vamos a ver cuántas páginas ocupa el segundo programa.
número de páginas del programa = 18.432 bytes/ 2.048= 9 páginas
En memoria todavía nos queda espacio para albergar este proceso. La memoria se divide en 4.096 páginas y
el primer proceso sólo ocupa 16 páginas. Quedan libres para albergar el segundo proceso 4.080 páginas.
Además, no se produce fragmentación interna, ya que todas las páginas del proceso quedan ocupadas al
completo.
2 . La gestión de memoria paginada evita la fragmentación externa. Por lo tanto, no existe fragmenta-ción de
este tipo debido a la naturaleza del sistema de gestión de memoria.
Comentario A un programa nunca se le puede asignar porciones de una página, aunque el programa puede
emplear sólo una parte de la última página asignada (en cuyo caso tendríamos fragmentación interna). El
número de páginas asociadas a un proceso es siempre un entero.
• El sistema operativo utiliza un mapa de bits para contabilizar el uso de la
memoria. Se sabe que la memoria tiene un tamaño de 1,5 G, que se utiliza un
sistema de gestión de memoria paginada y que el tamaño de la pagina esde 3K.
Se desea conocer cuantas K ocupa el mapa de bits que contabiliza el caso de la
memoria

Total memoria en K: 1,5G*1024*1024= 1.572.864 K

El número de marcos de memoria se obtiene dividiendo el tamaño de la memoria y el

tamaño de la página: 1.572.864 K / 3 K = 524.288

En el mapa de bits existe una entrada por cada marco y cada entrada ocupa un bit.

Al tener 524288 marcos tendríamos 524.288 bits,

en bytes sería: (524.288/8) = 65.536 bytes

En K sería (65.536/1024)= 64 k ocupa el mapa de bits.

• El sistema operativo utiliza un mapa de bits para contabilizar el uso de la memoria . Se sabe
que la memoria tiene un tamaño de 1,5 G, que se utiliza un sistema de gestión de memoria
paginada y que el tamaño de la página es de 3 K. Se desea conocer cuántas K ocupa el mapa
de bits que contabiliza el uso de la memoria.
• Resolución
• En el mapa de bits existe una entrada por cada marco y cada entrada ocupa un bit. Para
calcular el tamaño del mapa de bits primero debemos conocer el número de marcos que hay
en la memoria. Sabemos que cada marco tiene un tamaño de 3 K, y el tamaño de la memoria
en K será:
• 1, 5G x 1.024 x 1.024 = 1.572.864 K tiene la memoria.
• El número de marcos de memoria se obtiene dividiendo el tamaño de la memoria entre lo
que ocupa cada marco.
• 1.572.864K/3K/marco= 524.288 marcos.
• El mapa de bits tiene 52.488 entradas, por lo tanto ocupa esos bits. Para pasar de bits a K
dividiremos primero entre 8 y luego entre 1.024.
• 524.288 /8 = 65.536 bytes
• 65.536 /1.024 = 64 K ocupa el mapa de bits
• Comentario:
• La utilización de un mapa de bits para contabilizar el uso de la memoria presenta varios inconvenientes: (1) el mapa
puede llegar a ocupar mucho espacio; (2) cuando se desea localizar un marco libre, puede ocurrir que haya que recorrer
• Las paginas en nuestro sistema tiene un tamaño de 8K. También sabemos que le
tamaño de cada entrada de la tabla de paginas es de 32 bits. Se pide: calcular el
espacio ocupando por la tabla de paginas para un proceso con un espaci0 de
direccionamiento de 264 bytes.

Para calcular la tabla de páginas de un proceso primero debemos averiguar cuantas

páginas ocupa éste.
Las páginas en nuestro sistema tienen un tamaño de 8 K. También sabemos que el
tamaño de cada entrada de la tabla de páginas es de 32 bits. Se pide: calcular el
espacio ocupado por la tabla de páginas para un proceso con un espacio de
direccionamiento de 264 bytes.
Resolución
Para calcular lo que ocupa la tabla de páginas de un proceso primero debemos
averiguar cuántas páginas ocupa éste. Para saber el número de páginas que ocupa,
dividiremos su espacio de direccionamiento entre lo que ocupa cada página. El
tamaño de la página es de 8 Kbytes = 213 bytes, luego:
264 bytes/proceso 51 paginas
= 2
213 bytes/página
Lo que ocupa la tabla de páginas se calcula multiplicando el tamaño de cada
entrada por el número de entradas. Cada página ocupa una entrada. 251 entradas x
22 bytes/entrada = 253 bytes ocupa la tabla de páginas
Comentario:
Cuanto más pequeña es la página, más espacio ocupa la tabla de páginas de un
proceso. Sin embargo, reduciendo el tamaño de la página se reduce la
fragmentación interna que se pueda producir.
2.4.8.
Las direcciones que genera un proceso contienen, en este orden: número de página + de spl a - zami ent o.
Cada página tiene un tamaño de 2 K. Nos piden que calculemos la cadena de referencia correspondiente a
las siguientes direcciones generadas por el proceso:
0100 0200 0100 0200 0300 0200 0300 0900 0800 0900 0800
1000 0900 1100 1000 0900 1200 1100 1200 1100 3000 3100
3250 3150 3250 3150 3250 3150 4111 3200 4111 5000 6000
Nota: Las direcciones vienen dadas en hexadecimal.
Resolución
Para calcular la cadena de referencia de un proceso debemos conocer qué páginas son referenciadas. Este
dato se puede extraer de las direcciones generadas por el proceso. Sabemos que la dirección está formada
por (en este orden): número de página y desplazamiento; pero no conocemos cuántos bits ocupa cada
componente de la dirección. Sabemos que cada página tiene un tamaño de 2 K. De este dato podemos
deducir cuántos bits ocupa el desplazamiento. Restando el número de bits que ocupa el desplazamiento al
número de bits que ocupa la dirección, podemos deducir cuántos bits forman el número de página. Por un
lado, las direcciones vienen dadas en hexadecimal y están formadas por cuatro números, lo que son 16 bits.
Por otro lado, nos dicen que la página tiene 2 K, luego para representar este desplazamiento necesitaremos
11 bits 211 = 2.048. Si la dirección ocupa 16 bits y el desplazamiento 11, el número de página está formado
por 5 bits. En nuestro caso estos 5 bits son los de más peso.
Como ya sabemos cuántos bits ocupa cada parte de la dirección, vamos a coger la primera dirección
generada ver cuál es el valor del número de página y cuál es el valor del desplazamiento. En la Figura 2.9 se
ve qué bits de esta dirección corresponden al número de página y cuáles al desplazamiento.
• Dirección

0100

0000 0001 0000 0000

pagina desplazamiento
Figura 2.9 Descomposición en número de página y desplazamiento para la dirección 0100.
Luego la dirección de memoria 0100 se encuentra en la página 0. Una vez que hemos visto cómo calcular la página a la que
hace referencia una dirección, podemos averiguar cuál es la cadena de referencia correspondiente a las direcciones
generadas por el proceso:
012121268681012
Si dos o más direcciones que se generan seguidas hacen referencia a la misma página, solamente incluimos una referencia a
la página. La cadena completa generada por el proceso sería:
• 0001 0200 0100 0200 0300 0200 0300 0900 0800 0900 0800
0 0 0 0 0 0 0 1 1 1 1
1000 0900 1100 1000 0900 1200 1100 1200 1100 3000 3100
2 1 2 2 1 2 2 2 2 6 6
3250 3150 3250 3150 3250 3150 4111 3200 4111 5000 6000
6 6 6 6 6 6 8 6 8 10 12
Comentario
El tamaño de la dirección en la paginación es dependiente al bardware.Cuanto
mas grande sea la pagina mas bits ocupara el desplazamiento
Segmentación.
La gestión de memoria segmentada se fundamenta en dividir los procesos en
segmentos. Estos segmentos pueden ser de diferente longitud, aunque existe un
tamaño máximo de segmento que depende de la arquitectura de la máquina. En la
mayoría de los sistemas los procesos se dividen en tres segmentos: código, datos y
pila.
Cuando el proceso se carga en memoria se le asigna tantas zonas memoria como
segmentos tenga; el tamaño de las zonas será el mismo que el de los segmentos. No
es necesario que las zonas designadas sean contiguas, pero el contenido de un
segmento debe estar situado en un bloque contiguo de memoria.
Cuando se carga el proceso en memoria se le asignan tantas zonas de memoria como
segmentos tenga y se rellena la tabla de segmentos. En segmentación, la protección
se establece en función del límite o tamaño del segmento. También se pueden
establecer distintos derechos de acceso a cada segmento del proceso, mediante la
inclusión de bits de acceso en la tabla de segmentos. La información de un segmento
es compartida por dos o más procesos, si se incluye en la tabla de segmentos de
cada proceso la dirección base del segmento a compartir.
Uno de los inconvenientes que presenta la segmentación es que existe un tamaño
máximo de segmento y puede ocurrir que algunos procesos tengan segmentos
mayores que el tamaño máximo. Otro inconveniente Importante es que, de vez en
cuando, se necesita compactar la memoria.
EJERCICIO SEGMENTACIÓN:
• En un sistema, el tamaño de la memoria es de 1 M y se sigue un esquema de gestión de memoria segmentado. El tamaño
del segmento varía en función de las necesidades de los distintos procesos que van llegando al sistema. Todo proceso
tiene tres segmentos: el de código, el de datos y el de pila. En el instante uno la tabla de segmentos tiene el contenido
que se muestra en la Tabla 2.6. A partir de este instante llegan al sistema dos procesos (B, C), cuyas características se
muestran en la Tabla 2.7, junto con las características del proceso que estaba en el sistema (A). Se pide:
• 1.¿Cuándo se carga en memoria el proceso B? ¿Y el C? Muestre el contenido de la tabla de segmentos después de
cargarse cada proceso.
• 2. ¿Se produce algún tipo de fragmentación?
• 3.Después de que se han cargado en memoria los procesos B y C, vamos a suponer que llegan al sistema otros dos
procesos (D, E). Los instantes de llegada, así como las características de estos dos nuevos procesos, se muestran en la
Tabla 2.7. Se pide; dibuje el contenido de la nueva tabla de segmentos.
• Resolución
• ■ El proceso B se cargará en memoria en el instante en el que llegue, ya que hay sitio disponible. Concretamente, sus
segmentos se situarán a continuación de los segmentos del proceso A. El con-tenido de la tabla de segmentos después de
llegar este proceso se muestra en la Figura 2.11. En esta figura también se puede ver el estado de la memoria después de
cargarse el proceso B. TRABAJO T.LLEGADA DURACION TAMAÑO

BASE TAMAÑO ESTADO A 0 6 CODIGO 250K / PILA 50K /

DATOS 100K
SEGMENTO SEGMENTO SEGMENTO
B 1 5 CODIGO 350K /PILA 50K
0K 100K S.O /DATOS 100K
100K 250K CODIGO A C 2 7 CODIGO 300K /PILA 50K
/DATOS 100K
350K 50K PILA A
D 8 15 CODIGO 250K /PILA 50K
400K 100K DATOS A /DATOS 100K

500K 524K LIBRE E 14 7 CODIGO 364K /PILA 50K

/DATOS 100K
TABLA 2.6 estado de segmentos después de cargarse el proceso A
TABLA 2.7 CARACTERISTICAS DE LOS TRABAJOS QUE LLEGAN AL SISTEMA
0K 100K S.O

100K 250K CODIGO A

350K 50K PILA A

400K 100K DATOS A

500K 524K
TABLA LIBRE
2.6 estado de segmentos después de cargarse el proceso A
TRABAJO T.LLEGADA DURACION TAMAÑO

A 0 6 CODIGO 250K
PILA 50K
DATOS 100K
B 1 5 CODIGO 350K
PILA 50K
DATOS 100K
C 2 7 CODIGO 300K
PILA 50K
DATOS 100K
D 8 15 CODIGO 250K
PILA 50K
DATOS 100K
E 14 7 CODIGO 364K
PILA 50K
DATOS 100K

TABLA 2.7 CARACTERISTICAS DE LOS TRABAJOS QUE LLEGAN AL SISTEMA

 BASE TAMAÑO ESTADO SO

0 100 SO
CODIGO A

100 250 CODIGO A

350 50 PILA A
PILA A
400 100 DATOS A
DATOS A
500 350 CODIGO B

850 50 PILA B CODIGO B

900 100 DATOS B

1000 24 LIBRE

PILA B
DATOS B

FIGURA 2.11 estado de la tabla de segmentos y de memoria después de cargarse en

el proceso B
• Para el proceso B no hay fragmentación externa porque consigue ubicarse en memoria. Con un sistema de
gestión de memoria segmentado no puede existir nunca fragmentación interna.
■ En el instante 2, cuando llega el proceso C al sistema, hay 24 K libres de memoria. En este instante el
proceso C no puede cargarse en memoria, no hay espacio libre suficiente. El proceso C dispondrá de espacio
libre suficiente en el instante 6, una vez que se libera la memoria de los procesos A y B. Una posible
ubicación de los segmentos de C es la que se muestra en la Figura 2.12
SO
Base tamaño SO
CODIGO C
100 300 CODIGO C
400 50 PILA C
450 100 DATOS C
550 474 LIBRE
PILA C
DATOS C

FIGURA 2.12 estado de la tabla y de la memoria después de cargarse el

proceso c
Cuando llega el proceso C al sistema, no disponemos de memoria suficiente para
ubicarlo. También podemos observar que se produce una fragmentación externa
de 24 K. El proceso C, como comienza a ejecutarse en el instante 6, finalizará su
ejecución en el instante 13.
■ El proceso D llega en el instante 8 y tiene memoria libre suficiente. Si
suponemos que se sitúa a continuación de los segmentos del proceso C, la tabla
de segmentos tendrá el contenido que se muestra en la Figura 2.13.
Para el proceso D no existe ningún tipo de fragmentación. El proceso D finaliza su
ejecución en el instante 23.
■ El proceso E llega al sistema en el instante 14. En este momento están libres las
zonas de memoria ocupadas por los segmentos del proceso C, así como un
segmento de 74 K en las últimas posiciones de la memoria.
El estado de la tabla de segmentos es el que se muestra en la Figura 2.14. Hay
espacio libre suficiente para albergar al proceso E, pero éste no puede ser ubicado
en memoria porque dicho espacio no está situado de forma contigua para albergar
a los tres segmentos. Podríamos ubicar el segmento de código y el de pila en los
bloques que deja libres el proceso C, pero no podemos ubicar al segmento de
datos porque el espacio sobrante no está situado de forma contigua. Por lo tanto,
se produce fragmentación externa. La solución a este problema es compactar el
espacio libre.
BASE TAMAÑO SO
SO
0 100 SO
100 300 CODIGO C
400 50 PILA C CODIGO C

450 100 DATOS C

550 250 CODIGO D
800 50 PILA D
850 100 DATOS D PILA C
950 74 LIBRE
DATOS C

CODIGO D

PILA D

DATOS D

FIGURA 2.13 estado de la tabla y de la memoria después de cargarse el

proceso D
 BASE TAMAÑO ESTADO SO

0 100 SO
100 300 LIBRE
400 50 LIBRE
450 100 LIBRE
550 250 CODIGO D
800 50 PILA D
850 100 DATOS D
950 74 LIBRE CODIGO D

COMENTARIO
Si no se compacta la memoria porque es una
operación muy costosa el proceso E tiene que
esperar ha ser cargado en la memoria .Se PILA D
cargara cuando alguno de los procesos ya
albergados libere memoria y haya espacio DATOS D
contiguo suficiente

FIGURA 2.14 estado de la tabla y de la memoria después de cargarse el

proceso E
2.4.1 2.
Nos piden calcular el máximo espacio de direccionamiento lógico de los procesos
que se ejecutan en un procesador, que tiene un sistema de gestión de memoria
segmentado. Se sabe que el tamaño máximo de un segmento es de 32 K, que los
selectores de segmento tienen un tamaño de 10 bits y que sólo existe una tabla de
descriptores local.
Resolución
Lo primero que tenemos que calcular es cuántos segmentos diferentes podemos
tener. Esto lo averiguamos a través del tamaño del selector: si éste tiene un
tamaño de 10 bits, quiere decir que como máximo podemos direccionar 21°
segmentos. Si cada segmento tiene como máximo 32 K, el máximo espacio de
direccionamiento para un proceso será:
32 K/segmento x 210 segmentos x 1 = 32768 K = 32 M
Multiplicamos por 1, ya que existe una sola tabla de segmentos.
Comentario:
Además de esta tabla local de segmentos también puede existir una tabla global
de segmentos. Si esto se da, hay que tener en cuenta la tabla global a la hora de
calcular el máximo espacio de direccionamiento.
 MEMORIA VIRTUAL
Todos los sistemas de gestión de memoria que hemos examinado en el apartado
anterior deben cargar el programa completo en memoria para que este
pueda ejecutarse. En los sistemas de gestión de memoria más avanzados,
paginación y segmentación, hemos visto que el proceso se carga en
memoria dividido en varios bloques, bien sean páginas o segmentos.

Una de las ventajas más importantes derivadas de la utilización de memoria

virtual es que se pueden ejecutar programas más grandes que la memoria. La
limitación en el tamaño de proceso viene dada por la capacidad de
almacenamiento del disco.
Otra ventaja ligada a lo anterior, es que se pueden cargar más procesos en
memoria. Como no cargamos el proceso completo hay más espacio disponible
para otros procesos y, en consecuencia, aumentados el rendimiento de la CPU.

Los procesos se ejecutan solo en memoria principal, a esta memoria se la llama

memoria real. Pero el usuario tiene la sensación de que trabaja con una
memoria de mayor tamaño. A esta memoria se la denomina memoria virtual y
está situada en el disco. Como consecuencia de ello existen dos tipos de
direcciones: direcciones reales o físicas y direcciones lógicas o virtuales.
Hardware

El hardware que habitualmente se utiliza para implementar un sistema de

gestión de memoria virtual basada en paginación es: dispositivo de
almacenamiento auxiliar, unidad de gestión de memoria y buffer de traducción
adelantada. Además se deben manejar dos estructuras de datos
imprescindibles: tabla de páginas y mapa de archivos.

MMU o unidad de gestión de memoria Si existe memoria virtual las direcciones

no se mandan directamente al bus de direcciones sino a la MMU. Este
dispositivo o conjunto de dispositivos, se encarga de traducir dinámicamente
las direcciones virtuales o reales consultando la tabla de páginas.

Dispositivo de almacenamiento auxiliar Es el disco duro, en el que se almacenan

todas las páginas del proceso.

Tabla de páginas Es una estructura de datos que se utiliza con el mismo objetivo
que en segmentación y paginación: para ayudar a la traducción de dirección
virtual a real. Esta tabla tendrá una entrada por cada página del proceso. En
cada entrada, además de la dirección del marco asignado, se almacenan
diferentes bits. Por ejemplo el bit de presencia que indica si la página
correspondiente está cargada o no en memoria. Se puede incorporar más bits
para facilitar el funcionamiento de la memoria virtual.
TLB o buffer de traducción adelantada La mayoría de los sistemas de gestión de
memoria virtual hacen uso de un cache especial para las entradas de la tabla
de páginas. Este cache funciona del mismo modo que una memoria asociativa
y contiene las entradas de la tabla de páginas usadas hace menos tiempo.

Mapa de archivos Esta estructura de datos se emplea para conocer dónde se

encuentran almacenadas, en el dispositivo de almacenamiento auxiliar, las
páginas del proceso.

Funcionamiento.
Los programas residen en el dispositivo de almacenamiento auxiliar. Las páginas
almacenadas en los dispositivos, a medida que son necesarias, se van
cargando en marcos de memoria.

Cuando intentamos acceder a una dirección y la página correspondiente no está

en memoria, será necesario traer dicha página del almacenamiento auxiliar a
memoria.
El proceso que se está ejecutando va generando direcciones, estas direcciones
son virtuales y deben ser traducidas a reales. La traducción la realiza la MMU
consultando la tabla de páginas.

Como estamos trabajando con un sistema de gestión de memoria que no tiene

todo el proceso cargado en memoria, puede ocurrir que la dirección a la que se
está intentando acceder no esté presente en memoria. Para evitar realizar
traducciones innecesarias primero la MMU comprueba si la página a la que
queremos acceder está en memoria, consultando el bit de presencia de la tabla
de páginas.

Pueden ocurrir dos cosas:

1. Si la página está en un marco de memoria, primero se comprueba si el acceso.
Es válido, se realiza la traducción de la dirección virtual consultando la entrada
correspondiente de la tabla de páginas. Finalmente, se accede a la dirección
real.

2. Si la página que contiene la dirección a la que queremos acceder no está en

memoria, lo que hay que hacer es traerla del almacenamiento secundario a
memoria. Antes de traerla se ha comprobado que la dirección de acceso está
dentro del rango de direcciones del proceso. Para traerla debemos encontrar un
marco libre de memoria.
Si hay un marco libre en memoria se carga la página del disco en la memoria. Para
localizar la página en el disco consultaremos el mapa de archivos. Una vez que
esta la página en memoria es necesario modificar el contenido de la tabla de
páginas, se activa el bit de presencia y se guarda la dirección del marco.

Si a la hora de traer una página a memoria no encontramos un hueco libre, este

deberá ser generado. Será necesario reemplazar algunas de las páginas que hay
en memoria. El algoritmo de reemplazo de páginas es el que determina cual es la
página que debe ser reemplazada, una vez elegida la página víctima, se consulta
el bit sucio de la tabla de páginas para saber si la víctima ha sido modificada, no
será necesario realizar dicha operación de E/S.

A continuación se siguen los mismos pasos que se realizan cuando se han

encontrado un marco libre: localizar la página en el almacenamiento secundario
a través del mapa de archivos, realizar la operación de E/S correspondiente para
cargar la página en memoria y modificar el contenido de la tabla de páginas.
Software

El diseño del gestor de memoria virtual debe tener en cuenta los siguientes
aspectos:
1. La técnica de memoria virtual puede realizarse usando paginación,
segmentación o una combinación de ambas. Para decidir cuál de todas ellas
utilizar hay que tener en cuenta la plataforma de hardware disponible.
2. La política de lectura está relacionada con la decisión de cuando se debe cargar
una página en memoria. Una de las alternativas, denominada paginación
bajo demanda pura, consiste en traer a memoria las páginas solo cuando se
hace referencia a una posición que contengan.
La otra alternativa consiste en traer anticipadamente páginas a memoria. A
esta ultima estrategia se le da el nombre de paginación bajo demanda previa
y, a diferencia de la anterior, puede traer a memoria páginas que no van ser
utilizadas. Si su funcionamiento es correcto carga en memoria la/s página/s
que en próximas referencias van a ser utilizadas.
3. La política de ubicación determina en que parte de la memoria va a residir cada
bloque del proceso cuando se trae del almacenamiento secundario. En
paginación no tiene sentido hablar de esa política porque todos los bloques
son de igual tamaño.

4. La política de reemplazo o el algoritmo de reemplazo, elige la página de

memoria que debe ser reemplazada cuando se tiene que cargar una nueva
página y no hay ningún marco libre. Antes de mencionar algunas de las
técnicas de reemplazo utilizadas vamos a definir que es la cadena de
referencia.
Existen muchos algoritmos de reemplazo. Vamos a explicar algunos de ellos:
• El algoritmo FIFO (First In First Out) sustituye la primera página que ha
entrado en memoria.
• El algoritmo LRU (Least Recently Used) sustituye la página que hace más
tiempo no se utiliza.
• Este algoritmo es aproximación al óptimo.
• El algoritmo no se puede implementar, ya que sustituye la página que va
a tardar más tiempo en ser utilizada.
5. La política de asignación, también llamada algoritmo de asignación, determina
el número de marcos de memoria que se asigna a cada proceso. Puede
ocurrir a que todos los procesos se les asigne marcos de forma igualitaria o
que se haga proporcionalmente, teniendo en cuenta diferentes
características del proceso (por ejemplo, tamaño, prioridad, etc.).

6. Otro concepto muy interesante y muy utilizado es el conjunto de trabajo de un

proceso. El conjunto de trabajo en un instante T es el conjunto de páginas a
las que el proceso ha hecho referencia en las últimas N unidades de tiempo.
Si una página se esta usando, pertenece al conjunto de trabajo. Este esta
formado a su vez por las páginas que deben estar en memoria para la
ejecución eficaz del proceso. Un proceso durante su ejecución va cambiando
el contenido de su conjunto de trabajo. Con un conjunto de trabajo
adecuado a cada proceso, aumentaremos el grado de multiprogramación del
sistema, permitiendo que convivan en él más procesos.
 DIR.
VIRTUAL

PAG.
DIR ACCEDER
EN
SI VALIDA?
MF?
SI
NO NO

DIR NO ACCEDER
VALIDA? NO

SI

MARCO CARG PAG EN MF

LIBRE? SI MODIF TABLA PAG
NO
NO

SELEC. PAG PAG ALMACENAR PAG

VICTIMA SUCIA? VICTIMA
SI
2.4.1 0.
Supongamos un sistema que gestiona una memoria paginada. Cada página tiene un
tamaño de 2 K. Se pide calcular el máximo espacio de direccionamiento lógico, sabiendo
que la tabla de páginas tiene un tamaño de 28 K y que cada entrada ocupa 16 bits.
Resolución
Para conocer el máximo espacio de direccionamiento debemos saber cuántas entradas,
como máximo, puede albergar la tabla de páginas. Sabiendo el número máximo de páginas
que se pueden referenciar y multiplicándolo por el tamaño de la página, averiguamos el
máximo espacio de direccionamiento lógico. Para calcular el número de entradas de la
tabla de páginas dividiremos el tamaño de la tabla entre lo que ocupa cada entrada.
16 bits = 2 bytes
28 𝐾𝑏𝑦𝑡𝑒𝑠 28 𝑥 210
Número de entradas = 2 𝑏𝑦𝑡𝑒𝑠/𝑒𝑛𝑡𝑟𝑎𝑑𝑎
= 2
= 14 x 210 entradas
Si multiplicamos el número de entradas de la tabla de páginas por el tamaño de cada
página sabremos el espacio máximo de direccionamiento lógico.
14 x 210 entradas x 2 K/página = 14 x 210 x 2 x 21° = 28 x 220 = 28 M
Comentario:
El número de entradas de la tabla de páginas depende del tamaño de la página: para un
mismo proceso, cuanto menor es el tamaño de la página más entradas tiene la tabla de
páginas. Tanto con paginación como con segmentación si el tamaño de un proceso es
mayor que la memoria física, ese proceso no se puede ejecutar. Esto no ocurre con un
sistema de gestión de memoria virtual ya que en ellos se pueden ejecutar procesos de
mayor tamaño que la memoria física.
 MEMORIA VIRTUAL
2.4.13.
Nuestro sistema operativo realiza una gestión de memoria virtual. Tenemos un
proceso cuyo espacio lógico de direcciones está formado por 100 páginas. Cada
una de estas páginas tiene un tamaño de 2 K. También sabemos que el tamaño de
la memoria física es de 1 M. Queremos conocer de cuántos bits se componen
tanto la dirección física o real como la lógica o virtual.
Resolución
1. La dirección lógica o virtual está compuesta por número de página +
desplazamiento. Calculamos el número de bits que necesitamos para referenciar
100 páginas. 2^7 = 128, por lo tanto necesitaremos 7 bits para referenciar 100
páginas. Si cogemos 6 sólo podemos referenciar 64 páginas. Para calcular el
número de bits necesarios para especificar el desplazamiento, debemos tener en
cuenta que cada página tiene un tamaño de 2 K, 2^11 = 2.048. Necesitamos 11 bits
para especificar el máximo desplazamiento.
dirección virtual = 7 bits (número de página) + 11 bits (desplazamiento) = 18 bits
2. La dirección física o real se compone de número de marco + desplazamiento. En
el apartado anterior ya hemos calculado que necesitamos 11 bits para especificar
el desplazamiento dentro de una página. El desplazamiento en el marco es el
mismo, ya que éste tiene el mismo tamaño que la página.
• Si queremos calcular cuántos bit, son necesarios para referenciar los marcos de
la memoria física. primero debemos saber en cuántos marcos se divide la
memoria. Para calcular el número de Micos de página dividiremos el tamaño
total de la memoria real entre lo que ocupa cada marco.
1 x 1.024 /2K =512 marcos
Especificamos 512 marcos con 9 bits ya que 29 = 512
dirección real = 9 bits (número de marco) + 11 bits (desplazamiento) = 20 bits
Comentario En la dirección virtual y real deben coincidir el número de bits que
especifican el desplazamiento. El número de bits para especificar el número de
marco y el de página no tiene que ser igual y. normalmente. no coincide.
• 2.4.14.
• Supongamos un sistema con memoria virtual en el que se utiliza una paginación bajo demanda pura en este sistema se ha
asignado al proceso A tres marcos de pagina .La cadena de referencia de dicho proceso es :
489786786586545656464
Donde cada numero representa una pagina
1.Se pide determinar el numero de fallos de pagina que se producen para los siguientes casos
2.LRU es el algoritmo de paginas de remplazo mas utilizado
3.¿cual de estos dos algoritmos es el mas adecuado para la mencionada cadena de referencia?
Resolución
1. El algoritmo FIFO reemplaza la página que ha entrado primero. es decir, la primera en entrar es la pasmen en salir.
Aplicando este algoritmo a nuestra cadena de referencia. Lis tres primera. páginas ¡traducen fallo de página. pero no es
necesario liberar marcos ya que hay algunos libres. Cuando se hace referencia a la página 7 lodos los marcos están
ocupados por lo que hay que liberar uno. Se libera el que contiene la página que más tiempo Ilesa en memoria en este
caso la página 4. Si aplicamos el algoritmo pro a toda la cadena de referencia. se producirán 9 fallos de página. en la
Figura 2.1 .5 vemos dónde se producen los fallos de página.
2. 2. El algoritmo LRU, usado menos recientemente. es una aproximación al reemplazo óptimo. Este método sustituye la
página menos usada en el pasado inmediato. Al aplicar este algoritmo a nuestro ejemplo vemos que, igual que para el
algoritmo FIFO. la carga en memoria de las tres primeras páginas produce un fallo en cada una. Cuando se referencia la
página 7. como no esta cargada en memoria. produce fallo. Además hay que desalojar un marco. Se vacía del marco en
el que está la página 4. ya que es la que hace más tiempo no se referencia.
En la Figura 2.16 se ve cómo se aplica el algoritmo LRU a toda la cadena de referencia. Con eme algoritmo se producen en
total 7 fallos de página.
3. De los dos algoritmos examinados el que mejores resultados presenta para el proceso A es el LRU. Con esta política de
reemplazo se producen 7 fallos de página, mientras que con la política FIFO se producen 9.
Comentario El algoritmo LRU es más aproximado al óptimo que el FFO. Normalmente, con el reemplazo LRU se producen
menos fallos de página que con el algoritmo FIFO.
 0 1 2 0 1 2

4 4 X 6 5 6 8

8 4 8 X 5 5 6 8

9 4 8 9 X 4 5 4 8 X

7 7 8 9 X 5 5 4 8

8 7 8 9 6 5 4 6 X

6 7 6 9 X 5 5 4 6

7 7 6 9 6 5 4 6

8 7 6 8 X 4 5 4 6

6 7 6 8 6 5 4 6

5 5 6 8 X 4 5 4 6

8 5 6 8

Nº DE PAGINA FALLO DE PAGINA

FIGURA 2.15 Fallos de pagina aplicado en el algoritmo FIFO y con 3 marcos

 0 1 2 0 1 2

4 4 X 6 5 8 6

8 4 8 X 5 5 8 6

9 4 8 9 X 4 5 4 6 x

7 7 8 9 X 5 5 4 6

8 7 8 9 6 5 4 6

6 7 8 6 X 5 5 4 6

7 7 8 6 6 5 4 6

8 7 8 6 4 5 4 6

6 7 8 6 6 5 4 6

5 5 8 6 x 4 5 4 6

8 5 8 6

Fallo de pagina
Nº pagina

FIGURA 2.16 fallos de pagina aplicado el algoritmo LRU Y con 3 marcos

Estamos trabajando en un sistema con memoria virtual en el que la asignación de
marcos es global y se utiliza una paginación bajo demanda pura. Existen 5 marcos
de página y tenemos dos procesos A y B.
La cadena de referencia para el proceso A es:
7 15 17 13 15 11 15 11 9 9
La cadena de referencia para el proceso B es:
3786757555
Se pide determinar el número de fallos de página que se producen si aplicamos el
algoritmo de reemplazo de páginas LRU
Nota: Se supone que la primera página que se carga es la primera del proceso A,
después la primera del proceso B, a continuación la segunda del A y así
sucesivamente. Se considera que no llegan procesos nuevos al sistema mientras A
o B se están ejecutando. En un sistema con gestión de memoria virtual lo normal
es que haya más de cinco marcos. En este ejercicio, para simplificar, hemos
considerado que la memoria principal está formada únicamente por cinco marcos.
• Resolución
La carga de la página 7 del proceso A produce un fallo. Lo mismo ocurre con las cuatro siguientes páginas
que se cargan. Estas páginas, en orden cronológico de carga, son: 3 de B. 15 de A. 7 de B. 17 de A. Cuando
hay que cargar la página 8 del proceso B no hay marcos libres, tenemos que desalojar un marco. Saldrá de
memoria la página que lleva más tiempo sin usarse. que es la 7 del proceso A. En la Figura 2.17 se muestra
a qué páginas se van asignando los marcos y cuándo se produce un fallo de página. En total vemos que se
producen 13 fallos de página.
0 1 2 3 4 0 1 2 3 4
7 7 X 11 11 13 6 15 7 X
3 7 3 X 5 11 5 6 15 7 X
15 7 3 15 X 15 11 5 6 15 7
7 7 3 15 7 X 7 11 5 6 15 7
17 8 3 15 7 17 X 11 11 5 6 15 7
8 8 3 15 7 17 X 5 11 5 6 15 7
13 8 13 15 7 17 X 9 11 5 9 15 7 X
6 8 13 6 7 17 X 5 11 5 9 15 7
15 8 13 6 15 17 X 9 11 5 9 15 7
7 8 13 6 15 7 X 5 11 5 9 15 7

Figura 2.17 Fallos de página con

Nº DE PAGINA FALLO DE PAGINA algoritmo LRU y asignación global de
5 marcos.
• Comentario Si nos dijeran que mientras se ejecutan A y B pueden llegar más
procesos al sistema, el ejercicio no se podría resolver porque no conocemos la
cadena de referencia de los nuevos procesos.
• Queremos traducir las direcciones virtuales, generadas por un proceso, a
direcciones reales En un sistema que soporta memoria virtual paginada . Cada
página tiene un tamaño de 2 K y Tabla 2.8 es la tabla de páginas del proceso. Las
direcciones virtuales que queremos traducir son:
I. 0x1873
2. 0x2033 NUMERO DE NUMERO
PAGINA DE MARCO
3. 0x1089 0 7
1 4
2 -
3 10
4 8

TABLA 2.8 tabla de paginas

Resolución En un sistema con memoria virtual paginada la dirección virtual está
formada por:
número de página + desplazamiento.
Dependiendo de las características del sistema, cada componente de la dirección
virtual ocupa un número de bits determinado. Para realizar la traducción debemos
averiguar cuántos bits ocupa cada componente. Si sabemos que la página tiene un
tamaño de 2 K deducimos que el desplazamiento es de 11 bits, ya que:
log2 2048 = 11 bits para desplazamiento
• El resto de bits que forman la dirección virtual se utilizan para especificar el
número de página. Por lo tanto, el número de página en la dirección virtual
ocupa 5 bits, los de mayor peso. Los pasos que debemos seguir para traducir la
dirección virtual a real son:
Descomponer la dirección virtual en número de página (5 bits) y desplazamiento
(11 bits).
■ Buscar en la tabla de páginas el número de marco correspondiente al número
de página de la dirección virtual
■ La dirección real es número de marco + desplazamiento. El desplazamiento
coincide en la dirección virtual y real. La página y el marco tienen el mismo
tamaño. I. Descomponemos la dirección virtual 1873 tal y como se ve en la Figura
2.18. Por lo tanto, 1873 corresponde a la página 3 que está en memoria física
ubicada en el marco 10 y desplazamiento 73. Luego la dirección virtual 1873
corresponde al marco 10 y dentro de éste a un desplazamiento de 73.
Dirección
1873

0001 1000 0111 00 11

Pagina desplazamiento
• 2. La dirección virtual 2033 corresponde al marco 8 y desplazamiento 33 tal
y como se ve
DIRECCION
2033

0010 0000 0011 0011

Pagina desplazamiento

Comentario
Si la página a la que hace referencia una dirección virtual no está cargada en
memoria, dicha dirección no se puede traducir. En un sistema con gestión de
memoria paginada, para traducir una dirección virtual a real el primer requisito es
que la página esté asociada a un marco. En caso contrario, lo primero que hay que
hacer es cargar la página en memoria, es decir, asociarla a un marco.
2.4.17 Instante de tiempo Página
Trabajamos en un sistema que soporta memoria 0 0
virtual Paginada y nos piden que calculemos que 3 1
páginas forman un conjunto de trabajo. Sabemos 5 2
que se trabaja con una ventana de 6 unidades de 6 0
tiempo y que la cadena de referencia en función
8 2
del tiempo, es la que se muestra en la tabla 2.9.
11 3
La solución se calculará en función del tiempo.
12 4
14 2
15 5
16 6
18 7
20 8

Tabla 2.9 pagina referenciada e instante referencia

Resolución
Debemos calcular en cada instante qué páginas forman parte del conjunto de trabajo. Como la
ventana que se utiliza es de 6 unidades de tiempo, el conjunto de trabajo, en un instante, lo
forman las páginas que han sido referenciadas entre ese instante y los cinco anteriores. El
número de páginas que forman el conjunto de trabajo varía de un instante a otro. En la Tabla
2.10 se muestran, entre los instantes 1 y 20, las páginas que forman el conjunto de trabajo y
cuántos componentes (páginas) forman dicho conjunto de trabajo.
Instante de tiempo pagina Cantidad de
paginas
0 0 1
1 0 1
2 0 1
3 0,1 2
4 0,1 2
5 0,1,2 3
6 0,1,2 3
7 0,1,2 3
8 0,1,2 3
9 0,1,2 3
10 0,2 2
11 0,2,3 3
12 0,2,3,4 4
13 2,3,4 3
14 2,3,4 3
15 2,3,4,5 4
16 2,3,4,5,6 5
17 2,3,4,5,6 5
18 2,4,5,6,7 5
19 2,5,6,7 4
20 2,5,6,7,8 5
• Comentario El conjunto de trabajo varía de tamaño de un instante a otro. Si
hubiera más procesos ejecutándose. tendríamos varios conjuntos de trabajo.
uno por proceso. En la ventana de tiempo habría páginas de varios procesos.