Sistemas Operativos: Gestión de Memoria, Virtual y en UNIX/Windows

Documento de Universidad sobre Sistemas Operativos: Gestión de Memoria. El Pdf, de Informática, explora la administración de memoria, la memoria virtual y su implementación en UNIX y Windows, detallando técnicas como la multiprogramación, paginación y segmentación.

Ver más

8 páginas

Tema 17: Sistemas operativos: gestión de memoria
Contenido
0. Introducción .............................................................................................................. 1
1. Administración de la memoria .................................................................................... 2
1.1. Multiprogramación con particiones fijas ............................................................... 2
1.2. Multiprogramación con particiones variables ........................................................ 2
1.2.1. Administración de la memoria con mapas de bits .............................................. 2
1.2.2. Administración de la memoria con listas enlazadas ........................................... 2
1.2.3. Administración de la memoria con el sistema de los asociados .......................... 3
1.2.4. Asignación del hueco de intercambio ................................................................ 3
2. Memoria virtual .......................................................................................................... 3
2.1. Paginación .......................................................................................................... 3
2.1.1. Tablas de páginas .......................................................................................... 3
2.1.2. Memorias asociativas .................................................................................... 3
2.1.3. Tablas de páginas invertidas .......................................................................... 4
2.1.4. Algoritmos de reemplazo de páginas. ............................................................. 4
2.2. Segmentación ..................................................................................................... 5
2.3. Sistemas combinados: segmentación paginada ................................................... 5
3. UNIX .......................................................................................................................... 6
3.1. Implantación del control de la memoria en UNIX .................................................. 6
3.2. Gestión de memoria en Linux ............................................................................... 6
4. Windows .................................................................................................................... 6
4.1. Manejo de fallos de página ................................................................................... 7
4.2. El algoritmo de reemplazo de páginas ................................................................... 7
4.3. Administración de memoria física ........................................................................ 7
5. Conclusiones ............................................................................................................. 8
6. Bibliografía ................................................................................................................. 8
0. Introducción
La memoria RAM debe ser gestionada cuidadosamente por el administrador de memoria
del sistema operativo, que asigna, rastrea y libera memoria según la necesidad de los
procesos. En sistemas multiprogramados, es necesario intercambiar procesos con el
disco. El tema explora varios esquemas de administración de memoria, desde los más
simples hasta los más avanzados, y concluye con un estudio de la gestión de memoria en
Linux y Windows.
1. Administración de la memoria
En la multiprogramación, los procesos que exceden la memoria deben almacenarse en el
disco. Para ejecutarlos, se trasladan a la memoria principal. Este proceso de mover los
procesos entre la memoria principal y el disco se llama intercambio.
1.1. Multiprogramación con particiones fijas
La multiprogramación básica divide la memoria en particiones fijas, lo que puede generar
desperdicio si las tareas no utilizan todo el espacio. También puede haber desajustes, con
particiones grandes vacías y pequeñas saturadas. Otra opción es usar una cola única para
asignar tareas a particiones liberadas, pero esto también puede generar desperdicio. Una
alternativa es asignar la tarea más grande que quepa, aunque esto discrimina a las tareas
pequeñas. Para mejorar, se pueden crear particiones dedicadas para tareas pequeñas o
limitar las exclusiones de tareas.
1.2. Multiprogramación con particiones variables
En sistemas con particiones variables, el número y tamaño de los procesos en memoria
cambia dinámicamente. Para gestionar los huecos libres, se puede usar compactación,
que mueve los procesos hacia la parte inferior de la memoria, pero tiene un alto coste. Si
los procesos tienen un tamaño fijo, la asignación es sencilla. Sin embargo, cuando un
proceso necesita crecer y no hay huecos adyacentes, debe moverse, lo que puede requerir
intercambiar otros procesos.
Los sistemas operativos utilizan tres métodos para registrar el uso de memoria: mapas de
bits, listas y sistemas amigables.
1.2.1. Administración de la memoria con mapas de bits
En un mapa de bits, la memoria se divide en unidades de asignación, y cada unidad se
representa con un bit que indica si está libre (0) u ocupada (1). El inconveniente principal
es que, para cargar un proceso de k unidades, el sistema debe buscar una secuencia
continua de k ceros en el mapa, lo que puede ser lento. Por esta razón, los mapas de bits
no se utilizan con frecuencia.
1.2.2. Administración de la memoria con listas enlazadas
La memoria se organiza como una lista enlazada de segmentos, cada uno representando
un hueco o un proceso. Esta lista puede estar ordenada por direcciones para facilitar las
actualizaciones y fusionar huecos adyacentes, usando una lista doblemente enlazada.
Existen varios algoritmos para asignar memoria:
Primero en ajustarse: busca el primer hueco que se ajuste, rápido pero puede
dejar fragmentos.
Mejor en ajustarse: encuentra el hueco más pequeño, más lento y puede
fragmentar la memoria.
Para optimizar, se pueden usar dos listas separadas (una para procesos y otra para
huecos), o una lista de huecos ordenada por tamaño, lo que mejora la velocidad del
algoritmo de mejor ajuste. Un enfoque adicional es ajuste rápido, que mantiene listas para
tamaños comunes, agilizando la búsqueda de huecos, aunque puede ser costoso al
fusionar huecos.

Visualiza gratis el PDF completo

Regístrate para acceder al documento completo y transformarlo con la IA.

Vista previa

Introducción a la Gestión de Memoria

La memoria RAM debe ser gestionada cuidadosamente por el administrador de memoria del sistema operativo, que asigna, rastrea y libera memoria según la necesidad de los procesos. En sistemas multiprogramados, es necesario intercambiar procesos con el disco. El tema explora varios esquemas de administración de memoria, desde los más simples hasta los más avanzados, y concluye con un estudio de la gestión de memoria en Linux y Windows.1. Administración de la memoria

En la multiprogramación, los procesos que exceden la memoria deben almacenarse en el disco. Para ejecutarlos, se trasladan a la memoria principal. Este proceso de mover los procesos entre la memoria principal y el disco se llama intercambio.

Multiprogramación con Particiones Fijas

La multiprogramación básica divide la memoria en particiones fijas, lo que puede generar desperdicio si las tareas no utilizan todo el espacio. También puede haber desajustes, con particiones grandes vacías y pequeñas saturadas. Otra opción es usar una cola única para asignar tareas a particiones liberadas, pero esto también puede generar desperdicio. Una alternativa es asignar la tarea más grande que quepa, aunque esto discrimina a las tareas pequeñas. Para mejorar, se pueden crear particiones dedicadas para tareas pequeñas o limitar las exclusiones de tareas.

Multiprogramación con Particiones Variables

En sistemas con particiones variables, el número y tamaño de los procesos en memoria cambia dinámicamente. Para gestionar los huecos libres, se puede usar compactación, que mueve los procesos hacia la parte inferior de la memoria, pero tiene un alto coste. Si los procesos tienen un tamaño fijo, la asignación es sencilla. Sin embargo, cuando un proceso necesita crecer y no hay huecos adyacentes, debe moverse, lo que puede requerir intercambiar otros procesos.

Los sistemas operativos utilizan tres métodos para registrar el uso de memoria: mapas de bits, listas y sistemas amigables.

Administración de Memoria con Mapas de Bits

En un mapa de bits, la memoria se divide en unidades de asignación, y cada unidad se representa con un bit que indica si está libre (0) u ocupada (1). El inconveniente principal es que, para cargar un proceso de k unidades, el sistema debe buscar una secuencia continua de k ceros en el mapa, lo que puede ser lento. Por esta razón, los mapas de bits no se utilizan con frecuencia.

Administración de Memoria con Listas Enlazadas

La memoria se organiza como una lista enlazada de segmentos, cada uno representando un hueco o un proceso. Esta lista puede estar ordenada por direcciones para facilitar las actualizaciones y fusionar huecos adyacentes, usando una lista doblemente enlazada. Existen varios algoritmos para asignar memoria:

  • Primero en ajustarse: busca el primer hueco que se ajuste, rápido pero puede dejar fragmentos.
  • Mejor en ajustarse: encuentra el hueco más pequeño, más lento y puede fragmentar la memoria.

Para optimizar, se pueden usar dos listas separadas (una para procesos y otra para huecos), o una lista de huecos ordenada por tamaño, lo que mejora la velocidad del algoritmo de mejor ajuste. Un enfoque adicional es ajuste rápido, que mantiene listas para tamaños comunes, agilizando la búsqueda de huecos, aunque puede ser costoso al fusionar huecos.

Administración de Memoria con el Sistema de los Asociados

El administrador de memoria utiliza bloques de potencias de dos. Comienza con un bloque grande y lo divide en bloques más pequeños según sea necesario. Por ejemplo, si se solicita un bloque de 70 KB, se asigna uno de 128 KB. Al liberar memoria, los bloques del mismo tamaño se fusionan para restaurar bloques grandes rápidamente.

Este enfoque mejora la eficiencia, pero genera fragmentación interna (bloques más grandes que el tamaño requerido) y fragmentación externa (huecos entre bloques ocupados).

Asignación del Hueco de Intercambio

Cuando un proceso necesita intercambiarse, se le asigna un hueco en el disco. Algunos sistemas usan los mismos algoritmos de administración de memoria para gestionar estos huecos, mientras que otros asignan un hueco fijo al proceso en el disco, evitando que se le asigne un espacio diferente cada vez. Cuando el proceso finaliza, su hueco de intercambio se libera.

Memoria Virtual

La memoria virtual permite que el tamaño total de un programa supere la memoria física disponible, gestionando las partes activas en la memoria principal y el resto en el disco. Las principales técnicas para implementarla son paginación y segmentación.

Paginación

En los sistemas con memoria virtual, la paginación divide el espacio de direcciones virtuales en páginas y la memoria física en marcos de página del mismo tamaño. Las direcciones virtuales generadas por los programas se traducen a direcciones físicas mediante la Unidad de Administración de Memoria (MMU). Las transferencias entre memoria y disco se realizan por unidades de página. Si una página no está en memoria, se genera un fallo de página: el sistema operativo selecciona un marco poco utilizado, guarda su contenido en disco, carga la nueva página y reinicia la instrucción.

Tablas de Páginas

La tabla de páginas traduce las páginas virtuales a marcos físicos de memoria. La implementación más simple es tener una tabla en hardware, que se carga al inicio del proceso para evitar accesos durante la ejecución, aunque esto puede afectar el rendimiento. Otra opción es mantener la tabla en memoria principal, lo que facilita los cambios de contexto pero requiere accesos adicionales. Para mejorar la eficiencia, muchos sistemas usan tablas de páginas multinivel, cargando solo las partes necesarias en memoria.

Memorias Asociativas

La memoria asociativa o TLB (Translation Lookaside Buffer) se utiliza en la MMU para optimizar la búsqueda de direcciones de memoria, almacenando las entradas más utilizadas. Cuando se presenta una dirección virtual, la MMU consulta la TLB; si encuentra la entrada, obtiene el marco directamente, y si no, consulta la tabla de páginas. Para evitar el uso de entradas obsoletas, se emplean dos métodos: invalidación de todas las entradas y el uso de un campo de identificación de contexto que mejora la eficiencia al validar solo las entradas correspondientes al proceso actual. Esto optimiza la gestión de memoria en sistemas multiproceso.

Tablas de Páginas Invertidas

Con direcciones virtuales de 32 bits y páginas de 4 KB, cada proceso requiere 4 MB para su tabla de páginas, lo que es manejable con paginación multinivel. Sin embargo, con 64 bits, las direcciones virtuales exceden la memoria física disponible, lo que lleva a usar tablas de páginas invertidas. Estas tablas asocian entradas con marcos físicos, reduciendo el tamaño de la tabla. Las tablas invertidas se complementan con una TLB para acelerar los accesos. En caso de fallo de página, se consulta la tabla invertida; si no está en memoria, se recurre a una tabla de páginas convencional almacenada en disco, lo que aumenta el tiempo de acceso.

Algoritmos de Reemplazo de Páginas

Cuando ocurre un fallo de página, el sistema reemplaza una página de poco uso. Si la página fue modificada, se guarda en disco; si no, la copia en disco sigue válida. La nueva página se carga en el mismo lugar.

Reemplazo de Páginas Según el Uso No Tan Reciente (NRU)

Los sistemas de memoria virtual utilizan dos bits por página: R (referencia) y M (modificación). El bit R se activa al acceder a la página, y el M al escribir en ella. Periódicamente, el bit R se limpia. Al producirse un fallo de página, las páginas se clasifican en cuatro clases según los bits R y M, y el algoritmo NRU selecciona aleatoriamente la página más baja para reemplazar, prefiriendo las no referenciadas y modificadas. Este enfoque es simple, pero no siempre es óptimo en rendimiento.

Reemplazo "Primero en Entrar, Primero en Salir" (FIFO)

El algoritmo FIFO (First-In, First-Out) reemplaza la página más antigua en memoria cuando ocurre un fallo de página. Mantiene una lista de páginas, y la primera entrada se elimina para agregar la nueva. Su desventaja es que puede eliminar páginas útiles, lo que disminuye su eficiencia, por lo que no se usa con frecuencia.

Reemplazo de Páginas de la Segunda Oportunidad

El algoritmo Segunda Oportunidad es una modificación de FIFO. Revisa el bit R de la página más antigua antes de reemplazarla. Si R es 0, la página se reemplaza. Si R es 1, el bit se limpia y la página se mueve al final de la lista. Este proceso continúa hasta encontrar una página no referenciada, funcionando igual que FIFO si todas las páginas han sido referenciadas.

Reemplazo de Páginas del Reloj

El algoritmo del reloj es una mejora del algoritmo de segunda oportunidad que evita la ineficiencia de mover páginas en una lista. En lugar de una lista lineal, organiza las páginas en una lista circular con un puntero (la "manecilla") que apunta a la página más antigua. En caso de fallo de página:

  • Si el bit R es 0, la página se reemplaza con la nueva y la manecilla avanza una posición.
  • Si R es 1, se limpia el bit y la manecilla avanza a la siguiente página, repitiendo el proceso hasta encontrar una página con R = 0.

Este algoritmo funciona igual que la segunda oportunidad, pero de manera más eficiente debido a su estructura circular.

Segmentación

2.2. Segmentación

Sistemas Combinados: Segmentación Paginada

2.3. Sistemas combinados: segmentación paginada

UNIX

3. UNIX

Implantación del Control de la Memoria en UNIX

3.1. Implantación del control de la memoria en UNIX

Gestión de Memoria en Linux

3.2. Gestión de memoria en Linux

Windows

4. Windows.

Manejo de Fallos de Página en Windows

4.1. Manejo de fallos de página

Algoritmo de Reemplazo de Páginas en Windows

4.2. El algoritmo de reemplazo de páginas.

Administración de Memoria Física en Windows

4.3. Administración de memoria física

Conclusiones

5. Conclusiones.

Bibliografía

6. Bibliografía

¿Non has encontrado lo que buscabas?

Explora otros temas en la Algor library o crea directamente tus materiales con la IA.