# Mapas de memoria, localidad y aislamiento

Lab 3 · Memoria · Sistemas Operativos
Page: https://alfonsocampodonico.com/classes/operating-systems/lab-memory?lang=es
Code: https://github.com/AlfonsoCampodonico/os-lab/tree/main/starter/lab3-memory-probe (`gh repo clone AlfonsoCampodonico/os-lab`)

> ¿Cómo presenta el sistema operativo la memoria como un único espacio de direcciones y, al mismo tiempo, controla el mapeo, la protección y el rendimiento?

## Pregunta guía

¿Cómo presenta el sistema operativo la memoria como un único espacio de direcciones y,
al mismo tiempo, controla el mapeo, la protección y el rendimiento?

## Conceptos

- stack vs. heap
- intuición sobre memoria virtual
- mapas de memoria
- localidad
- `mmap`
- protección y segmentation faults

## Escenario

Estás construyendo una sonda de memoria para estudiantes que necesitan ver cómo cambian
los espacios de direcciones en tiempo de ejecución. La herramienta tiene que mostrar los mapeos y permitirte comparar
patrones de acceso.

Proyecto inicial: `starter/lab3-memory-probe`

## Tareas de observación

1. Corré `./zig-out/bin/memory_probe maps`
2. Inspeccioná `/proc/self/maps`
3. Compará los modos de acceso secuencial y aleatorio (usá `touch 512` o
   más; con 8 MB la diferencia es ruido)

Anotá:

- dónde aparecen el ejecutable, el stack, el heap y las bibliotecas compartidas
- qué patrón de acceso es más rápido
- un ejemplo de un mapeo creado por `mmap`

## Tareas de implementación

El código inicial ya trae una versión mínima de los ítems 1–3; leelo,
explicá cada parte y después extendelo para que soporte:

1. Imprimir regiones de memoria seleccionadas con etiquetas.
2. Cargas de trabajo que toquen la memoria de forma secuencial y aleatoria.
3. Una pequeña demo de `mmap` sobre un archivo.
4. Un experimento controlado que muestre el comportamiento de protección o aislamiento.
5. Una explicación breve de por qué importa la localidad.

## Puntos de control

- ¿Cuál es la diferencia entre reservar memoria en el heap y mapear memoria?
- ¿Por qué el orden de acceso importa para el rendimiento?
- ¿Qué información de `/proc/<pid>/maps` revela las bibliotecas compartidas?
- ¿Qué te dice un segmentation fault sobre la protección de memoria?

## Entregables

- `memory_probe.zig` actualizado
- la salida de ejecución de al menos dos experimentos
- respuestas a las preguntas de los puntos de control

## Objetivos extra

- comparar el costo de tocar páginas para distintos tamaños de arreglo
- agregar un modo de salida CSV para graficar
- mostrar cómo un proceso hijo hereda los mapeos después de `fork()`

## Verificación sugerida

```bash
zig build -p zig-out
./zig-out/bin/memory_probe maps
./zig-out/bin/memory_probe touch 512 sequential
./zig-out/bin/memory_probe touch 512 random
```

## Criterios de corrección

- razonamiento preciso sobre los conceptos de memoria virtual
- experimentos útiles con salidas claras
- conexión clara entre el comportamiento observado y la teoría


## Compilarlo

Con Zig **0.16.x** instalado (la 0.17 eliminó `@cImport`, que usan los starters), desde la raíz del repositorio:

```sh
zig build -p zig-out
bash scripts/smoke_test.sh
```
