Paginación: páginas y marcos

1. El problema: la fragmentación externa

Con segmentación (tema 15), cada segmento es un bloque contiguo en la RAM. Al cargar y descargar procesos, quedan huecos que no son suficientemente grandes para un segmento nuevo, aunque la memoria libre total sea suficiente. Es la fragmentación externa (tema 12).

La causa raíz es que los bloques tienen tamaños variables y deben ser contiguos. La solución es hacer que todos los bloques tengan el mismo tamaño, de modo que cualquier hueco sirva para cualquier bloque.

2. La idea: bloques de tamaño fijo

La paginación divide la memoria en bloques de tamaño fijo:

• Página (page): un bloque de tamaño fijo de la memoria virtual de un proceso.
• Marco (frame): un bloque de tamaño fijo de la memoria física (RAM).

Ambos tienen el mismo tamaño (típicamente 4096 bytes). Un proceso se divide en páginas, y cada página se carga en un marco libre. Los marcos no necesitan ser contiguos en la RAM.

Paginación es la técnica que divide la memoria virtual en páginas y la física en marcos del mismo tamaño, asignando cada página a un marco libre, eliminando la fragmentación externa.

3. Páginas y marcos

El tamaño de página es una potencia de 2 (típicamente 4 KiB, a veces 2 MiB o 1 GiB para páginas grandes). Se elige para que la división de direcciones sea simple (bits).

El número de páginas de un proceso es ceil(tamaño_proceso / tamaño_página). El número de marcos de la RAM es RAM / tamaño_página.

4. Cómo se traduce una dirección

La dirección virtual se divide en dos partes:

• Número de página (p): los bits altos.
• Desplazamiento (d): los bits bajos (dentro de la página).

La MMU usa p para indexar la tabla de páginas y obtener el número de marco f. La dirección física es f × tamaño_página + d. El desplazamiento no cambia: es el mismo en la página y en el marco.

Traducción: dirección virtual = (p, d). Si la tabla de páginas tiene entrada p → f, entonces dirección física = (f, d) = f × tamaño_página + d.

5. Ventajas

• Sin fragmentación externa: cualquier marco libre sirve para cualquier página.
• Asignación simple: basta con mantener una lista de marcos libres (bitmap o lista).
• Compartición fácil: varias páginas virtuales pueden apuntar al mismo marco (código compartido).
• Memoria virtual: se pueden cargar solo las páginas necesarias (paginación por demanda, tema 29).
• Protección por página: cada entrada de la tabla tiene bits de permisos.

6. Desventajas

• Fragmentación interna: el último bloque de cada proceso puede no estar completo (hasta una página menos 1 byte).
• Overhead de la tabla: la tabla de páginas ocupa memoria (una entrada por página).
• Dos accesos a memoria: cada acceso requiere leer la tabla y luego la RAM (mitigado por la TLB, tema 24).
• Complejidad: las tablas multinivel (tema 22) son necesarias para espacios grandes.

7. Ejemplo numérico

Página de 4096 bytes (0x1000). Un proceso de 10000 bytes (0x2710) necesita 3 páginas (ceil(10000/4096) = 3). La tabla de páginas podría ser:

Traducción de la dirección virtual 0x1234:

• p = 0x1234 / 0x1000 = 1 (página 1).
• d = 0x1234 % 0x1000 = 0x234.
• Marco = tabla[1] = 2.
• Física = 2 × 0x1000 + 0x234 = 0x2234.

8. Experimento en C

El programa siguiente simula la traducción con paginación:

#include <stdio.h>

int main(void)
{
    const int PS = 4096;  /* tamaño de página */
    int tabla[] = {5, 2, 8};  /* página -> marco */
    unsigned int vaddr = 0x1234;

    unsigned int p = vaddr / PS;
    unsigned int d = vaddr % PS;
    unsigned int f = tabla[p];
    unsigned int fis = f * PS + d;

    printf("virtual  = 0x%04X\\n", vaddr);
    printf("página   = %u (0x%X)\\n", p, p);
    printf("desp.    = 0x%03X\\n", d);
    printf("marco    = %u\\n", f);
    printf("física   = 0x%04X\\n", fis);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o paginacion paginacion.c
$ ./paginacion
virtual  = 0x1234
página   = 1 (0x1)
desp.    = 0x234
marco    = 2
física   = 0x2234física   = 0x2234

9. Probar con un simulador

Este simulador traduce una dirección virtual a física usando una tabla de páginas editable.

10. En Linux hoy

Linux usa paginación para toda la gestión de memoria. El tamaño de página por defecto es 4 KiB (consultable con getconf PAGESIZE). El sistema mantiene la tabla de páginas de cada proceso y la MMU (con la TLB) la consulta en cada acceso.

• getconf PAGESIZE: tamaño de página (4096).
• /proc/PID/maps: muestra las regiones, no las páginas individuales.
• /proc/PID/pagemap: expone la traducción virtual→física (restringido).

11. Resumen

• La paginación divide la memoria virtual en páginas y la física en marcos del mismo tamaño.
• La dirección virtual se divide en número de página (p) y desplazamiento (d).
• La MMU traduce: p → marco f, y la física es f × tamaño_página + d.
• Elimina la fragmentación externa (cualquier marco sirve para cualquier página).
• Costo: fragmentación interna (último bloque), overhead de la tabla, y dos accesos a memoria.

12. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Calcula el número de páginas para un proceso de 10000, 4096 y 4097 bytes con página de 4096.
2. Traduce a mano la dirección 0x2ABC con página de 4096 y tabla {3, 7, 1}. ¿Cuál es la física?
3. Modifica paginacion.c para aceptar la dirección virtual y la tabla como argumentos.
4. Explica por qué la paginación no tiene fragmentación externa.
5. Calcula cuántos marcos tiene una RAM de 8 GiB con páginas de 4 KiB.
6. Investiga qué son las páginas grandes (huge pages) y por qué se usan.
7. Dibuja el mapa de memoria de un proceso de 3 páginas en marcos no contiguos.