Simulador de paginación

1. Qué vamos a simular

El simulador recibe una dirección virtual y la traduce a física recorriendo una tabla de dos niveles:

• Nivel 1 (directorio): la página virtual se divide en índice de directorio e índice de tabla.
• Nivel 2 (tabla de páginas): se obtiene el marco físico.
• Desplazamiento: se concatena al marco para formar la dirección física.

El usuario avanza paso a paso y ve en cada nivel qué entrada se consulta y qué valor se obtiene.

2. El programa de ejemplo

Este programa en C simula la traducción con dos niveles (directorio de 4 entradas, tabla de 4 entradas por directorio):

#include <stdio.h>

int main(void)
{
    const int PS = 16;  /* tamaño de página (16 B, para el ejemplo) */
    const int DIR_ENTRIES = 4;
    const int TBL_ENTRIES = 4;

    /* Directorio: índice -> base de tabla */
    int dir[] = {0, 1, -1, -1};  /* -1 = no presente */
    /* Tablas: [dir][tbl] -> marco */
    int tbl[4][4] = {
        {5, 2, -1, -1},
        {8, -1, 3, -1},
        {-1, -1, -1, -1},
        {-1, -1, -1, -1}
    };

    unsigned int vaddr = 0x2B;  /* dirección virtual de ejemplo */
    unsigned int p = vaddr / PS;   /* número de página (0-15) */
    unsigned int d = vaddr % PS;   /* desplazamiento */
    unsigned int dirIdx = p / TBL_ENTRIES;
    unsigned int tblIdx = p % TBL_ENTRIES;

    printf("virtual = 0x%02X (p=%u, d=%u)\\n", vaddr, p, d);
    printf("dirIdx=%u, tblIdx=%u\\n", dirIdx, tblIdx);

    if (dir[dirIdx] == -1) { printf("Fallo: directorio no presente\\n"); return 1; }
    int marco = tbl[dirIdx][tblIdx];
    if (marco == -1) { printf("Fallo: página no presente\\n"); return 1; }
    unsigned int fis = marco * PS + d;
    printf("marco=%d, fisica=0x%02X\\n", marco, fis);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o pag2niveles pag2niveles.c
$ ./pag2niveles
virtual = 0x2B (p=2, d=11)
dirIdx=0, tblIdx=2
marco=3, fisica=0x3Bmarco=3, fisica=0x3B

3. Tablas de dos niveles

En el ejemplo, la memoria virtual se divide en 16 páginas (4 directorios × 4 tablas). El directorio tiene 4 entradas, cada una apuntando a una tabla de 4 páginas. Solo se crean las tablas que se necesitan.

4. El recorrido paso a paso

Para traducir una dirección virtual con dos niveles:

1. Dividir la dirección: p = v / PS, d = v % PS.
2. Dividir p: dirIdx = p / TBL_ENTRIES, tblIdx = p % TBL_ENTRIES.
3. Consultar directorio: si dir[dirIdx] == -1, fallo de página (tabla no presente).
4. Consultar tabla: marco = tbl[dirIdx][tblIdx]. Si es -1, fallo de página.
5. Calcular física: física = marco × PS + d.

5. El simulador interactivo

Memoria con directorio de 4 entradas y tablas de 4 entradas. Avanza paso a paso y observa el recorrido.

6. Qué observar

• El recorrido tiene 3 fases: directorio, tabla, marco.
• Un fallo en el directorio impide consultar la tabla.
• Un fallo en la tabla impide obtener el marco.
• El desplazamiento se conserva y se concatena al final.
• Las tablas no presentes (-1) detienen la traducción.

7. Limitaciones del simulador

Este simulador es una simplificación. No modela:

• Los bits de protección (presente, R/W, etc.).
• La TLB (se asume que no hay caché de traducciones).
• La paginación por demanda (carga automática de páginas).
• Más de 2 niveles (x86-64 tiene 4).

8. En Linux

Linux usa 4 niveles de tabla (o 5 con 5-level paging). Las herramientas para inspeccionar:

$ getconf PAGESIZE
4096
$ cat /proc/cpuinfo | grep -i 'address sizes'
address sizes   : 46 bits physical, 48 bits virtual

• getconf PAGESIZE: tamaño de página (4096).
• address sizes: bits de dirección física y virtual.
• Con 5-level paging, el espacio virtual pasa a 57 bits.

9. Resumen

• El simulador recorre una tabla de dos niveles (directorio + tabla de páginas).
• La traducción tiene 3 fases: directorio, tabla, marco.
• Un fallo en cualquier nivel detiene la traducción.
• El desplazamiento se conserva y se concatena al marco.
• En Linux se usan 4 niveles (o 5 con 5-level paging).

10. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Configura el directorio con la entrada 0 a -1 y traduce una dirección de la página 0-3. ¿Qué falla?
2. Configura la tabla con la entrada 2 a -1 y traduce la dirección de la página 2. ¿Qué falla?
3. Traduce la dirección 11 (p=0, d=11) y 27 (p=1, d=11). ¿Cuál es la física?
4. Modifica el simulador para soportar 4 niveles (como x86-64).
5. Explica por qué el simulador no modela la TLB.
6. Investiga cómo Linux gestiona las tablas de páginas de un proceso.
7. Dibuja el recorrido de la dirección 43 paso a paso.