Facultad de Ingeniería

“Escuela Académico Profesional de Ing. De Sistemas”

Informe
“Administración de Memoria, Paginación: Algoritmos de Paginación”

Autor(es):
- Baltodano Quispe, Carlos Javier
- Cano Lazo, Aldrín Alexander
- Marcatinco Pariona, Jean Pierre
- Naupan Falcon, José Alonso
- Obando Miranda, Estefano

Asesor:
Chunga Zapata, Elmer Alfredo

Lima – Perú
2020
 ÍNDICE
1. ADMINISTRACIÓN DE MEMORIA..................................................................................................... 3
VINCULACIÓN DE LAS INSTRUCCIONES Y LOS DATOS DE MEMORIA.........................................................................3
ASIGNACIÓN CONTIGUA...............................................................................................................................3
ASIGNACIÓN CON MÚLTIPLES PARTICIONES FIJAS..............................................................................................4
ASIGNACIÓN CON PARTICIONES VARIABLES......................................................................................................4
PROBLEMA DE LA ASIGNACIÓN DINÁMICA DE MEMORIA.....................................................................................5
ALMACENAMIENTO VIRTUAL:........................................................................................................................5
INTERCAMBIO / SWAP...............................................................................................................................5
FUNDAMENTOS DE LA MEMORIA VIRTUAL......................................................................................................6
ALMACENAMIENTO VIRTUAL.........................................................................................................................6
2. PAGINACIÓN................................................................................................................................... 7
ALGORITMOS DE PLANIFICACIÓN........................................................................................................ 7
1. PRIMERA EN ENTRAR, PRIMERA EN SALIR (FIFO FIRST IN,FIRST OUT ).............................................................7
2. ÓPTIMO................................................................................................................................................7
3. SEGUNDA OPORTUNIDAD (RELOJ)..............................................................................................................8
4. DE PÁGINAS DE RELOJ (CLOCK) (RELOJ MEJORADO).....................................................................................8
5. NO USADA RECIENTEMENTE (NOT RECENTLY USED, NRU).............................................................................8
6. ALGORITMO DE REEMPLAZO DE PÁGINAS: MENOS USADAS RECIENTEMENTE (LRU).............................................9
7. ALGORITMO DE ENVEJECIMIENTO AGING.....................................................................................................9
1. Administración de Memoria
La administración de memoria se refiere a los distintos métodos y operaciones que se
encargan de obtener la máxima utilidad de la memoria, organizando los procesos y
programas que se ejecutan de manera tal que se aproveche de la mejor manera
posible el espacio disponible.
Para poder lograrlo, la operación principal que realiza es la de trasladar la información
que deberá ser ejecutada por el procesador, a la memoria principal. Actualmente esta
administración se conoce como Memoria Virtual ya que no es la memoria física del
procesador sino una memoria virtual que la representa. Entre algunas ventajas, esta
memoria permite que el sistema cuente con una memoria más extensa teniendo la
misma memoria real, con lo que esta se puede utilizar de manera más eficiente. Y por
supuesto, que los programas que son utilizados no ocupen lugar innecesario.
Las técnicas que existen para la carga de programas en la memoria son: partición fija,
que es la división de la memoria libre en varias partes (de igual o distinto tamaño) y la
partición dinámica, que son las particiones de la memoria en tamaños que pueden ser
variables, según la cantidad de memoria que necesita cada proceso.
Entre las principales operaciones que desarrolla la administración de memoria se
encuentran la reubicación, que consiste en trasladar procesos activos dentro y fuera
de la memoria principal para maximizar la utilización del procesador, la protección,
mecanismos que protegen los procesos que se ejecutan de interferencias de otros
procesos; uso compartido de códigos y datos, con lo que el mecanismo de protección
permite que ciertos procesos de un mismo programa que comparten una tarea tengan
memoria en común.
Vinculación de las instrucciones y los datos de memoria
Pueden realizarse en tres estadías:

 Tiempo de compilación: Si se conoce previamente la ubicación de memoria,

pueden generarse código absoluto, el código debe ser compilado si la dirección
de inicio cambia.
 Tiempo de carga: Si se conocen las direcciones en tiempo de compilación, debe
generarse código reubicable.
 Tiempo de ejecución: La vinculación se retarda hasta el tiempo de corrida si los
procesos pueden ser movidos durante la ejecución de una posición de memoria
a otra.
Asignación contigua
 Generalmente la memoria principal tiene dos particiones: Para el sistema
operativo residente que puede ser colocado en memoria baja o alta de acuerdo
a la ubicación del vector de interrupciones- Los procesos de los usuarios se
colocan en particiones.
 Asignación de partición única.
 Asignación con partición única.
Asignación con múltiples particiones fijas
Particiones configuradas por usuario, predeterminados, se usó en OS/360/MFT
(multiprogramación con un # fijo de tareas). Recolocación: El enlazador debe
determinar que direcciones recolocarse vs carga absoluta x parte.
Protección: Bloque de 2k con clave, o Registro de base y límite. Fragmentación. No se
puede aplicar overlays en este esquema de administración de memoria Sistemas de
protección:
- Registro límite y base.
- Protección por cable.
- fragmentación interna: desperdicios de espacios de memoria.
Asignación con particiones variables
El tamaño de la partición se establece en el momento de cargar el programa y
dependiendo su tamaño.
Los procesos tienen que correr en memoria antigua. Tiene un problema de
fragmentación externa, por los huecos que quedan después de la ejecución; la solución
es mover el proceso, que se está ejecutando, proceso de comprensión. Condensación:
Fusión de dos huecos antiguos.
El esquema actual de administración de memoria nace de los dos anteriores. Nace la
paginación y la segmentación.
Problema de la asignación dinámica de memoria
Cómo satisfacer la solicitud de un tamaño n, a partir de huecos libres. Estrategia de
colocación:

 Peor ajuste: Hueco más grande.

 Siguiente ajuste.
 Estrategia sofisticada: Sistema Buddy – Lista de huecos con tamaños potencias
de 2.
El primer ajuste junto con el mejor ajuste son los mejores que el peor ajusten en
términos de velocidad y utilización de almacenamiento.
Almacenamiento Virtual:
 Capacidad de obtener acceso a direcciones en un espacio de almacenamiento
mucho mayor que el disponible en el almacenamiento primario del sistema.
 SO Atlas, Manchester 1960.
 Disociación de las direcciones (V) a las que hace referencia un proceso en
ejecución de las direcciones disponibles en el almacenamiento primario (R)
 Las direcciones calculadas por procesos no necesariamente las disponibles en el
almacenamiento primario.
 Dirección real: dirección disponible en memoria.
 Dirección virtual: direcciones usadas por procesos.
Para pasar eficientemente los programas de la memoria de intercambio a la principal,
se debe hacer por hw.
Intercambio / SWAP
 Un proceso puede intercambiarse temporalmente de memoria a un
almacenamiento de respaldo y luego puede ser retomado hacia la memoria
para su ejecución.
 El almacenamiento de respaldo se hace en el disco duro, que debe ser rápido y
tener suficiente espacio para ubicar copia de todas las imágenes de memoria
para todos los usuarios; debe proveer acceso directo a estas imágenes de
memoria.
 Descargar (swap out), cargar (swap in) – Variante de intercambio en algoritmos
de planificación por prioridad; los procesos de baja prioridad se saca de
memoria de tal forma que el proceso de mayor prioridad puede ser cargado y
ejecutado.
 La mayor parte del tiempo es tiempo de interferencia; este es directamente
proporcional a la cantidad de memoria intercambiada.
 Existen versiones modificadas de intercambio de los diferentes sistemas,
ejemplo: Unix, Linux y Windows.
Fundamentos de la Memoria Virtual
El procesador utiliza y genera direcciones virtuales.

 Parte del mapa de memoria (virtual) está en disco (swap) y parte en memorial
principal.
 La MMU (Memory Managament Unit) traduce las direcciones virtuales en
físicas.
 La MMU produce un fallo de página (trap) cuando la dirección no está en
memoria principal.
 El SO (Sistema Operativo) trata el fallo de página, haciendo un transvase entre
la memoria principal y el área de intercambio (swap disco).
En el esquema de MMU, el valor de registro de reubicación de suma a cada dirección
generada por el proceso del usuario al momento de ser enviado a la memoria.
Almacenamiento Virtual
Espacio de direcciones virtuales, V: espacio de direcciones a las que se puede hacer
referencia un proceso. Espacio de direcciones reales, R: Almacenamiento Físico
disponible, en general V >> R Traducción dinámica de direcciones (DAT): V ===> R
Mapa de correspondencia de traducción de direcciones: por bloques: =s páginas, <>
segmento. Direccionamiento bidimensional: Bloque, desplazamiento Paginación:
División de la memoria y de los programas en tamaños iguales.
Segmentación: División de la memoria en tamaños correspondientes a los
componentes del programa y los programas son divididos en sus componentes básicos
(ej. Sub-rutinas) “La paginación es a la partición fija como la segmentación a las
particiones variables”. El almacenamiento virtual de un usuario no tiene que ser
continuo ni siquiera en almacenamiento secundario.
2. Paginación
La paginación es una estrategia de organización de la memoria física que consiste en
dividir la memoria en porciones de igual tamaño. A dichas porciones se las conoce
como páginas físicas o marcos. La división de la memoria en páginas facilita la gestión
de la memoria física. Los marcos están identificados por un número, conocido como
número de página física. Cada página física se asigna en exclusividad a un proceso.
A su vez, se dispone de páginas lógicas. Todo proceso tiene su propio espacio de
páginas lógicas, cada página lógica está mapeada a un marco. El mapeo entre páginas
lógicas y páginas físicas se mantiene en la tabla de páginas. Cada proceso dispone de
su propia tabla de páginas. En tiempo de conmutación de procesos, se restablece la
tabla de páginas del proceso que pasa a estado a activo, por tanto, forma parte del
contexto de la ejecución del proceso en estado activo.

Algoritmos de planificación

1. Primera en entrar, primera en salir (FIFO First In,First Out )

El método FIFO es junto con el método LIFO (Last in, First out), una herramienta muy
utilizada en la gestión del almacén. Este método el sistema operativo solo tiene que
guardar en que orden las paginas fueron cargadas de modo que al necesitar hacer
espacio pueda fácilmente elegir la primera cargada. Se usa una cola, al cargar una
página nueva se ingresa en el último lugar .Aunque las colas FIFO son simples e
intuitivas, no se comportan de manera aceptable en la aplicación práctica, por lo que
es raro su uso en su forma simple. Uno de los problemas que presentan es la llamada
Anomalía FIFO o Anomalía de Belady. Belady encontró ejemplos en los que un sistema
con un numero de marcos de paginas igual a tres tenía menos fallos de maquinas que
un sistema con cuatro marcos de paginas .El problema consiste en que podemos quitar
de memoria una pagina de memoria muy usada, solo porque es antigua

2. Óptimo

Este algoritmo tiene como finalidad retirar la página que vaya a ser referenciada más
tarde, por ejemplo, si hay una página A que será usada dentro de 10000 instrucciones,
y una página B que será usada dentro de 2800 instrucciones, se debería eliminar de la
memoria la página A. Como se puede deducir, para esto el sistema operativo debería
ver en cuánto tiempo será usada cada página en memoria y elegir la que está más
distante. El problema de este método es que necesita conocimiento del futuro, por lo
que es imposible su implementación. Es un algoritmo teórico. Se utiliza a los efectos
comparativos con los algoritmos factibles de ser implementados para ver cuál se
aproxima más a éste.
3. Segunda oportunidad (Reloj)

Es una pequeña modificación al algoritmo FIFO, que funciona bastante mejor que el
FIFO. En este caso cuando una página debe ser sacada se toma la primera en la cola, y
en vez de sacarla, consulta el valor de un bit de referencia. En caso de estar fijado (en
1) Se cambia el bit a 0 y se lo coloca al final de la obstrucción, actualizando su tiempo
de carga como si recién hubiera llegado al procesador. De esta forma, se le da una
segunda oportunidad. Si el bit se encuentra sin fijar (en 0), la página se saca de
memoria. Cada vez que la MMU accede a una página, fija su bit de referencia a 1. Para
esto es necesario soporte para bit de referencia por hardware.

4. De páginas de reloj (Clock) (Reloj Mejorado)

Existe una mejora en el algoritmo de segunda oportunidad que presenta una mejora
en la implementación. Es el algoritmo del CLOCK, que lo que hace es tener una lista
circular, de forma que, al llegar al último elemento de la lista, pasa automáticamente al
primero. Los elementos no se mueven al final de la cola cuando son accedidos,
simplemente se cambia el bit de referencia a 1. Esto nos evita tener que hacer
movimientos de punteros en el caso de implementarlo con una lista enlazada. De
hecho, se puede implementar con un array perfectamente, ahorrando así memoria.

5. No usada recientemente (Not Recently Used, NRU)

Este algoritmo favorece a las páginas que fueron usadas recientemente. Funciona de la
siguiente manera: cuando una página es referenciada, fija el bit de referencia para esa
página. Similarmente, cuando una página es modificada, fija su bit de modificación.
Usualmente estas operaciones son realizadas por el hardware, aunque puede hacerse
también por software. En un tiempo fijo, el sistema operativo pone en 0 los bits de
referencia de todas las páginas, de modo que las páginas con su bit de referencia en 1
son las que fueron referenciadas dentro del último intervalo de reloj. Cuando una
página debe ser reemplazada, el sistema operativo divide las páginas en cuatro
categorías:

 Categoría 0: No referenciada, No modificada

 Categoría 1: No referenciada, modificada
 Categoría 2: referenciada, No modificada
 Categoría 3: referenciada, modificada
Las mejores páginas para cambiar son las que se encuentran en la categoría 0,
mientras que las peores son las de la categoría 3. Se desaloja al azar una página de la
categoría más baja que no esté vacía. Este algoritmo se basa en la suposición de que es
mejor desalojar una página modificada a la que no se ha hecho referencia en al menos
un tic de reloj, en vez de una página limpia que se está usando mucho.
6. Algoritmo de reemplazo de páginas: menos usadas recientemente (LRU)

Una buena aproximación al algoritmo óptimo se basa en la observación de que las

páginas que se hayan utilizado con frecuencia en las últimas instrucciones, tal vez se
volverán a usar con frecuencia en las siguientes. Por el contrario, las páginas que no se
hayan utilizado por mucho tiempo probablemente seguirán sin utilizarse por mucho
tiempo más. Esta idea sugiere un algoritmo factible: cuando ocurra un fallo de página,
hay que descartar la página que no se haya utilizado durante la mayor longitud de
tiempo. A esta estrategia se le conoce como paginación LRU (Least Recently Used,
Menos usadas recientemente)

7. Algoritmo de envejecimiento aging

Desciende del algoritmo "No usada frecuentemente", con algunas modificaciones
necesarias para tener en cuenta en qué momento fue usada frecuentemente una
página, y no solamente cuántas veces fue.
En vez de sólo incrementar el contador de la página cuando es referenciada, primero
se desplaza a la derecha (se divide entre 2) y después sí se suma 1. Por ejemplo, si los
bits de referencia de una página fueron 1, 0, 0, 1, 1 y 0 en los últimos 6 ticks del reloj,
el contador se verá así: 10000000, 01000000, 00100000, 10010000, 11001000,
01100100.
De esta forma, cuando se necesite eliminar una página de memoria, se eliminará la
que tenga el número más pequeño en su contador.
Este algoritmo consigue una buena aproximación al algoritmo óptimo.