Sesión 10
Memoria Virtual y Sistemas de Archivos

Paginación, Segmentación y Estructuras de Directorios

Unidad 2 - Clase 2

Navegación: ← → F pantalla completa

Sistemas Operativos · Grupo 050
Conexión con Sesión 9

De la RAM al Disco: El puente

La clase anterior estableció que la RAM es rápida pero limitada/volátil, y el disco es lento pero masivo/persistente. Hoy profundizamos cómo el SO hace que un proceso "vea" un espacio de memoria gigante y cómo administra los archivos en disco.

  • ¿Qué es **Memoria Virtual** y por qué es esencial para la multiprogramación?
  • ¿Cómo se implementa con **Paginación** y **Segmentación**?
  • ¿Cómo el **Sistema de Archivos** organiza miles de millones de bloques en carpetas y archivos legibles?

Objetivo de hoy: Entender los algoritmos de paginación/segmentación y las estructuras de archivos/directorio para justificar decisiones de diseño en el proyecto E2.

Indicadores A-II, B-II, C-II [file:113]
Algoritmos de Paginación

Paginación: División en bloques fijos

Para evitar fragmentación externa, la memoria virtual se divide en **Páginas** (lógicas, tamaño fijo 4KB) y la RAM en **Marcos** (físicos, mismo tamaño). El SO mantiene una **Tabla de Páginas** que mapea cada página a un marco.

Ventajas:

  • Sin fragmentación externa (solo interna ≤4KB).
  • Intercambio eficiente de páginas (I/O de bloques fijos).

Ejemplo de Dirección Lógica:

Dirección Lógica (32 bits): 0x0012ABCD Páginas de 4KB (12 bits offset): 0x0012AB | CD → Busca Página 0x0012AB en Tabla → Marco 0x000A Dirección Física: 0x000A | CD
La MMU hace esta traducción en hardware
Algoritmos de Segmentación

Segmentación: División lógica variable

Alternativa a la paginación: divide la memoria en **Segmentos** de tamaño variable (código, datos, pila). Cada segmento tiene su propia tabla con base y límite.

Ventajas:

  • Segmentos semánticos (código separado de datos).
  • Compartición fácil entre procesos (bibliotecas compartidas).

Desventajas:

  • Fragmentación externa (huecos entre segmentos).
  • Problemas de compacidad (necesita compactor).

Moderno: Muchos SO combinan ambos (Paginación + Segmentación = Paged Segmentation).

Indicadores C-II [file:113]
Comparación Paginación vs Segmentación

¿Cuándo usar cada técnica?

CriterioPaginaciónSegmentación
Tamaño de bloquesFijo (4KB)Variable
FragmentaciónSolo interna (≤4KB)Externa (huecos grandes)
Traducciones1 Tabla (rápida)Tabla por segmento (lenta)
ComparticiónPor página (compleja)Por segmento (natural)
Uso en ProyectoSwap de logs pesadosCódigo vs Datos del Gestor
Elegir según rendimiento y semántica del código
Mecánica de Page Fault

Algoritmo de Reemplazo de Páginas

Cuando la RAM está llena y llega una nueva página, el SO debe decidir cuál página vieja expulsar. Algoritmos comunes:

  • FIFO (First In First Out): Expulsa la más antigua. Simple pero sufre "anomalía de Belady".
  • LRU (Least Recently Used): Expulsa la menos usada recientemente. Excelente pero requiere hardware de contadores.
  • OPT (Óptimo): Expulsa la que se usará más tarde (imposible en práctica, solo teórico).

En tu PC: Windows usa LRU aproximado. Linux usa variantes como Clock Algorithm.

Relación directa con rendimiento percibido
Ejemplo Práctico

Simulación de Paginación (4KB páginas)

Estado Inicial RAM (3 Marcos libres):

MarcoPágina Lógica
0P0 del Proceso A
1P1 del Proceso A
2P0 del Proceso B

Proceso A pide P2 (Page Fault):

LRU: Expulsa P0 de A (menos usada) Nuevo estado: Marco 0: P2 de A ← Nueva página del disco Marco 1: P1 de A Marco 2: P0 de B
Ejecutar en pizarra para la clase
Sistemas de Almacenamiento

Sistemas de Archivos (FAT, NTFS, ext4)

El SO organiza el disco en bloques y crea una capa lógica:

  • FAT (File Allocation Table): Simple, cadenas enlazadas. Bueno para USBs pequeños.
  • NTFS (Windows): Inodos avanzados, journaling (recuperación), compresión, encriptación.
  • ext4 (Linux): Extensible, gran rendimiento, soporte snapshots.

Común: Todos usan **Inodos** para metadatos + punteros a bloques de datos.

Indicadores D-II [file:113]
Asignación de Espacio a Archivos

Métodos de Asignación

¿Cómo asigna el SO bloques del disco a un archivo de 10GB?

Contigua:

  • Bloques consecutivos en disco.
  • Acceso ultra-rápido (sin saltos).
  • Fragmentación externa grave.

Enlazada:

  • Cada bloque apunta al siguiente.
  • Sin fragmentación externa.
  • Lento para acceso aleatorio.

Indexada (Mejor): Inodo con array de punteros a bloques. NTFS/ext4.

Relación con rendimiento de I/O
Directorios Internos

Estructura Física de Directorios

Un directorio es un archivo especial con tabla [Nombre → Inodo]. Ejemplo de entrada:

Nombre: "main.cs" → Inodo: 40582 Nombre: "." → Inodo: 40580 (Auto-referencia) Nombre: ".." → Inodo: 40001 (Padre) Estructura en Disco: Bloque 40580: ["main.cs" → 40582, "datos.csv" → 40612]

Operación Open("src/main.cs"): SO lee directorios padre hasta encontrar el Inodo 40582, carga metadatos, devuelve Handle.

Por esto listar un directorio con 1M archivos toma tiempo
Ejemplo Práctico

¿Qué pasa al guardar "log.txt"?

Flujo físico:

  1. SO busca/aloca Inodo libre (ej. #40583).
  2. Asigna bloques libres (ej. 500-510).
  3. Escribe metadatos en Inodo.
  4. Actualiza Directorio padre con nueva entrada.
Inodo 40583 de log.txt: Tamaño: 1KB Bloques: [500, 501] Permisos: rw-r--r-- Creado: 2026-03-11 21:00 Directorio logs/: ["log.txt" → 40583]
Diagrama en pizarra: Inodo → Bloques → Directorio
Código Práctico

Creando estructura para Proyecto E2

# PYTHON - Crear árbol de archivos para Gestor import os # Rutas relativas desde cwd del proyecto os.makedirs("data", exist_ok=True) os.makedirs("logs", exist_ok=True) with open("data/procesos.csv", "w") as f: f.write("PID,Burst,Arrival\n1,5,0\n2,3,1\n") print("Estructura lista para simulación")

¿Qué Syscalls genera? mkdir → create → open → write → close (x2).

Ejecutar en VS Code Terminal para demo
Algoritmos Avanzados

Reemplazo de Páginas (Profundización)

AlgoritmoPolíticaVentajaDesventaja
FIFOMás antiguaSimpleAnomalía Belady
LRUMenos usadaÓptimo prácticoHardware caro
ClockBit de referenciaAproximación LRU barataComplejidad media

En tu Gestor E2: Usar streams para evitar saturar páginas con logs pesados.

Linux usa variante Clock
Sistemas de Archivos

FAT vs NTFS vs ext4

FSAsignaciónRecuperaciónSeguridadUso
FAT32EnlazadaNoBásicaUSB
NTFSIndexada + JournalSí (Journaling)ACLs, EncriptaciónWindows
ext4Indexada + ExtentSíPermisos UnixLinux
Journaling = Registro de transacciones para recuperación
Ejemplo Práctico

Segmentación en tu Gestor

Segmento 0: Código (Main + FCFS) - 32KB Segmento 1: Datos (Lista Procesos) - 16KB Segmento 2: Pila (Variables locales) - 8KB Segmento 3: Heap (Logs dinámicos) - Variable Acceso a heap[100]: Tabla Seg 3 → Base: 0x4000, Límite: 64KB 0x4000 + 100 = Dirección Física

Si Heap crece más allá del límite → **Segmentation Fault** (kill del proceso).

Semántica natural para código estructurado
Aplicación al Proyecto

Impacto en E2 del Gestor

  • Logs pesados: Usar streams (no ReadAllText) para evitar thrashing al simular 1000+ procesos.
  • CSV de entrada: Leer línea por línea, mapear a objetos sin cargar todo en memoria.
  • Persistencia: Append a "logs/auditoria.log" con timestamps (modo 'a').
  • Estructura: Usar rutas relativas `./data/procesos.csv` para portabilidad.

Buena práctica: `File.AppendAllText("logs/log.txt", entry)` genera solo Syscalls mínimas.

Directamente aplicable a rúbrica de E2
Errores Comunes

Fragmentación y Thrashing en la Práctica

Fragmentación Externa (Segmentación):

  • Huecos pequeños inutilizables entre segmentos.
  • Solución: Compactor de memoria (costoso).

Thrashing en Desarrollo:

  • Debuggear con VS Code + Docker + Chrome abierto → Swap constante.
  • Solución: Cerrar apps, usar streams para datos.
Por qué tu PC "llora" al compilar proyectos grandes
Demo en Terminal

Observar Memoria Virtual en Acción

# Linux - Ver uso de Swap (Paginación) free -h # Ver procesos y memoria top # Presiona 1 para ver núcleos # Windows PowerShell Get-Process | Sort-Object WS | Select -Last 10 # Monitorear en tiempo real watch -n 1 free -h

Actividad clase: Abrir 10 pestañas Chrome + VS Code → Observar Swap crecer.

Ejecutar en laboratorio
Para Reflexión

¿Por qué importa esto para programadores?

  • ¿Por qué `File.ReadAllText(2GB)` colapsa pero streams no?
  • ¿Por qué rutas relativas en lugar de absolutas en código?
  • ¿Cómo paginación explica el lag al debuggear proyectos grandes?
  • ¿Por qué `AppendText` es mejor que `WriteAllText` para logs?

Conexión E2: Tu Gestor leerá CSV pesado → Streams + rutas relativas obligatorias.

Discusión plenaria 10 min
Resumen Unidad 2 - Clase 2

Conceptos Clave Cubiertos

ConceptoImplementaciónImpacto en Proyecto
PaginaciónBloques fijos 4KBEvitar thrashing con streams
SegmentaciónBloques variablesCódigo/datos separados
InodosMetadatos + punterosBase de archivos log/CSV
Asignación IndexadaTabla en InodoRendimiento I/O logs

Próxima: Actividad 3 - Práctica con estructuras de archivos. ¡Prepárense para terminal!

Indicadores A-II a E-II cubiertos [file:113]