16 · Segmentación

Apuntes propios sobre el capítulo 16 de OSTEP (Segmentation). Fuente: https://ostep.org

16.1 Generalizar base y límite

El problema del cap. 15: reservar el espacio de direcciones entero y contiguo desperdicia el gran hueco entre heap y pila. Idea de la segmentación: un par base/límite por cada región lógica (segmento) — código, heap, pila — y colocar cada segmento independientemente en RAM física. Solo se reserva lo que cada segmento usa; el hueco virtual no ocupa nada físico.

 RAM física:
  ┌────────┐
  │ código │← base_código
  ├────────┤     (los tres segmentos, dispersos
  │  pila  │← base_pila        y compactos)
  ├────────┤
  │  heap  │← base_heap
  └────────┘

16.2 ¿A qué segmento pertenece una dirección?

Dos enfoques:

  • Explícito: los bits altos de la dirección virtual seleccionan el segmento; el resto es el desplazamiento (offset) dentro de él. Con 3 segmentos, 2 bits: 01|0110100 → segmento 1 (heap), offset 0x34 → física = base_heap + 0x34, comprobando offset < límite_heap. Pega: partir el espacio en cuadrantes fijos limita el tamaño de cada segmento (y desperdicia un cuadrante si hay 3 segmentos y 4 combinaciones).
  • Implícito: el hardware deduce el segmento por el origen del acceso (fetch → código; relativo a SP → pila; resto → heap).

La pila complica: crece hacia abajo. Hace falta un bit por segmento que indique el sentido de crecimiento y una aritmética de traducción ligeramente distinta (offsets “negativos” desde el tope).

16.3 Compartición y protección

Con bits de protección por segmento (lectura/escritura/ejecución) aparece un beneficio nuevo: compartir segmentos de código entre procesos (el mismo segmento físico de solo-lectura mapeado en muchos procesos), con la ilusión intacta. La comprobación de permisos se hace junto a la de límites; violarla → excepción.

16.4 El problema fatal: fragmentación externa

El SO ahora gestiona huecos de tamaños variables en RAM. Al crear y destruir procesos, la memoria libre queda picada en huequitos: puede haber 24 MiB libres en total y no caber un segmento de 20 MiB porque ningún hueco es contiguo suficiente. Es la fragmentación externa.

Remedios paliativos:

  • Compactar: parar procesos, mover segmentos para juntar los huecos, actualizar bases. Carísimo (copiar memoria masivamente) y hostil a heaps que crecen.
  • Mejores algoritmos de asignación (best-fit, worst-fit, buddy… cap. 17): ayudan, pero ningún algoritmo elimina la fragmentación externa con tamaños variables.

Además, la segmentación sigue siendo gruesa: si el heap está casi vacío por dentro, igualmente su parte usada+dispersa debe estar completa en RAM. La solución a ambas cosas — trocear en unidades fijas y pequeñas — es la paginación (cap. 18).

Ampliación (no está en OSTEP)

  • x86 de 32 bits tenía segmentación completa en hardware (GDT/LDT, selectores CS/DS/SS); casi nadie la usó de verdad encima de la paginación, y x86-64 la eliminó de facto (bases forzadas a 0, salvo FS/GS que sobreviven como punteros baratos a datos por-hilo — TLS — y per-CPU en el kernel). La historia falló a favor de la paginación pura.
  • El término segmentation fault es el fósil lingüístico de esta época: hoy casi siempre señala una violación de paginación, no de segmentos.
  • La idea de “regiones lógicas con permisos” sobrevive en otro plano: las VMAs de Linux (/proc/pid/maps) son exactamente eso, implementadas sobre paginación.

Referencias

  • OSTEP cap. 16.
  • Dennis, Segmentation and the Design of Multiprogrammed Computer Systems, JACM 1965 — el paper fundacional (Multics).
  • Intel SDM vol. 3, cap. de segmentación — para ver el fósil x86 en detalle.