Paginación y memoria virtual

Un programa usa direcciones virtuales. La memoria física contiene los bytes en marcos. La paginación divide el espacio de direcciones virtuales en páginas de igual tamaño y la memoria física en marcos del mismo tamaño. El sistema operativo puede colocar cualquier página en cualquier marco libre. La página 0 podría ocupar el marco 12 y la página 1 el marco 3; el programa sigue viendo direcciones virtuales consecutivas.

Esto elimina la fragmentación externa en las asignaciones de páginas individuales. Con segmentos de tamaño variable, una solicitud puede fallar porque el espacio libre está dividido en huecos demasiado pequeños. Con paginación, un marco libre siempre tiene espacio para una página. Un espacio de direcciones disperso puede dejar un gran hueco entre el montículo y la pila sin reservar marcos físicos para ese hueco.

Mide el espacio sin usar dentro de las páginas

La paginación sigue teniendo fragmentación interna. Una región debe ocupar páginas completas incluso cuando su última página está parcialmente vacía. Una región de 9000 bytes necesita tres páginas de 4 KiB: dos páginas contienen 8192 bytes, por lo que quedan 808 bytes para la tercera. La asignación ocupa 12 288 bytes, de los que 3288 bytes no se usan. KiB significa 1024 bytes; MiB significa 1 048 576 bytes. Algunos libros usan KB y MB para estas cantidades binarias.

Divide la dirección en campos

Una dirección identifica tanto una página como un byte dentro de ella. Para un tamaño de página de $2^k$ bytes, los $k$ bits inferiores son el desplazamiento. Los bits superiores restantes son el número de página virtual, o VPN. Una dirección de 32 bits con páginas de 4 KiB tiene 12 bits de desplazamiento y 20 bits de VPN. Hay $2^{20}$ páginas virtuales posibles en ese espacio de direcciones.

Para 0x00403A7C, los últimos tres dígitos hexadecimales dan el desplazamiento 0xA7C, porque cada dígito hexadecimal representa cuatro bits. Los primeros cinco dígitos dan el VPN 0x00403. Este atajo funciona aquí porque el límite entre campos cae entre dígitos hexadecimales. Para otro tamaño de página, cuenta los bits antes de dividir el valor hexadecimal escrito.

La aritmética decimal da el mismo resultado:

Aquí $P$ es el tamaño de página en bytes. Con páginas de 1024 bytes, la dirección virtual 5000 tiene VPN 4 y desplazamiento 904. Cuatro páginas completas suman 4096 bytes; los 904 bytes restantes sitúan la dirección dentro de la página 4. Los desplazamientos comienzan en cero, por lo que los de esta página van de 0 a 1023.

La traducción sustituye el VPN por un número de marco físico. Copia el desplazamiento sin cambios: el byte 904 de una página virtual es el byte 904 de su marco. El número de página por sí solo no es una dirección de byte. Multiplica un número de marco por el tamaño de página para hallar la dirección inicial del marco y después suma el desplazamiento.

Elige un tamaño de página

Las páginas más grandes reducen el número de mapeos y permiten que cada traducción en caché cubra más bytes. También desperdician más espacio en páginas parcialmente utilizadas y transfieren más datos cuando se carga una página. Un tamaño habitual de página base es 4 KiB; otros sistemas usan 16 KiB o 64 KiB. x86-64 también admite mapeos grandes, como páginas de 2 MiB.

Una tabla de páginas registra los mapeos de un proceso. En una tabla de páginas lineal, el VPN indexa un arreglo: la entrada 4 describe la página virtual 4. Cada proceso tiene su propia tabla, por lo que la misma dirección virtual puede referirse a distintos bytes físicos en procesos diferentes. En un cambio de contexto, el sistema operativo selecciona la tabla del nuevo proceso mediante un registro base de la tabla de páginas.

Lee el estado y los permisos de la entrada

Una entrada de la tabla de páginas, o PTE, contiene un número de marco físico (PFN) e información de control. En el modelo didáctico, un bit de validez indica que la página pertenece al espacio de direcciones; un bit de presencia indica que su contenido reside en memoria física. Los bits de protección controlan la lectura, la escritura, la ejecución y el acceso desde modo usuario. Un bit de modificación registra las escrituras realizadas desde que se borró por última vez. Un bit de acceso registra el uso desde que se borró por última vez; también se llama bit de referencia o de uso.

Estas son funciones conceptuales, no una garantía de que el hardware tenga una organización idéntica. x86 no tiene un bit de validez independiente en una PTE. Cuando el bit de presencia está desactivado, el sistema operativo consulta sus propios registros para distinguir una dirección sin usar de una página válida almacenada en otro lugar. En x86, el hardware activa los bits de acceso y modificación; el sistema operativo los gestiona y los borra.

Localiza la entrada y el byte

Para traducir una dirección con una tabla lineal:

1. Divide la dirección virtual en VPN y desplazamiento.
2. Localiza su entrada en $\mathrm{t}\mathrm{a}\mathrm{b}\mathrm{l}\mathrm{e}\mathrm{b}\mathrm{a}\mathrm{s}\mathrm{e}+\mathrm{V}\mathrm{P}\mathrm{N}\times \mathrm{P}\mathrm{T}\mathrm{E}\mathrm{s}\mathrm{i}\mathrm{z}\mathrm{e}$.
3. Comprueba si el mapeo existe, está presente y permite este acceso.
4. Forma la dirección física a partir de $\mathrm{P}\mathrm{F}\mathrm{N}\times \mathrm{p}\mathrm{a}\mathrm{g}\mathrm{e}\mathrm{s}\mathrm{i}\mathrm{z}\mathrm{e}+\mathrm{o}\mathrm{f}\mathrm{f}\mathrm{s}\mathrm{e}\mathrm{t}$.
5. Lee o escribe el byte en esa dirección física.

Con páginas de 1024 bytes, la dirección virtual 5000 da VPN 4 y desplazamiento 904. Supón que la PTE 4 está presente y permite la lectura solicitada, con PFN 9. El marco 9 comienza en 9216, por lo que la dirección física del byte es 10 120. La dirección de la propia tabla es un cálculo separado: si las entradas ocupan 4 bytes, la PTE 4 está 16 bytes después de la base de la tabla.

En un ejemplo hexadecimal, las páginas de 4 KiB dividen 0x00403A7C en el VPN 0x403 y el desplazamiento 0xA7C. Si el mapeo permitido contiene el PFN 0x1F2B5, la dirección física es 0x1F2B5A7C. La PTE está en base + 0x403 × 4 = base + 0x100C. Añadir el desplazamiento forma una dirección de datos; multiplicar el VPN por el tamaño de la entrada localiza la PTE. Estas dos direcciones tienen fines distintos.

Una comprobación fallida genera una excepción. El sistema operativo puede cargar una página válida que no reside en memoria, proporcionar memoria inicializada a cero o reparar otro mapeo legítimo. Una dirección no válida o un acceso prohibido suele causar un fallo de segmentación. Una página presente puede rechazar una escritura si su protección la prohíbe.

Calcula el espacio de la tabla y las lecturas de memoria

Las tablas lineales son costosas incluso para procesos pequeños. Con direcciones virtuales de 32 bits y páginas de 4 KiB, cada tabla necesita 1 048 576 entradas. Con 4 bytes por entrada, son 4 MiB por proceso, incluidas las entradas para páginas virtuales sin usar. Cien procesos necesitan 400 MiB solo para estas tablas.

También añaden una búsqueda a cada referencia a memoria. En un modelo sencillo sin caché de traducciones, el procesador lee una PTE y después los datos solicitados: dos accesos a memoria. La compartición sigue siendo posible: dos procesos pueden mapear deliberadamente sus páginas virtuales independientes al mismo PFN, como ocurre con el código de programa de solo lectura.

Un búfer de traducción adelantada, o TLB, es una pequeña caché de hardware de traducciones de direcciones en la unidad de gestión de memoria (MMU). Contiene mapeos recientes de VPN a PFN e información de acceso. Almacena traducciones en caché, mientras que una caché de datos contiene bytes del programa. Un programa puede fallar en una caché y acertar en la otra.

Sigue los aciertos y los fallos

Ante un acierto en la TLB, la MMU obtiene el PFN de la entrada en caché, comprueba los permisos de acceso y combina el PFN con el desplazamiento sin cambios. No necesita leer la tabla de páginas. Un acierto nunca elimina la necesidad de aplicar la protección. El bit de validez de la TLB indica que una entrada en caché es utilizable; no indica si una página virtual pertenece al espacio de direcciones del proceso.

Ante un fallo de TLB, el sistema debe buscar la traducción en la tabla de páginas. Si la página está presente y el acceso está permitido, instala la traducción y completa o vuelve a intentar la referencia. No se necesita una lectura del almacenamiento. Si la tabla indica, en cambio, que falta un mapeo o que el acceso está prohibido, un fallo de página requiere la intervención del sistema operativo. Un fallo de TLB por sí solo no es un fallo de página.

Predice la reutilización a partir de la localidad

Las TLB pueden contener muchas menos entradas que el número de páginas virtuales, pero funcionan bien porque los programas presentan localidad. La localidad espacial significa que se usan direcciones cercanas en momentos próximos. Una vez que se almacena una traducción en caché, muchas direcciones de esa página pueden usarla. La localidad temporal significa que es probable que las direcciones usadas recientemente vuelvan a utilizarse, como ocurre con las instrucciones de un bucle.

Considera 16 384 enteros de cuatro bytes almacenados consecutivamente en un arreglo alineado con un límite de página. Con páginas de 4 KiB, cada página contiene 1024 enteros, por lo que el arreglo ocupa 16 páginas. Si se comienza con una TLB vacía y sin otras traducciones que interfieran, el primer entero de cada página causa un fallo. Los siguientes 1023 de esa página aciertan. Hay 16 fallos y 16 368 aciertos en total, lo que da una tasa de acierto de aproximadamente el 99,9 %.

El orden de acceso cambia ese resultado. En C, int a[1024][1024] almacena las filas de forma consecutiva. Supón enteros de cuatro bytes, alineación con un límite de página, páginas de 4 KiB y una TLB LRU de 64 entradas. Cada fila ocupa una página. El recorrido por filas tiene un fallo por fila, es decir, 1024 fallos. El recorrido por columnas visita 1024 páginas distintas antes de volver a la primera. Su traducción ya ha sido expulsada, por lo que las 1 048 576 referencias al arreglo fallan. El tamaño del arreglo no cambia; cambia la distancia entre usos de una misma traducción.

Calcula el coste medio de aciertos y fallos

El modelo de tiempo debe indicar el coste de un acierto y de un fallo. Supón que la memoria tarda 100 ns, que la búsqueda en la TLB no añade tiempo y que un fallo en una tabla lineal añade una lectura de memoria. Un acierto cuesta 100 ns y un fallo resuelto cuesta 200 ns. Con una tasa de acierto del 98 %:

Este promedio incluye el acceso final a los datos en ambos casos. Contar solo la lectura adicional de la PTE como el coste total del fallo subestimaría el total. Con tablas multinivel, un fallo puede necesitar varias lecturas de tablas, por lo que la localidad importa aún más.

Un fallo de TLB necesita una búsqueda de la traducción, pero las arquitecturas reparten ese trabajo de distintas formas. Con una TLB gestionada por hardware, como en x86 y ARM, la MMU recorre la tabla de páginas desde la raíz de la tabla seleccionada. El hardware define el formato que puede recorrer. Si el mapeo es utilizable, rellena la caché de traducciones sin llamar a un manejador del sistema operativo para el fallo ordinario.

Una TLB gestionada por software, usada en los diseños clásicos de MIPS y SPARC, genera una excepción ante un fallo. Un manejador del sistema operativo encuentra el mapeo y lo inserta mediante instrucciones privilegiadas. Esto da al sistema operativo más libertad sobre la estructura de su tabla. El retorno de esta excepción vuelve a intentar la instrucción que falló; el retorno de una llamada al sistema normalmente continúa después de la llamada.

Mantén accesible el manejador de recarga

El manejador de fallos necesita acceso fiable a sus propias instrucciones y datos. Si atender un fallo provoca de inmediato el mismo tipo de fallo sin resolver dentro del manejador, el sistema puede dejar de avanzar. Los diseños lo evitan mediante memoria no traducida o traducciones fijadas permanentemente para el código y los datos esenciales del manejador.

Selecciona el espacio de direcciones correcto

Los cambios de contexto plantean otro problema. El proceso A podría mapear el VPN 7 al marco 20, mientras que el proceso B mapea el VPN 7 al marco 90. Conservar la entrada sin etiqueta de A después de cambiar a B enviaría a B al marco incorrecto. Cargar la raíz de la tabla de páginas de B no hace por sí solo que sea seguro usar un mapeo en caché sin etiqueta.

Una solución es invalidar las entradas pertinentes de la TLB al cambiar de proceso. Se borran sus bits de validez, lo que obliga al nuevo proceso a rellenarlas. Otra solución etiqueta las entradas con un identificador de espacio de direcciones (ASID). La búsqueda comprueba entonces tanto la página virtual como su etiqueta de espacio de direcciones. x86 llama a su etiqueta identificador de contexto de proceso, o PCID. Las entradas de varios espacios de direcciones pueden permanecer en caché mientras el hardware selecciona solo las que pertenecen al contexto actual. La reutilización de etiquetas debe seguir gestionándose para que una entrada antigua no se confunda con un nuevo espacio de direcciones.

Invalida los mapeos modificados

Un cambio en una PTE también deja desactualizada una traducción en caché. Supón que el sistema operativo elimina el permiso de escritura en memoria, pero deja una entrada de la TLB que permite escribir. El procesador podría seguir permitiendo escrituras mediante esa entrada antigua. El sistema operativo debe invalidar las traducciones afectadas. En una máquina con varios núcleos, debe participar cada núcleo que pueda tener el mapeo en caché. Esta coordinación se llama invalidación coordinada de las TLB.

Calcula la cobertura de traducción

Además de la corrección, la capacidad también importa. La cobertura de la TLB es la cantidad de memoria representada por las traducciones en caché:

Una TLB de 64 entradas cubre 256 KiB con páginas de 4 KiB y 128 MiB con páginas de 2 MiB. La cobertura describe los mapeos cubiertos, no la capacidad de la memoria física. Los procesadores reales pueden tener capacidades de TLB distintas para diferentes tamaños de página, por lo que este cálculo compara un número fijo de entradas.

Cuando una TLB está llena, reemplaza una traducción. LRU favorece las entradas usadas recientemente; el reemplazo aleatorio elige sin registrar el uso reciente. Recorrer cíclicamente una página más de las que caben perjudica a LRU porque cada traducción se expulsa justo antes de volver a necesitarse.

Una tabla de páginas lineal reserva una entrada para cada página virtual posible. La mayoría de los procesos usan solo una pequeña parte de su espacio de direcciones: el código y el montículo están cerca de un extremo, la pila cerca del otro y un gran hueco los separa. Una tabla con millones de entradas no válidas sigue consumiendo memoria. Reducir este coste implica cambiar el tamaño de página, la organización de la tabla o ambos.

Reduce el número de páginas

Las páginas más grandes reducen el número de VPN. Con un espacio de direcciones de 32 bits y páginas de 16 KiB, 14 bits forman el desplazamiento y 18 bits forman el VPN. Una tabla lineal necesita entonces 262 144 entradas. Con 4 bytes por entrada ocupa 1 MiB, frente a los 4 MiB para páginas de 4 KiB. Esto ahorra espacio de tabla aunque el proceso siga pudiendo direccionar 4 GiB de bytes virtuales.

El coste se traslada a otra parte. Una asignación pequeña puede desperdiciar más espacio de su última página y cargar una página en memoria transfiere más bytes. Aumentar el tamaño de página no distingue una parte del espacio de direcciones usada de forma densa de un hueco sin usar; simplemente da a ambos menos entradas.

Omite los huecos con tablas de segmentos separadas

Un esquema híbrido de segmentación y paginación proporciona al código, el montículo y la pila sus propias tablas de páginas. Cada segmento tiene una base de tabla y un límite para sus números de página. El hueco entre segmentos no necesita entradas. La traducción primero selecciona el segmento, comprueba su límite y después busca la página dentro de ese segmento.

Este enfoque depende de una división útil en segmentos. Sus tablas pueden tener distintas longitudes y necesitar espacio físico contiguo, lo que reintroduce la fragmentación externa para las propias tablas. Las páginas de datos del proceso siguen siendo de tamaño fijo; los objetos fragmentados son ahora las tablas de páginas de tamaño variable.

Indexa los marcos físicos

Una tabla de páginas invertida cambia lo que describe una entrada. Tiene una entrada por marco físico para toda la máquina y registra el proceso y el VPN que lo ocupan. Con 16 GiB de memoria física y marcos de 4 KiB, necesita 4 194 304 entradas independientemente de cuántos procesos tengan espacios de direcciones virtuales grandes. Sigue siendo necesario conocer el tamaño de la entrada para convertir ese recuento en un total de bytes.

Una tabla ordinaria usa el VPN como índice directo de un arreglo. En cambio, una tabla invertida busca el par formado por la identidad del espacio de direcciones y el VPN. Una estructura hash puede hacer que esto sea eficiente, pero las colisiones pueden requerir búsquedas adicionales. Los marcos compartidos también necesitan un tratamiento adicional porque un marco puede tener varios nombres virtuales. Las tablas de páginas con hash, como las usadas en sistemas PowerPC, utilizan ideas de búsqueda relacionadas; una tabla con hash no es necesariamente una tabla invertida estricta de una entrada por marco.

Asigna tablas según la región usada

Las tablas de páginas multinivel conservan la búsqueda mediante índices y asignan páginas de tabla de nivel inferior solo donde se necesitan mapeos. Una entrada de nivel superior puede marcar todo un intervalo sin usar sin asignar su tabla de nivel inferior. Esta es la solución habitual en los sistemas modernos. El ahorro es mayor para espacios de direcciones dispersos, mientras que un fallo de TLB necesita más pasos de búsqueda.

Compara las opciones preguntándote qué determina el tamaño. Una tabla lineal crece con el número de páginas virtuales por proceso. Una tabla invertida crece con el número de marcos físicos del sistema. Una jerarquía crece con las ramas de la tabla necesarias para los mapeos. Ninguno de estos recuentos es el número de bytes de datos del programa que residen actualmente en memoria.

Una tabla de páginas de dos niveles divide una tabla lineal grande en partes del tamaño de una página. Un directorio de páginas apunta a esas partes. El directorio se asigna, pero una página de tabla de nivel inferior solo se asigna cuando su región necesita mapeos. Una entrada ausente del directorio puede representar todo un intervalo sin usar.

Deduce la división 10/10/12

Toma una dirección virtual de 32 bits, páginas de 4 KiB y entradas de 4 bytes. Cada página de la tabla de páginas contiene 1024 entradas, por lo que un índice de 10 bits selecciona una entrada. La dirección se divide en 10 bits de directorio, 10 bits de tabla y 12 bits de desplazamiento. Cada tabla de nivel inferior mapea 1024 páginas, que cubren 4 MiB de direcciones virtuales. El directorio también tiene 1024 entradas y ocupa una página de 4 KiB.

Sigue las entradas del directorio y de la tabla

El recorrido sigue punteros físicos:

1. Suma $\mathrm{d}\mathrm{i}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{o}\mathrm{r}\mathrm{y}\mathrm{i}\mathrm{n}\mathrm{d}\mathrm{e}\mathrm{x}\times 4$ a la base física del directorio. Lee esa entrada del directorio de páginas (PDE).
2. Si apunta a una página de tabla, multiplica su PFN por 4096 para obtener la base física de esa tabla.
3. Suma $\mathrm{t}\mathrm{a}\mathrm{b}\mathrm{l}\mathrm{e}\mathrm{i}\mathrm{n}\mathrm{d}\mathrm{e}\mathrm{x}\times 4$ y lee la PTE.
4. Comprueba el mapeo final y combina su PFN con el desplazamiento.

La PDE apunta a una tabla, mientras que la PTE apunta a la página de datos solicitada. Confundir estas funciones envía una referencia a la memoria de la tabla de páginas en lugar de a los datos del programa.

Para la dirección virtual 0x00803ABC, el índice del directorio es 2, el índice de la tabla es 3 y el desplazamiento es 0xABC. Supón que la entrada 2 del directorio apunta al marco 0xA1. Su tabla comienza en 0xA1000. La entrada 3 está 12 bytes después del inicio de esa tabla, en 0xA100C. Si la PTE presente y permitida contiene el PFN 0x2F3C4, la dirección de datos es 0x2F3C4ABC.

Observa los dos multiplicadores distintos. Un índice de tabla cuenta entradas, por lo que debes multiplicarlo por el tamaño de la entrada. Un PFN cuenta marcos, por lo que debes multiplicarlo por el tamaño de página. El desplazamiento cuenta bytes dentro de la página final y no necesita ninguno de los dos multiplicadores. La base del directorio y los punteros usados durante el recorrido son direcciones físicas; usar punteros virtuales exigiría otra traducción para realizar esta traducción.

Cuenta las tablas y las lecturas de búsqueda

El espacio depende de cómo se distribuyan los mapeos. Supón que un proceso usa los 8 MiB inferiores de su espacio de 4 GiB y los 4 MiB superiores, con ambas regiones alineadas con los límites del directorio. La región inferior necesita dos páginas de tabla y la superior una. Al añadir el directorio se obtienen cuatro páginas, o 16 KiB, en lugar de una tabla lineal de 4 MiB. Mapear el mismo número de páginas de datos de forma dispersa entre muchas regiones del directorio podría necesitar más páginas de tabla.

En el esquema didáctico básico, una PDE no válida significa que ninguna de las páginas de su región de 4 MiB pertenece al espacio de direcciones. El recorrido se detiene sin leer una PTE. Los sistemas operativos completos también pueden usar entradas ausentes para la asignación diferida, por lo que sus registros de software determinan el significado de una entrada no presente para el hardware.

La jerarquía ahorra espacio al añadir trabajo ante un fallo de TLB. Un recorrido de dos niveles sin caché lee una PDE y una PTE antes de acceder a los datos: tres lecturas de memoria en total, frente a dos con una tabla lineal. Un acierto de TLB evita esas lecturas de tablas. Esto hace que una tasa alta de aciertos sea especialmente valiosa a medida que aumenta la profundidad de la jerarquía.

El número de niveles de tabla se deriva de tres cantidades: el ancho implementado de la dirección virtual, el tamaño de página y el tamaño de la entrada. Primero calcula el ancho del desplazamiento. Después calcula cuántas entradas caben en una página de tabla y cuántos bits seleccionan una entrada. Por último, divide los bits restantes del VPN en campos de índice y redondea el número de niveles hacia arriba si es necesario.

Deduce los cuatro niveles

Para la paginación x86-64 de cuatro niveles, el ancho implementado de la dirección virtual es de 48 bits. Una página de 4 KiB proporciona 12 bits de desplazamiento. Una entrada de 8 bytes da 512 entradas por página de tabla, seleccionadas por 9 bits. El VPN tiene 36 bits, por lo que se necesitan cuatro índices de 9 bits. Un recorrido correcto sin caché sigue cuatro entradas y después accede a los datos.

Los niveles son PML4, tabla de punteros a directorios de páginas, directorio de páginas y tabla de páginas. Sus índices ocupan los bits 47–39, 38–30, 29–21 y 20–12. CR3 identifica la raíz física. Linux llama a los niveles correspondientes PGD, PUD, PMD y PTE; su jerarquía genérica incluye un nivel P4D, que se integra en otro cuando la arquitectura usa solo cuatro niveles.

Distingue el ancho de dirección de la RAM

Un espacio de direcciones implementado de 48 bits contiene 256 TiB de bytes direccionables. Las direcciones siguen almacenándose en valores de 64 bits: en la forma canónica ordinaria, los bits por encima del bit 47 repiten ese bit. Los intervalos válidos inferior y superior están separados por un hueco no canónico. Llamarlo espacio de direcciones de 48 bits no significa que se pueda usar cualquier patrón de 64 bits ni que un proceso reciba 256 TiB de RAM.

Una tabla lineal sería enorme. Hay $2^{36}$ páginas virtuales; al multiplicar por entradas de 8 bytes se obtienen $2^{39}$ bytes, o 512 GiB por proceso. Una jerarquía representa los intervalos sin usar mediante ramas ausentes en lugar de reservar todas esas entradas.

Los procesadores que admiten paginación de cinco niveles pueden usar 57 bits de dirección virtual implementados cuando ese modo está activado. Se añade un índice más de 9 bits por encima de la PML4, lo que da 128 PiB de bytes direccionables y una posible lectura adicional de tabla. Los bits superiores de una dirección canónica repiten entonces el bit 56. El soporte del procesador y el modo de paginación activado determinan qué ancho se aplica.

Detén el recorrido en una página grande

Las páginas grandes detienen el recorrido antes. En x86-64, una entrada del nivel de directorio de páginas puede mapear directamente una página de 2 MiB, lo que deja 21 bits de desplazamiento. Una entrada de la tabla de punteros a directorios de páginas puede mapear una página de 1 GiB, lo que deja 30 bits de desplazamiento. Los bits inferiores que de otro modo seleccionarían entradas de nivel inferior seleccionan ahora bytes dentro de esa página grande.

Esto reduce tanto la longitud del recorrido como el número de traducciones necesarias para una región dada. Aumenta la cobertura de la TLB, lo que puede ayudar a las bases de datos y otras cargas de trabajo grandes. El mapeo físico necesita una región contigua de marcos debidamente alineada, y una página grande parcialmente usada puede desperdiciar mucha más memoria. Linux admite la asignación explícita de páginas enormes y las páginas enormes transparentes; los tamaños admitidos dependen de la arquitectura.

El recuento sencillo de costes supone que no hay entradas de tabla en caché. Los procesadores reales almacenan en caché estructuras de paginación, y las lecturas de tablas pueden acertar en las cachés ordinarias. Por tanto, cuatro niveles no garantizan cuatro demoras de memoria principal en cada fallo de TLB. Describen la cadena de dependencias y su coste sin caché.

Los espacios de direcciones virtuales pueden superar en conjunto la memoria física porque no todas las páginas tienen que permanecer residentes. El espacio de intercambio almacena el contenido de las páginas desplazadas en un disco o una unidad SSD. Linux puede usar una partición o un archivo de intercambio; Windows usa un archivo de paginación. La memoria física contiene el subconjunto de páginas residentes en cada momento.

La paginación mueve páginas individuales. Una salida de página la escribe en el almacenamiento de respaldo antes de reutilizar su marco; una entrada de página la vuelve a leer. Históricamente, el intercambio también significaba trasladar un proceso completo. En el uso actual, la palabra suele referirse al movimiento de páginas, por lo que debes identificar qué objeto se está moviendo.

Interpreta el mapeo ausente

El bit de presencia de una PTE indica al hardware si hay disponible un mapeo residente. Si una página válida se ha trasladado al espacio de intercambio, el sistema operativo registra dónde puede encontrarse su contenido, ya sea en bits de la entrada definidos por software o en metadatos separados. Un bit de presencia en cero no identifica por sí mismo el espacio de intercambio: también puede describir memoria sin asignar o de asignación diferida.

Un fallo de página es una excepción causada por un acceso que no puede completarse con el mapeo actual. Puede indicar una ausencia o una violación de protección. El manejador decide si el acceso es legítimo y cómo resolverlo. Una gestión satisfactoria puede cargar bytes almacenados, proporcionar memoria llena de ceros, mapear un marco residente existente o hacer una copia privada. Un acceso realmente no válido suele producir un fallo de segmentación.

Restaura una página guardada

Sigue la lectura de una página desde el espacio de intercambio con páginas de 1024 bytes:

1. La dirección virtual 5000 da el VPN 4 y el desplazamiento 904.
2. La TLB no tiene una traducción utilizable. El recorrido de la tabla de páginas encuentra que la página válida no está presente; los registros de software identifican el bloque 37 del espacio de intercambio.
3. El manejador obtiene el marco 9. Si no hay ningún marco libre, la recuperación de memoria debe liberar espacio primero.
4. El sistema operativo lee el bloque 37 en el marco 9. El proceso que causó el fallo espera; otro proceso listo para ejecutarse puede usar la CPU.
5. Al terminar la lectura, el sistema operativo instala el PFN 9, marca el mapeo como presente y deja el proceso listo para ejecutarse.
6. Se vuelve a intentar la instrucción. La traducción llega ahora a la dirección física 10 120.

La instrucción reanuda la operación prevista una vez que los bytes están disponibles. Avanzar más allá de la instrucción fallida haría perder una lectura o escritura. El proceso puede percibir una demora, pero su dirección virtual no ha cambiado.

Clasifica el fallo y predice la demanda

Un fallo mayor necesita una lectura del almacenamiento. Un fallo menor se resuelve sin esa entrada/salida, por ejemplo, proporcionando un marco lleno de ceros o mapeando un marco que ya está residente. Por tanto, un gran número de fallos menores no implica el mismo tráfico del dispositivo que el mismo número de fallos mayores. En Linux, /usr/bin/time -v informa de los dos recuentos para un comando.

La paginación por demanda espera hasta que se accede a una página antes de proporcionarla. Esto permite que un programa comience sin cargar todo su contenido. La precarga incorpora páginas que se espera necesitar pronto. Las buenas predicciones evitan esperas posteriores; las malas consumen ancho de banda y memoria para páginas que nunca se usan.

Mantén separados los eventos. Un fallo de TLB requiere buscar una traducción. Un fallo de página requiere que el sistema operativo gestione un problema de mapeo. Un fallo de segmentación es un resultado habitual de un acceso prohibido. Una página residente y con los permisos necesarios puede causar un fallo de TLB sin que ocurra ninguno de los otros eventos.

Una lectura poco frecuente del almacenamiento puede dominar el tiempo medio de memoria. Sea $p$ la probabilidad de que una referencia cause un fallo mayor, $M$ el tiempo de acceso ordinario y $F$ el tiempo total de servicio de una referencia que causa un fallo. Un modelo sencillo de dos casos da:

Aquí $F$ incluye la lectura del almacenamiento, el trabajo del sistema operativo y cualquier escritura diferida necesaria de una víctima modificada. Es el coste total del caso con fallo, no solo una pequeña penalización por buscar una PTE.

Calcula el efecto de fallos poco frecuentes

Supón que un acceso ordinario tarda 100 ns y un fallo mayor tarda 8 ms en total. Convierte 8 ms a 8 000 000 ns antes de calcular el promedio. Con un fallo por cada 1000 referencias:

Esto es aproximadamente 81 veces el tiempo de acceso ordinario. Una tasa de fallos del 0,1 % parece pequeña, pero un fallo cuesta tanto como muchos miles de referencias a memoria.

Para una ralentización inferior al 10 %, exige un promedio inferior a 110 ns. Al despejar se obtiene:

Esto equivale a menos de aproximadamente un fallo mayor por cada 800 000 referencias. La probabilidad permitida depende del tiempo de servicio supuesto. Para un tiempo de servicio ilustrativo de una unidad SSD de 0,1 ms, la espera es más corta, pero sigue siendo de 100 000 ns: mil accesos de 100 ns.

Mantén marcos preparados

El sistema operativo intenta tener marcos preparados antes de que un fallo necesite uno. Un demonio de paginación en segundo plano, como kswapd de Linux, recupera memoria cuando los marcos libres caen por debajo de un umbral bajo. En el modelo básico de umbrales, continúa hasta alcanzar un umbral alto. Esto evita que cada fallo tenga que esperar a que se seleccione y prepare una víctima.

Conserva los cambios antes de reutilizar el marco

Una página modificada contiene cambios realizados desde que se borró por última vez el estado de modificación. Antes de reutilizar su marco, esos cambios deben conservarse si la página sigue formando parte de la memoria de un proceso. Su escritura diferida puede hacerse en segundo plano. Después de una escritura satisfactoria, la página residente puede marcarse como limpia; una escritura posterior vuelve a marcarla como modificada.

Una página limpia solo puede descartarse sin una nueva escritura cuando su contenido puede recuperarse o regenerarse. El código de programa no modificado puede volver a leerse del ejecutable. Una página con una copia actualizada en el espacio de intercambio puede leerse desde allí. Una página anónima limpia sin una copia recuperable no puede simplemente olvidarse. El bit de modificación por sí solo no demuestra que exista almacenamiento de respaldo.

Si un fallo debe expulsar de forma síncrona una página modificada, puede requerir una escritura de la víctima seguida de la lectura solicitada. Preferir una víctima limpia y recuperable evita esa escritura en la ruta crítica del fallo. La agrupación combina varias escrituras en transferencias más grandes, algo especialmente útil en discos.

Los fallos de página son puntos de control útiles para posponer trabajo. Un mapeo puede pertenecer a un proceso antes de que el sistema operativo le asigne un marco privado. Con la inicialización a cero por demanda, el primer acceso obtiene memoria llena de ceros. Esto evita asignar y poner a cero por adelantado todas las páginas reservadas. La inicialización a cero también impide que un proceso vea datos que dejó otro proceso.

El fallo no necesita una lectura del disco porque el contenido requerido son ceros, no bytes guardados. Es un fallo menor. Un sistema puede optimizar la implementación, pero el resultado visible sigue siendo que la memoria recién proporcionada tiene el contenido de ceros requerido.

Comparte código de solo lectura

Las tablas de páginas separadas no requieren copias separadas de todas las páginas. Dos PTE pueden contener el mismo PFN, incluso en direcciones virtuales distintas. Los procesos que ejecutan el mismo programa pueden compartir código de solo lectura. Cincuenta procesos que usan un editor pueden hacer referencia a una copia residente de cada página de código compartida. La protección de solo lectura impide que un proceso cambie esas instrucciones para todos.

Crea contenido privado al escribir

La copia en escritura (COW) permite compartir inicialmente páginas que más adelante pueden necesitar contenido privado. Después de fork(), el padre y el hijo tienen espacios de direcciones separados, pero pueden compartir sus marcos de datos privados ordinarios. El sistema operativo marca sus mapeos privados con permiso de escritura como de solo lectura y registra que son mapeos COW. Las lecturas se realizan sin copiar.

Cuando cualquiera de los dos procesos escribe por primera vez en una página COW compartida, la escritura infringe su protección actual y causa un fallo de página. El manejador reconoce el caso COW legítimo, asigna un marco privado, copia la página, instala un mapeo con permiso de escritura para el proceso que escribió y vuelve a intentar la instrucción. El otro proceso conserva el contenido original. El sistema operativo también debe hacer que las traducciones en caché concuerden con los mapeos modificados.

Para un proceso con 400 MiB de datos privados residentes, supón que su hijo escribe en tres páginas distintas de 4 KiB antes de llamar a exec(). Los datos copiados a causa de esas escrituras suman 12 288 bytes. Las escrituras repetidas en una página que ya es privada no causan una nueva copia de página completa cada vez. La creación de tablas de páginas y otras tareas de gestión del proceso siguen teniendo costes; COW evita copiar de inmediato los 400 MiB de datos.

Esto es especialmente útil cuando a fork() le sigue pronto exec(), que sustituye el espacio de direcciones del hijo. Copiar todos los datos antiguos inmediatamente realizaría un trabajo que el hijo podría no usar nunca. Los mapeos con permiso de escritura compartidos de forma intencional tienen una semántica distinta: COW describe los mapeos privados que deben separarse al escribir.

Una PTE de solo lectura por sí sola no indica que se use COW. Una escritura en código de programa realmente de solo lectura es un error; una escritura en una página de datos protegida por COW puede corregirse. Los registros de software distinguen los casos, por lo que la misma excepción de protección del hardware puede dar lugar a un reintento satisfactorio o a un fallo de segmentación.

Protege los mapeos del núcleo

Los mapeos del núcleo también usan protección. Un diseño tradicional mapea la memoria del núcleo en el espacio de direcciones de cada proceso con acceso exclusivo del supervisor, lo que permite entrar en el núcleo sin seleccionar un mapeo completamente distinto. El código en modo usuario no puede acceder a esas páginas solo porque tengan direcciones. El aislamiento de las tablas de páginas del núcleo, introducido en los sistemas afectados después de que Meltdown se hiciera público en 2018, elimina la mayoría de los mapeos del núcleo mientras se ejecuta código de usuario y cambia los mapeos al entrar en el núcleo.

Una política de reemplazo elige una página residente para expulsarla cuando una página necesaria no tiene un marco libre disponible. La memoria física actúa como caché del contenido de las páginas. La política intenta conservar páginas cuyo uso futuro evitará fallos costosos. Un fallo de reemplazo es un evento abstracto de residencia; que necesite entrada/salida depende de la procedencia del contenido ausente.

Registra aciertos y fallos

Compara políticas usando la misma cadena de referencias, el mismo número de marcos y el mismo estado inicial. Una cadena de referencias enumera números de página en orden de acceso. Para cada referencia, pregunta primero si la página está residente. Si lo está, registra un acierto. De lo contrario, registra un fallo, carga la página y expulsa una víctima solo si la memoria ya está llena.

Las primeras referencias son fallos incluso mientras quedan marcos libres. Estos fallos obligatorios no pueden evitarse eligiendo otra víctima. Los fallos posteriores causados por capacidad insuficiente son fallos por capacidad. El reemplazo de páginas no tiene conflictos de colocación: una página puede ocupar cualquier marco. Los fallos por conflicto pertenecen a cachés con colocación restringida, no a este modelo de marcos totalmente flexible.

Elige el uso futuro más lejano

La política óptima, OPT o MIN, elige la página cuyo próximo uso está más lejos en el futuro. Una página que nunca volverá a usarse es una víctima ideal. Esto produce el menor número de fallos para una cadena de referencias conocida, pero un sistema operativo en ejecución no puede conocer referencias futuras arbitrarias. OPT proporciona una referencia para las políticas prácticas.

Usa tres marcos inicialmente vacíos y la cadena 1, 2, 3, 1, 4, 1, 5, 2, 1, 4, 3, 1. Las tres primeras referencias llenan la memoria y fallan. La siguiente referencia a 1 acierta. En la referencia 5 llega la página 4: las páginas residentes 1, 2 y 3 se usarán de nuevo en las posiciones 6, 8 y 11, respectivamente. Expulsa la 3, cuyo próximo uso es el más lejano.

Después de que la referencia a 1 acierte, la página 5 llega en la posición 7. Las páginas residentes 1, 2 y 4 se usarán de nuevo en las posiciones 9, 8 y 10, respectivamente, por lo que OPT expulsa la 4. Las siguientes referencias a 2 y 1 aciertan. La referencia a la página 4 falla en la posición 10; puede expulsarse la 2 o la 5 porque ninguna vuelve a usarse. Después falla la referencia a la página 3 y se retira otra página sin uso futuro. La referencia final a 1 acierta.

Compara los totales y las cargas de trabajo

El seguimiento tiene 7 fallos y 5 aciertos. Contando las 12 referencias, la tasa de acierto es 5/12, aproximadamente el 41,7 %. Hay cinco páginas distintas y, por tanto, cinco fallos obligatorios. Si la tasa indicada excluye esos fallos, pasa a ser 5/7, aproximadamente el 71,4 %. Ambas tasas pueden describir el mismo seguimiento, por lo que siempre debes identificar el denominador.

Para no perderte, mantén la referencia actual separada de la secuencia futura. OPT compara el siguiente uso de cada página residente después de la posición actual; no elige la página con el número más alto ni la que se cargó primero. Si dos páginas no vuelven a usarse, cualquiera de las dos elecciones conserva la optimalidad.

Las cargas de trabajo influyen en cuánto importa la política. Cuando las referencias tienen la misma probabilidad para todas las páginas, el uso anterior ofrece poca orientación. Con localidad, un pequeño conjunto de páginas de uso frecuente recibe muchas referencias, y conservarlo mejora la tasa de acierto. La diferencia entre el número de fallos de una política práctica y el de OPT mide la mejora posible para esa carga de trabajo.

FIFO expulsa la página que se cargó antes entre las residentes actuales. Una cola registra el orden de llegada. Un acierto no mueve la página al final de esa cola. Esto hace que FIFO sea fácil de mantener, pero puede expulsar una página que sigue usándose con frecuencia simplemente porque llegó hace mucho tiempo.

Registra el último uso en lugar de la llegada

LRU, reemplazo de la página menos recientemente utilizada, registra el uso más reciente de cada página residente. Ante un acierto, esa página pasa a ser la usada más recientemente; ante un fallo con la memoria llena, sale la página cuyo último uso es más antiguo. Esto sigue la localidad temporal: el uso reciente suele predecir el uso en un futuro próximo. El momento de llegada y el del último uso son historiales distintos.

El reemplazo aleatorio elige al azar una víctima residente sin mantener el orden de uso reciente. Su resultado varía entre ejecuciones. Puede evitar el patrón de fallo determinista de LRU en una carga de trabajo cíclica, pero también puede tomar decisiones desafortunadas. LFU, reemplazo de la página menos frecuentemente utilizada, registra recuentos en lugar del uso reciente. Sin envejecimiento, puede conservar una página que fue popular en una fase anterior del programa pero que ahora no se usa.

Sigue las políticas en la misma cadena

Compara tres marcos vacíos con 1, 2, 3, 1, 4, 1, 5, 2, 1, 4, 3, 1. Las páginas 1, 2 y 3 llenan primero la memoria. El acierto en 1 deja sin cambios el orden de FIFO, por lo que la llegada de 4 expulsa a 1. En cambio, LRU considera que 1 es reciente y expulsa a 2. Por tanto, la siguiente referencia a 1 falla con FIFO y acierta con LRU.

En LRU, los fallos posteriores expulsan a 3 para la página 5, a 4 para la página 2, a 5 para la página 4 y a 2 para la página 3. Termina con 8 fallos y 4 aciertos. FIFO produce 10 fallos y 2 aciertos. OPT produce 7 fallos en la misma cadena. LRU mejora a FIFO en este caso, pero no alcanza el óptimo que conoce el futuro.

Explica la anomalía de Belady

Más marcos no mejoran todas las políticas en todas las cadenas. La anomalía de Belady es un aumento de fallos cuando FIFO recibe más marcos. Para 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5, FIFO tiene 9 fallos con tres marcos y 10 con cuatro. La capacidad adicional cambia las víctimas posteriores de la cola, por lo que sus conjuntos residentes no están necesariamente contenidos unos en otros.

LRU y OPT son algoritmos de pila: si los empates se resuelven de forma coherente, el conjunto residente con menos marcos está contenido en el conjunto con más marcos. Por tanto, aumentar la capacidad no puede convertir un acierto con menos memoria en un fallo con más memoria. LRU produce 10 fallos con tres marcos y 8 con cuatro en la cadena de la anomalía.

Reconoce cargas de trabajo desfavorables para el uso reciente

LRU sigue teniendo cargas de trabajo desfavorables. Recorre cíclicamente tres veces las páginas 1, 2, 3, 4 con tres marcos. Cada página nueva expulsa la que se necesitará a continuación y produce 12 fallos. OPT necesita 6. El reemplazo aleatorio puede conservar páginas útiles durante un ciclo y aquí funciona mejor en promedio. Un recorrido de una sola vez también puede expulsar un conjunto útil de páginas de uso frecuente de una caché LRU.

Una comparación de políticas debe incluir su carga de trabajo y el número de marcos. La localidad hace que el uso reciente sea útil en muchos programas, lo que motiva las aproximaciones de LRU en sistemas reales. Un bucle periódico que apenas supera la capacidad favorece otra elección; una ventaja observada en una cadena corta no establece una clasificación universal.

LRU exacto necesita trabajo en cada referencia a memoria. Con marcas de tiempo, cada referencia actualiza una marca y la selección de la víctima busca la más antigua. Con una lista ordenada, la víctima está disponible al final, pero cada referencia debe mover su página al principio. Actualizar esta estructura por software en cada lectura y escritura sería demasiado costoso.

Lee el bit de uso

El hardware ofrece una señal más barata: el bit de uso, también llamado bit de acceso o de referencia. El hardware lo activa cuando se lee o escribe una página. El sistema operativo lo borra para comenzar otro intervalo de observación. Un bit activado significa al menos un uso desde la última vez que se borró; no es un recuento de frecuencia y no revela el orden exacto del último uso.

Busca una víctima

El algoritmo del reloj coloca los marcos en un círculo y mantiene una manecilla que apunta al siguiente candidato. Al reemplazar, examina el bit de uso del candidato. Si el bit es 1, la manecilla lo borra y avanza. Si el bit es 0, ese marco es la víctima. La nueva página entra con su bit de uso activado y la manecilla avanza más allá de ella. Un acierto activa el bit de la página referenciada sin mover la manecilla.

Supón que el círculo contiene A con bit 1, B con bit 0 y C con bit 1, y que la manecilla está en A. Un fallo en D borra el bit de A y avanza hasta B. B ya tiene el bit en 0, por lo que D reemplaza a B con el bit en 1 y la manecilla termina en C. Si la siguiente referencia es un fallo en E, la manecilla borra el bit de C, encuentra después el de A en 0 y reemplaza a A. Si se hubiera accedido a A entre esos fallos, su bit sería 1 y recibiría otra oportunidad.

Si todos los bits están en 1 y no intervienen nuevos accesos, una vuelta los borra todos. La manecilla expulsa entonces la página inicial cuando regresa a ella. Esa selección concreta se parece a la siguiente víctima de FIFO según el orden de llegada, pero el reloj generalmente sigue el historial de uso y la posición de la manecilla; no siempre equivale a FIFO.

Un seguimiento completo del reloj necesita una convención de inicialización. Aquí, los marcos vacíos se llenan en orden con el bit en 1; la manecilla permanece en el marco 0 hasta el primer reemplazo. Los aciertos activan los bits. Cada reemplazo hace avanzar la manecilla. Con esa convención, tres marcos para 1, 2, 3, 1, 4, 1, 5, 2, 1, 4, 3, 1 producen 10 fallos. Una cadena corta puede ocultar el beneficio de una aproximación del uso reciente; el reloj suele seguir bien la localidad en ejecuciones más largas.

Considera el coste de escritura y las variantes reales

El estado de modificación añade el coste de conservar una víctima. Una preferencia del reloj mejorado clasifica los pares (uso, modificación) como (0,0), (0,1), (1,0) y después (1,1). Esto favorece una página que no se ha usado recientemente ni tiene cambios sin guardar. Las implementaciones difieren en cómo borran bits durante los recorridos y programan las escrituras. La escritura diferida en segundo plano puede limpiar una candidata modificada antes de que el reemplazo la necesite.

Los sistemas reales usan variantes más elaboradas. VAX/VMS colocaba las páginas retiradas en listas de páginas limpias o modificadas para que un proceso pudiera recuperar una antes de que se reutilizara su marco. Linux ha usado listas activas e inactivas y ofrece LRU multigeneracional, que agrupa las páginas según el uso reciente observado. Estos sistemas usan información del hardware para orientar las decisiones del sistema operativo; el bit de uso del hardware no elige por sí mismo una víctima.

La hiperpaginación ocurre cuando los procesos pasan la mayor parte del tiempo cargando páginas en memoria a causa de fallos y expulsando páginas que volverán a necesitar pronto. El dispositivo de almacenamiento permanece ocupado mientras cae la utilización de la CPU, aunque los programas aún tengan trabajo por hacer. Una carga baja de CPU por sí sola no identifica la hiperpaginación; la pista es la combinación de paginación intensa y escaso progreso.

La causa es una demanda de memoria superior a los marcos disponibles. Un proceso necesita que un conjunto útil de páginas esté residente para completar su fase actual. Si los conjuntos activos de varios procesos no caben juntos, sus fallos desplazan repetidamente páginas útiles. Iniciar aún más procesos puede empeorar esta presión aunque la CPU parezca poco utilizada.

Estima la demanda actual de páginas

El conjunto de trabajo, escrito $W(t,\mathrm{\Delta })$, estima las necesidades actuales de un proceso. En el modelo de ventana de referencias, es el conjunto de páginas distintas de las últimas $\mathrm{\Delta }$ referencias que terminan en el instante $t$. Cuenta cada página una sola vez, aunque aparezca varias veces en la ventana. El tamaño del conjunto de trabajo es un número de páginas, no el número de referencias.

Con una ventana de 5 y la cadena 1, 2, 1, 3, 2, 1, 4, 5, 4, 5, 4, 6, 5, 4, examina el estado después de la referencia 6. Las últimas cinco referencias son 2, 1, 3, 2, 1, lo que da {1, 2, 3}, de tamaño 3. Después de la referencia 8 la ventana es 3, 2, 1, 4, 5, lo que da un tamaño de 5. Después de la referencia 11 es 4, 5, 4, 5, 4, lo que da un tamaño de 2. La demanda alcanza temporalmente un máximo mientras se solapan las fases antigua y nueva.

Controla la demanda activa y la asignación

Una ventana corta puede omitir páginas que aún se necesitan; una demasiado larga puede incluir páginas de una fase terminada. El modelo del conjunto de trabajo de Peter Denning relaciona estas necesidades cambiantes con la asignación. Una política de conjunto de trabajo ejecuta procesos solo cuando sus conjuntos de trabajo combinados caben en memoria. Si no caben, suspende uno o más procesos y libera sus marcos. Esto es control de admisión.

El control de la frecuencia de fallos de página (PFF) usa las tasas de fallos medidas. Por encima de un umbral superior, un proceso necesita más marcos. Por debajo de un umbral inferior, algunos marcos pueden reasignarse. Si un proceso necesita marcos y no hay ninguno disponible, puede ser necesario suspender un proceso. Dos umbrales reducen los ajustes continuos alrededor de un único límite.

Con reemplazo global, un fallo puede expulsar una página de otro proceso. Esto se adapta con flexibilidad a la demanda cambiante, pero permite que un proceso aumente los fallos de otro. Con reemplazo local, las víctimas proceden solo de la asignación del proceso que causa el fallo. Esto limita las interferencias, pero no puede ayudar a un proceso que tiene demasiado pocos marcos asignados sin cambiar la asignación.

Elige soluciones para la presión sobre la memoria

Las soluciones útiles reducen la demanda o aumentan la capacidad: ejecutar menos programas, añadir memoria física o mejorar la localidad, por ejemplo, recorriendo los arreglos en el orden de almacenamiento. Un intercambio más rápido reduce el coste de cada fallo mayor; no hace que un conjunto activo demasiado grande quepa en memoria. Sustituir un disco por una unidad SSD puede mejorar el progreso sin eliminar la causa.

Bajo una presión extrema, el mecanismo de terminación por falta de memoria de Linux puede terminar un proceso seleccionado cuando la recuperación y el intercambio no logran liberar suficiente memoria. La selección usa una puntuación basada en el uso de memoria y ajustes de política, no simplemente la identidad del proceso más grande. La memoria puede recuperarse cuando el proceso termina, y su trabajo se pierde. Esta es una liberación de recursos de último recurso, distinta de suspender un proceso para que pueda reanudarse más tarde.