Sistemas de archivos — práctica con problemas guiados paso a paso: bloques y fragmentación interna, lecturas según la asignación, el i-nodo y un ejercicio con el formato del examen (y el bloque que conté desde 1)

En el simulacro de IC2 había una pregunta del i-nodo que me pareció de regalo: bloques de 2 KiB, 12 punteros directos, «¿qué puntero lleva al byte 23 000?». Dividí 23 000 entre 2048, me salió 11,2 y pensé: «está en el bloque 12, así que ya no es directo: indirecto simple». Mal. Los bloques lógicos se cuentan desde 0, como los bytes: el byte 23 000 está en el bloque 11, que es el duodécimo y último directo. Por un bloque me fui al nivel de índices equivocado. Desde entonces, en cualquier cálculo de bloques, escribo primero «bloque = byte / tamaño, división entera, contando desde 0».

Esta es la práctica guiada de sistemas de archivos. En la teoría de sistemas de archivos viste los atributos, los directorios, la asignación contigua, enlazada, FAT e indexada, el i-nodo de Unix y la gestión del espacio libre, con la carpeta de la práctica de IC2. Aquí resolvemos cuatro problemas paso a paso: cuántos bloques ocupa un archivo y cuánto se pierde, cuántas lecturas cuesta llegar a un bloque con cada asignación, el tamaño máximo con un i-nodo y qué puntero lleva a cada byte, y un ejercicio con el formato del examen. Después, en los ejercicios de sistemas de archivos, te toca a ti.

Antes de empezar

Conviene tener claro:

• Que los tamaños van en potencias de 2: 1 KiB = 1024 B, 1 MiB = $2^{20}$ B, 1 GiB = $2^{30}$ B.
• Que un archivo ocupa bloques enteros: el número de bloques se redondea hacia arriba y lo que sobra en el último es fragmentación interna.
• Cómo guarda cada asignación los enlaces: en el directorio (contigua), en los propios bloques (enlazada), en una tabla (FAT) o en un bloque de índices (indexada).
• La estructura del i-nodo: 12 punteros directos, uno indirecto simple, uno doble y uno triple; con N punteros por bloque, el máximo es $(12 + N + N^2 + N^3) \times$ tamaño de bloque.

Si alguno te suena dudoso, repasa la teoría antes de seguir.

Cómo se resuelve un problema de archivos

Los cuatro problemas siguen el mismo método de cuatro pasos:

1. Pasa todo a bytes o a potencias de 2 y apunta el tamaño de bloque y de puntero.
2. Cuenta en bloques: tamaño / bloque redondeando hacia arriba para ocupar; byte / bloque con división entera (desde 0) para localizar.
3. Aplica la estructura: qué hay que leer con cada asignación, en qué tramo del i-nodo cae un bloque, cuántos bits o entradas hacen falta.
4. Comprueba con una cuenta al revés: bloques × tamaño ≥ archivo, tramos que suman el total, órdenes de magnitud razonables.

Problema 1: bloques y fragmentación interna

Enunciado. Un disco usa bloques de 2 KiB. ¿Cuántos bloques ocupa cada archivo y cuántos bytes se pierden en su último bloque?

Archivo	Tamaño
foto.jpg	5000 B
tfg.docx	20 KiB
video.mp4	3 MiB + 100 B

La idea

Un archivo no puede ocupar medio bloque: si le sobra un byte, necesita otro bloque entero. Así que los bloques son el tamaño entre 2048 redondeado hacia arriba, y lo perdido es lo que queda libre en el último: bloques × 2048 − tamaño.

Paso a paso

Archivo	Tamaño (B)	Tamaño / 2048	Bloques	Perdido (B)
foto.jpg	5000	2,44	3	3 · 2048 − 5000 = 1144
tfg.docx	20 480	10 exactos	10	0
video.mp4	3 145 828	1536,05	1537	1537 · 2048 − 3 145 828 = 1948

En el vídeo, 3 MiB son exactamente $3 \cdot 2^{20} / 2^{11} = 1536$ bloques; los 100 bytes de más obligan a usar uno más, casi vacío.

Comprobación

• Lo perdido es siempre menor que un bloque (0 ≤ perdido < 2048): los tres lo cumplen.
• Con tamaños que son múltiplo de 2 KiB no se pierde nada: tfg.docx.

Preguntas que te puedes hacer

¿Por qué no se usan bloques muy pequeños para no perder nada? Porque cada bloque es una entrada más en la FAT, en el mapa de bits o en los índices, y más lecturas para un archivo grande. Bloques grandes: menos gestión y más fragmentación interna.

¿Cuánto se pierde de media? Medio bloque por archivo. Con muchos archivos pequeños, la fragmentación interna puede ser una parte importante del disco.

¿Las asignaciones necesitan bloques de más? La indexada, sí: el bloque de índices. La enlazada no gasta bloques, pero cada bloque guarda el puntero al siguiente y le caben menos datos.

Pruébalo tú

• ¿Cuántos bloques ocupa un archivo de 1 byte? ¿Y uno de 0 bytes?
• Repite la tabla con bloques de 4 KiB. ¿Qué archivo pierde ahora más?

Problema 2: lecturas según la asignación

Enunciado. Un programa quiere leer el bloque lógico 6 (el séptimo, contando desde 0) de un archivo que ya tiene abierto. ¿Cuántas lecturas de disco hacen falta con asignación contigua, enlazada, FAT (con la tabla en memoria) e indexada (con el bloque de índices en disco)?

La idea

La pregunta es siempre la misma: ¿dónde está apuntado en qué bloque físico está el bloque 6? Si se puede calcular sin leer nada (contigua, o FAT ya en memoria), basta con leer el dato. Si hay que ir siguiendo enlaces en el disco (enlazada), hay que leer todos los bloques anteriores. Si está en un bloque de índices en disco, una lectura más.

Paso a paso

Asignación	Cómo se encuentra el bloque 6	Lecturas
Contigua	físico = inicio + 6, calculado	1
Enlazada	leer el 0 para saber dónde está el 1, … hasta el 5 para saber dónde está el 6	7 (del 0 al 6)
FAT en memoria	seguir la cadena en la tabla, que está en la RAM	1
Indexada	leer el bloque de índices y después el dato	2

Comprobación

• La contigua y la FAT tienen acceso directo; la enlazada no: el coste crece con el número de bloque (para el bloque k, k + 1 lecturas).
• La indexada siempre cuesta 2 (o más, con varios niveles de índices), sea cual sea el bloque.

Preguntas que te puedes hacer

¿Por qué la FAT no cuenta como lecturas? Porque está en memoria: seguir la cadena es mirar la RAM. Si la FAT no cupiera en memoria y hubiera que leerla del disco, sí costaría lecturas.

Entonces, ¿por qué no se usa siempre la contigua? Porque necesita un hueco contiguo del tamaño del archivo y sufre fragmentación externa; además, el archivo no puede crecer si se le acaba el sitio.

¿Y con el i-nodo? Para un bloque directo, 1 lectura (el i-nodo ya está en memoria al abrir el archivo); por el indirecto simple, 2; por el doble, 3; por el triple, 4.

Pruébalo tú

• ¿Cuántas lecturas cuesta el bloque 0 con cada asignación?
• Con enlazada, ¿cuántas lecturas cuesta leer el archivo entero de 10 bloques, de principio a fin? ¿Y el bloque 9 solo?

Problema 3: el i-nodo

Enunciado. Un sistema de archivos tipo Unix usa bloques de 2 KiB, punteros de 4 bytes y un i-nodo con 12 punteros directos, uno indirecto simple, uno doble y uno triple. a) ¿Cuál es el tamaño máximo de un archivo? b) ¿Qué puntero lleva a los bytes 20 000, 600 000 y 2 000 000 000?

La idea

Lo primero es saber cuántos punteros caben en un bloque de índices: $N = 2048 / 4 = 512$. Cada nivel multiplica por N: el simple llega a 512 bloques, el doble a $512^2$ y el triple a $512^3$. Para localizar un byte, se pasa a bloque lógico (división entera, desde 0) y se mira en qué tramo cae.

Paso a paso

a) Bloques alcanzables por cada puntero:

Puntero	Bloques	Acumulado (bloques lógicos)
12 directos	12	0 … 11
Indirecto simple	512	12 … 523
Indirecto doble	$512^2 = 262\,144$	524 … 262 667
Indirecto triple	$512^3 = 134\,217\,728$	262 668 … 134 480 395

Casi todo lo pone el triple: $512^3 \times 2 \text{ KiB} = 2^{27} \times 2^{11} = 2^{38}$ B = 256 GiB.

b)

Byte	Bloque lógico (byte / 2048)	Tramo	Puntero
20 000	9	0 … 11	directo
600 000	292	12 … 523	indirecto simple
2 000 000 000	976 562	≥ 262 668	indirecto triple

Comprobación

• 9 · 2048 = 18 432 ≤ 20 000 < 20 480 = 10 · 2048: el byte 20 000 está en el bloque 9.
• El tramo del triple empieza en 12 + 512 + 262 144 = 262 668: 976 562 es mayor, así que no basta con el doble.
• El total de bloques es la suma de los cuatro tramos: 12 + 512 + 262 144 + 134 217 728 = 134 480 396.

Preguntas que te puedes hacer

¿Por qué el puntero triple no se usa casi nunca y aun así está? Porque la mayoría de los archivos son pequeños y caben en los directos (rápidos), pero el triple permite que los pocos archivos enormes existan sin cambiar la estructura.

¿Cuántas lecturas cuesta llegar al byte 2 000 000 000? Con el i-nodo en memoria, 4: los tres niveles de índices del triple y el bloque de datos.

¿Y si los punteros fueran de 8 bytes? $N = 256$: el triple llegaría a $256^3$ bloques y el máximo bajaría a unos 32 GiB. Punteros más grandes permiten discos mayores, pero archivos más pequeños con la misma estructura.

¿El máximo real lo limita solo el i-nodo? No: también el campo del tamaño del archivo en el i-nodo y el tamaño del disco. En el examen, lo que se pide es el límite de la estructura.

Pruébalo tú

• ¿Qué puntero lleva al byte 1 073 741 824 (1 GiB)?
• Repite el apartado a) con bloques de 4 KiB y punteros de 4 bytes.

Problema 4: un ejercicio con el formato del examen

En la parte escrita y en los cálculos del test de IC2 caen preguntas de espacio libre y de tablas: cuánto ocupa el mapa de bits o la FAT de un disco. Se valora que todo vaya en potencias de 2 y que se vean las unidades. Este ejercicio es original y está escrito con ese formato.

Ejercicio. Un disco de 256 GiB usa bloques de 4 KiB. a) ¿Cuántos bloques tiene? b) ¿Cuánto ocupa un mapa de bits para gestionar el espacio libre? c) ¿Cuánto ocuparía una FAT con entradas de 4 bytes? d) ¿Cuál de las dos cabe con más holgura en la memoria de un portátil de 8 GiB?

Concepto	Resultado
Bloques del disco	___
Mapa de bits	___
FAT con entradas de 4 B	___

La idea

Todo es dividir potencias de 2: el disco entre el bloque da los bloques; el mapa de bits tiene un bit por bloque; la FAT, una entrada por bloque. Hay que tener cuidado con las unidades: bits y bytes, MiB y GiB.

Paso a paso

a) $256 \text{ GiB} = 2^{8} \cdot 2^{30} = 2^{38}$ B y $4 \text{ KiB} = 2^{12}$ B:

b) Un bit por bloque: $2^{26}$ bits $= 2^{26} / 8 = 2^{23}$ B = 8 MiB.

c) 4 B por bloque: $2^{26} \cdot 2^{2} = 2^{28}$ B = 256 MiB.

d) Las dos caben, pero el mapa de bits ocupa 32 veces menos (4 bytes son 32 bits): 8 MiB frente a 256 MiB.

Concepto	Resultado
Bloques del disco	$2^{26} = 67\,108\,864$
Mapa de bits	$2^{23}$ B = 8 MiB
FAT con entradas de 4 B	$2^{28}$ B = 256 MiB

Comprobación y cómo se corrige

• FAT / mapa de bits = 32: es la relación entre 4 bytes y 1 bit, sea cual sea el disco.
• Orden de magnitud: el mapa de bits de un disco de 256 GiB con bloques de 4 KiB es «del orden de MiB», nunca de GiB.

Se valora ver los exponentes en cada paso y las unidades bien puestas. Un 8 sin unidad, o confundir bits y bytes (64 MiB en el mapa de bits), cuenta como error aunque la potencia de 2 esté bien.

Pruébalo tú

• Repite el ejercicio con bloques de 1 KiB. ¿Por cuánto se multiplican el mapa de bits y la FAT?
• ¿Cuántos bits necesitaría como mínimo cada entrada de la FAT para numerar todos los bloques de este disco?

Errores típicos en esta práctica

• Usar potencias de 10: 1 KiB son 1024 bytes y 1 GiB son $2^{30}$.
• Redondear hacia abajo los bloques que ocupa un archivo.
• Contar los bloques lógicos desde 1 al localizar un byte.
• Contar mal las lecturas de la enlazada: para el bloque k, k + 1.
• Confundir bits y bytes en el mapa de bits.
• Olvidar el bloque de índices en la asignación indexada.

Compruébalo con Python

Este programa hace las cuentas de los cuatro problemas: bloques con math.ceil, lecturas, los tramos del i-nodo y el espacio libre. Hazlo primero a mano.

# Sistemas de archivos de papel: bloques, lecturas según la asignación, i-nodo y espacio libre.
import math
KiB, MiB, GiB = 1024, 1024 ** 2, 1024 ** 3
B = 2 * KiB                                    # tamaño de bloque
for nombre, tam in (("foto.jpg", 5000), ("tfg.docx", 20 * KiB), ("video.mp4", 3 * MiB + 100)):
    n = math.ceil(tam / B); print(f"{nombre}: {n} bloques, se pierden {n * B - tam} B dentro del último")

k = 6                                          # leer el bloque lógico 6 (contando desde 0)
print("lecturas para el bloque 6: contigua 1, enlazada", k + 1, "| FAT en RAM 1 | indexada", 1 + 1)

N = B // 4                                     # punteros de 4 B por bloque de índices
directos = 12
niv = [directos, N, N ** 2, N ** 3]
acum = 0
for nom, n in zip(("directos", "simple", "doble", "triple"), niv):
    acum += n; print(f"{nom}: {n} bloques, acumulado {acum} bloques = {acum * B / GiB:.4f} GiB")
print(f"máximo: {acum * B} B = {acum * B / GiB:.2f} GiB")
for byte in (20000, 600000, 2 * 10 ** 9):
    b = byte // B
    nivel = "directo" if b < 12 else "simple" if b < 12 + N else "doble" if b < 12 + N + N ** 2 else "triple"
    print(f"byte {byte}: bloque lógico {b}, puntero {nivel}")

disco = 256 * GiB; bloques = disco // (4 * KiB)
print(f"disco 256 GiB, bloques de 4 KiB: {bloques} bloques; mapa de bits {bloques // 8 // MiB} MiB; FAT de 4 B {bloques * 4 // MiB} MiB")

Salida (ejecutado una vez):

foto.jpg: 3 bloques, se pierden 1144 B dentro del último
tfg.docx: 10 bloques, se pierden 0 B dentro del último
video.mp4: 1537 bloques, se pierden 1948 B dentro del último
lecturas para el bloque 6: contigua 1, enlazada 7 | FAT en RAM 1 | indexada 2
directos: 12 bloques, acumulado 12 bloques = 0.0000 GiB
simple: 512 bloques, acumulado 524 bloques = 0.0010 GiB
doble: 262144 bloques, acumulado 262668 bloques = 0.5010 GiB
triple: 134217728 bloques, acumulado 134480396 bloques = 256.5010 GiB
máximo: 275415851008 B = 256.50 GiB
byte 20000: bloque lógico 9, puntero directo
byte 600000: bloque lógico 292, puntero simple
byte 2000000000: bloque lógico 976562, puntero triple
disco 256 GiB, bloques de 4 KiB: 67108864 bloques; mapa de bits 8 MiB; FAT de 4 B 256 MiB

Cosas que observar:

1. math.ceil(tam / B) es el redondeo hacia arriba: con foto.jpg da 3, no 2,44.
2. El acumulado del i-nodo sale en GiB: los directos y el simple apenas aportan; el doble llega a medio GiB y el triple pone los 256.
3. Para localizar un byte, byte // B es la división entera que cuenta desde 0; el byte 2 000 000 000 cae en el bloque 976 562.
4. El mapa de bits y la FAT salen de la misma cantidad de bloques; la FAT es 32 veces mayor.

Resumen

• Bloques ocupados = tamaño / bloque, hacia arriba; lo que sobra en el último es fragmentación interna.
• Lecturas para el bloque k: contigua 1, enlazada k + 1, FAT en memoria 1, indexada 2.
• i-nodo: N = bloque / puntero; máximo $(12 + N + N^2 + N^3) \times$ bloque.
• Bloque lógico de un byte = byte / bloque, división entera, desde 0; después, en qué tramo cae.
• Mapa de bits: un bit por bloque; FAT: una entrada por bloque.
• Todo en potencias de 2 y con unidades.

Checklist: ¿lo has practicado?

• ¿Has hecho los cuatro problemas en papel antes de leer el paso a paso?
• ¿Sabes cuándo se redondea hacia arriba y cuándo es división entera?
• ¿Puedes decir cuántas lecturas cuesta un bloque con cada asignación?
• ¿Sabes calcular el máximo del i-nodo y localizar un byte en sus tramos?
• ¿Has comprobado los problemas con el programa de Python?
• ¿Has intentado los «Pruébalo tú» sin mirar la teoría?

Si has respondido que sí a casi todo, estás listo para los ejercicios de sistemas de archivos, con un test de todo el tema y cálculos de bloques, i-nodos y mapas de bits con casillas que se corrigen solas. ¡Nos vemos allí!

Siguiente paso: ejerciciosSistemas de archivos — ejercicios tipo examen con bloques, FAT, i-nodos y enlaces (y el atajo que apuntaba a la nada)

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →