Ráfagas de CPU y de entrada/salida

1. Que es una rafaga

Una rafaga de CPU (CPU burst) es un periodo continuo en el que un proceso tiene la CPU y la usa para ejecutar instrucciones. Una rafaga de entrada/salida (I/O burst) es un periodo en el que el proceso esta bloqueado esperando que termine una operacion de E/S (leer del disco, recibir datos de la red, esperar una tecla).

El ciclo de vida de un proceso es una alternancia de estas dos rafagas: calcula un poco, espera E/S, calcula un poco mas, espera E/S de nuevo, y asi hasta que termina. La duracion de cada rafaga depende del programa y de los datos que procesa.

La distincion entre rafagas de CPU y de E/S es fundamental para la planificacion porque:

• Un proceso en rafaga de CPU esta en la cola de listos o en la CPU. Es candidato a recibir tiempo de procesador.
• Un proceso en rafaga de E/S esta bloqueado. No puede ejecutarse hasta que la operacion termine, y no compite por la CPU.

El planificador solo tiene que decidir entre los procesos que estan en rafaga de CPU (listos o en ejecucion). Los que estan en rafaga de E/S no compiten.

2. El ciclo de vida de un proceso

El ciclo de vida de un proceso tipico es una alternancia de rafagas de CPU y de E/S. Este diagrama muestra el recorrido:

La primera rafaga de CPU suele ser corta: el proceso inicializa, lee la entrada, prepara los datos. Luego pide E/S (lee un archivo, recibe datos de la red). La segunda rafaga de CPU procesa los datos leidos. Luego pide mas E/S. Y asi hasta que termina.

La ultima rafaga es siempre de CPU: el proceso escribe el resultado, cierra archivos, y termina. No hay rafaga de E/S despues de la ultima de CPU.

La duracion de las rafagas depende del programa y de los datos. Un programa que procesa un archivo grande puede tener rafagas de CPU largas (procesando los datos) y rafagas de E/S cortas (leyendo bloques del disco). Un programa interactivo puede tener rafagas de CPU muy cortas (procesar una tecla) y rafagas de E/S largas (esperando al usuario).

3. Procesos limitados por CPU

Un proceso limitado por CPU (CPU-bound) es un proceso cuyas rafagas de CPU son mucho mas largas que sus rafagas de E/S. Pasa la mayor parte del tiempo calculando, y poco tiempo esperando. Ejemplos: compiladores, codificadores de video, simulaciones cientificas, mineria de criptomonedas.

Los procesos limitados por CPU son faciles de planificar: se ejecutan en la CPU casi continuamente, y el planificador solo tiene que decidir cuando darles la CPU y por cuanto tiempo. Su rafaga de CPU puede durar segundos o minutos.

Un proceso limitado por CPU típico tiene:

• Rafagas de CPU largas: segundos o minutos.
• Rafagas de E/S cortas: milisegundos (leer un bloque del disco).
• Baja frecuencia de E/S: pocas operaciones de E/S por segundo.
• Alto uso de CPU: cerca del 100 % en un nucleo.

En la salida de top, un proceso limitado por CPU aparece con %CPU cerca de 100 y en estado R (running). En ps, su estado es R y su WCHAN es - (no esta dormido).

$ ./compilar_kernel &
[1] 1234
$ ps -o pid,stat,pcpu,comm -p 1234
    PID STAT %CPU COMMAND
   1234 R+   99.8 compilar_kernel
$ grep ctxt /proc/1234/status
voluntary_ctxt_switches:    12
nonvoluntary_ctxt_switches:  4500

Pocos cambios voluntarios (no se bloquea en E/S) y muchos cambios involuntarios (el planificador lo interrumpe al expirar el quantum). %CPU cerca de 100.

4. Procesos limitados por E/S

Un proceso limitado por E/S (I/O-bound) es un proceso cuyas rafagas de CPU son mucho mas cortas que sus rafagas de E/S. Pasa la mayor parte del tiempo esperando, y poco tiempo calculando. Ejemplos: servidores web, bases de datos, programas interactivos, copias de archivos.

Los procesos limitados por E/S son mas dificiles de planificar porque:

• Rafagas de CPU muy cortas: milisegundos o microsegundos.
• Rafagas de E/S largas: segundos o mas.
• Alta frecuencia de E/S: muchas operaciones de E/S por segundo.
• Bajo uso de CPU: cerca del 0-5 % en un nucleo.

Un proceso limitado por E/S típico tiene rafagas de CPU de milisegundos (procesar una peticion) y rafagas de E/S de segundos (leer de disco, esperar red). El planificador los ve entrar y salir de la cola de listos muy rapidamente.

$ ./servidor_web &
[1] 1235
$ ps -o pid,stat,pcpu,comm -p 1235
    PID STAT %CPU COMMAND
   1235 S+    2.1 servidor_web
$ grep ctxt /proc/1235/status
voluntary_ctxt_switches:    15000
nonvoluntary_ctxt_switches:  50

Muchos cambios voluntarios (se bloquea en E/S) y pocos cambios involuntarios (no usa la CPU lo suficiente para que expire el quantum). %CPU bajo (2.1 %). Estado S (sleeping).

En la practica, la mayoria de los procesos son limitados por E/S. Los procesos limitados por CPU son la excepcion. Por eso, la planificacion de CPU es mas relevante para los procesos limitados por CPU que para los limitados por E/S (que pasan la mayor parte del tiempo bloqueados).

5. El modelo de rafagas

El modelo de rafagas es una simplificacion del comportamiento de un proceso. En lugar de modelar cada instruccion, se modela el proceso como una secuencia de rafagas de CPU y de E/S:

Proceso = (rafaga CPU 1, rafaga E/S 1, rafaga CPU 2, rafaga E/S 2, ..., rafaga CPU n). La ultima rafaga es siempre de CPU.

Este modelo se usa en los simuladores de planificacion porque simplifica el analisis. En lugar de simular cada instruccion, se simula cada rafaga como una unidad de trabajo.

La duracion de las rafagas se puede medir (como vimos en el tema 1 con schedstat) o se puede estimar. En los simuladores, se usan valores fijos o aleatorios.

El modelo de rafagas tiene limitaciones:

• No modela la memoria: no tiene en cuenta los fallos de pagina ni el cache.
• No modela la E/S real: las rafagas de E/S son "cajas negras" que duran un tiempo fijo.
• No modela la interaccion: no tiene en cuenta la sincronizacion entre procesos.

A pesar de estas limitaciones, el modelo de rafagas es la base de todos los algoritmos de planificacion que estudiaremos.

6. Como medir las rafagas

Las rafagas de CPU se pueden medir con las herramientas del sistema:

El archivo /proc/PID/schedstat es el mas directo: tiene tres numeros que son exactamente las rafagas de CPU y de espera.

El comando time es el mas simple: ejecuta un programa y muestra el tiempo real (wall clock), el tiempo de usuario (CPU en modo usuario) y el tiempo de sistema (CPU en modo nucleo).

$ time ./trabajo 2 A
A        unidades=2  termino en  0.69 s  CPU usada 0.69 s  espero en la cola  0.00 s  turnos 176

real    0m0.694s
user    0m0.692s
sys     0m0.000s

real es el tiempo total (wall clock). user es el tiempo de CPU en modo usuario. sys es el tiempo de CPU en modo nucleo. Para un proceso limitado por CPU, real ≈ user + sys. Para un proceso limitado por E/S, real >> user + sys.

7. Un programa que mide sus propias rafagas

El siguiente programa mide sus propias rafagas de CPU y de E/S, y las imprime:

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

static double segundos(clockid_t reloj)
{
    struct timespec t;
    clock_gettime(reloj, &t);
    return t.tv_sec + t.tv_nsec / 1e9;
}

int main(void)
{
    double cpu_antes = segundos(CLOCK_PROCESS_CPUTIME_ID);
    double real_antes = segundos(CLOCK_REALTIME);

    /* Rafaga de CPU: calcular */
    volatile unsigned long suma = 0;
    for (unsigned long i = 0; i < 100000000UL; i++)
        suma += i;

    double cpu_despues_calc = segundos(CLOCK_PROCESS_CPUTIME_ID);
    double real_despues_calc = segundos(CLOCK_REALTIME);

    /* Rafaga de E/S: leer un archivo */
    int fd = open("/etc/hostname", O_RDONLY);
    char buf[256];
    read(fd, buf, sizeof buf);
    close(fd);

    double cpu_despues_io = segundos(CLOCK_PROCESS_CPUTIME_ID);
    double real_despues_io = segundos(CLOCK_REALTIME);

    /* Leer schedstat */
    unsigned long long en_cpu = 0, espera = 0, turnos = 0;
    FILE *f = fopen("/proc/self/schedstat", "r");
    if (f) {
        fscanf(f, "%llu %llu %llu", &en_cpu, &espera, &turnos);
        fclose(f);
    }

    printf("Rafaga de CPU:   %.4f s de CPU, %.4f s de reloj\n",
           cpu_despues_calc - cpu_antes,
           real_despues_calc - real_antes);
    printf("Rafaga de E/S:   %.4f s de CPU, %.4f s de reloj\n",
           cpu_despues_io - cpu_despues_calc,
           real_despues_io - real_despues_calc);
    printf("Total:           %.4f s de CPU, %.4f s de reloj\n",
           cpu_despues_io - cpu_antes,
           real_despues_io - real_antes);
    printf("schedstat:       en_cpu=%.4f s, espera=%.4f s, turnos=%llu\n",
           en_cpu / 1e9, espera / 1e9, turnos);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o medir_rafagas medir_rafagas.c
$ ./medir_rafagas
Rafaga de CPU:   0.0280 s de CPU, 0.0280 s de reloj
Rafaga de E/S:   0.0000 s de CPU, 0.0001 s de reloj
Total:           0.0280 s de CPU, 0.0281 s de reloj
schedstat:       en_cpu=0.0280 s, espera=0.0000 s, turnos=8

La rafaga de CPU tardo 0.028 s de CPU y 0.028 s de reloj (no hubo espera). La rafaga de E/S tardo 0.0001 s de reloj (muy rapida porque el archivo estaba en cache). El proceso es limitado por CPU.

8. Observar rafagas en Linux

Linux ofrece varias formas de observar las rafagas de los procesos:

La columna WCHAN (wait channel) de ps muestra en que funcion del nucleo esta dormido el proceso. Si esta en estado R, aparece -. Si esta en S, muestra la funcion (por ejemplo, hrtimer_nanosleep para sleep).

La relacion entre el tiempo de CPU y el tiempo total (reloj) indica el tipo de proceso:

• Limitado por CPU: tiempo de CPU ≈ tiempo de reloj (el proceso usa la CPU casi todo el tiempo).
• Limitado por E/S: tiempo de CPU << tiempo de reloj (el proceso espera la mayor parte del tiempo).

9. La distribucion de las rafagas

En los sistemas reales, las rafagas de CPU no tienen una duracion fija. Suelen seguir una distribucion exponencial o de cola larga: la mayoria de las rafagas son muy cortas (milisegundos), pero hay unas pocas muy largas (segundos o minutos).

Esta distribucion es importante porque:

• Los algoritmos de planificacion deben manejar rafagas cortas y largas: un algoritmo que funciona bien para rafagas cortas puede ser terrible para rafagas largas.
• La prediccion de rafagas es dificil: como la distribucion tiene cola larga, predecir la duracion de la proxima rafaga es complicado (tema 15 del curso de Planificacion).
• El quantum debe adaptarse: un quantum fijo puede ser demasiado largo para rafagas cortas (desperdicio) o demasiado corto para rafagas largas (muchos cambios de contexto).

En el curso de Planificacion de la CPU, usaremos rafagas de duracion fija para simplificar el analisis. Pero es importante recordar que en la realidad las rafagas son variables.

10. Por que importa para la planificacion

Las rafagas son el insumo fundamental de la planificacion. Todo lo que el planificador hace se basa en las rafagas:

• FCFS (First-Come First-Served): ejecuta las rafagas en orden de llegada. Un proceso con rafaga larga bloquea a los demas.
• SJF (Shortest Job First): ejecuta primero las rafagas mas cortas. Minimiza el tiempo de espera promedio.
• Round Robin: da a cada rafaga un quantum de tiempo. Las rafagas largas se dividen en varios turnos.
• Prioridades: las rafagas de procesos con mayor prioridad se ejecutan primero.
• Colas multinivel: las rafagas se clasifican en colas segun su duracion y comportamiento.

Entender las rafagas es el primer paso para entender la planificacion. En los temas siguientes, cada algoritmo se explicara en terminos de como maneja las rafagas.

La distincion entre procesos limitados por CPU y por E/S tambien es importante:

• Procesos limitados por CPU: tienen rafagas de CPU largas. Son los que mas se benefician de la planificacion (porque compiten por la CPU).
• Procesos limitados por E/S: tienen rafagas de CPU cortas. Pasan la mayor parte del tiempo bloqueados, por lo que no compiten mucho por la CPU.

Un sistema con muchos procesos limitados por E/S tiene poca contencion por la CPU. Un sistema con muchos procesos limitados por CPU tiene mucha contencion. La planificacion es mas relevante en el segundo caso.

11. Resumen

• Una rafaga de CPU es un periodo continuo de ejecucion. Una rafaga de E/S es un periodo de espera.
• El ciclo de vida de un proceso es una alternancia de rafagas de CPU y de E/S.
• Los procesos limitados por CPU tienen rafagas de CPU largas y pocas E/S.
• Los procesos limitados por E/S tienen rafagas de CPU cortas y muchas E/S.
• El modelo de rafagas simplifica el proceso a una secuencia de rafagas.
• Las rafagas se miden con /proc/PID/schedstat, time, perf stat y strace.
• La relacion tiempo de CPU / tiempo total indica el tipo de proceso.
• Las rafagas siguen una distribucion de cola larga: muchas cortas, unas pocas muy largas.
• Los algoritmos de planificacion se basan en las rafagas.

12. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Compila y ejecuta medir_rafagas.c. Observa la duracion de la rafaga de CPU y de E/S.
2. Modifica medir_rafagas.c para leer un archivo grande (por ejemplo, /var/log/syslog). Observa como cambia la rafaga de E/S.
3. Ejecuta un comando intensivo en CPU (como yes > /dev/null) y observa su %CPU y estado en top.
4. Ejecuta un comando que lee mucho del disco (como find / -type f) y observa su %CPU y estado.
5. Mira cat /proc/PID/schedstat de un proceso limitado por CPU y de uno limitado por E/S. Compara los valores.
6. Usa time para medir un comando limitado por CPU y uno limitado por E/S. Compara real, user y sys.