← Comunicación entre ProcesosBloque 10 · Protocolos, fallos y diagnóstico · Tema 44 de 52

Tema 44

Depurar y comparar mecanismos

Vas a reconstruir una conversación a partir de syscalls, descriptores y estados del sistema, y a medir intercambios que realmente completaron su contrato. Un laboratorio hará visible una referencia que retrasa EOF. Otro comparará dos tuberías y sockets Unix con el mismo trabajo, calentamiento, verificación y varias corridas, conservando los resultados para poder revisarlos.

1. Empezar por una pregunta comprobable

«El programa se queda esperando» todavía no identifica una causa. Antes de cambiar tamaños de búfer o mecanismos, pregunta qué operación espera, qué condición la haría avanzar y qué proceso tiene la responsabilidad de producirla.

Un diagnóstico útil relaciona estado de aplicación, referencias del sistema y secuencia de operaciones. Una medición útil define su contrato y verifica que ese contrato se completó.

PreguntaEvidencia inicialComprobación siguiente
¿Por qué no llega EOF?read espera sin datos.Localizar todas las referencias de escritura, también heredadas o duplicadas.
¿Por qué no sale la respuesta?send parcial o EAGAIN.Comprobar sufijo pendiente, consumidor y registro de escritura.
¿Por qué consume CPU sin avanzar?Muchas llamadas inmediatas o trabajo local repetido.Buscar sondeo, EOF no retirado o interés sin trabajo.
¿Qué mecanismo conviene para esta carga?Datos de varias ejecuciones válidas.Comparar el mismo intercambio y sus límites, sin trazador.

Las herramientas muestran partes distintas del problema. Una captura aislada no reconstruye toda una historia, y un contador de llamadas no demuestra por sí solo un fallo. Usa hipótesis que puedan rechazarse con un ensayo controlado.

2. Reconstruir llamadas con strace

strace observa syscalls y señales de un proceso. Con -f sigue los procesos descendientes; con -ff puede separar sus archivos de salida. Iniciar el programa bajo el trazador permite observar la creación y herencia de recursos desde el comienzo.

Bash · sintaxis de una traza sobre el supervisor del tema 43
$ ensayo=$(mktemp -d)
$ strace -ff -tt -T -yy -s 64 -o "$ensayo/traza" -e trace=clone,clone3,fork,wait4,poll,kill,sendto,recvfrom,close ./supervisor43 resiste
OpciónPropósitoLímite de interpretación
-f / -ff.Seguir descendientes; separar archivos con -ff.No atribuir al padre una llamada del trabajador.
-tt.Mostrar marcas de tiempo.No es el reloj interno con el que tu protocolo calcula su plazo.
-T.Mostrar duración observada de cada syscall.No equivale a CPU consumida dentro del núcleo.
-yy.Agregar detalles de los descriptores cuando están disponibles.El número sigue siendo local y reutilizable.
-s 64.Limitar la representación de cadenas y datos mostrados.La visualización puede truncarse aunque se hayan transferido más bytes.
-e trace=…Seleccionar llamadas relevantes.Lo que se excluye del filtro no aparece en la evidencia.

La traza puede contener datos de aplicación. En los ejemplos se usan procesos y contenidos de prueba propios, con archivos dentro de un directorio privado. Opciones y restricciones de la herramienta se documentan en strace(1).

3. Interpretar retornos, esperas y tiempos

fragmento ilustrativo · los números de descriptor pueden variar
read(3, "ho", 2)                = 2
read(3, "la", 2)                = 2
read(3, ...                    /* esperando mas datos o EOF */

/* En otro proceso, una referencia de escritura sigue abierta. */

Las llamadas mostradas como unfinished y resumed deben relacionarse por proceso y operación. Una lectura corta positiva es progreso, no necesariamente truncamiento. Cero significa EOF para una lectura de flujo con capacidad positiva; EAGAIN indica falta de avance en ese momento.

En Linux, send y recv pueden aparecer como sendto y recvfrom. La biblioteca puede implementar una interfaz de espera con otra syscall, y clock_gettime puede resolverse mediante vDSO sin aparecer como llamada al núcleo. La ausencia de un nombre concreto en la traza no demuestra que el programa omitió esa función de C.

strace -c resume llamadas, errores y tiempos según su configuración. Sirve para localizar patrones, pero su resumen no mide automáticamente latencia de petición, throughput útil ni tiempo de CPU total de todos los procesos.

El trazador modifica la ejecución. Una comparación de rendimiento debe realizarse aparte, sin strace ni registros detallados en la región medida. La traza se utiliza para explicar comportamiento, no para presentar sus tiempos como costo sin instrumentación.

4. Inspeccionar /proc y fdinfo

Bash · usar el PID real de un proceso propio todavía activo
$ ls -l "/proc/$pid/fd"
$ readlink "/proc/$pid/fd/$fd"
$ cat "/proc/$pid/fdinfo/$fd"
$ ps -o pid,ppid,stat,wchan:24,cmd -p "$pid"

Las entradas fd son referencias numeradas. Para pipes y sockets, readlink suele mostrar tipo e inodo; una instancia epoll o un timerfd puede aparecer como anon_inode con su tipo. Se documentan en proc_pid_fd(5).

fdinfo agrega información según el recurso: posición y flags, registros de epoll o estado de temporizadores, entre otros. Los flags se muestran en octal; no los interpretes como decimal. Para un pipe, relaciona el modo de acceso con la dirección que ese descriptor mantiene abierta. Véase proc_pid_fdinfo(5).

La información puede cambiar mientras se lee: un descriptor se cierra o reutiliza, un proceso termina y el PID puede dejar de referirse a él. Los permisos y espacios de nombres también limitan qué se puede observar. Un wchan ausente o cero no prueba ausencia de espera.

Relacionar inodos ayuda a localizar copias, pero no autoriza a cerrar referencias ajenas ni a borrar nombres. El diagnóstico de una ruta residual conserva las reglas de propiedad e identidad del tema 32.

5. Relacionar procesos y referencias con lsof

Bash · seleccionar procesos propios y, opcionalmente, sockets Unix
$ lsof -nP -p "$pid"
$ lsof -nP -a -p "$pid" -U
$ lsof -nP -a -p "$padre,$hijo" -d "$extra,$lector"

-n y -P evitan resoluciones de nombres de red y servicios donde correspondan. -p selecciona procesos; -U selecciona sockets Unix; -a combina criterios por intersección. Sin comprender la combinación de filtros podrías obtener una lista más amplia de la que pretendías.

La columna FD distingue referencias de lectura, escritura o lectura/escritura. NODE y NAME permiten contrastarlas con /proc cuando la información está disponible. lsof también muestra recursos que no son IPC, como bibliotecas y directorios; no todos los renglones representan una conexión. Véase lsof(8).

Un descriptor de escritura sobrante puede pertenecer a un proceso que ya no envía nada. Que su CPU esté inactiva no impide que mantenga abierta la condición que retrasa EOF en otro participante.

6. Observar sockets Unix con ss

Para observar un servicio de los temas 38 o 39, ejecuta ese servidor sobre un directorio privado y conserva su PID y ruta reales. Mientras permanezca activo, consulta desde otra terminal:

Bash · sockets Unix y escucha
$ ss -xanp
$ ss -xlnp
$ lsof -nP -a -p "$pid" -U

-x selecciona Unix, -a incluye estados que no se muestran por defecto, -l limita a escucha y -p solicita asociación con procesos cuando los permisos lo permiten. Las opciones se describen en ss(8).

La escucha y cada conectado son recursos distintos. Una ruta publicada no identifica por sí sola a todas las sesiones aceptadas y un socketpair no necesita una ruta pública. No esperes encontrarlo como un archivo del directorio del servicio.

Recv-Q y Send-Q describen colas del núcleo cuya interpretación depende del tipo y estado. En una escucha se relacionan con conexiones pendientes y capacidad, no con los mismos datos de una conversación establecida. No son el tamaño de tu cola de respuestas de aplicación ni una confirmación de que el trabajo se ejecutó.

7. Laboratorio de una referencia que retiene EOF

Guarda eof44.c junto a plazo37.h del tema 37. El hijo recibe hola y espera EOF. En modo fuga, el padre duplica su referencia de escritura después de fork, envía los datos y cierra la original, pero conserva la copia durante la inspección.

El hijo avisa por otra tubería cuando ya acumuló los cuatro bytes. El padre imprime entonces sus identificadores. Enter, EOF en la entrada de control, una señal de fin o treinta segundos liberan la copia. No se utiliza una demora para adivinar si los datos ya llegaron.

eof44.c · una copia de escritura basta para retrasar EOF
#define _GNU_SOURCE
#include "plazo37.h"
#include <sys/wait.h>
#include <poll.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>

static volatile sig_atomic_t parar44;
static void marcar44(int signo) { parar44 = signo; }
static int cerrar_e44(int *fd)
{
    if (*fd == -1) return 0;
    int n = *fd; *fd = -1;
    if (close(n) == -1) { perror("close"); return -1; }
    return 0;
}
static int escribir_e44(int fd, const void *datos, size_t total)
{
    const unsigned char *p = datos;
    size_t usados = 0;
    while (usados < total) {
        ssize_t n = write(fd, p + usados, total - usados);
        if (n > 0) usados += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else { if (n == 0) errno = EIO; perror("write"); return -1; }
    }
    return 0;
}

int main(int argc, char **argv)
{
    if (argc != 2 || (strcmp(argv[1], "correcto") && strcmp(argv[1], "fuga"))) {
        fprintf(stderr, "Uso: %s correcto|fuga\n", argv[0]); return EXIT_FAILURE;
    }
    struct sigaction accion = {0};
    accion.sa_handler = marcar44; sigemptyset(&accion.sa_mask);
    if (sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1 ||
        signal(SIGPIPE, SIG_IGN) == SIG_ERR || signal(SIGCHLD, SIG_DFL) == SIG_ERR) {
        perror("señales"); return EXIT_FAILURE;
    }
    int datos[2] = { -1, -1 }, listo[2] = { -1, -1 }, extra = -1;
    int salida = EXIT_FAILURE, estado;
    pid_t hijo = -1;
    if (pipe2(datos, O_CLOEXEC) == -1 || pipe2(listo, O_CLOEXEC) == -1) {
        perror("pipe2"); goto fin;
    }
    int lector_hijo = datos[0];
    hijo = fork();
    if (hijo == -1) { perror("fork"); goto fin; }
    if (hijo == 0) {
        if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR)
            _exit(2);
        if (close(datos[1]) == -1 || close(listo[0]) == -1) _exit(2);
        char cuerpo[4], bloque[2];
        size_t usados = 0;
        int aviso = 0;
        for (;;) {
            ssize_t n = read(datos[0], bloque, sizeof bloque);
            if (n > 0) {
                if ((size_t)n > sizeof cuerpo - usados) _exit(3);
                memcpy(cuerpo + usados, bloque, (size_t)n); usados += (size_t)n;
                if (usados == 4 && !aviso) {
                    if (escribir_e44(listo[1], "R", 1) == -1) _exit(3);
                    aviso = 1;
                }
            } else if (n == 0) break;
            else if (errno != EINTR) _exit(3);
        }
        if (usados != 4 || memcmp(cuerpo, "hola", 4) != 0) _exit(3);
        if (dprintf(STDOUT_FILENO, "Hijo verifico hola y EOF\n") < 0) _exit(3);
        if (close(datos[0]) == -1 || close(listo[1]) == -1) _exit(3);
        _exit(0);
    }
    if (cerrar_e44(&datos[0]) == -1 || cerrar_e44(&listo[1]) == -1) goto fin;
    if (strcmp(argv[1], "fuga") == 0) {
        extra = fcntl(datos[1], F_DUPFD_CLOEXEC, 0);
        if (extra == -1) { perror("duplicar escritor"); goto fin; }
    }
    if (escribir_e44(datos[1], "hola", 4) == -1 || cerrar_e44(&datos[1]) == -1) goto fin;
    char byte;
    ssize_t n;
    do { n = read(listo[0], &byte, 1); } while (n == -1 && errno == EINTR);
    if (n != 1 || byte != 'R') { fprintf(stderr, "Hijo no confirmo recepcion\n"); goto fin; }
    if (cerrar_e44(&listo[0]) == -1) goto fin;
    printf("EOF44 listo; padre=%jd; hijo=%jd; extra=%d; lectura_hijo=%d\n",
           (intmax_t)getpid(), (intmax_t)hijo, extra, lector_hijo);
    if (extra != -1) puts("Inspeccion: Enter, EOF de control o 30 s para cerrar la copia");
    if (fflush(stdout) == EOF) goto fin;
    if (extra != -1) {
        struct timespec limite;
        if (fijar_plazo37(&limite, 30) == -1) goto fin;
        while (!parar44) {
            struct timeval tv;
            int r = restante37(&limite, &tv);
            if (r == -1) goto fin;
            if (r == 0) break;
            int ms = tv.tv_sec >= 1 ? 250 : (int)((tv.tv_usec + 999) / 1000);
            if (ms > 250) ms = 250;
            struct pollfd p = { .fd = STDIN_FILENO, .events = POLLIN };
            r = poll(&p, 1, ms);
            if (r == -1) { if (errno == EINTR) continue; perror("poll"); goto fin; }
            if (p.revents & (POLLERR | POLLNVAL)) goto fin;
            if (p.revents & (POLLIN | POLLHUP)) {
                n = read(STDIN_FILENO, &byte, 1);
                if (n == 0 || (n == 1 && byte == '\n')) break;
                if (n == -1 && errno != EINTR && errno != EAGAIN) goto fin;
            }
        }
    }
    salida = EXIT_SUCCESS;
fin:
    if (cerrar_e44(&extra) == -1) salida = EXIT_FAILURE;
    for (unsigned i = 0; i < 2; ++i) {
        if (cerrar_e44(&datos[i]) == -1) salida = EXIT_FAILURE;
        if (cerrar_e44(&listo[i]) == -1) salida = EXIT_FAILURE;
    }
    if (hijo > 0) {
        if (salida != EXIT_SUCCESS && kill(hijo, SIGKILL) == -1 && errno != ESRCH)
            perror("kill de limpieza");
        pid_t r;
        do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
        if (r != hijo || !WIFEXITED(estado) || WEXITSTATUS(estado) != 0) salida = EXIT_FAILURE;
    }
    if (parar44 && salida == EXIT_SUCCESS) salida = 128 + (int)parar44;
    return salida;
}

La copia extra se crea después de fork y solo existe en el padre. El hijo cierra los extremos que no usa; por tanto, el modo fuga aísla una causa concreta de EOF retenido. No hay un nombre público que borrar.

La espera de inspección revisa cancelación en intervalos de hasta 250 ms. Es una decisión de este laboratorio, no una espera indefinida que dependa de una bandera sin mecanismo de despertar. La recogida final supone el trabajador finito mostrado; no sustituye al supervisor del tema 43 frente a cualquier proceso arbitrariamente detenido.

8. Seguir el caso desde otra terminal

Bash · terminal A
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 eof44.c -o eof44
$ ./eof44 fuga
EOF44 listo; padre=4200; hijo=4201; extra=3; lectura_hijo=3
Inspeccion: Enter, EOF de control o 30 s para cerrar la copia

En la terminal B reemplaza los cuatro valores por los que imprimió tu ejecución. Los números son ilustrativos y cada descriptor es local a su proceso, aunque dos números coincidan.

Bash · terminal B, mientras la inspección sigue activa
$ padre=4200; hijo=4201; extra=3; lector=3
$ readlink "/proc/$padre/fd/$extra"
$ readlink "/proc/$hijo/fd/$lector"
$ cat "/proc/$padre/fdinfo/$extra"
$ cat "/proc/$hijo/fdinfo/$lector"
$ lsof -nP -a -p "$padre,$hijo" -d "$extra,$lector"
$ ps -o pid,ppid,stat,wchan:24,cmd -p "$padre,$hijo"

Los enlaces deben identificar la misma tubería: el padre conserva escritura y el hijo lectura. Después de acumular hola, el hijo todavía puede esperar más datos o EOF. No concluyas que «el mensaje nunca llegó»: el aviso de arranque confirmó que ya recibió los cuatro bytes.

Vuelve a A y pulsa Enter. Al cerrarse la copia, el hijo debe imprimir que verificó hola y EOF, y ambos terminar normalmente. Contrasta con correcto, que no conserva la referencia y no espera control interactivo.

Bash · repetir el caso con su traza completa
$ strace -f -tt -T -yy -s 32 -e trace=pipe2,fcntl,clone,clone3,read,write,close,wait4 ./eof44 fuga

Busca F_DUPFD_CLOEXEC, el cierre del escritor original, la copia que permanece abierta y el read que finalmente retorna cero. El trazador y la inspección en vivo son recorridos separados; no necesitas dejar la primera ejecución abierta para iniciar la segunda.

9. Definir qué se mide

MétricaDefinición en este laboratorioInterpretación
Tiempo por ronda.Tiempo total de N peticiones y sus respuestas, dividido por N.Promedio de RTT verificado de esa corrida.
Intercambios por segundo.N dividido por segundos transcurridos.Rondas completas, con una sola petición propia en vuelo.
MiB/s útiles bidireccionales.2 × N × bytes por cuerpo, dividido por tiempo y 2²⁰.Datos útiles de ida y vuelta, sin contar metadatos del núcleo.
CPU del padre.Incremento de CLOCK_PROCESS_CPUTIME_ID del padre.No incluye CPU del trabajador ni toda la actividad del sistema.

Dividir RTT por dos no mide directamente la latencia de ida: petición y respuesta incluyen planificación, llamadas y trabajo en ambos participantes. Si solo se mide send completo, se mide aceptación local, no el mismo contrato de ronda verificada.

El promedio de una corrida tampoco es su percentil 99 ni la mediana de cada petición individual. El script resumirá medianas de promedios entre corridas, manteniendo explícita esa diferencia.

10. Elegir reloj y región medida

CLOCK_MONOTONIC mide tiempo transcurrido sin depender de ajustes discontinuos del calendario. CLOCK_PROCESS_CPUTIME_ID mide CPU del proceso que lo consulta. Sus significados y resoluciones se documentan en clock_gettime(2).

separación del experimento · dos marcas para muchas rondas
crear canales y trabajador
preparar buffers
realizar cien rondas de calentamiento, verificadas

inicio = reloj monotónico
cpu_inicio = CPU del padre
realizar N rondas medidas, verificadas
cpu_fin = CPU del padre
fin = reloj monotónico

cerrar referencias y recoger al trabajador
solo si todo fue correcto: emitir resultado CSV

El tiempo de pared incluye las consultas al reloj de CPU que están dentro de sus marcas. No incluye creación del canal, fork, calentamiento ni recogida final. Se verifican los resultados de esa recogida antes de publicar la muestra.

Medir muchas rondas con dos marcas reduce el peso relativo de consultar el reloj. La resolución nominal obtenida con clock_getres no es una garantía de precisión de una medida ni de ausencia de ruido.

11. Comparar contratos equivalentes

El programa compara dos tuberías, una por dirección, con un socketpair AF_UNIX STREAM. En ambos casos hay padre y trabajador, el mismo cuerpo binario, una petición en vuelo, eco exacto, bucles de E/S parcial y verificación de cada respuesta.

Decisión mantenidaMotivo
Mismo tamaño de cuerpo e iteraciones.No comparar costos por unidad de trabajo diferente.
Mismo patrón binario y comparación completa.No declarar más rápido a un programa que deja de verificar el contrato.
Mismo calentamiento y región medida.No incluir preparación solo en uno de los mecanismos.
Sin trazador ni salida por ronda.No medir principalmente instrumentación o terminal.
Cierre y estado del trabajador comprobados.No publicar una ejecución incompleta como muestra válida.

Esta prueba no compara colas de mensajes ni memoria compartida sincronizada. Para incluirlas habría que conservar un intercambio equivalente y explicar sus diferencias de copia, sincronización, capacidad y representación. Tampoco mide el costo de descubrir un servicio por ruta ni miles de clientes concurrentes.

12. Benchmark completo y verificado en C

Guarda medir44.c. Es autónomo para Linux. Recibe mecanismo pipe o unix, entre una y cien mil rondas y cuerpos entre uno y 65536 bytes. El trabajador ejecuta cien rondas de calentamiento más las medidas; no imprime durante ellas.

medir44.c · mismo ping-pong, relojes separados y salida solo tras verificar
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CALENTAR44 100u
struct canal44 { int padre_in, padre_out, hijo_in, hijo_out; };

static int cerrar_m44(int *fd)
{
    if (*fd == -1) return 0;
    int n = *fd; *fd = -1;
    if (close(n) == -1) { perror("close"); return -1; }
    return 0;
}
static int cerrar_dos44(int *a, int *b)
{
    if (*a == *b) *b = -1;
    int fallo = cerrar_m44(a) == -1;
    if (cerrar_m44(b) == -1) fallo = 1;
    return fallo ? -1 : 0;
}
static int numero44(const char *s, unsigned maximo, unsigned *v)
{
    if (!*s) return -1;
    for (const char *p = s; *p; ++p) if (*p < '0' || *p > '9') return -1;
    errno = 0; char *fin;
    unsigned long n = strtoul(s, &fin, 10);
    if (errno || *fin || n < 1 || n > maximo) return -1;
    *v = (unsigned)n; return 0;
}
static int abrir_m44(int unix_socket, struct canal44 *c)
{
    if (unix_socket) {
        int par[2];
        if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, par) == -1) return -1;
        c->padre_in = c->padre_out = par[0];
        c->hijo_in = c->hijo_out = par[1];
    } else {
        int ida[2], vuelta[2];
        if (pipe2(ida, O_CLOEXEC) == -1) return -1;
        if (pipe2(vuelta, O_CLOEXEC) == -1) {
            int error = errno; close(ida[0]); close(ida[1]); errno = error; return -1;
        }
        c->padre_in = vuelta[0]; c->padre_out = ida[1];
        c->hijo_in = ida[0]; c->hijo_out = vuelta[1];
    }
    return 0;
}
static int transferir44(int fd, unsigned char *p, size_t total, int escribir)
{
    size_t hechos = 0;
    while (hechos < total) {
        ssize_t n = escribir ? write(fd, p + hechos, total - hechos) :
                               read(fd, p + hechos, total - hechos);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else {
            if (n == 0) fprintf(stderr, "Transferencia incompleta o sin progreso\n");
            else perror(escribir ? "write" : "read");
            return -1;
        }
    }
    return 0;
}
static int ronda44(struct canal44 *c, unsigned char *peticion,
                   unsigned char *respuesta, size_t bytes)
{
    if (transferir44(c->padre_out, peticion, bytes, 1) == -1 ||
        transferir44(c->padre_in, respuesta, bytes, 0) == -1) return -1;
    if (memcmp(peticion, respuesta, bytes) != 0) {
        fprintf(stderr, "Respuesta incorrecta\n"); return -1;
    }
    return 0;
}
static int diferencia44(const struct timespec *a, const struct timespec *b, uint64_t *ns)
{
    time_t segundos = b->tv_sec - a->tv_sec;
    long nanos = b->tv_nsec - a->tv_nsec;
    if (nanos < 0) { --segundos; nanos += 1000000000L; }
    if (segundos < 0 || (uint64_t)segundos > (UINT64_MAX - (uint64_t)nanos) / 1000000000u)
        return -1;
    *ns = (uint64_t)segundos * 1000000000u + (uint64_t)nanos;
    return 0;
}

int main(int argc, char **argv)
{
    unsigned rondas, bytes;
    if (argc != 4 || (strcmp(argv[1], "pipe") && strcmp(argv[1], "unix")) ||
        numero44(argv[2], 100000u, &rondas) == -1 ||
        numero44(argv[3], 65536u, &bytes) == -1) {
        fprintf(stderr, "Uso: %s pipe|unix rondas(1..100000) bytes(1..65536)\n", argv[0]);
        return EXIT_FAILURE;
    }
    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR || signal(SIGCHLD, SIG_DFL) == SIG_ERR) {
        perror("señales"); return EXIT_FAILURE;
    }
    struct canal44 c = { -1, -1, -1, -1 };
    unsigned char *peticion = malloc(bytes), *respuesta = malloc(bytes);
    int salida = EXIT_FAILURE, estado;
    pid_t hijo = -1;
    uint64_t pared_ns = 0, cpu_ns = 0;
    if (peticion == NULL || respuesta == NULL) { perror("malloc"); goto fin; }
    for (unsigned i = 0; i < bytes; ++i) peticion[i] = (unsigned char)(i % 251u);
    if (abrir_m44(strcmp(argv[1], "unix") == 0, &c) == -1) { perror("crear canal"); goto fin; }
    hijo = fork();
    if (hijo == -1) { perror("fork"); goto fin; }
    if (hijo == 0) {
        if (cerrar_dos44(&c.padre_in, &c.padre_out) == -1) _exit(2);
        for (unsigned i = 0; i < CALENTAR44 + rondas; ++i) {
            if (transferir44(c.hijo_in, respuesta, bytes, 0) == -1 ||
                transferir44(c.hijo_out, respuesta, bytes, 1) == -1) _exit(3);
        }
        if (cerrar_dos44(&c.hijo_in, &c.hijo_out) == -1) _exit(2);
        _exit(0);
    }
    if (cerrar_dos44(&c.hijo_in, &c.hijo_out) == -1) goto fin;
    for (unsigned i = 0; i < CALENTAR44; ++i)
        if (ronda44(&c, peticion, respuesta, bytes) == -1) goto fin;
    struct timespec inicio, final, cpu_inicio, cpu_final;
    if (clock_gettime(CLOCK_MONOTONIC, &inicio) == -1 ||
        clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &cpu_inicio) == -1) {
        perror("clock inicio"); goto fin;
    }
    for (unsigned i = 0; i < rondas; ++i)
        if (ronda44(&c, peticion, respuesta, bytes) == -1) goto fin;
    if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &cpu_final) == -1 ||
        clock_gettime(CLOCK_MONOTONIC, &final) == -1) {
        perror("clock final"); goto fin;
    }
    if (diferencia44(&inicio, &final, &pared_ns) == -1 ||
        diferencia44(&cpu_inicio, &cpu_final, &cpu_ns) == -1 || pared_ns == 0) {
        fprintf(stderr, "Intervalo de reloj invalido\n"); goto fin;
    }
    salida = EXIT_SUCCESS;
fin:
    if (cerrar_dos44(&c.padre_in, &c.padre_out) == -1) salida = EXIT_FAILURE;
    if (cerrar_dos44(&c.hijo_in, &c.hijo_out) == -1) salida = EXIT_FAILURE;
    if (hijo > 0) {
        if (salida != EXIT_SUCCESS && kill(hijo, SIGKILL) == -1 && errno != ESRCH)
            perror("kill de limpieza");
        pid_t r;
        do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
        if (r != hijo || !WIFEXITED(estado) || WEXITSTATUS(estado) != 0) salida = EXIT_FAILURE;
    }
    free(peticion); free(respuesta);
    if (salida == EXIT_SUCCESS) {
        puts("mecanismo,iteraciones,bytes,tiempo_ns,cpu_padre_ns");
        printf("%s,%u,%u,%" PRIu64 ",%" PRIu64 "\n", argv[1], rondas, bytes, pared_ns, cpu_ns);
        if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
    }
    return salida;
}

En socketpair, entrada y salida de un participante son el mismo descriptor; cerrar_dos44 evita cerrarlo dos veces. En las tuberías son referencias distintas. Cada rama de fork cierra los extremos del otro participante antes del intercambio.

Los cuerpos se conocen por tamaño fijo y número de rondas; no se utiliza EOF como delimitador de cada respuesta. El lector exige todos los bytes esperados. Si el trabajador termina temprano, el retorno cero falla la muestra, en lugar de publicar un tiempo menor por trabajo incompleto.

Es un benchmark bloqueante y finito. No es un supervisor general frente a procesos arbitrariamente detenidos; el controlador siguiente impone un límite externo y administra su propio grupo de procesos.

13. Repetir corridas y conservar CSV

Guarda comparar44.py. Ejecuta varias corridas por mecanismo, alterna cuál se prueba primero y guarda cada muestra válida. El CSV se crea con modo exclusivo para no sobrescribir otro archivo por accidente.

comparar44.py · muestras crudas, validación y mediana entre corridas
import argparse
import csv
import io
import json
import os
from pathlib import Path
import platform
import signal
import statistics
import subprocess
import sys

CAMPOS = ["mecanismo", "iteraciones", "bytes", "tiempo_ns", "cpu_padre_ns"]

def ejecutar(exe, modo, rondas, cuerpo):
    proceso = subprocess.Popen([str(exe), modo, str(rondas), str(cuerpo)],
                               stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                               text=True, start_new_session=True)
    try:
        salida, errores = proceso.communicate(timeout=15)
    except BaseException:
        try:
            os.killpg(proceso.pid, signal.SIGKILL)
        except ProcessLookupError:
            pass
        proceso.communicate()
        raise
    if proceso.returncode != 0:
        raise ValueError("corrida fallida: " + errores.strip())
    lector = csv.DictReader(io.StringIO(salida))
    filas = list(lector)
    if lector.fieldnames != CAMPOS or len(filas) != 1:
        raise ValueError("CSV de corrida incompatible")
    fila = filas[0]
    if fila["mecanismo"] != modo:
        raise ValueError("mecanismo de respuesta incorrecto")
    for nombre in CAMPOS[1:]:
        fila[nombre] = int(fila[nombre])
    if fila["iteraciones"] != rondas or fila["bytes"] != cuerpo:
        raise ValueError("carga de respuesta incompatible")
    if fila["tiempo_ns"] <= 0 or fila["cpu_padre_ns"] < 0:
        raise ValueError("tiempos invalidos")
    return fila

def main():
    p = argparse.ArgumentParser()
    p.add_argument("ejecutable", type=Path)
    p.add_argument("--rondas", type=int, default=5000)
    p.add_argument("--bytes", type=int, default=64)
    p.add_argument("--corridas", type=int, default=7)
    p.add_argument("--csv", type=Path, required=True)
    a = p.parse_args()
    if not 1 <= a.rondas <= 100000 or not 1 <= a.bytes <= 65536 or not 3 <= a.corridas <= 51:
        raise ValueError("carga o cantidad de corridas fuera de rango")
    exe = a.ejecutable.resolve(strict=True)
    print(json.dumps({"sistema": platform.platform(), "python": platform.python_version(),
                      "cpus_logicas": os.cpu_count(), "ejecutable": str(exe),
                      "rondas": a.rondas, "bytes": a.bytes, "corridas": a.corridas}),
          file=sys.stderr, flush=True)
    muestras = {"pipe": [], "unix": []}
    with a.csv.open("x", newline="", encoding="utf-8") as archivo:
        escritor = csv.DictWriter(archivo, fieldnames=["corrida"] + CAMPOS)
        escritor.writeheader()
        for i in range(a.corridas):
            orden = ("pipe", "unix") if i % 2 == 0 else ("unix", "pipe")
            for modo in orden:
                fila = ejecutar(exe, modo, a.rondas, a.bytes)
                muestras[modo].append(fila)
                escritor.writerow({"corrida": i + 1, **fila})
                archivo.flush()
    escritor = csv.writer(sys.stdout)
    escritor.writerow(["mecanismo", "corridas", "mediana_ns_por_ronda",
                       "min_ns_por_ronda", "max_ns_por_ronda", "mediana_mib_s",
                       "mediana_cpu_padre_ns_por_ronda"])
    for modo, filas in muestras.items():
        tiempos = [f["tiempo_ns"] / f["iteraciones"] for f in filas]
        caudales = [2 * f["bytes"] * f["iteraciones"] * 1e9 / f["tiempo_ns"] / 2**20
                    for f in filas]
        cpu = [f["cpu_padre_ns"] / f["iteraciones"] for f in filas]
        escritor.writerow([modo, len(filas), f"{statistics.median(tiempos):.3f}",
                           f"{min(tiempos):.3f}", f"{max(tiempos):.3f}",
                           f"{statistics.median(caudales):.3f}",
                           f"{statistics.median(cpu):.3f}"])
    sys.stdout.flush()

if __name__ == "__main__":
    try:
        main()
    except (ValueError, OSError, subprocess.TimeoutExpired) as error:
        print(error, file=sys.stderr)
        sys.exit(1)
Bash en Linux · conservar muestras y contexto en un directorio nuevo
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 medir44.c -o medir44
$ ensayo=$(mktemp -d)
$ uname -a > "$ensayo/entorno.txt"
$ gcc --version >> "$ensayo/entorno.txt"
$ python3 comparar44.py ./medir44 --rondas 5000 --bytes 64 --corridas 7 --csv "$ensayo/muestras.csv" > "$ensayo/resumen.csv" 2> "$ensayo/control.log"
$ cat "$ensayo/resumen.csv"
$ cat "$ensayo/control.log"

El resumen contiene resultados medidos en tu entorno; no se proporcionan cifras ficticias como si fueran universales. Cada mecanismo tendrá siete muestras válidas. El script no publica un resumen final si una corrida falla; el archivo crudo puede conservar un prefijo de muestras completadas.

El grupo nuevo de cada corrida pertenece al controlador. Si se agota su límite, termina ese grupo y recoge al proceso que lanzó, para que un trabajador no conserve las tuberías de captura abiertas. No se usa ese mecanismo para señalar procesos ajenos.

14. Leer resultados sin atribuir causas falsas

La mediana de ns por ronda resume los promedios de varias corridas. Los mínimos y máximos muestran parte de la variación entre ellas. No son una distribución de latencias individuales y no permiten deducir p95 o p99 de las peticiones.

Registra tamaño, iteraciones, compilador, optimización, kernel, carga concurrente y configuración de CPU relevante. La afinidad y la topología pueden cambiar el resultado: dos participantes en el mismo núcleo o en núcleos distintos no representan el mismo experimento.

Alternar el orden reduce un sesgo sencillo de «siempre medir uno al principio», pero no elimina ruido, cambios de frecuencia ni efectos de caché. Para diferencias pequeñas hacen falta más evidencia y condiciones controladas; no elijas un mecanismo solo porque una ejecución fue menor.

Un cuerpo mayor puede aumentar MiB/s y también aumentar tiempo por ronda. Ambas observaciones pueden ser correctas. El benchmark tiene una petición en vuelo; para estudiar throughput bajo concurrencia se necesita otra carga, con ventana, límites y verificación equivalentes.

Antes de atribuir una regresión a pipe o a sockets, contrasta contadores de aplicación, traza de corrección y recursos. Un proceso que omitió datos o no recogió a su trabajador no produjo una muestra comparable, aunque terminara antes.

15. Explorar las métricas y sus unidades

Esta calculadora usa datos didácticos editables, no mediciones del equipo. Permite ver cómo cambian las fórmulas al medir una ronda verificada o solo la aceptación local de un envío. No decide qué mecanismo es más rápido en tu sistema.

Promedio A—

Promedio B—

Caudal útil A—

Caudal útil B—

Tiempo total A / tiempo total B—

Qué distribución se conoceUn total y cantidad; no percentiles individuales

Los datos iniciales son ficticios y sirven para comprobar unidades.

Con los datos iniciales, A tiene un promedio de 20000 ns por ronda y transporta dos cuerpos por operación. Cambiar el contrato a aceptación local cambia tanto el nombre de la métrica como el numerador del caudal: no convierte ese tiempo en RTT.

Un promedio derivado de una sola duración no permite calcular percentiles. Marcar la ejecución como trazada conserva las cuentas aritméticas, pero cambia la interpretación: ahora se observa un programa instrumentado.

16. Pruebas de los laboratorios y diagnóstico

Referencias y observación

  1. Recepción ya confirmada. Espera «EOF44 listo» antes de inspeccionar y comprueba que el hijo recibió los cuatro bytes.
  2. Referencia extra. En fuga, localiza el mismo pipe en el padre y el hijo, con direcciones distintas.
  3. EOF liberado. Envía Enter por el control y comprueba verificación y recogida. En correcto no debe esperar ese control.
  4. Inspección finita. Prueba EOF de control, señal de cancelación y plazo reducido en una copia del programa.
  5. Herramientas. Relaciona /proc, lsof y la traza con los mismos procesos y recursos, sin depender de números ilustrativos.

Integridad antes de rendimiento

Ejecuta ambos mecanismos con cuerpos de uno, 64, 4096 y 65536 bytes. Fuerza read y write reales de un byte e introduce EINTR en un controlador de pruebas; el intercambio debe conservar el contenido y el número de rondas.

Haz que el trabajador altere un byte o termine antes de completar su respuesta. medir44 debe fallar sin emitir una fila CSV de éxito. Comprueba que un error de creación o de fork también cierra los recursos ya obtenidos.

El controlador Python debe rechazar CSV malformado, mecanismo o carga equivocados, tiempos imposibles y retorno no cero. Si una corrida queda detenida, debe vencer el límite externo, terminar su grupo propio y recoger al proceso lanzado.

Verifica las fórmulas con datos conocidos: N=10000, B=64, T=0,2 s producen 20000 ns por ronda y aproximadamente 6,104 MiB/s útiles bidireccionales. No confíes solo en que el CSV «tenga números».

Interpretar una aparente espera

Un proceso dormido en read puede estar esperando datos o EOF; uno en futex podría estar esperando sincronización usada por una biblioteca; uno que no muestra syscalls puede estar ejecutando código de usuario. La hipótesis debe contrastarse con el estado de la aplicación y la función de cada recurso.

Los filtros de herramientas, permisos y espacios de nombres pueden dejar información fuera de la captura. Antes de concluir que un recurso no existe, comprueba qué proceso, instante y ámbito observaste. El controlador debe mantener un límite propio y limpiar sus procesos de prueba si una aserción falla.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Suponer que espera de read significa datos no enviados.Se ignoran referencias que retienen EOF.Relacionar bytes ya recibidos y escritores abiertos.
Confundir descriptor con identidad global.Se atribuyen llamadas o recursos a otra sesión.Proceso, ciclo de vida y referencia asociados.
Leer flags de fdinfo como decimal.Se interpretan mal acceso y opciones.Recordar su representación octal.
Usar filtros lsof sin considerar su combinación.Se obtiene evidencia de más recursos de los previstos.Selección explícita y AND con -a cuando corresponda.
Interpretar colas de escucha como bytes de respuesta.Se comparan magnitudes distintas.Contexto de tipo y estado en ss.
Medir rendimiento bajo strace.Se incluye el costo del trazador.Separar diagnóstico y corridas de medición.
Comparar solo send con una ronda verificada.Los resultados corresponden a contratos distintos.Misma frontera de finalización.
Dividir RTT por dos y llamarlo latencia de ida medida.Se atribuye una precisión no observada.Informar la métrica realmente medida.
Incluir fork y calentamiento solo en un caso.Se introduce un sesgo de preparación.Región medida equivalente y documentada.
Publicar un tiempo aunque la respuesta sea incompleta.Una falla aparece como mejora.Resultado CSV solo tras validar datos y trabajador.
Llamar p99 a la mediana de promedios.Se inventa una distribución no medida.Nombrar y conservar las muestras disponibles.
Generalizar una corrida pequeña a todo IPC.Se ignoran carga, topología y sincronización.Conclusiones limitadas al experimento y sus condiciones.

18. Resumen

19. Preguntas de repaso y práctica

Responde separando evidencia, hipótesis, métrica y alcance de la conclusión.

1. ¿Qué debe preguntarse antes de cambiar un programa que espera?

Qué operación espera, qué condición la haría avanzar y qué participante posee la referencia o trabajo que debe producirla.

2. ¿Una lectura de dos bytes demuestra el fin de una petición?

No por sí sola. La interpretación depende del protocolo; un retorno corto positivo representa progreso.

3. ¿Por qué el hijo de eof44 puede haber recibido hola y seguir esperando?

Porque el padre conserva otra referencia de escritura. No hay más datos, pero todavía no existe EOF.

4. ¿Qué relaciona dos enlaces pipe:[inodo] de procesos distintos?

Ayudan a identificar referencias al mismo recurso de tubería. Aún hay que distinguir lectura y escritura y revisar su vida útil.

5. ¿En qué base se muestran los flags de fdinfo?

En octal. No deben interpretarse como un número decimal.

6. ¿Para qué sirve -a en los ejemplos lsof?

Para combinar criterios por intersección y no ampliar la selección de forma involuntaria.

7. ¿Send-Q confirma que la aplicación remota ejecutó una tarea?

No. Es información de cola del núcleo, cuyo significado depende del recurso y su estado.

8. ¿La duración -T de strace es CPU del núcleo?

No. Es duración observada de la syscall, que puede incluir espera y la influencia de la instrumentación.

9. ¿Qué mide CLOCK_PROCESS_CPUTIME_ID en el padre?

CPU de ese proceso. No incorpora automáticamente la CPU del trabajador.

10. ¿Qué queda fuera del tiempo de medir44?

Creación de canales, fork, calentamiento y recogida final. La recogida se verifica antes de publicar la muestra.

11. ¿Por qué se cuentan dos cuerpos en el caudal útil?

Porque cada ronda medida incluye petición y eco del mismo tamaño. No se están contando solo bytes de una dirección.

12. ¿La mediana de siete promedios es la mediana de todas las peticiones?

No. Son estadísticas de conjuntos distintos. Para percentiles individuales habría que medir esa distribución.

13. ¿Qué debe pasar si un trabajador responde un prefijo y termina?

La corrida falla y no publica un resultado CSV de éxito por ese trabajo incompleto.

14. ¿Alternar el orden elimina todo el ruido?

No. Reduce un sesgo sencillo, pero siguen influyendo carga, frecuencia, caché y planificación.

15. ¿El resultado permite elegir memoria compartida o colas de mensajes?

No directamente. Esos mecanismos no se midieron y requerirían otra comparación con sincronización y contrato equivalentes.

Para practicar y ampliar

  1. Diagnostica eof44 sin leer primero qué descriptor es extra y contrasta después tu hipótesis.
  2. Relaciona la misma tubería entre traza, /proc y lsof.
  3. Inspecciona escucha, conectados y registros epoll de un servidor propio del curso.
  4. Ejecuta medir44 con cuerpos de uno, 64, 4096 y 65536 bytes.
  5. Verifica E/S parcial y EINTR antes de comparar rendimiento.
  6. Provoca una respuesta incorrecta y confirma que no se emite una muestra válida.
  7. Conserva siete corridas por mecanismo y recalcula sus resúmenes desde el CSV.
  8. Explica qué cambia al incluir creación de procesos en otra región medida.
  9. Diseña una carga con varias peticiones en vuelo sin quitar validación ni límites.
  10. Propón una comparación con memoria compartida que contabilice sincronización y la misma confirmación de resultado.
Próximo paso

El tema 45 abre las aplicaciones en sistemas reales con IPC en servidores web: supervisor, trabajadores, reparto de conexiones y cierre ordenado. Las herramientas de este tema permitirán observar esa arquitectura sin confundir referencias, trabajo y métricas.