← Comunicación entre ProcesosBloque 9 · Multiplexación y bucles de eventos · Tema 40 de 52

Tema 40

Level-triggered y edge-triggered

Vas a observar por qué una lectura parcial puede volver a notificarse en level-triggered y dejar trabajo sin otro aviso garantizado en edge-triggered. Aprenderás a drenar hasta EAGAIN, conservar escrituras pendientes y repartir turnos mediante una cola de trabajo local. Un laboratorio completo aplicará contrapresión con memoria acotada y reanudará la lectura sin depender de una nueva llegada de datos.

1. Qué cambia respecto del tema 39

El tema 39 utilizó el modo predeterminado de epoll: level-triggered, abreviado LT. El servidor podía realizar una sola lectura por evento porque la condición pendiente podía notificarse otra vez.

Edge-triggered, abreviado ET, se solicita agregando EPOLLET al registro. Cambia la forma de programar el trabajo pendiente: después de una lectura parcial no se debe dormir suponiendo que el núcleo repetirá el aviso solo porque todavía quedan bytes.

En ET, una conexión puede tener trabajo conocido aunque no llegue otro evento. Antes de dormir, la aplicación debe haber llegado a EAGAIN, EOF, error o una pausa deliberada con reanudación programada.

LaboratorioObjetivoQué se verifica
modos40.c.Comparar una lectura parcial en LT y ET.El resto permanece disponible aunque ET no repita el aviso en el ensayo.
flujo40.c.Transportar y transformar un MiB con ET.Contenido, EOF, cola acotada, turnos y reanudación.

Ambos usan socketpair y un único proceso para controlar el orden sin pausas artificiales. El segundo representa cliente y servidor como dos participantes del bucle, conserva una cola de respuesta y frena temporalmente al consumidor para provocar presión real en los sockets.

2. Condición persistente y notificación de cambio

AspectoLevel-triggeredEdge-triggered
Registro.Modo predeterminado.Se agrega EPOLLET.
Quedan datos después de leer un prefijo.La condición puede volver a notificarse.No se debe depender de otro aviso por ese resto.
Trabajo por turno.Puede limitarse y volver a esperar por la condición persistente.Si se limita antes de agotar, se conserva como trabajo local listo.
EAGAIN.No hay avance ahora.Permite dejar de considerar lista esa dirección y esperar un nuevo aviso.
Protocolo.La aplicación reconoce sus mensajes.La aplicación sigue reconociendo sus mensajes.

Una explicación útil de ET es «notificación de cambio», pero no significa «exactamente un evento por byte» ni «un evento por llamada send». Se pueden reunir condiciones y también aparecer avisos al registrar o modificar intereses. La regla de programación es comprobar la E/S real, no contar supuestos flancos físicos.

La comparación y el ejemplo de datos que quedan sin consumir se describen en epoll(7). ET tampoco activa O_NONBLOCK: cada socket debe configurarse por separado.

3. El atasco después de una lectura parcial

secuencia controlada · nadie vuelve a enviar ni cambia el registro
1. El emisor deja ocho bytes en el socket.
2. epoll_wait devuelve EPOLLIN.
3. El receptor retira solo dos bytes.
4. Permanecen seis bytes, pero no se conserva una tarea local.
5. El receptor vuelve a esperar.

LT: la condicion de lectura sigue preparada.
ET: no debe suponerse otra notificacion por esos seis bytes.

Si el emisor espera una respuesta y no envía nada más, nadie tiene motivos para cambiar la situación. Los datos existen, pero el programa dejó de atenderlos. Agregar un timeout que despierte cada tanto puede ocultar el error sin corregir la planificación.

En este caso la operación que resuelve el problema es seguir leyendo, no solicitar otra vez los mismos bytes al emisor. Al llegar a EAGAIN el receptor sabe que agotó lo que podía retirar en ese momento.

4. Laboratorio completo para comparar LT y ET

Guarda modos40.c. Precarga ocho bytes en un par vacío, registra el receptor en LT o ET y retira dos. Una segunda consulta de timeout cero evita que el ensayo se cuelgue. Después se drena el resto y se verifica el contenido completo.

modos40.c · mismos datos y distinto modo de notificación
#define _GNU_SOURCE
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int consultar40(int epfd, struct epoll_event *ev)
{
    int n;
    do { n = epoll_wait(epfd, ev, 1, 0); } while (n == -1 && errno == EINTR);
    return n;
}

static int probar40(int et)
{
    int par[2], epfd = -1, fallo = 1;
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                   0, par) == -1) { perror("socketpair"); return -1; }
    epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) { perror("epoll_create1"); goto fin; }
    ssize_t n;
    do { n = send(par[0], "abcdefgh", 8, MSG_NOSIGNAL); }
    while (n == -1 && errno == EINTR);
    if (n != 8) { fprintf(stderr, "Precarga incompleta\n"); goto fin; }
    struct epoll_event ev = { .events = EPOLLIN | (et ? EPOLLET : 0), .data.u32 = 1 };
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, par[1], &ev) == -1) {
        perror("ADD"); goto fin;
    }
    if (consultar40(epfd, &ev) != 1 || !(ev.events & EPOLLIN)) goto fin;
    char datos[8];
    do { n = recv(par[1], datos, 2, 0); } while (n == -1 && errno == EINTR);
    if (n != 2) goto fin;
    int segundo = consultar40(epfd, &ev);
    if ((!et && segundo != 1) || (et && segundo != 0)) {
        fprintf(stderr, "Resultado inesperado en el ensayo controlado\n"); goto fin;
    }
    size_t usados = 2;
    for (;;) {
        char bloque[2];
        n = recv(par[1], bloque, sizeof bloque, 0);
        if (n > 0) {
            if ((size_t)n > sizeof datos - usados) goto fin;
            memcpy(datos + usados, bloque, (size_t)n);
            usados += (size_t)n;
        } else if (n == -1 && errno == EINTR) continue;
        else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) break;
        else goto fin;
    }
    if (usados != 8 || memcmp(datos, "abcdefgh", 8) != 0) goto fin;
    printf("%s: segunda consulta=%d; ocho bytes verificados; final EAGAIN\n",
           et ? "ET" : "LT", segundo);
    fallo = 0;
fin:
    if (epfd != -1 && close(epfd) == -1) fallo = 1;
    if (close(par[0]) == -1) fallo = 1;
    if (close(par[1]) == -1) fallo = 1;
    return fallo ? -1 : 0;
}

int main(void)
{
    if (probar40(0) == -1 || probar40(1) == -1) return EXIT_FAILURE;
    return fflush(stdout) == EOF ? EXIT_FAILURE : EXIT_SUCCESS;
}

El emisor permanece abierto y no realiza más envíos entre las dos consultas. Tampoco se modifica el registro ni existe otro lector. Esas condiciones hacen reproducible el contraste; no pretenden describir todas las fuentes posibles de otra notificación en una aplicación concurrente.

5. Compilar y reproducir la diferencia

Bash en Linux · comparación sin esperar indefinidamente
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 modos40.c -o modos40
$ timeout 5s ./modos40
LT: segunda consulta=1; ocho bytes verificados; final EAGAIN
ET: segunda consulta=0; ocho bytes verificados; final EAGAIN

El cero de la consulta ET no indica EOF ni desaparición de los seis bytes. El programa los retira directamente y los compara. La recepción final retorna EAGAIN porque el emisor sigue abierto y ya no quedan datos.

La precarga exige aceptar ocho bytes en un par vacío para iniciar este experimento. Es una preparación diminuta de laboratorio, no una función general de envío pendiente. El segundo programa sí administra avances parciales durante toda la transferencia.

6. Drenar hasta EAGAIN, EOF o error

regla de recepción · cada retorno tiene una consecuencia distinta
recv > 0: incorporar bytes y continuar mientras exista capacidad
EINTR:    conservar progreso y aplicar la politica de reintento
EAGAIN:   no queda avance inmediato; esperar un aviso futuro
recv == 0: marcar EOF y retirar el trabajo de entrada terminado
otro error: fallar o cerrar segun el contrato

presupuesto agotado antes de EAGAIN:
    conservar la direccion como lista y reencolarla localmente

cola de salida llena:
    pausar lectura y programar una reanudacion al liberar espacio

Drenar significa consumir lo disponible para esa dirección, no esperar a completar a toda costa una petición de tamaño desconocido. Las funciones de recepción deben mantener límites y validar el protocolo aunque el interlocutor siga produciendo.

No interpretes un retorno corto como garantía universal de haber drenado cualquier recurso. Estos ejemplos de STREAM usan EAGAIN como punto explícito para dejar de intentar. Las reglas de recepción se consultan en recv(2).

EOF y los errores son resultados terminales que también detienen el drenaje. Mantener una tarea local de EOF ya procesado puede producir un bucle activo aunque no haya nuevos eventos.

7. Escrituras pendientes e intento inmediato

La capacidad de escritura y la existencia de una respuesta son condiciones distintas. Un socket pudo estar preparado para escribir cuando todavía no había datos de aplicación que enviar. Si esos datos se generan después, no conviene esperar pasivamente otro flanco de capacidad.

  1. Al producir salida, programar un intento. La cola pasa de vacía a no vacía y la aplicación tiene trabajo nuevo.
  2. Avanzar por los retornos positivos. Conservar exactamente el sufijo que send todavía no aceptó.
  3. Al obtener EAGAIN, esperar capacidad. El interés EPOLLOUT permanece mientras haya bytes pendientes.
  4. Al vaciar la salida, retirar ese interés. No hay trabajo de escritura que justifique otra tarea local.

Un presupuesto que termina después de un retorno positivo conserva la tarea lista en la cola local. EAGAIN, en cambio, desmarca esa disponibilidad conocida hasta un aviso nuevo o hasta una decisión explícita que vuelva a probar la operación.

send completo no confirma que el proceso remoto utilizó el resultado. El laboratorio verificará la recepción completa y EOF en el cliente. Las reglas de envíos parciales y MSG_NOSIGNAL se documentan en send(2).

8. Presupuestos y cola de trabajo listo

Un emisor continuo puede mantener ocupada una rutina que drena sin límite. Para repartir atención se asigna un presupuesto de llamadas o bytes y se conserva el trabajo que todavía no llegó a EAGAIN.

Eventos del núcleo y cola local alimentan los turnos de trabajoUn evento agrega una tarea lista. Se procesa con presupuesto; al agotarlo se reencola si todavía se puede avanzar. Al encontrar EAGAIN se espera al núcleo. Una pausa por capacidad se reanuda localmente al bajar la cola. Aviso de epollo reanudación localCola de tareas listassin duplicadosTurno acotadocon progreso guardadoPresupuesto: reencolar. EAGAIN: esperar. EOF: terminar entrada.No dormir mientras quede una tarea local que puede avanzar.
Los resultados del núcleo no son la única fuente de trabajo listo de la aplicación.

Una marca «ya en cola» evita agregar muchas copias de la misma tarea por eventos combinados o repetidos. Al retirarla para procesar se limpia la marca; si continúa lista, vuelve al final para ceder turno a las otras.

Con trabajo local, la siguiente consulta puede usar timeout cero para incorporar eventos adicionales sin dormir. Cuando no hay tareas listas, se permite una espera positiva. Hacer consultas de cero en una cola que solo contiene tareas bloqueadas sería otro sondeo activo: hay que retirar esas tareas al encontrar EAGAIN.

9. Contrapresión y reanudación de lectura

Si el servidor transforma entrada más rápido de lo que puede enviar respuestas, su cola de salida crece. El ejemplo usa un anillo de 2048 bytes: al llenarlo pausa la lectura y retira EPOLLIN y EPOLLRDHUP del interés de esa fase.

Cuando el envío reduce la cola hasta 512 bytes, se vuelve a habilitar la lectura y se programa un intento local inmediato. Los bytes pueden llevar tiempo esperando en el socket; no hace falta una nueva escritura remota para justificar ese intento.

UmbralAcciónEstado que se conserva
Cola llega a 2048 bytes.Pausar recepción de más cuerpo.Contadores, datos del anillo y conocimiento de entrada pendiente.
Cola baja a 512 bytes o menos.Reactivar interés y probar lectura localmente.La petición continúa desde su posición anterior.
send retorna EAGAIN.Esperar capacidad de salida.El anillo no descarta el sufijo.

La separación de umbrales evita alternar pausa y reanudación por cada byte. EPOLL_CTL_MOD puede reevaluar disponibilidad al cambiar intereses, pero el diseño no depende exclusivamente de que ese cambio produzca el aviso que necesita. La actualización de máscaras se documenta en epoll_ctl(2).

10. Contrato del laboratorio de flujo

El cliente genera un MiB binario mediante un patrón por posición, termina el envío y recibe la transformación ASCII. El servidor transforma fragmentos a medida que llegan y conserva las respuestas en su anillo. Ambos extremos son no bloqueantes y se registran con EPOLLET.

Para provocar presión sin depender de pausas temporales, el controlador no habilita inicialmente la recepción del cliente. La habilita cuando el servidor pausa por cola llena o cuando el cliente ya aceptó toda su petición. Esta última condición permite que también terminen variantes con entradas pequeñas.

Los dos participantes comparten una cola de tareas de capacidad dos, sin duplicados, y cada turno hace hasta ocho llamadas de datos. La disponibilidad conocida de lectura o escritura se conserva al agotar ese presupuesto y se borra cuando la operación retorna EAGAIN.

El tamaño total pertenece al contrato de este laboratorio; no es un enmarcado general. No se publica una ruta ni se aceptan clientes. La identidad de los dos participantes es estable durante toda la ejecución, por lo que el ejemplo no necesita reutilizar posiciones ni generaciones.

11. Programa completo con cola acotada

Guarda flujo40.c junto a plazo37.h del tema 37. El resto es autónomo. El plazo de diez segundos se revisa incluso cuando hay trabajo local; no se renueva por actividad.

flujo40.c · EPOLLET, anillo de respuesta y turnos que no pierden trabajo
#define _GNU_SOURCE
#include "plazo37.h"
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>

#define TOTAL40 (1024u * 1024u)
#define CAP40 2048u
#define BAJO40 512u
#define BLOQUE40 512u
#define TURNO40 8u

enum { CLIENTE40, SERVIDOR40 };
struct tarea40 {
    int lectura, escritura, eof, fin_envio;
    uint32_t mascara;
};
struct cola40 {
    unsigned items[2], cabeza, usados;
    int dentro[2];
};
struct flujo40 {
    int epfd, fd[2], consumo;
    struct tarea40 tarea[2];
    struct cola40 listas;
    unsigned char anillo[CAP40];
    size_t cabeza, usados, enviados, recibidos, procesados;
    int pausada;
    size_t pausas, reanudaciones, esperas, turnos;
};

static unsigned char dato40(size_t i) { return (unsigned char)(i % 251u); }
static unsigned char mayus40(unsigned char b)
{
    return b >= 'a' && b <= 'z' ? (unsigned char)(b - 'a' + 'A') : b;
}
static int espera40(void) { return errno == EAGAIN || errno == EWOULDBLOCK; }

static void encolar40(struct cola40 *q, unsigned quien)
{
    if (q->dentro[quien]) return;
    q->items[(q->cabeza + q->usados) % 2u] = quien;
    ++q->usados; q->dentro[quien] = 1;
}
static unsigned sacar40(struct cola40 *q)
{
    unsigned quien = q->items[q->cabeza];
    q->cabeza = (q->cabeza + 1u) % 2u;
    --q->usados; q->dentro[quien] = 0;
    return quien;
}

static int lista40(const struct flujo40 *f, unsigned quien)
{
    const struct tarea40 *t = &f->tarea[quien];
    if (quien == CLIENTE40)
        return (f->consumo && !t->eof && t->lectura) ||
               (f->enviados != TOTAL40 && t->escritura);
    return (!t->eof && !f->pausada && t->lectura) ||
           (f->usados && t->escritura);
}

static int intereses40(struct flujo40 *f, unsigned quien, int alta)
{
    struct tarea40 *t = &f->tarea[quien];
    uint32_t mask = EPOLLET;
    if (quien == CLIENTE40) {
        if (f->consumo && !t->eof) mask |= EPOLLIN | EPOLLRDHUP;
        if (f->enviados != TOTAL40) mask |= EPOLLOUT;
    } else {
        if (!f->pausada && !t->eof) mask |= EPOLLIN | EPOLLRDHUP;
        if (f->usados) mask |= EPOLLOUT;
    }
    if (!alta && mask == t->mascara) return 0;
    struct epoll_event ev = { .events = mask, .data.u32 = quien + 1u };
    if (epoll_ctl(f->epfd, alta ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
                  f->fd[quien], &ev) == -1) {
        perror("epoll_ctl"); return -1;
    }
    t->mascara = mask;
    return 0;
}

static int cliente40(struct flujo40 *f)
{
    struct tarea40 *t = &f->tarea[CLIENTE40];
    unsigned char bloque[BLOQUE40];
    for (unsigned k = 0; k < TURNO40; ++k) {
        if (f->consumo && t->lectura && !t->eof) {
            ssize_t n = recv(f->fd[CLIENTE40], bloque, sizeof bloque, 0);
            if (n > 0) {
                if ((size_t)n > TOTAL40 - f->recibidos) {
                    fprintf(stderr, "Respuesta excesiva\n"); return -1;
                }
                for (size_t i = 0; i < (size_t)n; ++i)
                    if (bloque[i] != mayus40(dato40(f->recibidos + i))) {
                        fprintf(stderr, "Respuesta incorrecta\n"); return -1;
                    }
                f->recibidos += (size_t)n;
            } else if (n == 0) {
                if (f->recibidos != TOTAL40) {
                    fprintf(stderr, "Respuesta truncada\n"); return -1;
                }
                t->eof = 1; t->lectura = 0;
            } else if (errno == EINTR) continue;
            else if (espera40()) { t->lectura = 0; ++f->esperas; }
            else { perror("recv cliente"); return -1; }
        } else if (t->escritura && f->enviados != TOTAL40) {
            size_t pedido = TOTAL40 - f->enviados;
            if (pedido > sizeof bloque) pedido = sizeof bloque;
            for (size_t i = 0; i < pedido; ++i) bloque[i] = dato40(f->enviados + i);
            ssize_t n = send(f->fd[CLIENTE40], bloque, pedido, MSG_NOSIGNAL);
            if (n > 0) f->enviados += (size_t)n;
            else if (n == -1 && errno == EINTR) continue;
            else if (n == -1 && espera40()) { t->escritura = 0; ++f->esperas; }
            else { if (n == 0) errno = EIO; perror("send cliente"); return -1; }
        } else break;
    }
    if (f->enviados == TOTAL40 && !t->fin_envio) {
        if (shutdown(f->fd[CLIENTE40], SHUT_WR) == -1) {
            perror("shutdown cliente"); return -1;
        }
        t->fin_envio = 1;
    }
    return 0;
}

static int servidor40(struct flujo40 *f)
{
    struct tarea40 *t = &f->tarea[SERVIDOR40];
    for (unsigned k = 0; k < TURNO40; ++k) {
        if (t->escritura && f->usados) {
            size_t pedido = CAP40 - f->cabeza;
            if (pedido > f->usados) pedido = f->usados;
            if (pedido > BLOQUE40) pedido = BLOQUE40;
            ssize_t n = send(f->fd[SERVIDOR40], f->anillo + f->cabeza,
                             pedido, MSG_NOSIGNAL);
            if (n > 0) {
                f->cabeza = (f->cabeza + (size_t)n) % CAP40;
                f->usados -= (size_t)n;
                if (f->pausada && f->usados <= BAJO40) {
                    f->pausada = 0; t->lectura = 1; ++f->reanudaciones;
                }
            } else if (n == -1 && errno == EINTR) continue;
            else if (n == -1 && espera40()) { t->escritura = 0; ++f->esperas; }
            else { if (n == 0) errno = EIO; perror("send servidor"); return -1; }
        } else if (t->lectura && !t->eof && !f->pausada) {
            size_t cola = (f->cabeza + f->usados) % CAP40;
            size_t pedido = CAP40 - f->usados;
            if (pedido > CAP40 - cola) pedido = CAP40 - cola;
            if (pedido > BLOQUE40) pedido = BLOQUE40;
            ssize_t n = recv(f->fd[SERVIDOR40], f->anillo + cola, pedido, 0);
            if (n > 0) {
                if ((size_t)n > TOTAL40 - f->procesados) {
                    fprintf(stderr, "Entrada excesiva\n"); return -1;
                }
                for (size_t i = 0; i < (size_t)n; ++i)
                    f->anillo[cola + i] = mayus40(f->anillo[cola + i]);
                f->usados += (size_t)n; f->procesados += (size_t)n;
                t->escritura = 1; /* Salida nueva: intentar sin esperar otro flanco. */
                if (f->usados == CAP40) { f->pausada = 1; ++f->pausas; }
            } else if (n == 0) {
                if (f->procesados != TOTAL40) {
                    fprintf(stderr, "Peticion truncada\n"); return -1;
                }
                t->eof = 1; t->lectura = 0;
            } else if (errno == EINTR) continue;
            else if (espera40()) { t->lectura = 0; ++f->esperas; }
            else { perror("recv servidor"); return -1; }
        } else break;
    }
    if (t->eof && f->usados == 0 && !t->fin_envio) {
        if (shutdown(f->fd[SERVIDOR40], SHUT_WR) == -1) {
            perror("shutdown servidor"); return -1;
        }
        t->fin_envio = 1;
    }
    return 0;
}

int main(void)
{
    struct flujo40 f = { .epfd = -1, .fd = { -1, -1 } };
    int fallo = 1;
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                   0, f.fd) == -1) { perror("socketpair"); return EXIT_FAILURE; }
    f.epfd = epoll_create1(EPOLL_CLOEXEC);
    if (f.epfd == -1) { perror("epoll_create1"); goto fin; }
    int capacidad = 4096;
    for (unsigned i = 0; i < 2; ++i) {
        if (setsockopt(f.fd[i], SOL_SOCKET, SO_SNDBUF,
                       &capacidad, sizeof capacidad) == -1) {
            perror("SO_SNDBUF"); goto fin;
        }
        f.tarea[i].lectura = f.tarea[i].escritura = 1;
        if (intereses40(&f, i, 1) == -1) goto fin;
        if (lista40(&f, i)) encolar40(&f.listas, i);
    }
    struct timespec limite;
    if (fijar_plazo37(&limite, 10) == -1) goto fin;
    while (!f.tarea[CLIENTE40].eof) {
        struct timeval tv;
        int r = restante37(&limite, &tv);
        if (r == -1) goto fin;
        if (r == 0) { fprintf(stderr, "Plazo global agotado\n"); goto fin; }
        int ms = tv.tv_sec >= 1 ? 1000 : (int)((tv.tv_usec + 999) / 1000);
        if (f.listas.usados) ms = 0;
        struct epoll_event ev[2];
        int n = epoll_wait(f.epfd, ev, 2, ms);
        if (n == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait"); goto fin;
        }
        for (int k = 0; k < n; ++k) {
            if (ev[k].data.u32 < 1 || ev[k].data.u32 > 2) {
                fprintf(stderr, "Identidad de evento invalida\n"); goto fin;
            }
            unsigned quien = ev[k].data.u32 - 1u;
            if (ev[k].events & EPOLLERR) {
                fprintf(stderr, "Error de socket en el laboratorio\n"); goto fin;
            }
            if (ev[k].events & (EPOLLIN | EPOLLRDHUP | EPOLLHUP))
                f.tarea[quien].lectura = 1;
            if (ev[k].events & (EPOLLOUT | EPOLLHUP))
                f.tarea[quien].escritura = 1;
            if (lista40(&f, quien)) encolar40(&f.listas, quien);
        }
        if (f.listas.usados) {
            unsigned quien = sacar40(&f.listas);
            ++f.turnos;
            int paso = quien == CLIENTE40 ? cliente40(&f) : servidor40(&f);
            if (paso == -1) goto fin;
            if (lista40(&f, quien)) encolar40(&f.listas, quien);
        }
        if (!f.consumo && (f.pausas || f.enviados == TOTAL40)) {
            f.consumo = 1; f.tarea[CLIENTE40].lectura = 1;
            encolar40(&f.listas, CLIENTE40);
        }
        for (unsigned i = 0; i < 2; ++i)
            if (intereses40(&f, i, 0) == -1) goto fin;
    }
    if (f.enviados != TOTAL40 || f.procesados != TOTAL40 ||
        f.recibidos != TOTAL40 || f.usados != 0 ||
        !f.tarea[CLIENTE40].fin_envio || !f.tarea[SERVIDOR40].fin_envio) {
        fprintf(stderr, "Flujo incompleto\n"); goto fin;
    }
    printf("Flujo ET verificado: %zu bytes y EOF\n", f.recibidos);
    printf("Pausas: %zu; reanudaciones: %zu; EAGAIN: %zu; turnos: %zu\n",
           f.pausas, f.reanudaciones, f.esperas, f.turnos);
    if (fflush(stdout) == EOF) goto fin;
    fallo = 0;
fin:
    /* No hay alias: cerrar ambas referencias retira sus registros. */
    for (unsigned i = 0; i < 2; ++i)
        if (f.fd[i] != -1 && close(f.fd[i]) == -1) fallo = 1;
    if (f.epfd != -1 && close(f.epfd) == -1) fallo = 1;
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}

Los bits lectura y escritura son conocimiento de trabajo que todavía puede intentarse, no una garantía de éxito. Se conservan al consumir el turno y se borran ante EAGAIN. lista40 excluye las direcciones pausadas, terminadas o sin salida para no reencolar tareas que no tienen nada útil que hacer.

El anillo conserva el sufijo aunque send acepte solo una parte. La entrada del cliente se genera por posición: si un envío es parcial, el siguiente bloque se reconstruye desde enviados y produce exactamente el mismo sufijo. En una aplicación con datos externos mutables sería necesario conservar su búfer real y su propiedad.

La cola local admite dos tareas porque solo existen dos identidades y dentro impide duplicados. No se crean ni reutilizan conexiones durante la ejecución. La limpieza cierra las únicas referencias a los sockets y después la instancia; un servidor con alias debe conservar la política explícita de retirada del tema anterior.

12. Ejecutar y verificar todos los bytes

Bash en Linux · guardar la cabecera de plazos y compilar
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 flujo40.c -o flujo40
$ timeout 15s ./flujo40
Flujo ET verificado: 1048576 bytes y EOF
Pausas: P; reanudaciones: R; EAGAIN: E; turnos: T

P, R, E y T representan los contadores numéricos de tu ejecución, no letras impresas. El consumidor retenido y los búferes pequeños están pensados para mostrar presión; los valores exactos dependen del sistema y de los fragmentos procesados.

El contrato exige verificar un MiB, el contenido transformado y el EOF de respuesta. El patrón contiene NUL y otros bytes no textuales. La cola de aplicación nunca debe superar 2048 bytes; los búferes del núcleo tienen su propia contabilidad.

Un código 124 de timeout corresponde al límite externo de la herramienta. No es un resultado correcto del protocolo. El plazo interno se revisa en el bucle y no garantiza interrumpir cualquier operación de stdio que se agregue después.

13. Adaptar aceptación, cierres e identidad

La escucha también necesita drenaje o reanudación

En un servidor ET, aceptar una conexión y volver a dormir puede dejar otras en la cola pendiente. Se continúa hasta EAGAIN o hasta un presupuesto o límite de capacidad que conserve trabajo local por reanudar.

esquema · aceptación con límites y propiedad explícitos
mientras haya capacidad y presupuesto:
    fd = accept4(..., SOCK_NONBLOCK | SOCK_CLOEXEC)
    si fd valido: registrar sesion y continuar
    si EINTR: revisar politica y conservar turno pendiente
    si EAGAIN: escucha agotada por ahora; esperar otro aviso
    otro error: aplicar politica de recursos

sin capacidad: retirar o pausar escucha
al liberar capacidad: reactivar y programar intento de aceptar
presupuesto agotado: reencolar escucha, no depender de otra conexion nueva

El servidor39 no debe modificarse agregando únicamente EPOLLET: lee y acepta una sola vez por aviso. Hay que adaptar también el envío inmediato, las tareas locales y la reanudación tras pausas. La API de espera sigue devolviendo solo un lote; la planificación local es de la aplicación. Véase epoll_wait(2).

Cierres y trabajos pendientes

RDHUP o HUP no permiten descartar los bytes ya recibidos por el transporte. Se drena la entrada según el contrato, se decide qué salida sigue siendo válida y se retiran las tareas terminales. Un error fatal cancela sus tareas y libera sus recursos.

Las tareas locales también necesitan identidad con generación si las posiciones se reutilizan. Validar solo los eventos del núcleo no basta: un elemento viejo de tu propia cola puede pertenecer a una sesión retirada. Si se usan punteros, su vida útil debe cubrir ambas fuentes de trabajo.

14. Elegir LT, ET y propiedad del trabajo

LT suele ofrecer una base sencilla para conservar corrección y limitar turnos. ET puede reducir ciertas repeticiones de avisos, pero exige que la aplicación registre correctamente todo el trabajo que dejó a medias y cada condición de reanudación.

No hay una promesa universal de que ET acelere cualquier servidor. Importan los tamaños de mensajes, cuántas conexiones están activas, la estrategia de colas, la cantidad de llamadas de control y el procesamiento de aplicación. Compara cargas representativas y verifica los resultados antes de comparar tiempos.

EPOLLONESHOT es una opción diferente: deshabilita el registro después de una notificación hasta rearmarlo con MOD. No es sinónimo de ET ni una solución automática para repartir una conexión entre hilos. Requiere su propia política de propiedad y rearme.

Los ejemplos utilizan un solo hilo, dos roles estables y ninguna escritura concurrente sobre sus estados. Un diseño con trabajadores necesita decidir quién puede encolar, consumir, modificar intereses y cerrar cada sesión.

15. Explorar avisos, turnos y contrapresión

El modelo representa una dirección de entrada y una cola de respuesta de cuatro bytes. Cada turno recibe o envía hasta dos bytes. Puedes comparar LT y ET, conservar trabajo local y pausar la lectura cuando se llena la respuesta.

Entrada pendiente en el transporte0 bytes

Respuesta en aplicación (máximo 4)0 bytes

Trabajo local de lecturaNo programado

Interés de lecturaActivo

Última consultaSin llamada

Último turnoNinguno

Un turno parcial conserva trabajo local; EAGAIN lo desmarca.

En ET, entrega cuatro bytes, consulta y lee dos. Olvida el trabajo local y consulta otra vez: el modelo no produce otro aviso por los dos restantes. Programar lectura local permite recuperarlos. El botón de olvido representa el error que se busca diagnosticar.

Para observar contrapresión, llena la cola de respuesta y deja entrada pendiente. La lectura se pausa; un envío que reduzca la cola hasta dos bytes la reactiva y programa trabajo local. El umbral didáctico es menor que en el programa C.

El simulador usa una regla simplificada de aviso ET al pasar la entrada de vacía a no vacía. No reproduce todos los avisos posibles del núcleo, reevaluaciones por MOD, EOF, fallos ni capacidad de los sockets de salida. El experimento C anterior establece las condiciones reales de comparación.

16. Pruebas y diagnóstico

Estados y resultados exigidos

  1. Comparación controlada. modos40 debe recuperar los ocho bytes en ambos modos y observar el contraste de la segunda consulta.
  2. Contenido completo. flujo40 debe verificar todos los bytes transformados y el EOF final.
  3. Presupuesto mínimo. Reduce TURNO40 a uno y comprueba que la cola local permite continuar sin depender de nuevos avisos.
  4. Presión real. Observa pausas y reanudaciones, y comprueba que usados nunca supere CAP40.
  5. Entrada pequeña. Reduce TOTAL40 para verificar la habilitación del consumidor aunque no se llegue a llenar el anillo.

Fragmentación, señales y errores

Limita llamadas reales de send y recv a un byte e introduce EINTR antes de algunas. Los contadores deben conservar avances. En un entorno ET no basta con inyectar EAGAIN arbitrario y luego esperar un flanco que el núcleo nunca tuvo motivos para generar: un controlador que pruebe ese caso debe modelar también la recuperación de disponibilidad.

Al alcanzar EAGAIN real por una cola vacía o un socket lleno, comprueba que esa dirección deja de reencolarse hasta una condición nueva. Si hay trabajo positivo después de agotar el presupuesto, debe permanecer en la cola local sin duplicarse.

Altera un byte de la respuesta manteniendo intacto el patrón esperado: el cliente debe fallar. Termina el envío de petición antes de TOTAL40: el servidor debe informar truncamiento. Haz fallar un MOD y comprueba salida de error y cierre de ambas referencias y de epoll.

Para ensayar el plazo, un controlador puede retener toda condición que permitiría progresar y usar una copia con presupuesto pequeño. El programa debe terminar por plazo aunque haya despertares o tareas locales; el límite no se renueva después de EINTR.

Bash en Linux · observar eventos y transferencias
$ strace -s 32 -e trace=epoll_ctl,epoll_wait,epoll_pwait,sendto,recvfrom,shutdown,close ./modos40
$ strace -c -e trace=epoll_ctl,epoll_wait,epoll_pwait,sendto,recvfrom ./flujo40

Relaciona MOD con cambios de fase, pausa y cola vacía o no vacía. Un gran número de consultas con cero no demuestra por sí solo un fallo si cada una acompaña trabajo local útil; sí es sospechoso si los turnos no transfieren datos ni cambian estado y repiten EAGAIN.

Las pruebas de tiempo deben admitir retrasos de planificación. Un controlador externo impone su propio límite, recoge los procesos y no deja recursos de ensayo abiertos si falla una comprobación.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Agregar EPOLLET sin cambiar las rutinas.Puede quedar entrada o aceptación pendiente sin atender.Drenaje o reanudación local explícita.
Esperar otro aviso después de leer un prefijo.Atasco aunque existan bytes.Conservar la dirección lista hasta EAGAIN o pausa gestionada.
Confundir turno agotado con EAGAIN.Se pierde trabajo todavía disponible.Reencolar al agotar presupuesto; desmarcar al no poder avanzar.
Reencolar siempre después de EAGAIN.Sondeo activo sin progreso.Esperar una condición nueva.
Esperar EPOLLOUT antes de probar salida recién creada.La capacidad pudo existir antes de producir la respuesta.Programar un intento inmediato y conservar el sufijo.
Leer más aunque la cola esté llena.Desbordamiento o memoria creciente.Acotar la cola y aplicar contrapresión.
Reactivar interés y olvidar el intento local.La recuperación depende de un aviso que se asumió sin verificar.Reanudar explícitamente desde el estado guardado.
Agregar varias copias de la misma tarea.Turnos repetidos y estado difícil de controlar.Marca de pertenencia a la cola.
Aceptar solo uno de varios clientes en ET.Conexiones pendientes pueden quedar sin atender.Drenar aceptación o conservarla como tarea local.
Dejar tareas de una sesión cerrada.Un trabajo viejo puede tocar otra conexión.Retirada, identidad con generación y validación local.
Suponer un evento por send.Se confunden avisos con mensajes o finalizaciones.Interpretar el flujo con el protocolo y los retornos reales.
Usar ET como sinónimo de mayor rendimiento.Se ignoran complejidad y costo del trabajo total.Comparar corrección y cargas representativas.

18. Resumen

19. Preguntas de repaso y práctica

Razona con tres fuentes de estado: condiciones del transporte, tareas locales y límites de las colas de aplicación.

1. ¿Cómo se activa ET?

Agregando EPOLLET a la máscara del registro. Los sockets deben configurarse no bloqueantes por separado.

2. ¿El cero de la segunda consulta ET significa EOF?

No. Solo indica que la consulta no devolvió otro evento. El laboratorio demuestra que todavía había seis bytes por leer.

3. ¿Un evento representa una llamada send remota?

No. Los avisos pueden reunir condiciones y no definen límites de mensajes.

4. ¿Qué diferencia hay entre agotar el presupuesto y obtener EAGAIN?

El presupuesto deja trabajo potencialmente disponible y se reencola. EAGAIN indica que esa llamada no puede avanzar ahora y se espera una condición nueva.

5. ¿Por qué se necesita una marca de pertenencia a la cola?

Para que eventos o reanudaciones no acumulen varias copias de una misma tarea lista.

6. ¿Se puede dormir mientras queda trabajo local listo?

No debería bloquearse la espera. Se puede consultar eventos sin dormir y seguir repartiendo turnos.

7. ¿Por qué se intenta enviar al generar una respuesta?

Porque la capacidad de escritura pudo estar disponible antes de que existieran esos datos y no conviene depender de otro aviso para empezar.

8. ¿Qué se conserva después de un envío parcial?

El sufijo no aceptado y el estado necesario para reconstruirlo o mantener su búfer válido.

9. ¿Qué hace el servidor cuando llena el anillo?

Pausa la lectura y retira sus intereses de entrada, sin descartar el contenido pendiente ni perder los contadores.

10. ¿Cómo se reanuda tras liberar capacidad?

Se reactiva el interés y se programa una lectura local. No se exige una nueva escritura remota.

11. ¿Por qué hay dos umbrales?

Para evitar alternar pausa y reanudación con cada pequeño cambio de ocupación.

12. ¿Qué debe hacer una escucha ET con varias conexiones pendientes?

Aceptar hasta EAGAIN o conservar trabajo local si termina antes por presupuesto o capacidad.

13. ¿Basta con validar generaciones en eventos del núcleo?

No. Las tareas de una cola local también pueden quedar obsoletas al retirar y reutilizar una sesión.

14. ¿EPOLLONESHOT es otro nombre para ET?

No. Es una opción de desactivación tras notificar que necesita rearme explícito y una política de propiedad del trabajo.

15. ¿ET siempre mejora el rendimiento?

No. La mejora depende de la carga, los avisos, las llamadas y el trabajo de aplicación. Hay que medir conservando primero la corrección.

Para practicar y ampliar

  1. Ejecuta modos40 y explica cómo se recuperan los datos después de una consulta ET sin eventos.
  2. Reduce TURNO40 a uno y verifica el flujo completo.
  3. Limita send y recv reales a un byte e inyecta EINTR sin perder avances.
  4. Prueba distintos tamaños totales, incluidos algunos menores que la cola.
  5. Registra la ocupación máxima y demuestra que no supera CAP40.
  6. Altera una respuesta y termina una petición antes de tiempo para comprobar los rechazos.
  7. Usa el simulador para perder trabajo ET y recuperarlo con una tarea local.
  8. Diseña el drenaje de aceptación ET con límite de clientes y presupuesto por turno.
  9. Extiende la identidad con generación a una cola local de sesiones reutilizables.
  10. Compara LT y ET con la misma carga, validación y límites de memoria antes de medir tiempos.
Próximo paso

El tema 41 abre el bloque de protocolos y fallos. Vas a reunir longitudes, delimitadores, validación, límites y versiones en un contrato de IPC que siga siendo correcto aunque los bytes lleguen fragmentados y los participantes fallen.