Particiones y fragmentación

1. El problema: repartir la RAM

Con los registros base y límite (tema 11) cada proceso ocupa un bloque contiguo de RAM. El sistema debe decidir cómo dividir la RAM entre los procesos. Hay dos enfoques clásicos:

• Particiones fijas: la RAM se divide en bloques de tamaño fijo al arrancar. Cada proceso ocupa una partición.
• Particiones variables: las particiones se crean dinámicamente, del tamaño exacto del proceso.

Ambos tienen un costo: el desperdicio de memoria que no se puede usar. Ese desperdicio se llama fragmentación.

2. Particiones fijas

La RAM se divide en n particiones de tamaño fijo (por ejemplo, 4 de 2 MiB en un equipo de 8 MiB). Cada proceso se asigna a una partición libre del tamaño adecuado. Si no hay ninguna libre del tamaño suficiente, el proceso espera.

3. Fragmentación interna

Es el espacio desperdiciado dentro de una partición asignada. Ocurre cuando el proceso es más pequeño que la partición que ocupa. Ese espacio no lo puede usar ningún otro proceso, porque la partición ya está asignada.

Fragmentación interna es el espacio libre dentro de una partición asignada que no puede ser usado por ningún otro proceso.

Ejemplo: particiones de 2 MiB y un proceso de 1,2 MiB. Sobran 0,8 MiB dentro de la partición. Con 4 procesos pequeños, se desperdician hasta 3,2 MiB.

4. Particiones variables

Las particiones se crean dinámicamente, del tamaño exacto del proceso. Al cargar un proceso se busca un hueco libre suficientemente grande; al terminar, se libera el hueco. Esto elimina la fragmentación interna.

5. Fragmentación externa

Es el espacio libre que queda entre particiones asignadas, en forma de huecos demasiado pequeños para un proceso nuevo. La memoria libre total puede ser suficiente, pero ningún hueco individual lo es.

Fragmentación externa es el espacio libre disperso en huecos que no pueden usarse para satisfacer una petición, aunque la suma sea suficiente.

Ejemplo: RAM de 10 MiB con procesos de 3, 2 y 3 MiB, dejando huecos de 1 y 1 MiB. Un proceso de 2 MiB no cabe, aunque haya 2 MiB libres en total.

6. Comparación: fijas vs variables

7. Compactación

La compactación es la solución a la fragmentación externa: se mueven los procesos en memoria para unir los huecos en un solo bloque libre. Requiere:

• Que la reubicación sea dinámica (base y límite o paginación).
• Detener los procesos durante el movimiento.
• Actualizar las direcciones (base) de cada proceso.

La compactación es costosa y se evita en los sistemas modernos mediante la paginación, que elimina la necesidad de bloques contiguos.

8. Ejemplo numérico

RAM de 16 MiB. Procesos: A (5 MiB), B (3 MiB), C (4 MiB). Hueco inicial: 4 MiB.

9. Experimento en C

El programa siguiente simula particiones fijas y variables sobre un mapa de memoria, calculando la fragmentación:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const int RAM = 16;          /* MiB */
    int fijas[] = {4, 4, 4, 4};  /* 4 particiones de 4 MiB */
    int proc[] = {5, 3, 4};     /* procesos en MiB */
    int nproc = 3;

    printf("=== Particiones fijas ===\\n");
    int interna = 0;
    for (int i = 0; i < nproc; i++) {
        int p = proc[i];
        int part = (p + 3) / 4 * 4;  /* redondear a múltiplo de 4 */
        if (part > 4) part = 8;       /* A necesita 2 particiones */
        interna += part - p;
        printf("proceso %d MiB -> partición %d MiB (desperdicio %d MiB)\\n", p, part, part - p);
    }
    printf("Fragmentación interna total: %d MiB\\n\\n", interna);

    printf("=== Particiones variables ===\\n");
    int usado = 0;
    for (int i = 0; i < nproc; i++) usado += proc[i];
    printf("Memoria usada: %d MiB, libre: %d MiB\\n", usado, RAM - usado);
    printf("Sin fragmentación interna.\\n");
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o particiones particiones.c
$ ./particiones
=== Particiones fijas ===
proceso 5 MiB -> partición 8 MiB (desperdicio 3 MiB)
proceso 3 MiB -> partición 4 MiB (desperdicio 1 MiB)
proceso 4 MiB -> partición 4 MiB (desperdicio 0 MiB)
Fragmentación interna total: 4 MiB

=== Particiones variables ===
Memoria usada: 12 MiB, libre: 4 MiB
Sin fragmentación interna.

10. Probar con un simulador

Este simulador muestra un mapa de memoria con procesos asignados y huecos libres. Puedes elegir entre particiones fijas y variables, y ver la fragmentación resultante.

11. En Linux hoy

Linux no usa particiones fijas ni variables en el sentido clásico: usa paginación (tema 18), que elimina tanto la fragmentación interna (salvo el último bloque de cada proceso) como la externa (los marcos se asignan de a uno). Pero el concepto de fragmentación sigue presente:

• Fragmentación interna: el último bloque de cada proceso puede no estar completo (desperdicio de hasta una página).
• Fragmentación externa: en el heap del asignador (glibc) quedan huecos entre bloques libres.
• Memoria física: la RAM se gestiona por marcos de página, sin fragmentación externa.

12. Resumen

• Las particiones fijas dividen la RAM en bloques de tamaño fijo; causan fragmentación interna.
• Las particiones variables crean bloques del tamaño exacto; causan fragmentación externa.
• La fragmentación interna es espacio desperdiciado dentro de una partición asignada.
• La fragmentación externa es espacio libre disperso en huecos inutilizables.
• La compactación une los huecos moviendo procesos, pero es costosa.
• La paginación elimina ambos tipos de fragmentación (salvo el último bloque).

13. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Modifica particiones.c para simular 5 procesos de tamaños aleatorios y calcular la fragmentación en ambos esquemas.
2. Implementa la compactación: dado un mapa con huecos, mueve los procesos para unir los huecos.
3. Calcula la fragmentación interna para particiones de 2, 4 y 8 MiB con los procesos del ejemplo.
4. Explica por qué un proceso de 5 MiB no cabe en particiones fijas de 4 MiB aunque haya 8 MiB libres.
5. Investiga cómo gestiona Linux la memoria física (buddy allocator) y qué fragmentación produce.
6. Compara la fragmentación interna de las particiones fijas con la del último bloque de un proceso paginado.
7. Dibuja un mapa de memoria con 3 procesos y huecos, y calcula si un proceso nuevo de 2 MiB cabe.