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

Tema 37

Esperar varios descriptores con select

Vas a dormir hasta que alguna de varias conversaciones pueda avanzar, sin dedicar una espera bloqueante a cada cliente. Construirás conjuntos de lectura y escritura, calcularás el límite de búsqueda y conservarás el estado de cada conexión entre turnos. También aprenderás a reconstruir los argumentos de select y a mantener un plazo total aunque lleguen señales.

1. Qué vamos a coordinar

El tema 36 mostró cómo recuperar el control al aparecer EAGAIN y conservar los bytes pendientes. Ahora falta decidir cuándo volver a intentar una operación sin consultar todas las conexiones de forma continua.

select recibe conjuntos de descriptores y espera hasta que alguno presente una condición solicitada, venza un tiempo de espera o una señal interrumpa la llamada. Al retornar, el bucle intenta operaciones no bloqueantes y actualiza cada conversación.

El conjunto de entrada expresa qué interesa observar. Después de select, ese mismo conjunto expresa qué resultó preparado en esa llamada. El estado permanente de la aplicación debe conservarse por separado.

DecisiónContrato del laboratorioConsecuencia
Canales.Tres pares AF_UNIX STREAM no bloqueantes.Se vigilan varios extremos sin construir otro servicio con ruta.
Petición.Hasta 64 bytes, terminados por SHUT_WR del cliente.EOF marca el fin de una única petición por conexión.
Respuesta.Mayúsculas ASCII, misma longitud y EOF.El cliente verifica contenido completo y terminación.
Turno.Como máximo una llamada de E/S por extremo preparado, de hasta dos bytes.Los avances parciales son visibles y un extremo no ocupa todo el despacho.
Plazo.Cinco segundos desde que empieza el bucle.Se recalcula la espera restante en cada vuelta.

Los dos lados de los pares viven en un mismo proceso para hacer reproducibles los ensayos. Las peticiones son pequeñas y se cargan antes de empezar la espera; después, servidor y cliente avanzan únicamente según los conjuntos devueltos. El mismo patrón de estado se aplica cuando los interlocutores están en procesos independientes.

2. La interfaz y los tres conjuntos

C · firma de select
#include <sys/select.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
ArgumentoInterés solicitadoUso en este tema
readfds.Preparación para lectura.Recibir petición, respuesta o detectar EOF.
writefds.Preparación para escritura.Enviar el sufijo de una respuesta pendiente.
exceptfds.Condiciones excepcionales, como ciertos datos fuera de banda.NULL; no es una lista general de errores del socket.
timeout.Límite relativo de esta espera.Valor nuevo calculado desde un plazo monotónico.

Un puntero NULL significa que no se utiliza ese conjunto. Para una espera sin límite se pasa timeout igual a NULL; para una consulta inmediata se pasa un timeval con ambos campos en cero.

La llamada no lee ni escribe datos del protocolo. Solo informa condiciones; las llamadas posteriores determinan cuántos bytes se procesaron, si apareció EOF o si hubo un error. La interfaz se documenta en select(2).

3. Preparar y consultar fd_set

C · operaciones sobre un conjunto
fd_set lectura;
FD_ZERO(&lectura);         /* Inicializar antes de agregar. */
FD_SET(fd, &lectura);      /* Solicitar este descriptor. */
FD_CLR(fd, &lectura);      /* Retirarlo si cambia el interes. */

/* Tras select exitoso: */
if (FD_ISSET(fd, &lectura)) {
    /* Intentar una lectura no bloqueante. */
}

No trates fd_set como un arreglo de enteros ni dependas de su representación interna. Usa las macros de la interfaz. Inicializa cada conjunto que vayas a pasar y verifica el rango del descriptor antes de operar con él.

Un descriptor puede pertenecer simultáneamente a lectura y escritura si la aplicación tiene trabajo válido en ambas direcciones. No dupliques la estructura de conexión: sigue habiendo un recurso, con dos intereses y dos partes de estado.

El retorno positivo cuenta bits preparados en los conjuntos resultantes. Un mismo descriptor preparado en lectura y escritura puede contribuir dos veces. Por eso no debe interpretarse automáticamente como «cantidad de clientes distintos».

4. Calcular nfds y respetar FD_SETSIZE

nfds es uno más que el mayor número de descriptor incluido en cualquiera de los conjuntos. No es la cantidad de descriptores ni la cantidad de conexiones.

ejemplo · dos descriptores con números separados
lectura:   { 4, 19 }
escritura: { 19 }

mayor descriptor vigilado = 19
nfds = 20

/* Hay dos descriptores distintos, pero nfds no es 2. */

Si nfds es demasiado pequeño, un descriptor agregado al conjunto puede quedar fuera del intervalo examinado. El programa parecerá esperar un cliente que ya tenía datos. Un valor innecesariamente grande agrega trabajo y debe mantenerse dentro del diseño y los límites de la interfaz.

Antes de FD_SET, FD_CLR o FD_ISSET exige 0 <= fd && fd < FD_SETSIZE. Usar las macros con un número negativo o fuera de rango provoca comportamiento indefinido. En la implementación habitual de glibc, FD_SETSIZE vale 1024; comprueba el símbolo, no una cifra escrita a mano.

El límite se refiere al número del descriptor: un único socket con número 1500 ya resulta incompatible con ese fd_set. Cambiar el límite de archivos abiertos del proceso no amplía automáticamente los conjuntos de la biblioteca.

El ejemplo rechaza un par si cualquiera de sus extremos no cabe, antes de usar las macros. Para aplicaciones que necesitan números o conjuntos mayores, poll y epoll son alternativas que se estudiarán a continuación.

5. Intereses persistentes y resultados temporales

select modifica los conjuntos. Tras un retorno exitoso, los descriptores que no estaban preparados quedan fuera de los resultados. Reutilizar esos resultados como entrada de la siguiente vuelta elimina silenciosamente intereses todavía necesarios.

dos estrategias · la fuente de verdad no es el resultado anterior
/* Estrategia A: copiar conjuntos maestros mantenidos por la aplicacion. */
lectura = lectura_maestra;
escritura = escritura_maestra;
select(maxfd + 1, &lectura, &escritura, NULL, &espera);

/* Estrategia B: reconstruir desde el estado de todas las conexiones. */
FD_ZERO(&lectura);
FD_ZERO(&escritura);
/* Agregar cada descriptor segun su estado y recalcular maxfd. */

El programa completo elige la segunda estrategia. En cada vuelta calcula qué cliente aún espera respuesta, qué servidor aún recibe y qué servidor tiene salida pendiente. Los conjuntos temporales se descartan al terminar ese despacho.

Si aparece EINTR o un error, no proceses los conjuntos como si describieran eventos válidos. Revisa la política de interrupción y vuelve a construir los argumentos antes de otra llamada.

La misma regla se aplica al timeval: se trata como un argumento consumible de esa espera. Linux puede modificarlo y el comportamiento no debe asumirse idéntico en otros sistemas. El ejemplo nunca reutiliza el valor ya pasado.

6. Retornos, EOF y preparación desactualizada

Retorno de selectSignificadoAcción del bucle
Mayor que cero.Hay bits preparados en los conjuntos resultantes.Examinar con FD_ISSET y atender cada estado.
Cero.Venció el timeout de esta llamada sin condiciones devueltas.Revisar el plazo y reconstruir si corresponde.
−1, EINTR.Una señal interrumpió la espera.Aplicar política y recalcular la siguiente espera.
−1, EBADF u otro error.Argumentos o recursos inválidos, u otro fallo.Diagnosticar; no anunciar un timeout ni procesar conjuntos inválidos.

EOF también hace que una lectura pueda terminar sin esperar. Si no retiras del interés de lectura un extremo que ya llegó al final y no tiene más trabajo, select puede seguir devolviéndolo en cada vuelta.

Una condición de escritura no garantiza enviar todo el búfer. Una condición de lectura no garantiza una trama completa ni reserva bytes para un consumidor. Si un alias retira datos entre la notificación y recv, la llamada puede obtener EAGAIN.

Por eso la espera se combina con sockets no bloqueantes. El bucle conserva progreso ante EAGAIN y retornos positivos parciales, y distingue EOF de errores. La lógica de transferencia sigue las reglas de recv(2) y send(2).

7. Timeout por espera y plazo total

Un timeval con tv_sec igual a dos limita una llamada de espera. Si ante cada señal se vuelve a conceder un timeout nuevo de dos segundos, una secuencia de interrupciones puede prolongar indefinidamente la operación de aplicación.

regla · presupuesto restante desde una fecha límite
limite = ahora_monotonico + presupuesto_total

en cada vuelta:
    restante = limite - ahora_monotonico
    si restante <= 0: terminar por plazo
    reconstruir conjuntos y timeval con restante
    select(...)
    si EINTR: volver al principio sin renovar el limite

CLOCK_MONOTONIC permite medir intervalos sin depender de ajustes discontinuos del reloj de calendario. No hace que select retorne con precisión exacta: la resolución y la planificación pueden retrasar el despertar. La base de tiempo se documenta en clock_gettime(2).

Con varias conexiones y temporizadores se espera hasta el vencimiento más cercano. Al despertar se revisan los plazos de aplicación además de los descriptores. Este tema utiliza un único plazo global fijo para que la política sea visible.

Un timeout cero sirve para una consulta puntual. Repetirlo continuamente sin trabajo convierte la espera en sondeo activo. timeout igual a NULL permite dormir sin límite y requiere una estrategia distinta para cancelación y temporizadores.

8. Cabecera para plazos monotónicos

Guarda plazo37.h junto a los dos programas siguientes. Sus funciones retornan −1 ante un fallo; restante37 retorna cero si venció el plazo o uno si produjo una espera positiva. Los ejemplos solo crean plazos pequeños y positivos de uno o cinco segundos.

La conversión redondea hacia arriba la fracción de microsegundo para no transformarla prematuramente en una consulta inmediata. Se normaliza el acarreo a segundos y se vuelve a consultar el reloj después de cada espera.

plazo37.h · reconstruir el timeout desde un límite fijo
#ifndef PLAZO37_H
#define PLAZO37_H
#include <sys/select.h>
#include <time.h>
#include <stdio.h>

static int fijar_plazo37(struct timespec *limite, int segundos)
{
    if (clock_gettime(CLOCK_MONOTONIC, limite) == -1) {
        perror("clock_gettime"); return -1;
    }
    limite->tv_sec += segundos;
    return 0;
}

static int restante37(const struct timespec *limite, struct timeval *espera)
{
    struct timespec ahora;
    if (clock_gettime(CLOCK_MONOTONIC, &ahora) == -1) {
        perror("clock_gettime"); return -1;
    }
    time_t s = limite->tv_sec - ahora.tv_sec;
    long ns = limite->tv_nsec - ahora.tv_nsec;
    if (ns < 0) { --s; ns += 1000000000L; }
    if (s < 0 || (s == 0 && ns == 0)) return 0;
    espera->tv_sec = s;
    espera->tv_usec = (ns + 999L) / 1000L;
    if (espera->tv_usec == 1000000L) {
        ++espera->tv_sec;
        espera->tv_usec = 0;
    }
    return 1;
}
#endif

Esta cabecera no es un planificador general ni acepta duraciones arbitrariamente grandes de entrada externa. El llamador es dueño del límite, decide qué hacer al vencer y mantiene sus estados de conexión.

9. Estado y turnos de tres conversaciones

Cada par tiene un extremo servidor y un extremo cliente. El servidor acumula la petición hasta EOF, transforma los bytes y habilita el interés de escritura mientras conserva salida pendiente. El cliente recibe, comprueba cada byte y exige EOF después de la respuesta completa.

Los intereses se reconstruyen desde el estado de cada conversaciónMientras el servidor recibe se agrega a lectura. Después de EOF, si tiene respuesta pendiente, se agrega a escritura. El cliente permanece en lectura hasta verificar respuesta y EOF. select devuelve solo los intereses preparados de esa vuelta. Estado por conexiónbytes, EOF, pendientesReconstruir conjuntosy esperar con selectIntentar E/S listay actualizar estadoLectura: entrada pendiente o cliente que espera respuestaEscritura: únicamente servidor con bytes de salida pendientes
La fuente de verdad es el estado de las conexiones; fd_set es una vista temporal de sus intereses.

La petición vacía requiere un caso explícito: al reconocer EOF no hay bytes de respuesta que justifiquen vigilar escritura. El servidor cierra su extremo y el cliente valida una respuesta vacía seguida de EOF.

El programa no acepta conexiones nuevas durante el despacho ni crea descriptores al cerrar otros. Eso evita la reutilización de números en esa misma instantánea de resultados. Un servidor dinámico necesita una política adicional para altas, bajas y resultados que ya tenía capturados.

10. Programa completo de multiplexación

Guarda select37.c. Las tres peticiones son hola, los bytes a/NUL/b y una petición vacía. Los límites y la comparación se expresan en bytes; no se busca un terminador dentro de los datos recibidos.

select37.c · tres conversaciones con estados y conjuntos reconstruidos
#define _GNU_SOURCE
#include "plazo37.h"
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define CANALES 3u
#define MAX_DATOS 64u

struct canal {
    int servidor, cliente;
    const unsigned char *peticion;
    size_t longitud;
    unsigned char respuesta[MAX_DATOS];
    size_t usados, enviados, verificados;
    int entrada_fin;
};

static int cerrar(int *fd)
{
    if (*fd == -1) return 0;
    int numero = *fd;
    *fd = -1;
    if (close(numero) == -1) { perror("close"); return -1; }
    return 0;
}

static int temporal(void)
{
    return errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK;
}

static unsigned char mayus(unsigned char b)
{
    return b >= 'a' && b <= 'z' ? (unsigned char)(b - 'a' + 'A') : b;
}

static int cargar_peticion(struct canal *c)
{
    size_t hechos = 0;
    while (hechos < c->longitud) {
        ssize_t n = send(c->cliente, c->peticion + hechos,
                         c->longitud - hechos, MSG_NOSIGNAL);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else {
            /* Solo se precargan peticiones diminutas en pares vacios. */
            if (n == 0) errno = EIO;
            perror("precarga de prueba"); return -1;
        }
    }
    if (shutdown(c->cliente, SHUT_WR) == -1) {
        perror("shutdown cliente"); return -1;
    }
    return 0;
}

static int atender_servidor(struct canal *c, int leer, int escribir)
{
    if (leer) {
        unsigned char bloque[2];
        ssize_t n = recv(c->servidor, bloque, sizeof bloque, 0);
        if (n > 0) {
            if ((size_t)n > MAX_DATOS - c->usados) {
                fprintf(stderr, "Peticion excesiva\n"); return -1;
            }
            memcpy(c->respuesta + c->usados, bloque, (size_t)n);
            c->usados += (size_t)n;
        } else if (n == 0) {
            c->entrada_fin = 1;
            for (size_t i = 0; i < c->usados; ++i)
                c->respuesta[i] = mayus(c->respuesta[i]);
            if (c->usados == 0) return cerrar(&c->servidor);
        } else if (!temporal()) {
            perror("recv servidor"); return -1;
        }
    }
    if (escribir) {
        size_t pedido = c->usados - c->enviados;
        if (pedido > 2) pedido = 2;
        ssize_t n = send(c->servidor, c->respuesta + c->enviados,
                         pedido, MSG_NOSIGNAL);
        if (n > 0) {
            c->enviados += (size_t)n;
            if (c->enviados == c->usados) return cerrar(&c->servidor);
        } else if (n == 0) {
            fprintf(stderr, "send sin progreso\n"); return -1;
        } else if (!temporal()) {
            perror("send servidor"); return -1;
        }
    }
    return 0;
}

static int atender_cliente(struct canal *c, unsigned indice)
{
    unsigned char bloque[2];
    ssize_t n = recv(c->cliente, bloque, sizeof bloque, 0);
    if (n > 0) {
        if ((size_t)n > c->longitud - c->verificados) {
            fprintf(stderr, "Respuesta excesiva\n"); return -1;
        }
        for (size_t i = 0; i < (size_t)n; ++i) {
            if (bloque[i] != mayus(c->peticion[c->verificados + i])) {
                fprintf(stderr, "Respuesta incorrecta\n"); return -1;
            }
        }
        c->verificados += (size_t)n;
    } else if (n == 0) {
        if (c->verificados != c->longitud) {
            fprintf(stderr, "Respuesta truncada\n"); return -1;
        }
        if (cerrar(&c->cliente) == -1) return -1;
        printf("Canal %u: %zu bytes verificados y EOF\n", indice + 1, c->verificados);
    } else if (!temporal()) {
        perror("recv cliente"); return -1;
    }
    return 0;
}

int main(void)
{
    static const unsigned char a[] = { 'h', 'o', 'l', 'a' };
    static const unsigned char b[] = { 'a', 0, 'b' };
    struct canal c[CANALES] = {0};
    for (unsigned i = 0; i < CANALES; ++i)
        c[i].servidor = c[i].cliente = -1;
    c[0].peticion = a; c[0].longitud = sizeof a;
    c[1].peticion = b; c[1].longitud = sizeof b;
    c[2].peticion = a; c[2].longitud = 0;
    int fallo = 1;

    for (unsigned i = 0; i < CANALES; ++i) {
        int par[2];
        if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                       0, par) == -1) { perror("socketpair"); goto fin; }
        c[i].servidor = par[0]; c[i].cliente = par[1];
        if (par[0] >= FD_SETSIZE || par[1] >= FD_SETSIZE) {
            fprintf(stderr, "Descriptor fuera de FD_SETSIZE\n"); goto fin;
        }
        if (cargar_peticion(&c[i]) == -1) goto fin;
    }
    struct timespec limite;
    if (fijar_plazo37(&limite, 5) == -1) goto fin;

    for (;;) {
        fd_set lectura, escritura;
        FD_ZERO(&lectura); FD_ZERO(&escritura);
        int maxfd = -1;
        unsigned clientes_activos = 0;
        for (unsigned i = 0; i < CANALES; ++i) {
            if (c[i].cliente != -1) {
                ++clientes_activos;
                FD_SET(c[i].cliente, &lectura);
                if (c[i].cliente > maxfd) maxfd = c[i].cliente;
            }
            int fd = c[i].servidor;
            if (fd == -1) continue;
            if (!c[i].entrada_fin) FD_SET(fd, &lectura);
            else if (c[i].enviados < c[i].usados) FD_SET(fd, &escritura);
            if (fd > maxfd) maxfd = fd;
        }
        if (!clientes_activos) break;
        struct timeval espera;
        int plazo = restante37(&limite, &espera);
        if (plazo == -1) goto fin;
        if (plazo == 0) { fprintf(stderr, "Plazo global agotado\n"); goto fin; }
        int n = select(maxfd + 1, &lectura, &escritura, NULL, &espera);
        if (n == -1) {
            if (errno == EINTR) continue;
            perror("select"); goto fin;
        }
        if (n == 0) continue; /* Revisar el reloj y reconstruir todo. */

        for (unsigned i = 0; i < CANALES; ++i) {
            int fd = c[i].servidor;
            int leer = fd != -1 && FD_ISSET(fd, &lectura);
            int escribir = fd != -1 && FD_ISSET(fd, &escritura);
            if (atender_servidor(&c[i], leer, escribir) == -1) goto fin;
            fd = c[i].cliente;
            if (fd != -1 && FD_ISSET(fd, &lectura)) {
                if (atender_cliente(&c[i], i) == -1) goto fin;
            }
        }
    }
    puts("Tres conversaciones completadas");
    if (fflush(stdout) == EOF) { perror("salida"); goto fin; }
    fallo = 0;
fin:
    for (unsigned i = 0; i < CANALES; ++i) {
        if (cerrar(&c[i].servidor) == -1) fallo = 1;
        if (cerrar(&c[i].cliente) == -1) fallo = 1;
    }
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}

Se comprueba el rango inmediatamente después de crear cada par y todos los descriptores posteriores proceden de esos pares. Nunca se aplica FD_ISSET a −1 gracias al cortocircuito de la condición.

El interés de escritura aparece en la vuelta posterior al EOF de petición. Al completar el envío se cierra el servidor: ya recibió EOF, no tiene más entrada que conservar y no queda salida de aplicación pendiente. El cliente todavía puede drenar los bytes aceptados antes de observar el cierre.

El programa limita cada operación de datos a dos bytes para hacer visible el estado incremental. No se utiliza exceptfds para detectar desconexiones: los resultados reales de recv y send resuelven el final o el fallo.

11. Compilar y verificar respuestas

Bash en Linux · guardar la cabecera y compilar
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 select37.c -o select37
$ timeout 10s ./select37
Canal 3: 0 bytes verificados y EOF
Canal 2: 3 bytes verificados y EOF
Canal 1: 4 bytes verificados y EOF
Tres conversaciones completadas
$ echo $?
0

Las líneas por canal pueden aparecer en otro orden si modificas fragmentos o planificación. Cada canal debe verificar su propia longitud, contenido y EOF; el orden relativo entre conversaciones no forma parte del protocolo.

La segunda respuesta contiene A, NUL y B. El programa la compara por bytes y no intenta imprimirla como una cadena. La tercera no tiene cuerpo: demuestra que no se debe vigilar escritura solo para «enviar cero bytes».

El plazo global comienza después de precargar estas peticiones pequeñas y cubre el bucle de multiplexación. No se presenta como un límite de duración para creación de recursos, stdio o cualquier operación futura ajena a esa espera.

12. Experimento de timeout e interrupciones

Guarda espera37.c junto a plazo37.h. Mantiene abierto un par sin datos y espera lectura durante un presupuesto total de un segundo. Instala un manejador de SIGUSR1 que solo cuenta señales de forma acotada; el flujo principal gestiona select y los diagnósticos.

espera37.c · el plazo no se reinicia después de EINTR
#define _GNU_SOURCE
#include "plazo37.h"
#include <sys/socket.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>

static volatile sig_atomic_t senales;
static void contar(int numero)
{
    (void)numero;
    if (senales < 100) ++senales;
}

int main(void)
{
    struct sigaction accion = {0};
    accion.sa_handler = contar;
    sigemptyset(&accion.sa_mask);
    if (sigaction(SIGUSR1, &accion, NULL) == -1) {
        perror("sigaction"); return EXIT_FAILURE;
    }
    int par[2];
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                   0, par) == -1) { perror("socketpair"); return EXIT_FAILURE; }
    int fallo = 1;
    unsigned interrupciones = 0;
    if (par[1] >= FD_SETSIZE) {
        fprintf(stderr, "Descriptor fuera de FD_SETSIZE\n"); goto fin;
    }
    struct timespec limite;
    if (fijar_plazo37(&limite, 1) == -1) goto fin;
    printf("Esperando lectura; PID=%jd\n", (intmax_t)getpid());
    if (fflush(stdout) == EOF) { perror("salida"); goto fin; }
    for (;;) {
        fd_set lectura;
        FD_ZERO(&lectura); FD_SET(par[1], &lectura);
        struct timeval espera;
        int r = restante37(&limite, &espera);
        if (r == -1) goto fin;
        if (r == 0) break;
        r = select(par[1] + 1, &lectura, NULL, NULL, &espera);
        if (r == -1) {
            if (errno == EINTR) { ++interrupciones; continue; }
            perror("select"); goto fin;
        }
        if (r > 0) {
            fprintf(stderr, "Preparacion inesperada en el par vacio\n"); goto fin;
        }
        /* r == 0: revisar el reloj, no reutilizar timeval ni fd_set. */
    }
    printf("Plazo agotado; senales=%d; EINTR=%u\n", (int)senales, interrupciones);
    if (fflush(stdout) == EOF) { perror("salida"); goto fin; }
    fallo = 0;
fin:
    if (close(par[0]) == -1) { perror("close A"); fallo = 1; }
    if (close(par[1]) == -1) { perror("close B"); fallo = 1; }
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}
Bash · ensayo sin señales
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 espera37.c -o espera37
$ timeout 5s ./espera37
Esperando lectura; PID=4200
Plazo agotado; senales=0; EINTR=0

El PID es ilustrativo. Para probar señales, un controlador debe esperar el mensaje inicial, enviar SIGUSR1 mientras la espera está activa y comprobar que el plazo original no se renueva. No envíes la señal antes de instalarse el manejador ni supongas que cada señal estándar se contará por separado.

Una señal puede llegar entre vueltas y no interrumpir select; por eso la cantidad recibida y la cantidad de retornos EINTR no tienen por qué coincidir. El experimento muestra reconstrucción y presupuesto, no una cola fiable de eventos de señal.

13. Altas, bajas y recursos del bucle

Lectura, escritura y vida de una conexión

Registra lectura mientras exista una etapa que pueda consumir entrada. Registra escritura mientras haya un sufijo pendiente y el estado permita enviarlo. Cuando ya no queden conexiones ni temporizadores o tareas pendientes, termina explícitamente en lugar de entrar por accidente en una espera indefinida sin descriptores.

Con conjuntos maestros, cada cierre exige FD_CLR y una actualización coherente del registro de conexiones. Reconstruir desde el estado evita arrastrar un bit de un descriptor cerrado, pero sigue siendo necesario marcar el recurso como retirado.

Reutilización del número y errores de ciclo de vida

El número de un descriptor puede volver a utilizarse después de close. Si durante el mismo despacho aceptas una conexión nueva con ese número, un bit de la instantánea anterior no debe interpretarse como preparación de la conexión recién creada.

Una política sencilla es diferir las altas hasta el siguiente ciclo o identificar también la generación del recurso. Si varios hilos cierran descriptores vigilados por otro, se necesita coordinación de propiedad; no uses close concurrente como mecanismo portable para despertar select.

Equidad y límites

select informa preparación de forma persistente mientras siga existiendo la condición. En este laboratorio, una lectura parcial deja bytes para otra vuelta y una escritura parcial mantiene el interés. El presupuesto de una llamada por extremo facilita que las demás conversaciones progresen.

Ese presupuesto no limita por sí solo el costo de una tarea de CPU ni la memoria de las colas. Un servicio real necesita límites por conexión, límites globales, contrapresión, plazos por operación y una política de desconexión para consumidores lentos.

El recorrido de conjuntos y el límite de FD_SETSIZE hacen que select sea útil para aprender y para conjuntos pequeños. Los siguientes temas compararán esa representación con poll y con el registro de intereses de epoll.

14. Señales y el siguiente paso hacia pselect

Reintentar EINTR sirve si la política es continuar hasta el mismo plazo. Para cancelar el servicio por una señal, el bucle también tiene que observar una bandera y aplicar su política de cierre.

Existe una carrera si se revisa una bandera y luego se entra en select sin límite: la señal puede llegar entre ambas operaciones, dejar la bandera activa y no interrumpir una espera que todavía no había empezado. El proceso podría dormir aunque la cancelación ya estuviera pendiente.

pselect permite cambiar la máscara de señales de forma atómica respecto de la espera y utiliza una estructura timespec. Resolver esa carrera exige configurar correctamente el bloqueo previo y la máscara usada al esperar, no solo reemplazar el nombre de la función.

El ejemplo de un segundo no utiliza señales para cancelar y mantiene un plazo finito; por eso no promete un despertar inmediato por una bandera. El tema 42 retomará pselect, ppoll y otros mecanismos de integración. La carrera y la motivación se explican en select_tut(2).

15. Explorar conjuntos de entrada y salida

El modelo usa los números didácticos 4 y 9. A tiene interés de lectura; B tiene interés de lectura y escritura porque empieza con una salida pendiente. Una llamada con timeout cero permite inspeccionar los conjuntos que select deja como resultado.

Intereses persistentesR={4, 9}; W={9}

Conjuntos que recibirá la próxima llamadaR={4, 9}; W={9}

Estado de A0 bytes; envío remoto abierto

Estado de BSin entrada; salida pendiente

Último retornoSin llamada

Última operación de E/SNinguna

La salida pendiente de B permite observar cómo desaparecen los intereses no preparados del resultado.

Ejecuta select al inicio: solo B aparece preparado para escritura. Entrega datos a A y vuelve a ejecutar sin reconstruir: A sigue fuera del conjunto temporal. Después reconstruye y consulta otra vez para que se observe su lectura.

Para probar EOF, retira los datos de A, termina el envío remoto y reconstruye. A aparece preparado aunque ya no haya bytes; recv devuelve cero. Si mantienes el interés y vuelves a consultar seguirá preparado hasta que lo retires.

Las operaciones de E/S se pueden intentar directamente para separar el resultado de la sonda del resultado real. B no recibe entrada durante la simulación y siempre tiene capacidad para su pequeño envío. El modelo no mide tiempos reales ni ejecuta llamadas al sistema.

16. Pruebas y diagnóstico

Pruebas de estructura y resultados

  1. Compilar los dos programas con la cabecera. Deben compilar sin advertencias y terminar con éxito en sus recorridos correctos.
  2. Contenido, binario y vacío. Verifica las tres longitudes, la conversión ASCII, el NUL intermedio y EOF de cada respuesta.
  3. Fragmentación adicional. Limita send y recv a un byte real por llamada. El estado debe conservarse entre notificaciones.
  4. Plazo sin actividad. espera37 debe terminar por el presupuesto y no por EOF, porque ambos extremos siguen abiertos.
  5. Interrupciones. Envía señales después del mensaje inicial y comprueba que el plazo no se renueva en cada EINTR.

Fallos que el controlador debe detectar

En una copia del primer programa, altera un byte de la respuesta del servidor: el cliente debe informar contenido incorrecto. Cierra el servidor antes de enviar el cuerpo completo: debe detectar truncamiento, no presentar EOF como una respuesta válida.

Con un emisor de prueba, transmite 64 bytes para el límite válido y 65 para el rechazo del servidor. No basta con probar solo las peticiones diminutas precargadas. El receptor comprueba capacidad antes de copiar y puede reconocer EOF con el búfer lleno sin escribir fuera del arreglo.

Un wrapper de pruebas puede retornar EINTR antes de llamadas reales o EAGAIN antes de algunas operaciones de datos. Debe comprobarse que se reconstruyen los conjuntos y que no se pierden avances anteriores. Si simula un retorno positivo parcial, tiene que transferir realmente esos bytes.

Para verificar FD_SETSIZE, un controlador puede reservar números altos y ejecutar el programa con esos descriptores heredados. Debe rechazarse el par antes de usar las macros, sin escritura fuera de fd_set. El ensayo depende del límite de archivos abiertos del entorno y necesita cerrar lo que reservó.

Para probar el cálculo del tiempo, usa un reloj de prueba que devuelva instantes controlados: vencimiento exacto, resta de nanosegundos con préstamo y redondeo que acarrea un segundo. Un ensayo de tiempo real debe permitir retrasos de planificación y nunca exigir un despertar en un instante exacto.

Bash en Linux · observar esperas y transferencias
$ strace -s 32 -e trace=select,pselect6,sendto,recvfrom,shutdown,close ./select37
$ strace -e trace=select,pselect6,clock_gettime ./espera37

La biblioteca puede implementar select mediante una llamada pselect6 del núcleo. clock_gettime puede resolverse por vDSO y no aparecer como syscall en strace. Una ausencia en esa traza no demuestra que el programa haya omitido calcular el plazo.

Si aparece EBADF, revisa la propiedad y el cierre de los descriptores vigilados. Si el bucle gira sin trabajo útil, busca escritura registrada con cola vacía, lectura de EOF que nunca se retira o un timeval cero reutilizado por error.

El controlador externo debe imponer su propio límite y limpiar recursos al fallar. El plazo del ejemplo se revisa en puntos concretos del bucle; no puede interrumpir cualquier operación de CPU o salida estándar que se agregue después.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Pasar cantidad de clientes como nfds.Se ignoran descriptores de número mayor.Mayor descriptor vigilado más uno.
Usar FD_SET con un descriptor fuera de rango.Comportamiento indefinido y posible corrupción de memoria.Validar antes de usar cualquier macro del conjunto.
No inicializar fd_set.Se incluyen bits indeterminados.FD_ZERO y construcción explícita.
Reutilizar los resultados de la vuelta anterior.Desaparecen intereses que no estaban preparados.Copiar maestros o reconstruir desde estados.
Reutilizar timeval sin reconstruir.La espera puede reducirse a cero y producir sondeo.Recalcular el restante antes de cada select.
Renovar todo el presupuesto después de EINTR.Las señales prolongan la operación.Conservar un límite absoluto monotónico.
Procesar conjuntos después de un error.Se despachan resultados no válidos.Resolver el retorno antes de FD_ISSET.
Tratar exceptfds como todos los errores.Se omiten fallos informados por la E/S normal.Consultar resultados de recv, send y operaciones específicas.
Dejar EOF registrado para siempre.La espera retorna continuamente sin progreso.Cambiar de estado o retirar y cerrar el recurso.
Vigilar escritura sin bytes pendientes.Se producen despertares inútiles.Intereses derivados de las colas reales.
Usar sockets bloqueantes tras la notificación.Una condición desactualizada puede retener el bucle.E/S no bloqueante y tratamiento de EAGAIN.
Reutilizar un número cerrado en el mismo despacho.Un evento antiguo puede aplicarse al recurso nuevo.Diferir altas o identificar la generación.

18. Resumen

19. Preguntas de repaso y práctica

Responde distinguiendo intereses, resultados, números de descriptor y estado permanente de la conversación.

1. ¿select recibe datos o solo informa condiciones?

Informa condiciones de preparación. La transferencia se intenta después con recv, send u otra operación apropiada.

2. ¿Qué nfds corresponde si se vigilan los descriptores 4 y 19?

Veinte: uno más que el mayor número. La cantidad de descriptores distintos es dos, pero no es el valor del argumento.

3. ¿Por qué se reconstruyen fd_set antes de cada llamada?

Porque select los modifica para dejar solo resultados preparados. Reutilizarlos sin reconstruir elimina intereses que seguían siendo necesarios.

4. ¿Un único socket con número mayor o igual a FD_SETSIZE es admisible?

No para esas macros y esa representación. El límite es el número del descriptor, no la cantidad total de conexiones.

5. ¿El retorno positivo cuenta siempre clientes distintos?

No. Cuenta bits preparados en los conjuntos; un descriptor puede contribuir en más de uno.

6. ¿exceptfds es el conjunto donde aparecen todos los errores?

No. Representa condiciones excepcionales específicas. Los errores y cierres también se resuelven mediante las operaciones normales.

7. ¿Una cola vacía impide siempre preparación de lectura?

No. EOF permite que recv termine sin esperar y puede mantener el descriptor preparado.

8. ¿Puede recv devolver EAGAIN después de select?

Sí. La observación puede quedar desactualizada, por ejemplo si otro consumidor retira los bytes. Por eso se utiliza E/S no bloqueante.

9. ¿Qué hacer con el timeval usado antes de reintentar?

Preparar uno nuevo, preferentemente desde el presupuesto restante si hay un plazo global.

10. ¿Por qué no se concede un segundo nuevo tras cada EINTR?

Porque las interrupciones podrían prolongar indefinidamente el plazo de aplicación. Se conserva el límite original.

11. ¿Por qué la respuesta vacía no habilita escritura?

Porque no hay bytes pendientes. El servidor puede completar su política de cierre para que el cliente observe EOF.

12. ¿Qué ocurre con los bytes aceptados antes de cerrar el servidor?

El cliente puede drenarlos antes de observar EOF en el cierre ordenado. El ejemplo verifica contenido y cantidad.

13. ¿Cómo se evita usar un bit antiguo para una conexión recién creada?

Separando las altas del despacho actual o comprobando también la identidad o generación del recurso, además de su número.

14. ¿Un presupuesto de dos bytes por turno resuelve todos los límites del servidor?

No. Ayuda al reparto de E/S, pero siguen haciendo falta límites de memoria, tiempos y tareas de CPU.

15. ¿Qué carrera ayuda a resolver pselect?

La señal que llega después de revisar una bandera y antes de entrar en la espera. La solución requiere una política correcta de máscaras de señales.

Para practicar y ampliar

  1. Dibuja los intereses de los seis extremos al comenzar y después de cada EOF de petición.
  2. Ejecuta los programas y relaciona cada retorno con el estado que lo hizo posible.
  3. Fuerza transferencias de un byte e interrupciones y verifica las tres respuestas.
  4. Prueba una petición de 64 bytes y otra de 65 con un emisor de laboratorio.
  5. Introduce una respuesta alterada y otra truncada y comprueba los rechazos.
  6. Usa el simulador para perder un interés al reutilizar resultados y recupéralo reconstruyendo.
  7. Prueba la resta de tiempos en casos con préstamo, vencimiento exacto y redondeo.
  8. Diseña un plazo distinto por conexión y calcula qué espera relativa usarías.
  9. Propón una política de altas y bajas que impida despachar eventos de un descriptor reutilizado.
  10. Adapta el servicio con ruta del tema 32 para separar escucha, clientes no bloqueantes y estado por conexión.
Próximo paso

El tema 38 cambiará los conjuntos por un arreglo de pollfd. Estudiarás POLLIN, POLLOUT y POLLHUP, y cómo mantener altas y bajas de clientes sin el límite de representación de fd_set.