← Comunicación entre ProcesosBloque 11 · Aplicaciones en sistemas reales · Tema 48 de 52

Tema 48

Comparar y combinar los mecanismos

Elegir IPC exige relacionar el contrato de la aplicación con volumen, estructura, aislamiento, vida de los procesos y recuperación. Vas a comparar las alternativas del curso, justificar combinaciones y verificar un mismo intercambio enviando la carga por socket o compartiéndola en memoria con un canal de control separado.

1. Empezar por restricciones y contrato

«¿Cuál es el IPC más rápido?» deja fuera preguntas decisivas: qué información debe llegar, quién puede modificarla, cuándo se libera una ranura, qué significa éxito y qué ocurre si un participante cae. Una medición solo es comparable después de definir esas condiciones.

La elección se hace en dos pasos: descartar mecanismos que no satisfacen las restricciones y comparar las alternativas restantes bajo el mismo contrato. Una ventaja de rendimiento no compensa una garantía que falta.

PreguntaEjemplo de requisitoConsecuencia
¿Dónde están los participantes?Procesos locales o máquinas distintas.Memoria compartida y sockets Unix no reemplazan una red remota.
¿Qué se comunica?Intención, flujo, registros o bloques grandes.Definir framing, límites y propiedad.
¿Qué se considera completado?Encolado, consumido, ejecutado o durable.Ubicar la confirmación correspondiente.
¿Cuánta confianza existe?Trabajadores propios o clientes no confiables.Decidir qué memoria y permisos se comparten.
¿Qué debe sobrevivir?Caída de un proceso o reinicio de la máquina.Separar vida del objeto y persistencia recuperable.
¿Qué plataformas importan?Linux concreto o varias implementaciones POSIX.Identificar extensiones y alternativas verificadas.

Una ficha de decisión debe registrar supuestos verificables: máximo de bytes por mensaje, máximo de trabajo en vuelo, plazos, responsable de recursos y comportamiento ante errores. «Normalmente los mensajes son pequeños» no establece un límite de memoria.

Después se elige una solución inicial sencilla y se mide. Si el cuello de botella es el cálculo o el disco, sustituir un socket por memoria compartida puede aumentar complejidad sin resolver la latencia dominante.

2. Comparar las capacidades de cada mecanismo

MecanismoUnidad y forma de accesoUso apropiadoResponsabilidad pendiente
Señales.Notificaciones de control; las estándar pueden agruparse.Parada, recarga e indicaciones simples.No contar tareas con señales estándar; atenderlas de forma segura.
Pipe anónimo.Flujo de bytes unidireccional.Canal entre procesos con descriptores preparados o heredados.Framing, cierres, EOF y contrapresión.
FIFO.Flujo de bytes con nombre.Encuentro local sencillo entre procesos independientes.Permisos, apertura, escritores y delimitación.
Cola POSIX.Mensajes acotados con prioridad.Trabajo estructurado que cabe en los límites configurados.Capacidad, prioridades, identidad y semántica de finalización.
Socket Unix de flujo.Flujo bidireccional por conexión.Servicios locales y conversaciones solicitud–respuesta.Protocolo, límites, credenciales y vida de sesiones.
Socket Unix de registros.Datagramas o secuencias de paquetes según el tipo.Mensajes con límites preservados por el transporte elegido.Tamaños, truncamiento, errores y capacidad.
Memoria compartida.Acceso común a una región.Datos voluminosos o estructuras compartidas justificadas.Sincronización, propiedad, versiones y recuperación de estado.
Semáforos.Permisos y esperas sobre contadores.Disponibilidad, exclusión o traspaso dentro de un protocolo.Los datos y la recuperación no están dentro del semáforo.
eventfd en Linux.Contador accesible por descriptor.Despertar un bucle que consulta estado pendiente.Compartir el descriptor y definir dónde vive el trabajo real.

La matriz compara capacidades, no posiciones de un ranking de velocidad. Tampoco confunde sincronización con transporte de cuerpos: un semáforo puede acompañar memoria compartida, pero no contiene una petición completa.

Las señales estándar no forman una cola exacta de ocurrencias; las señales de tiempo real tienen otras reglas y límites. Véase signal(7). Cambiar de tipo de señal exige revisar capacidad, interfaz y contexto de atención.

Una cola POSIX puede conservarse en el núcleo más allá de la vida de un participante mientras no se retire bajo sus reglas. Eso no la convierte en un registro durable frente a reinicio o pérdida de energía. Sus mensajes, prioridades y vida se describen en mq_overview(7).

3. Volumen, frecuencia y costo total

Un cuerpo grande puede hacer relevante transportar menos bytes por un canal. Pero reservar memoria compartida, coordinar propietarios, validar metadatos y recuperar una caída también tiene costo. Con mensajes pequeños, ese costo puede dominar la diferencia de transporte.

Modelo conceptual · no es una ecuación de rendimiento universal
costo del recorrido = preparación + producción + transferencia
                   + sincronización + espera de cola + validación
                   + confirmación + cierre / recuperación

comparar el mismo trabajo, no solo una llamada write frente a una asignación

El volumen total es distinto del tamaño máximo individual. Un millón de mensajes breves plantea problemas de llamadas y coordinación; unos pocos bloques grandes pueden plantear problemas de capacidad y memoria. La frecuencia, la concurrencia y el tiempo en vuelo determinan la presión sobre el sistema.

La localidad de caché y la distribución entre núcleos también influyen. Dos procesos modificando repetidamente metadatos cercanos pueden generar contención aunque el cuerpo no viaje por un socket. La memoria compartida evita ciertos recorridos de transporte, no el costo físico de acceder a memoria ni las copias que haga la aplicación.

El laboratorio contabiliza bytes del protocolo para mostrar qué se transporta por el socket. No cuenta copias internas del núcleo, tráfico de caché ni ancho de banda de memoria, y no publica tiempos ficticios para elegir una alternativa.

4. Flujos, mensajes, referencias y estado

Un flujo puede dividirse o agruparse entre llamadas de escritura y lectura. Un mensaje con límites preservados necesita igualmente validación de contenido y un tamaño máximo. Una referencia compartida necesita además comprobar que todavía identifica la versión esperada.

En pipes y FIFO no existe un mensaje por read. La atomicidad de ciertas escrituras hasta PIPE_BUF protege contra intercalado bajo las condiciones de la API; no obliga al lector a devolver ese registro completo en una llamada. Estas reglas están en pipe(7).

Los tipos de socket Unix permiten distintos contratos. SOCK_STREAM requiere framing propio; SOCK_SEQPACKET preserva registros, pero un búfer insuficiente puede truncar una recepción y debe comprobarse. No se elige un tipo omitiendo sus reglas de error. Véase unix(7).

RepresentaciónValidación mínimaRiesgo si falta
Cabecera y cuerpo en un flujo.Versión, tipo, identidad, longitud y progreso parcial.Desalineación o reserva de memoria sin límite.
Registro de cola.Tamaño, operación, identidad y prioridad admitida.Interpretar un mensaje incompatible o provocar inanición.
Índice de ranura compartida.Rango, generación y estado de propiedad.Leer una ranura reutilizada para otra operación.
Desplazamiento y longitud.offset ≤ capacidad y longitud ≤ capacidad − offset.Desbordamiento de suma o acceso fuera del mapeo.
Descriptor transferido.Origen, tipo y cantidad de derechos recibidos.Usar o filtrar un recurso que no pertenece al protocolo.

Una dirección virtual escrita por un proceso no es una referencia portable para otro. Un entero de descriptor tampoco identifica automáticamente el mismo recurso en otra tabla. El protocolo debe elegir índices, offsets o transferencia de referencias bajo reglas explícitas.

5. Topología, descubrimiento y vida útil

Cuando un supervisor crea trabajadores, puede preparar un socketpair, pipes y un mapeo antes de fork. El descubrimiento consiste en heredar exactamente las referencias necesarias. Los cierres por rama permiten que EOF y la liberación funcionen.

Procesos independientes necesitan un encuentro: ruta de socket o FIFO, nombre de objeto compartido, configuración o transferencia mediante otro canal. Ese encuentro requiere identidad, permisos, publicación atómica según la API y una política para nombres residuales.

Que un objeto tenga nombre no significa que su creador sea el único que lo usa. Retirar un nombre y cerrar la última referencia son acontecimientos distintos. La memoria ya mapeada puede seguir accesible después de retirar el nombre que se usó para abrirla; su ciclo se describe en shm_overview(7).

Entre máquinas, ni una ruta Unix ni un mapeo local resuelven la comunicación. Se necesita un transporte de red y un contrato de identidad, protección y fallo, como se introduce en el tema 47.

Una ficha de arquitectura debe decir quién crea, publica, abre, deja de admitir, cierra y retira cada recurso. Si todos los participantes se creen responsables de unlink, uno puede retirar un servicio que otros todavía necesitan.

6. Aislamiento y confianza entre participantes

Un socket permite recibir bytes en memoria propia y validarlos antes de actuar. Un mapeo de escritura compartida permite que otro participante cambie bytes que el consumidor está utilizando. La segunda opción aumenta las obligaciones sobre confianza y concurrencia.

Comprobar una longitud y usarla después no basta si otro proceso puede modificarla entre ambas acciones. Para memoria compartida hacen falta reglas de propiedad, copias estables cuando correspondan o una sincronización que mantenga válida la comprobación.

ParticipantesDecisión inicial razonableQué revisar
Padre e hijo de una aplicación controlada.Canal heredado; compartir datos si el costo lo justifica.Fallos parciales y respeto del protocolo.
Servicios locales con privilegios distintos.Socket con autenticación local y mensajes validados.Autorización por operación y acceso a recursos.
Cliente que no se considera confiable.Limitar y validar datos antes de usar estado interno.Memoria, CPU, identidad y aislamiento de capacidad.
Memoria compartida entre identidades distintas.Diseñar permisos y mutabilidad antes de usarla.No exponer estructuras críticas modificables sin defensa.

Un proceso que cae puede dejar estado de protocolo incompleto aunque no sea malicioso. El ejemplo usa participantes propios y una ranura exclusiva por fase; al fallar abandona el intercambio y destruye la región después de recoger al hijo.

Una comprobación de UID responde sobre una identidad local, no sobre toda la política de aplicación. Transferir un descriptor o un mapeo otorga acceso a un recurso; ese acceso debe formar parte de la autorización, no tratarse como un detalle incidental.

7. Publicación, notificación y capacidad

Hay tres preguntas diferentes: ¿dónde están los datos?, ¿qué permite leerlos de forma válida? y ¿qué despierta al consumidor? En un diseño sencillo un semáforo puede servir de publicación y de espera. En un bucle de eventos, una notificación por descriptor puede indicar que conviene revisar otra estructura.

eventfd mantiene un contador y se integra con esperas por descriptor en Linux. Según sus banderas, la lectura devuelve y consume el contador o una unidad. No transporta una lista de operaciones ni determina por sí solo qué ranuras son válidas. Véase eventfd(2).

Los semáforos POSIX coordinan permisos y acciones, según sem_overview(7). El significado de cada permiso pertenece al protocolo. Un sem_post no significa necesariamente que una tarea terminó, ni permite reconstruir una reserva perdida al caer un proceso.

Separación de responsabilidades
datos:          bytes en ranura o mensajes en canal
publicación:    transición sincronizada a estado consumible
notificación:   despertar para revisar trabajo pendiente
capacidad:      permiso para producir sin pisar datos en uso
confirmación:   identidad y resultado de una operación concreta

Si varias tareas se publican con una sola notificación, el consumidor debe drenar el estado pendiente según sus reglas. Si el aviso se agrupa o pierde una oportunidad de despertar, la estructura autoritativa no debe desaparecer con ese aviso.

Una cola acotada define qué hacer al agotarse capacidad: esperar con plazo, pausar lectura, rechazar o descartar bajo un contrato explícito. Reservar memoria sin límite no es una solución a la contrapresión.

8. Portabilidad y extensiones de plataforma

POSIX define interfaces de señales, pipes, semáforos, memoria compartida y colas, pero algunas funcionalidades pueden ser opcionales o tener límites distintos. Una aplicación portable debe verificar disponibilidad, valores y comportamiento en las plataformas que declara soportar.

DependenciaAlcanceTrabajo de adaptación
pipe, socketpair y operaciones de flujo.Interfaces disponibles en sistemas POSIX bajo sus especificaciones.Límites, banderas y política de cierre.
Semáforos compartidos entre procesos.Requieren soporte real de la implementación.Comprobar inicialización y alternativa de sincronización.
Colas y memoria compartida POSIX.API y entorno de objetos.Nombres, límites, permisos y bibliotecas de enlace.
epoll, signalfd, eventfd y timerfd.Extensiones de Linux.Otro bucle o mecanismo equivalente en otra plataforma.
Credenciales y transferencia de derechos.Detalles según sistema y tipo de socket.Validar interfaz y modelo de seguridad.

El laboratorio es de Linux: utiliza signalfd, banderas de creación de descriptores y MAP_ANONYMOUS. No se presenta como un ejemplo POSIX portable sin cambios. El núcleo de la decisión —datos, control, propiedad y confirmación— puede mantenerse mientras se adapta el soporte de plataforma.

Elegir una interfaz conocida como portable no elimina el trabajo de prueba. Tampoco conviene introducir una extensión solo por disponibilidad si un mecanismo ya utilizado resuelve la necesidad con menos estados.

9. Combinar mecanismos por responsabilidad

CombinaciónReparto de responsabilidadesCosto que se agrega
Pipe de datos y señales de control.Bytes del trabajo separados de intención de parada.Orden de cierre y observación de señales durante esperas.
Memoria compartida y semáforos.Cuerpos comunes con publicación y permisos de uso.Recuperación de fases incompletas.
Memoria compartida y socket de control.Bloques por región; identidad, offsets y resultados por canal.Relacionar versión de bloque y mensaje.
Cola compartida y eventfd.Estado pendiente en cola; despertar del bucle por descriptor.No confundir contador de avisos con identidad de tareas.
Socket Unix y transferencia de descriptores.Control y entrega de acceso a recursos locales.Validar derechos y cerrar referencias inesperadas.
IPC y diario de recuperación.Cooperación volátil separada de estado recuperable.Orden de sincronización y semántica de confirmación.

La combinación debe eliminar una limitación concreta. Si se agregan tres mecanismos que anuncian lo mismo sin una autoridad definida, aparecen estados contradictorios: el contador dice disponible, la cola está vacía y el socket espera una confirmación.

En el laboratorio, los semáforos gobiernan el acceso a la ranura compartida; el socket transporta identidad y confirmación. No se usa el envío de una cabecera como sustituto implícito de la sincronización de memoria.

Si el cuerpo ya es pequeño y el socket ofrece el contrato necesario, transportar todo por él puede ser una solución inicial más sencilla. Compartir memoria queda como una opción que necesita una justificación de carga y complejidad.

10. Invariantes de una ranura compartida

Una ranura, un productor y un consumidor
LIBRE ── productor toma permiso ──► ESCRIBIENDO
  ▲                                      │
  │                              publicar semáforo listo
  │                                      ▼
  └── consumidor libera permiso ◄── CONSUMIENDO
                                       │
                              ACK con secuencia y checksum
  1. El productor solo escribe después de tomar libre.
  2. El consumidor solo lee después de recibir metadatos válidos y tomar listo.
  3. La longitud y el offset se comprueban antes de acceder al rango.
  4. El consumidor termina de leer antes de devolver libre.
  5. El productor no avanza a la siguiente ronda sin un ACK válido de la actual.
  6. Un fallo abandona la región completa; no se reutilizan permisos a ciegas.

En este diseño no hay dos escritores simultáneos del cuerpo. El permiso protege la ranura y la secuencia identifica el intercambio. Son funciones distintas: una ranura libre no significa que el padre haya recibido el ACK correcto.

Con muchas ranuras y varios productores harían falta índices protegidos, propiedad por ranura y política de recuperación de reservas. Si una ranura se reutiliza, una generación ayuda a rechazar referencias antiguas. La secuencia simple del ejercicio no resuelve todos esos casos por extensión automática.

El consumidor ya no toca el cuerpo después de liberar libre. Aunque el ACK se envía luego, el padre tampoco reescribe hasta validarlo. El orden garantiza que el productor y consumidor no compitan por bytes mientras se calcula el resultado.

11. Contrato del laboratorio comparativo

combinar48.c crea padre e hijo conectados por socketpair de flujo. Los modos copiar y compartir verifican el mismo patrón binario, secuencia y checksum, con una sola operación en vuelo. El modo compartir agrega un mapeo anónimo y dos semáforos compartidos.

Partecopiarcompartir
Producción del cuerpo.Buffer privado del padre.Directamente en la ranura compartida bajo permiso.
Entrega.Cabecera y cuerpo por el socket.Publicación por semáforo y cabecera por el socket.
Consumo.El hijo recibe en su buffer privado.El hijo toma listo y lee la ranura.
Validación.Patrón esperado por secuencia y checksum FNV-1a de 32 bits sobre todos los bytes.
Confirmación.ACK de 24 bytes con la misma secuencia, longitud, offset y checksum.
Cierre.EOF en ambas direcciones, salida válida del hijo y recogida antes de emitir el CSV.

La cabecera ocupa 24 bytes: marca IPC8, versión 1, tipo DATA=1 o ACK=2, dos bytes reservados cero y cuatro uint32 big endian —secuencia, longitud, offset y checksum—. El offset debe ser cero en esta única ranura. La longitud va de uno a 65536 bytes y la secuencia crece desde uno.

El checksum detecta muchos errores accidentales, pero no autentica al emisor ni garantiza detectar toda corrupción. El hijo además contrasta cada byte con el patrón conocido de la ronda: no devuelve como resultado un checksum sin comprobar el cuerpo.

El padre aplica un plazo global de diez segundos a la conversación y a la espera cooperativa de su hijo. El hijo conserva el mismo límite absoluto heredado para sus esperas. Una carga máxima puede agotar ese límite en una máquina lenta; eso hace fallar el ensayo y no publica un éxito parcial.

Se contabilizan bytes de aplicación, no tiempos de rendimiento: copiar lleva 48N+NB bytes por el socket y compartir lleva 48N, para N rondas de B bytes. Ambos verifican NB bytes útiles. Las operaciones de semáforo, el tráfico de memoria y los costos del núcleo no están en ese contador.

12. Laboratorio completo en C

Guarda el siguiente programa como combinar48.c. No requiere archivos de apoyo. Las funciones de espera conservan el plazo absoluto, aceptan transferencias parciales y permiten que el padre observe SIGINT y SIGTERM mediante signalfd.

combinar48.c · mismo trabajo, dos rutas para la carga y confirmación verificable
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/mman.h>
#include <sys/signalfd.h>
#include <sys/wait.h>
#include <semaphore.h>
#include <poll.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define MAX48 65536u
#define CAB48 24u
struct region48 {
    sem_t libre, listo;
    unsigned char dato[MAX48];
};
static int cerrar48(int *fd)
{
    if (*fd < 0) return 0;
    int n = *fd; *fd = -1;
    if (close(n) == -1) { perror("close"); return -1; }
    return 0;
}
static int numero48(const char *s, unsigned maximo, unsigned *valor)
{
    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;
    *valor = (unsigned)n; return 0;
}
static uint32_t obtener48(const unsigned char *p)
{
    return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
           ((uint32_t)p[2] << 8) | p[3];
}
static void poner48(unsigned char *p, uint32_t n)
{
    for (unsigned i = 0; i < 4; ++i) p[i] = (unsigned char)(n >> (24u - 8u * i));
}
static void cabecera48(unsigned char *b, unsigned tipo, unsigned secuencia,
                       unsigned bytes, uint32_t suma)
{
    memset(b, 0, CAB48); memcpy(b, "IPC8", 4);
    b[4] = 1; b[5] = (unsigned char)tipo;
    poner48(b + 8, secuencia); poner48(b + 12, bytes);
    poner48(b + 16, 0); poner48(b + 20, suma);
}
static int validar48(const unsigned char *b, unsigned secuencia, unsigned bytes)
{
    uint32_t largo = obtener48(b + 12), offset = obtener48(b + 16);
    if (memcmp(b, "IPC8", 4) != 0 || b[4] != 1 || b[5] != 1 ||
        b[6] != 0 || b[7] != 0 || obtener48(b + 8) != secuencia ||
        offset > MAX48 || largo > MAX48 - offset ||
        offset != 0 || largo != bytes) {
        errno = EPROTO; return -1;
    }
    return 0;
}
static int64_t ahora48(void)
{
    struct timespec t;
    if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
    return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
static int restante48(int64_t fin)
{
    int64_t ahora = ahora48();
    if (ahora < 0) return -1;
    if (ahora >= fin) { errno = ETIMEDOUT; return -1; }
    return (int)(fin - ahora);
}
static int control48(int fd)
{
    struct signalfd_siginfo s;
    ssize_t n = read(fd, &s, sizeof s);
    if (n == -1 && (errno == EINTR || errno == EAGAIN)) return 0;
    if (n != (ssize_t)sizeof s) { errno = EIO; return -1; }
    errno = ECANCELED; return -1;
}
static int esperar48(int fd, short eventos, int control, int64_t fin)
{
    for (;;) {
        int ms = restante48(fin);
        if (ms == -1) return -1;
        struct pollfd p[2] = {
            { .fd = fd, .events = eventos },
            { .fd = control, .events = POLLIN }
        };
        int r = poll(p, 2, ms);
        if (r == -1) { if (errno == EINTR) continue; return -1; }
        if (p[1].revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
        if ((p[1].revents & POLLIN) && control48(control) == -1) return -1;
        if (p[0].revents & POLLNVAL) { errno = EBADF; return -1; }
        if (p[0].revents & (eventos | POLLERR | POLLHUP)) return 0;
    }
}
static int pausa48(int control, int64_t fin)
{
    int ms = restante48(fin);
    if (ms == -1) return -1;
    if (ms > 50) ms = 50;
    struct pollfd p = { .fd = control, .events = POLLIN };
    int r = poll(&p, 1, ms);
    if (r == -1) return errno == EINTR ? 0 : -1;
    if (p.revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
    if (p.revents & POLLIN) return control48(control);
    return 0;
}
static int tomar48(sem_t *s, int control, int64_t fin)
{
    for (;;) {
        if (sem_trywait(s) == 0) return 0;
        if (errno == EINTR) continue;
        if (errno != EAGAIN || pausa48(control, fin) == -1) return -1;
    }
}
static int transferir48(int fd, unsigned char *p, size_t total,
                        int escribir, int control, int64_t fin)
{
    size_t hechos = 0;
    while (hechos < total) {
        if (esperar48(fd, escribir ? POLLOUT : POLLIN, control, fin) == -1) return -1;
        ssize_t n = escribir ? send(fd, p + hechos, total - hechos, MSG_NOSIGNAL) :
                               recv(fd, p + hechos, total - hechos, 0);
        if (n > 0) hechos += (size_t)n;
        else if (n == 0) { errno = EPIPE; return -1; }
        else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return -1;
    }
    return 0;
}
static int eof48(int fd, int control, int64_t fin)
{
    for (;;) {
        if (esperar48(fd, POLLIN, control, fin) == -1) return -1;
        unsigned char b;
        ssize_t n = recv(fd, &b, 1, 0);
        if (n == 0) return 0;
        if (n > 0) { errno = EPROTO; return -1; }
        if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return -1;
    }
}
static uint32_t llenar48(unsigned char *p, unsigned bytes, unsigned secuencia)
{
    uint32_t h = UINT32_C(2166136261);
    for (unsigned i = 0; i < bytes; ++i) {
        p[i] = (unsigned char)((secuencia + i) % 251u);
        h = (h ^ p[i]) * UINT32_C(16777619);
    }
    return h;
}
static int comprobar48(const unsigned char *p, unsigned bytes,
                       unsigned secuencia, uint32_t esperado)
{
    uint32_t h = UINT32_C(2166136261);
    for (unsigned i = 0; i < bytes; ++i) {
        if (p[i] != (unsigned char)((secuencia + i) % 251u)) { errno = EPROTO; return -1; }
        h = (h ^ p[i]) * UINT32_C(16777619);
    }
    if (h != esperado) { errno = EPROTO; return -1; }
    return 0;
}
static int consumidor48(int fd, struct region48 *r, unsigned char *privado,
                        unsigned rondas, unsigned bytes, int64_t fin)
{
    for (unsigned secuencia = 1; secuencia <= rondas; ++secuencia) {
        unsigned char cab[CAB48];
        if (transferir48(fd, cab, sizeof cab, 0, -1, fin) == -1 ||
            validar48(cab, secuencia, bytes) == -1) return -1;
        unsigned char *datos = privado;
        if (r != MAP_FAILED) {
            if (tomar48(&r->listo, -1, fin) == -1) return -1;
            datos = r->dato;
        } else if (transferir48(fd, privado, bytes, 0, -1, fin) == -1) return -1;
        if (comprobar48(datos, bytes, secuencia, obtener48(cab + 20)) == -1) return -1;
        if (r != MAP_FAILED && sem_post(&r->libre) == -1) return -1;
        cab[5] = 2;
        if (transferir48(fd, cab, sizeof cab, 1, -1, fin) == -1) return -1;
    }
    if (eof48(fd, -1, fin) == -1 || shutdown(fd, SHUT_WR) == -1) return -1;
    return 0;
}
static int recoger48(pid_t hijo, int *estado, int control, int64_t fin)
{
    for (;;) {
        pid_t p = waitpid(hijo, estado, WNOHANG);
        if (p == hijo) return 0;
        if (p == -1 && errno == EINTR) continue;
        if (p == -1 || pausa48(control, fin) == -1) return -1;
    }
}
int main(int argc, char **argv)
{
    unsigned rondas, bytes;
    if (argc != 4 || (strcmp(argv[1], "copiar") && strcmp(argv[1], "compartir")) ||
        numero48(argv[2], 10000u, &rondas) == -1 || numero48(argv[3], MAX48, &bytes) == -1) {
        fprintf(stderr, "Uso: %s copiar|compartir rondas(1..10000) bytes(1..65536)\n", argv[0]);
        return EXIT_FAILURE;
    }
    int compartido = strcmp(argv[1], "compartir") == 0;
    sigset_t mascara;
    sigemptyset(&mascara); sigaddset(&mascara, SIGINT); sigaddset(&mascara, SIGTERM);
    if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
        signal(SIGCHLD, SIG_DFL) == SIG_ERR || signal(SIGPIPE, SIG_IGN) == SIG_ERR ||
        sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) {
        perror("senales"); return EXIT_FAILURE;
    }
    int control = -1, par[2] = { -1, -1 }, inicializados = 0;
    int salida = EXIT_FAILURE, recogido = 0, estado = 0;
    pid_t hijo = -1;
    struct region48 *r = MAP_FAILED;
    unsigned char *privado = NULL;
    control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
    if (control == -1 || socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, par) == -1) {
        perror("canales"); goto fin;
    }
    if (compartido) {
        r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
        if (r == MAP_FAILED) { perror("mmap"); goto fin; }
        if (sem_init(&r->libre, 1, 1) == -1) goto fin;
        inicializados = 1;
        if (sem_init(&r->listo, 1, 0) == -1) goto fin;
        inicializados = 2;
    } else {
        privado = malloc(bytes);
        if (privado == NULL) { perror("malloc"); goto fin; }
    }
    int64_t limite = ahora48();
    if (limite < 0) goto fin;
    limite += 10000;
    hijo = fork();
    if (hijo == -1) { perror("fork"); goto fin; }
    if (hijo == 0) {
        sigset_t vacia; sigemptyset(&vacia);
        if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
            sigprocmask(SIG_SETMASK, &vacia, NULL) == -1 ||
            cerrar48(&control) == -1 || cerrar48(&par[0]) == -1) _exit(2);
        int codigo = consumidor48(par[1], r, privado, rondas, bytes, limite);
        if (codigo == -1) perror("consumidor");
        if (cerrar48(&par[1]) == -1) codigo = -1;
        _exit(codigo == 0 ? 0 : 3);
    }
    if (cerrar48(&par[1]) == -1) goto fin;
    for (unsigned secuencia = 1; secuencia <= rondas; ++secuencia) {
        unsigned char *datos = privado;
        if (compartido) {
            if (tomar48(&r->libre, control, limite) == -1) goto error;
            datos = r->dato;
        }
        uint32_t suma = llenar48(datos, bytes, secuencia);
        unsigned char cab[CAB48], ack[CAB48];
        cabecera48(cab, 1, secuencia, bytes, suma);
        if (compartido && sem_post(&r->listo) == -1) goto error;
        if (transferir48(par[0], cab, sizeof cab, 1, control, limite) == -1) goto error;
        if (!compartido && transferir48(par[0], datos, bytes, 1, control, limite) == -1) goto error;
        if (transferir48(par[0], ack, sizeof ack, 0, control, limite) == -1) goto error;
        cab[5] = 2;
        if (memcmp(cab, ack, sizeof cab) != 0) { errno = EPROTO; goto error; }
    }
    if (shutdown(par[0], SHUT_WR) == -1 || eof48(par[0], control, limite) == -1 ||
        recoger48(hijo, &estado, control, limite) == -1) goto error;
    recogido = 1;
    if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) goto fin;
    salida = EXIT_SUCCESS;
    goto fin;
error:
    perror("intercambio padre");
fin:
    if (hijo > 0 && !recogido) {
        if (kill(hijo, SIGKILL) == -1 && errno != ESRCH) perror("kill propio");
        pid_t p;
        do { p = waitpid(hijo, &estado, 0); } while (p == -1 && errno == EINTR);
        if (p != hijo) salida = EXIT_FAILURE;
    }
    if (cerrar48(&par[0]) == -1) salida = EXIT_FAILURE;
    if (cerrar48(&par[1]) == -1) salida = EXIT_FAILURE;
    if (cerrar48(&control) == -1) salida = EXIT_FAILURE;
    if (r != MAP_FAILED) {
        if (inicializados >= 2 && sem_destroy(&r->listo) == -1) salida = EXIT_FAILURE;
        if (inicializados >= 1 && sem_destroy(&r->libre) == -1) salida = EXIT_FAILURE;
        if (munmap(r, sizeof *r) == -1) salida = EXIT_FAILURE;
    }
    free(privado);
    if (salida == EXIT_SUCCESS) {
        uint64_t carga = (uint64_t)rondas * bytes;
        uint64_t canal = (uint64_t)rondas * 2u * CAB48 + (compartido ? 0 : carga);
        puts("modo,rondas,bytes,verificados,bytes_canal,bytes_carga");
        printf("%s,%u,%u,%u,%" PRIu64 ",%" PRIu64 "\n",
               argv[1], rondas, bytes, rondas, canal, carga);
        if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
    }
    return salida;
}

El modo copiar no crea semáforos ni mapeo compartido. El modo compartir no envía el cuerpo por el socket. En ambos se conservan el protocolo de control y la validación del hijo, para que el contraste no se reduzca a «enviar datos» frente a «no hacer trabajo».

Ante un fallo, el padre termina y recoge al hijo antes de destruir semáforos o desmontar la región. Esa política permite abandonar con seguridad los recursos de esta ejecución; no implementa reparación de una cola compartida de larga vida.

13. Ejecutar y verificar ambos modos

Bash en Linux · compilar y contrastar una misma carga
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 combinar48.c -o combinar48 -pthread
./combinar48 copiar 100 4096
./combinar48 compartir 100 4096
ModoRondas verificadasBytes útilesBytes de protocolo por socket
copiar.100.409600.414400: carga más DATA y ACK.
compartir.100.409600.4800: solo DATA y ACK.

Estas cantidades se derivan del formato y del número de rondas, no son resultados de un benchmark ni prometen una relación de velocidades. El consumidor comprobó los mismos 409600 bytes útiles en ambos casos.

Guarda verificar48.py para repetir varios tamaños y contrastar el CSV con fórmulas independientes. El controlador alterna el orden por tamaño, impone un límite externo y crea el archivo de salida en modo exclusivo para no sobrescribir resultados anteriores.

verificar48.py · contrato, contabilidad y control de procesos propios
import argparse
import csv
import io
import os
from pathlib import Path
import signal
import subprocess
import sys

CAMPOS = ["modo", "rondas", "bytes", "verificados", "bytes_canal", "bytes_carga"]

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 or None in filas[0]:
        raise ValueError("CSV incompatible")
    fila = filas[0]
    if any(v is None for v in fila.values()) or fila["modo"] != modo:
        raise ValueError("campos incompletos o modo incorrecto")
    for nombre in CAMPOS[1:]:
        fila[nombre] = int(fila[nombre])
    carga = rondas * cuerpo
    canal = 48 * rondas + (carga if modo == "copiar" else 0)
    esperado = {"rondas": rondas, "bytes": cuerpo, "verificados": rondas,
                "bytes_canal": canal, "bytes_carga": carga}
    if any(fila[nombre] != valor for nombre, valor in esperado.items()):
        raise ValueError("carga, confirmaciones o contabilidad incorrectas")
    return fila

def main():
    p = argparse.ArgumentParser()
    p.add_argument("ejecutable", type=Path)
    p.add_argument("--rondas", type=int, default=25)
    p.add_argument("--salida", type=Path, required=True)
    a = p.parse_args()
    if not 1 <= a.rondas <= 10000:
        raise ValueError("rondas fuera de rango")
    exe = a.ejecutable.resolve(strict=True)
    tamanos = [1, 64, 4096, 65536]
    casos = 0
    with a.salida.open("x", newline="", encoding="utf-8") as archivo:
        escritor = csv.DictWriter(archivo, fieldnames=CAMPOS)
        escritor.writeheader()
        for i, cuerpo in enumerate(tamanos):
            modos = ("copiar", "compartir") if i % 2 == 0 else ("compartir", "copiar")
            for modo in modos:
                fila = ejecutar(exe, modo, a.rondas, cuerpo)
                escritor.writerow(fila)
                archivo.flush()
                casos += 1
    print(str(casos) + " casos verificados; datos guardados en " + str(a.salida),
          file=sys.stderr)

if __name__ == "__main__":
    try:
        main()
    except (ValueError, OSError, subprocess.TimeoutExpired) as error:
        print(error, file=sys.stderr)
        sys.exit(1)
Bash · conservar las ocho verificaciones
python3 verificar48.py ./combinar48 --salida casos48.csv

Una corrida fallida, CSV incompatible o cuenta incorrecta detienen la prueba. El archivo puede conservar un prefijo de casos ya verificados; no se imprime una confirmación global de éxito si falta alguno. Para repetir, elige otro nombre de salida.

La comprobación externa no demuestra por sí sola que un ejecutable arbitrario hizo el trabajo que declara. Se combina con el protocolo, la validación del consumidor y las inyecciones de fallo. La contabilidad tiene significado porque conocemos la implementación y contrastamos sus invariantes.

14. Interpretar bytes y medir rendimiento

bytes_canal cuenta bytes de aplicación enviados por ambas direcciones del socket. No incluye protocolos internos del núcleo, operaciones de semáforo, tráfico de memoria ni el tamaño reservado del mapeo. bytes_carga cuenta una vez cada cuerpo que el consumidor valida.

En compartir, el padre produce directamente en la ranura y el hijo la lee. Eso evita transportar el cuerpo por el socket del ejemplo. No se afirma «cero costo de copia» para todo el sistema: aún existen escrituras, lecturas, coherencia de caché y sincronización.

Si deseas medirDefine antesEvita concluir
Latencia por ronda.Inicio antes de producir o antes de enviar; final tras ACK verificado.Que tiempo de write sea tiempo de consumo.
Caudal útil.Bytes efectivamente verificados por unidad de tiempo.Que contar solo metadatos represente toda la carga útil.
Costo de preparación.Creación de canales, mapeo, semáforos y fork.Que un canal reutilizado tenga el mismo costo que una sesión nueva.
CPU total.Recursos de padre, hijo y participantes auxiliares.Que CPU del padre represente a todo el sistema.
Memoria.Reservas, buffers privados, región y concurrencia.Que menor volumen por socket implique menor memoria total.

El programa no realiza calentamiento ni publica duraciones. Si agregas tiempos, decide cómo tratar primer acceso a páginas, generación del patrón y cálculo de checksum. Esos costos pueden dominar una carga breve y deben mantenerse equivalentes o documentarse como parte del trabajo.

Reutiliza el método del tema 44: reloj monotónico, región medida explícita, varias corridas válidas y resultados crudos. Conserva la verificación y publica la muestra solo tras confirmar cierre y salida del consumidor.

Para evaluar una cola con varios trabajos en vuelo, cambia también el contrato y las métricas. Una carga secuencial de una ranura mide otra situación que un pipeline de muchas ranuras; mezclar ambos resultados oculta diferencias de concurrencia.

15. Explorar una decisión con restricciones

Este selector propone familias de soluciones según restricciones explícitas. No asigna una puntuación de velocidad ni sustituye una revisión de seguridad, soporte de plataforma y carga. La contabilidad inferior corresponde únicamente al formato de 24 bytes del laboratorio.

Familia candidata—

Control y sincronización—

Carga útil del laboratorio—

Socket en modo copiar—

Socket en modo compartir—

Siguiente comprobación—

—

Si se exige durabilidad, la respuesta agrega un protocolo de recuperación en vez de declarar durable una cola o un mapeo. Si se exige portabilidad, advierte qué extensiones del laboratorio no cumplen ese objetivo. Entre máquinas descarta las opciones de IPC local para el tramo remoto.

El volumen introducido no decide automáticamente el transporte: sirve para dimensionar el trabajo del ejemplo. El tamaño real a partir del cual otra arquitectura compensa su complejidad se obtiene con mediciones equivalentes y requisitos de operación.

16. Resolver casos con criterios explícitos

Filtro lanzado desde una shell

El productor y consumidor se conectan al crear la tubería del pipeline. Un flujo por pipe suele corresponder al contrato: bytes ordenados, EOF y contrapresión. Agregar memoria compartida requeriría un protocolo que una herramienta ordinaria de la shell no conoce.

Servicio local de consultas pequeñas

Un socket Unix de flujo con framing y credenciales permite sesiones bidireccionales y procesos independientes. Los cuerpos breves no justifican por sí solos abrir un mapeo por cliente. Si las consultas son registros, puede evaluarse un transporte de registros bajo sus límites.

Procesamiento repetido de bloques grandes

Si trabajadores propios consumen bloques del mismo host, una región con ranuras y control separado puede reducir transporte de cuerpos. La decisión exige límites de ranuras, generaciones, permisos, plazos y recuperación de un consumidor que cae durante su turno.

Parada de un servidor con bucle de eventos

La intención puede recibirse mediante señales integradas con signalfd en Linux o una alternativa apropiada. Los cuerpos de clientes permanecen en sockets. No hace falta transportar toda la configuración o cada tarea dentro de una señal estándar.

Trabajo estructurado con prioridades

Una cola POSIX puede conservar límites de mensaje y permitir prioridad cuando su capacidad se adapta al trabajo. Hay que evitar que un flujo constante de prioridad alta deje sin servicio al resto. La confirmación de extracción no equivale a ejecución ni a durabilidad.

Servicio repartido entre hosts

El tramo remoto necesita red, identidad y protección. Puede combinarse con sockets Unix dentro de cada host, como en el tema 47. El mismo formato puede mantenerse, pero una política de credenciales locales no se convierte automáticamente en autenticación remota.

En cada caso, documenta también por qué no hace falta otra pieza. Si un requisito cambia —clientes no confiables, cuerpos mayores, más concurrencia o confirmación durable— se revisa la decisión con ese nuevo contrato.

17. Probar fallos antes de optimizar

EnsayoResultado esperadoPropiedad observada
Ambos modos con 1, 64, 4096 y 65536 bytes.Mismas rondas y carga verificada; contabilidad distinta según el formato.Trabajo equivalente con las dos rutas.
send y recv reales de un byte, con EINTR.Intercambio completo sin saltar ni repetir desplazamientos.Framing correcto en un flujo.
Alterar un byte antes de entregar el cuerpo.El consumidor falla y no hay CSV de éxito.Validación real del contenido.
Secuencia, versión, tipo, longitud u offset inválidos.Rechazo antes de usar una referencia inválida.Protocolo de control y comprobación de rangos.
ACK con identidad o checksum incorrecto.El padre falla y recoge al hijo.No avanzar por cualquier confirmación.
EOF prematuro o bytes después de las rondas.Fallo del cierre esperado.Truncamiento y datos no contratados no pasan como éxito.
No publicar listo en una copia de prueba.Vence el plazo; el padre termina y recoge al hijo.Una pérdida de publicación no bloquea para siempre la ejecución.
Consumidor detenido con SIGSTOP.Finaliza la espera cooperativa, se solicita SIGKILL y se recoge.Separar petición de finalización y salida real.
SIGTERM al padre durante una espera.Abandona el intercambio y limpia después de recoger.Cancelación observada durante bloqueo.
Segundo sem_init falla o fork falla.Solo se destruyen los recursos ya creados.Limpieza del arranque parcial.

Las inyecciones se hacen en copias instrumentadas dentro de un directorio de prueba. No se cambia la semántica del sistema para toda la máquina. El controlador debe terminar únicamente sus procesos y conservar suficiente evidencia para distinguir un fallo de datos de un fallo de limpieza.

Para corromper la carga de manera determinista, altera un byte después de calcular el checksum y antes de publicar o enviar. Para un ACK inválido, altera el campo después de la validación del consumidor. Así se comprueba cada frontera sin depender de una carrera fortuita.

Reduce el plazo en las copias destinadas a comprobar timeout, sin retirar la limpieza. Un SIGKILL no ejecuta finalizadores y un proceso en espera no interrumpible del núcleo puede retrasar su recogida: el límite gobierna la espera cooperativa, no promete desaparición física instantánea en cualquier estado del núcleo.

El ejemplo destruye toda la región al fallar. Reanudar una cola compartida de larga vida exigiría revisar dueños, generaciones y permisos pendientes, no simplemente incrementar un contador hasta que parezca libre.

18. Revisar una arquitectura y sus límites

Ficha de decisión · completar para una aplicación concreta
Contrato: datos, resultado y significado de exito
Participantes: ubicacion, identidad y forma de arranque
Limites: bytes, trabajo en vuelo, memoria y tiempo
Alternativas descartadas: requisito que incumple cada una
Eleccion inicial: mecanismo de datos, control y sincronizacion
Propiedad: quien crea, publica, usa, cierra y retira
Fallo: que ocurre entre cada par de transiciones
Recuperacion: abandonar, reiniciar o reparar bajo que reglas
Validacion: integridad, cierres, hijos y recursos
Medicion: carga, region, estadisticas y costos incluidos
Condicion de revision: cambio de requisito o evidencia nueva
Atajo incorrectoProblemaPregunta que lo corrige
«Memoria compartida siempre gana».Omite sincronización, confianza y recuperación.¿Qué costo domina en esta carga y qué permisos se comparten?
«Un mensaje de cola ya está procesado».Confunde transporte y ejecución.¿Qué confirmación identifica el resultado?
«Un aviso equivale a una tarea».Ignora agrupación y estado pendiente.¿Dónde está la estructura autoritativa de trabajo?
«Como tiene nombre, es persistente».Confunde descubrimiento y durabilidad.¿Qué sobrevive al fallo considerado y cómo se reconstruye?
«Cierro el padre y todo se libera».Ignora referencias heredadas.¿Quién conserva el último descriptor o mapeo?
«Es POSIX, no necesita adaptación».Ignora opciones, límites e implementación.¿En qué plataformas se compila y se verifica realmente?

La durabilidad necesita un protocolo de almacenamiento, como muestra el tema 46. La preparación y el drenaje de procesos pertenecen al ciclo de servicio, como en el tema 45. Elegir otro transporte no elimina esas responsabilidades.

Una decisión puede cambiar al crecer la carga o al introducir clientes externos. Conviene registrar la condición que justificaría revisarla, en lugar de convertir la primera elección en una regla universal.

19. Resumen, repaso y práctica

Los mecanismos se comparan según el contrato que pueden sostener y el costo total de hacerlo. Un flujo, una cola, una región compartida y un aviso representan cosas diferentes. Combinarlos funciona cuando cada pieza tiene autoridad, límites y una transición de propiedad definida.

Preguntas de repaso

1. ¿Por qué no existe un ganador universal de IPC?

Las cargas y garantías difieren. La alternativa debe cumplir restricciones de datos, ubicación, confianza, vida y recuperación antes de comparar costos.

2. ¿PIPE_BUF convierte un pipe en una cola de registros?

No. Protege ciertas escrituras contra intercalado; el lector todavía recibe un flujo y debe reconstruir mensajes.

3. ¿Una cola POSIX confirma ejecución?

No. Publicar o extraer un mensaje no confirma que su trabajo se haya completado.

4. ¿Un objeto con nombre es durable?

No por ese hecho. Su vida en el núcleo o sistema de nombres no sustituye un protocolo de almacenamiento recuperable.

5. ¿Qué falta cuando se comparten bytes?

Propiedad, sincronización, validación de rangos, versiones y política de fallo de participantes.

6. ¿Qué representa un eventfd?

Un contador para notificación por descriptor. La identidad y contenido de las tareas deben vivir bajo otro contrato.

7. ¿Por qué no compartir escritura indiscriminadamente?

Otro participante podría alterar datos o metadatos mientras se comprueban o utilizan. Hay que diseñar permisos y protección.

8. ¿Qué protege libre en el laboratorio?

El derecho del productor a reutilizar la única ranura. No sustituye el ACK de una ronda concreta.

9. ¿Qué protege listo?

La publicación del cuerpo que el consumidor puede leer después de tomar el permiso correspondiente.

10. ¿El socket sustituye esa sincronización de memoria?

En este ejemplo no. Transporta metadatos y ACK; los semáforos establecen el traspaso de la ranura.

11. ¿Qué cambia entre copiar y compartir?

La ruta de la carga: buffer privado y socket, o ranura compartida. El patrón, validación y confirmación se mantienen.

12. ¿Por qué hay 48 bytes de control por ronda?

Una cabecera DATA de 24 y un ACK de 24. Los cuerpos agregan bytes al socket solamente en copiar.

13. ¿Menos bytes por socket demuestra menor latencia?

No. Faltan costos de memoria, sincronización, preparación, planificación y trabajo de aplicación.

14. ¿Cómo se recupera la ranura después de un fallo?

El laboratorio abandona la región completa, termina y recoge al hijo y después destruye. No repara una cola de larga vida.

15. ¿Qué distingue el siguiente proyecto?

Se atenderán varios clientes por socket Unix con epoll, manteniendo framing, límites y estado independiente por conexión.

Para practicar y ampliar

  1. Completa la ficha de decisión para un pipeline de shell y un servicio local.
  2. Explica qué opciones se descartan al exigir comunicación entre máquinas.
  3. Ejecuta los dos modos y recalcula todas las columnas del CSV.
  4. Fuerza transferencias reales de un byte y errores EINTR.
  5. Corrompe el cuerpo y comprueba que no se publica éxito.
  6. Altera offset, longitud, secuencia y ACK en copias de prueba.
  7. Omite una publicación de listo y verifica timeout y recogida.
  8. Diseña varias ranuras con generaciones y propietario por fase.
  9. Propón una notificación con eventfd que no sustituya la cola autoritativa.
  10. Adapta la espera de señales a otra plataforma y documenta sus límites.
  11. Agrega mediciones siguiendo el tema 44 sin retirar validación.
  12. Justifica cuándo conservarías todo el intercambio por socket.
Próximo paso

El tema 49 inicia el proyecto de un servidor local con epoll: múltiples clientes por socket Unix, mensajes enmarcados y límites de búfer. La elección del mecanismo queda acompañada por un contrato verificable de cada conexión.