Comparar costos y aislamiento

1. Por qué comparar

Los procesos y los hilos son las dos formas de concurrencia en un sistema operativo. Ambos permiten que varias tareas avancen simultáneamente, pero con costos y garantías distintas. La elección entre uno y otro afecta el rendimiento, la seguridad y la complejidad del programa.

En este tema mediremos los costos de creación, memoria y cambio de contexto de ambos modelos, y analizaremos el aislamiento y la seguridad. Esto nos permitirá tomar decisiones informadas en los temas siguientes (servidores, navegadores, videojuegos).

2. Costo de creación

Crear un proceso (fork) es más costoso que crear un hilo (pthread_create), porque fork crea una nueva tabla de páginas y configura el PCB. Pero con COW, el costo de fork es mucho menor que en el pasado.

Los hilos se crean 5-10 veces más rápido que los procesos. Esto es importante en sistemas que crean y destruyen tareas frecuentemente (servidores web, pools de conexiones).

Sin embargo, el costo de creación es solo una parte del costo total. Un proceso que se crea una vez y dura horas tiene un costo de creación amortizado. Un hilo que se crea y destruye miles de veces por segundo tiene un costo de creación significativo.

3. Costo de memoria

La memoria es donde la diferencia entre procesos e hilos es más marcada:

Los hilos son más eficientes en memoria porque comparten el espacio de direcciones y la tabla de páginas. Pero cada hilo tiene su propia pila (8 MB virtual por omisión), lo que puede ser significativo si hay muchos hilos.

Para reducir el consumo de memoria de los hilos, se puede reducir el tamaño de la pila con pthread_attr_setstacksize(). Por ejemplo, una pila de 64 KB en lugar de 8 MB reduce el consumo virtual en 128x.

4. Costo de cambio de contexto

El cambio de contexto entre procesos es más costoso que entre hilos, porque los procesos tienen espacios de direcciones distintos:

La diferencia se debe a la invalidación de la TLB (Translation Lookaside Buffer). Cuando se cambia de proceso, la TLB se invalida, y las primeras accesos a memoria del nuevo proceso causan fallos de TLB (costosos). Cuando se cambia de hilo, la TLB no se invalida, porque las tablas de páginas son las mismas.

En sistemas modernos con PCID (Process Context ID), la TLB no se invalida completamente al cambiar de proceso, lo que reduce el costo. Pero sigue siendo más costoso que cambiar entre hilos.

Los sistemas con muchos cambios de contexto (por ejemplo, un servidor con miles de hilos) pueden beneficiarse de usar hilos en lugar de procesos, porque el cambio de contexto es más barato.

5. Costo de comunicación

La comunicación entre procesos requiere IPC (pipes, sockets, memoria compartida, etc.), que tiene un costo. La comunicación entre hilos es directa (memoria compartida), pero requiere sincronización (mutex).

Los hilos tienen una ventaja clara en comunicación: compartir memoria es más rápido que IPC. Pero la sincronización (mutex) añade costo. Si la comunicación es frecuente y la sincronización es simple (sin contención), los hilos son más eficientes.

Si la comunicación es infrecuente o requiere sincronización compleja, la diferencia se reduce. Y si se necesita aislamiento (que un error en una tarea no afecte a las demás), los procesos son mejores.

6. Aislamiento

El aislamiento es la capacidad de un componente de fallar sin afectar a los demás. Los procesos ofrecen aislamiento completo: si un proceso falla (segfault, etc.), el núcleo lo termina y los demás procesos no se ven afectados. Los hilos no ofrecen aislamiento: un error en un hilo puede corromper la memoria de todos los hilos del proceso.

El aislamiento es la razón por la que los navegadores modernos usan procesos para las pestañas (tema 39): si una pestaña falla, no afecta a las demás. Los hilos no ofrecen esta garantía.

Sin embargo, el aislamiento tiene un costo: los procesos son más costosos de crear y comunicar. La elección entre aislamiento y rendimiento es una de las decisiones más importantes en el diseño de sistemas.

7. Seguridad

La seguridad es otro factor clave en la elección:

• Procesos: cada proceso tiene su propio UID/GID y sus propios permisos. Un proceso no puede acceder a la memoria de otro. Los procesos se pueden ejecutar con diferentes usuarios (setuid).
• Hilos: todos los hilos comparten el mismo UID/GID y los mismos permisos. Un hilo puede acceder a la memoria de todos los demás hilos. No hay aislamiento de seguridad entre hilos.

Si un programa procesa datos de diferentes usuarios o de diferentes niveles de confianza, los procesos son más seguros. Si todos los hilos operan con el mismo nivel de confianza, los hilos son aceptables.

8. Cuándo usar procesos

Los procesos son la mejor opción cuando:

• Se necesita aislamiento: cada tarea debe fallar independientemente.
• Se necesita seguridad: diferentes tareas operan con diferentes niveles de confianza.
• Las tareas son independientes: no comparten datos frecuentemente.
• Se ejecutan programas diferentes: cada proceso ejecuta un programa distinto (fork + exec).
• Se necesita robustez: un error en una tarea no debe afectar a las demás.

Ejemplos: servidores web (un proceso por sitio), navegadores (un proceso por pestaña), shells (un proceso por comando).

9. Cuándo usar hilos

Los hilos son la mejor opción cuando:

• Se necesita rendimiento: creación rápida, cambio de contexto barato.
• Se comparten datos frecuentemente: memoria compartida es más rápida que IPC.
• Se necesita paralelismo: aprovechar múltiples núcleos para una tarea.
• Las tareas son cooperativas: trabajan juntas en la misma tarea.
• Se necesita responsividad: un hilo maneja la UI mientras otro hace trabajo pesado.

Ejemplos: servidores de alto rendimiento (un hilo por conexión), videojuegos (hilos de render, física, audio), aplicaciones con UI (hilo de UI + hilo de trabajo).

10. Medir costos en la práctica

Para medir los costos de creación, memoria y cambio de contexto, se usan herramientas como:

La forma más precisa de medir es con perf stat, que usa los contadores de hardware del procesador:

$ perf stat -e context-switches,cpu-migrations,page-faults ./programa
...
       1234      context-switches
          5      cpu-migrations
       5678      page-faults

perf stat muestra los contadores de hardware: cambios de contexto, migraciones entre CPUs, y fallos de página. Es la herramienta más precisa para medir el rendimiento.

11. Un programa que mide y compara

El siguiente programa mide el tiempo de creación y el consumo de memoria de procesos e hilos:

#define _POSIX_C_SOURCE 200809L
#include 
#include 
#include 
#include 
#include 
#include 
#include 

static double tiempo_ms(void)
{
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec * 1000.0 + ts.tv_nsec / 1e6;
}

static void medir_procesos(int n)
{
    double t0 = tiempo_ms();
    for (int i = 0; i < n; i++) {
        pid_t pid = fork();
        if (pid == 0) _exit(0);
        if (pid < 0) { perror("fork"); return; }
    }
    for (int i = 0; i < n; i++) wait(NULL);
    double t1 = tiempo_ms();
    printf("Procesos: %d creados en %.2f ms (%.2f us/proceso)\n",
           n, t1 - t0, (t1 - t0) * 1000.0 / n);
}

static void *hilo_vacio(void *arg) { (void) arg; return NULL; }

static void medir_hilos(int n)
{
    pthread_t *hilos = malloc(n * sizeof *hilos);
    double t0 = tiempo_ms();
    for (int i = 0; i < n; i++)
        pthread_create(&hilos[i], NULL, hilo_vacio, NULL);
    for (int i = 0; i < n; i++)
        pthread_join(hilos[i], NULL);
    double t1 = tiempo_ms();
    printf("Hilos:    %d creados en %.2f ms (%.2f us/hilo)\n",
           n, t1 - t0, (t1 - t0) * 1000.0 / n);
    free(hilos);
}

int main(void)
{
    int n = 100;
    printf("Creando %d procesos e hilos...\n\n", n);
    medir_procesos(n);
    medir_hilos(n);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -pthread -o medir_costos medir_costos.c
$ ./medir_costos
Creando 100 procesos e hilos...

Procesos: 100 creados en 2.50 ms (25.00 us/proceso)
Hilos:    100 creados en 0.50 ms (5.00 us/hilo)

Los hilos se crean 5 veces más rápido que los procesos. Esta diferencia se mantiene incluso con COW, porque fork sigue necesitando crear una tabla de páginas.

12. Resumen

• Los procesos son 5-10x más lentos de crear que los hilos.
• Los procesos usan más memoria (tabla de páginas separada).
• El cambio de contexto entre procesos es más costoso (invalida TLB).
• La comunicación entre procesos requiere IPC (más costoso que memoria compartida).
• Los procesos ofrecen aislamiento y seguridad que los hilos no tienen.
• Los hilos son preferibles para rendimiento y comunicación fácil.
• Los procesos son preferibles para aislamiento y seguridad.
• perf stat mide contadores de hardware (context-switches, page-faults, etc.).

13. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Compila y ejecuta medir_costos.c. Observa la diferencia entre procesos e hilos.
2. Usa perf stat -e context-switches,page-faults ./medir_costos para medir contadores de hardware.
3. Modifica medir_costos.c para medir el consumo de memoria (VmRSS) de cada modelo.
4. Escribe un benchmark que mida el tiempo de comunicación entre procesos (pipe) vs hilos (variable compartida).
5. Reduce la pila de los hilos a 64 KB y mide el consumo de memoria.
6. Compara el rendimiento de un servidor con procesos vs un servidor con hilos.