Costo del cambio de contexto

1. Qué es un cambio de contexto

Un cambio de contexto (context switch) es el proceso de guardar el estado del proceso que se está ejecutando y restaurar el estado de otro proceso, para que este último pueda ejecutarse. Es la operación fundamental que permite la multiprogramación: la CPU pasa de un proceso a otro.

El cambio de contexto ocurre en varias situaciones:

• Al expirar el quantum: en Round Robin, cuando se le acaba el tiempo al proceso.
• Al llegar un proceso de mayor prioridad: en la planificación por prioridades apropiativa.
• Al bloquearse el proceso: cuando pide E/S o espera un evento.
• Al terminar el proceso: cuando acaba su ejecución.

Cada cambio de contexto consume tiempo de CPU que no se dedica a ningún proceso. Es overhead puro: trabajo que el sistema hace para poder hacer trabajo.

2. Qué incluye

Un cambio de contexto incluye los siguientes pasos:

1. Guardar el estado del proceso saliente. Registros de la CPU (PC, SP, registros generales), estado de la FPU, registros de control. guardar
2. Actualizar la PCB. Guardar el estado en la Process Control Block del proceso saliente (tiempo de CPU usado, estado, etc.). PCB
3. Cambiar la tabla de páginas. Actualizar el registro CR3 (en x86) para que la MMU use la tabla de páginas del nuevo proceso. memoria
4. Invalidar la caché TLB. La Translation Lookaside Buffer se invalida porque las traducciones de direcciones virtuales a físicas cambian. TLB
5. Restaurar el estado del proceso entrante. Cargar los registros desde la PCB del nuevo proceso. restaurar
6. Volver al modo usuario. La CPU pasa de modo núcleo a modo usuario y continúa la ejecución del nuevo proceso. usuario

Los pasos 3 y 4 (cambio de tabla de páginas e invalidación de TLB) son los más costosos, porque afectan a la memoria y a la caché de traducción de direcciones.

3. Costo directo e indirecto

El costo de un cambio de contexto se divide en dos partes:

El costo directo es pequeño (microsegundos). El costo indirecto puede ser mucho mayor (milisegundos), porque la caché del procesador se llena con datos del nuevo proceso y los datos del anterior se pierden.

El costo indirecto es la razón por la que un quantum muy corto degrada el rendimiento: no es el tiempo de guardar registros, sino la pérdida de caché.

4. Cómo medirlo en Linux

Linux ofrece varias herramientas para medir el costo de un cambio de contexto:

Ejemplo con perf stat:

$ perf stat -e context-switches,cpu-migrations,cycles,instructions ./trabajo 100 A

 Performance counter stats for './trabajo 100 A':

               123      context-switches
                 0      cpu-migrations
     1,234,567,890      cycles
       987,654,321      instructions

       0.345678901 seconds time elapsed

El programa trabajo (del tema 1) hizo 123 cambios de contexto involuntarios (el planificador lo interrumpió 123 veces al expirar el quantum). Con 100 unidades de trabajo (34 s de CPU), eso da un cambio cada 0,28 s, lo que corresponde a un quantum de ~4 ms.

5. Valores típicos

El costo directo es pequeño (microsegundos), pero el indirecto puede ser mucho mayor. Por eso, el overhead total de un cambio de contexto puede ser de 10 a 100 veces el costo directo.

En sistemas modernos con cachés grandes (L3 de 32 MB), el costo indirecto puede ser de milisegundos si el nuevo proceso tiene un patrón de acceso muy diferente al anterior.

6. Incluirlo en la simulación

Los simuladores del curso (temas 12, 16, 19, 23) no incluyen el costo del cambio de contexto. Para incluirlo, se añade un tiempo c (costo del cambio) en cada transición entre procesos:

Tiempo de fin de P_i = tiempo de inicio + ráfaga + c (si hay cambio de contexto).

El primer proceso no paga costo de cambio (no hay proceso anterior). Los procesos que se ejecutan consecutivamente sin cambio (porque el anterior terminó y el siguiente empieza inmediatamente) tampoco pagan costo adicional, porque el cambio ya se contabilizó al empezar el anterior.

En la práctica, el costo del cambio de contexto se añade al tiempo total de la simulación, lo que aumenta las métricas de todos los procesos.

function roundRobinConCosto(procesos, quantum, costoCambio) {
    var p = procesos.map(function (x) {
        return { pid: x.pid, llegada: x.llegada, rafaga: x.rafaga,
            restante: x.rafaga, inicio: 0, fin: 0, respuesta: 0,
            espera: 0, retorno: 0, primera: true };
    });
    p.sort(function (a, b) {
        if (a.llegada !== b.llegada) return a.llegada - b.llegada;
        return a.pid - b.pid;
    });
    var cola = [];
    var t = 0;
    var idx = 0;
    var terminados = 0;
    var n = p.length;
    while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
    while (terminados < n) {
        if (cola.length === 0) {
            t = p[idx].llegada;
            while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
            continue;
        }
        var proc = cola.shift();
        if (proc.primera) { proc.inicio = t; proc.primera = false; }
        /* Costo de cambio de contexto (si no es el primer proceso). */
        if (t > 0) t += costoCambio;
        var duracion = Math.min(quantum, proc.restante);
        t += duracion;
        proc.restante -= duracion;
        while (idx < n && p[idx].llegada <= t) { cola.push(p[idx]); idx++; }
        if (proc.restante <= 0) {
            proc.fin = t;
            proc.respuesta = proc.inicio - proc.llegada;
            proc.retorno = proc.fin - proc.llegada;
            proc.espera = proc.retorno - proc.rafaga;
            terminados++;
        } else {
            cola.push(proc);
        }
    }
    return p;
}

El costo del cambio se añade al tiempo total, lo que aumenta las métricas de todos los procesos. El impacto es mayor cuanto más corto sea el quantum (más cambios de contexto).

7. Impacto en el quantum

El costo del cambio de contexto es el factor que limita lo corto que puede ser un quantum. Si el cambio tarda c y el quantum es q, el overhead es:

Overhead = c / (c + q) × 100 %

Para que el overhead sea aceptable (por ejemplo, menos del 5 %), se necesita:

q > c / 0,05 − c ≈ 20·c

Si el cambio de contexto tarda 10 μs (costo directo), el quantum mínimo para un overhead del 5 % es 200 μs. Si se incluye el costo indirecto (100 μs), el quantum mínimo es 2000 μs (2 ms).

Esta es la razón por la que los quantums típicos son de 1-10 ms: un quantum más corto tendría un overhead inaceptable.

8. Cómo minimizarlo

Los sistemas operativos usan varias técnicas para minimizar el costo del cambio de contexto:

• Quantum adaptativo: usar un quantum más largo cuando hay pocos procesos y más corto cuando hay muchos.
• Colas multinivel: los procesos interactivos (ráfagas cortas) se ejecutan con quantum corto; los de cálculo (ráfagas largas) con quantum largo.
• Afinidad de CPU: mantener un proceso en el mismo núcleo para preservar la caché (tema 29).
• Cambios de contexto diferidos: no cambiar de contexto inmediatamente, sino cuando sea necesario (lazy context switching).
• Optimización del código del núcleo: minimizar el tiempo de guardar/restaurar registros.

Linux usa afinidad de CPU y quantum adaptativo (en CFS, el tiempo de ejecución se calcula dinámicamente) para minimizar el overhead.

9. Simulador interactivo

Este simulador ejecuta Round Robin con un costo de cambio de contexto configurable. Cambia el costo y observa cómo afecta a las métricas:

10. Resumen

• Un cambio de contexto guarda el estado del proceso saliente y restaura el del entrante.
• Incluye guardar registros, actualizar PCB, cambiar tabla de páginas e invalidar TLB.
• El costo directo es de 1-10 μs; el indirecto (caché) puede ser de 10-1000 μs.
• Se mide con perf, /proc/PID/status, perf sched y vmstat.
• El overhead total puede ser 10-100 veces el costo directo.
• El costo del cambio limita lo corto que puede ser un quantum.
• Para un overhead del 5 %, el quantum debe ser al menos 20 veces el costo del cambio.
• Los sistemas minimizan el costo con quantum adaptativo, afinidad de CPU y optimización del núcleo.

11. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Mide el número de cambios de contexto de un programa con perf stat.
2. Calcula el overhead para c = 5 μs y q = 1 ms, 5 ms, 10 ms.
3. Modifica el simulador para incluir el costo indirecto (multiplicador).
4. Compara las métricas con y sin costo de cambio para el mismo conjunto.
5. Investiga cómo vmstat muestra los cambios de contexto del sistema.
6. Explica por qué la afinidad de CPU reduce el costo indirecto.