← Comunicación entre ProcesosBloque 7 · Semáforos POSIX entre procesos · Tema 30 de 52

Tema 30

Proyecto: un búfer circular compartido

Vas a integrar memoria compartida y semáforos en una cola acotada que reutiliza sus posiciones. Varios productores publicarán tareas y varios consumidores calcularán resultados. El proyecto incluirá identificadores, tres semáforos, mensajes de fin, validación del trabajo completo y un supervisor que cancela a los participantes ante fallos o agotamiento de su presupuesto temporal.

1. Contrato y alcance del proyecto

El canal del tema 28 tenía una casilla, un productor y un consumidor. Ahora construiremos una región con varias posiciones reutilizables, de modo que pueda haber varias tareas pendientes y varios participantes compitiendo por insertarlas y retirarlas.

Las tareas se identifican con los números de 1 a N. La tarea i transporta el valor i y su resultado es i × i. Cada identificador debe confirmarse exactamente una vez en una ejecución aceptada.

ParámetroRangoSignificado
Tareas.1 a 10000.Trabajo real que se debe confirmar.
Productores.1 a 4.Procesos que generan identificadores distintos.
Consumidores.1 a 8.Procesos que retiran y calculan tareas.
Capacidad.1 a 64.Posiciones activas del búfer.
Demora opcional.0 a 20 ms.Coste simulado por cálculo, fuera de la exclusión.
Presupuesto opcional.100 a 60000 ms.Ventana monotónica de supervisión; 10000 ms por defecto.

Una ejecución se acepta si terminan correctamente todos los hijos, se confirma cada identificador una vez y el búfer queda vacío tras consumir todos los mensajes de fin.

La parada normal completa el trabajo y envía fines. Una cancelación solicitada, un fallo o el agotamiento del presupuesto descartan la ejecución y terminan a los hijos pendientes. No se intenta recuperar una cola parcialmente modificada.

El programa es independiente, de un solo hilo antes de fork, y conoce todos los usuarios de la región. No es un servicio con clientes externos ni un formato binario portable entre arquitecturas.

2. Región compartida y participantes

Productores y consumidores sobre una cola circular compartidaVarios productores insertan en un búfer circular de capacidad finita. Varios consumidores retiran tareas. La región contiene índices, tres semáforos y registros de confirmación. El supervisor crea y recoge a todos los hijos. Productor 1Productor PBufer circular compartidoentrada / salida / usadoshuecos / elementos / mutextareas y mensajes de finConsumidor 1Consumidor C
El supervisor no produce ni consume desde un bucle bloqueante: puede seguir observando a todos los hijos.

El padre crea un mapeo anónimo MAP_SHARED antes de fork. Todos los hijos heredan la misma región. No hay nombres que retirar con shm_unlink ni sem_unlink: los semáforos se inicializan dentro del mapeo.

La región contiene una reserva fija para 64 mensajes, pero solo se utilizan las primeras capacidad posiciones. Esto mantiene simple la asignación de memoria y permite probar capacidad uno sin recompilar.

También contiene una marca de confirmación por identificador y una salida propia para cada consumidor. Esas estructuras tienen límites de laboratorio; no representan almacenamiento ilimitado para una carga de duración indefinida.

3. Índices circulares y ocupación

entrada señala dónde se insertará el próximo mensaje; salida señala dónde se retirará el próximo. Después de usar una posición, el índice avanza con la operación módulo capacidad.

reglas · capacidad mayor que cero y validada al comenzar
entrada = (entrada + 1) % capacidad;
salida  = (salida  + 1) % capacidad;

/* usados distingue estados que pueden compartir los mismos indices. */
/* usados == 0: vacio. usados == capacidad: lleno. */

Si la capacidad es cuatro, la secuencia de un índice es 0, 1, 2, 3, 0, 1... Volver a cero no borra mensajes pendientes: la reserva de huecos impide sobrescribir una posición todavía ocupada.

Los índices iguales no demuestran por sí solos que esté vacío. También pueden coincidir después de llenar todas las posiciones. El proyecto utiliza usados para validar el estado bajo mutex, y semáforos para decidir cuándo puede progresar cada rol.

La FIFO conserva el orden de inserción efectiva. Con varios productores no se promete que los identificadores se inserten en orden numérico. Tampoco el orden de retirada determina el orden de finalización de cálculos ejecutados fuera del mutex.

4. Huecos, elementos y exclusión

SemáforoInicialRepresentación
huecos.Capacidad.Permisos para reservar posiciones de escritura.
elementos.0.Permisos para retirar mensajes publicados.
mutex.1.Acceso exclusivo a índices y campos comunes del protocolo.

Los tres objetos sem_t se ubican en la estructura nativa compartida y se preparan una sola vez con sem_init y pshared igual a uno. Ningún hijo vuelve a inicializarlos. El contrato de preparación se describe en sem_init(3).

huecos y elementos representan capacidad y disponibilidad; mutex evita que dos productores elijan la misma entrada o dos consumidores actualicen la misma salida. Ninguno reemplaza a los otros.

El padre no consulta sem_getvalue para autorizar acciones ni para decidir que terminó el trabajo. Las adquisiciones pertenecen a las operaciones sem_wait y la validación final se hace cuando no quedan hijos.

5. Insertar y retirar sin espera circular

protocolo normal · capacidad primero, exclusión después
INSERTAR                            RETIRAR
esperar huecos                      esperar elementos
esperar mutex                       esperar mutex
  escribir en entrada                 copiar desde salida
  avanzar entrada                     avanzar salida
  incrementar usados                  decrementar usados
publicar mutex                      publicar mutex
publicar elementos                  publicar huecos

No se toma mutex antes de esperar una plaza. Si el búfer está lleno y un productor espera huecos conservando mutex, un consumidor podría necesitar ese mismo mutex para retirar y devolver la plaza: aparecería una dependencia circular.

El consumidor reserva un elemento antes de tomar la exclusión. Dentro solo copia el mensaje y actualiza metadatos. El cálculo y la demora simulada suceden fuera del mutex, para que otros participantes puedan utilizar el búfer.

Retirar un mensaje permite reutilizar su posición antes de terminar el cálculo. El consumidor mantiene una copia local, no un puntero que siga apuntando a una casilla susceptible de sobrescritura.

La espera se reintenta ante EINTR sin entrar hasta el éxito, según sem_wait(3). Si falla una operación de control, el hijo informa fallo y el supervisor cancela la ejecución; no se reconstruyen permisos a ciegas.

6. Invariantes y permisos en tránsito

Mientras mutex protege una actualización, entrada y salida permanecen dentro de 0..capacidad−1 y usados dentro de 0..capacidad. Una inserción correcta suma uno; una retirada correcta resta uno.

Los permisos pueden estar reservados por operaciones en curso. Un productor puede haber consumido huecos y todavía no haber publicado elementos; un consumidor puede haber consumido elementos y todavía no haber publicado huecos.

No se exige que una consulta aislada muestre siempre huecos + elementos = capacidad. Hay que incluir las reservas en tránsito y las fases de publicación.

Tampoco usados equivale en todo instante al valor consultable de elementos: un mensaje puede estar insertado y pendiente de publicación, o reservado para una retirada que todavía no actualizó los índices.

La corrección se obtiene siguiendo transiciones completas, no haciendo diagnósticos a partir de dos lecturas independientes de contadores. Al terminar todos los participantes, el programa comprueba que no quedan mensajes ni trabajo sin confirmar.

7. Cerrar la producción y enviar el fin

El productor de índice p genera p + 1, p + 1 + P, p + 1 + 2P... hasta N. Así los identificadores se reparten sin duplicados aunque haya más productores que tareas.

Cuando termina de publicar sus tareas, cada productor decrementa productores_activos bajo mutex. Quien observa que era el último se encarga de insertar un mensaje FIN por consumidor.

  1. Completar la publicación real. Cada productor solo se declara terminado después de que todas sus inserciones retornaron correctamente.
  2. Elegir un único cierre. El último productor se identifica modificando el contador protegido.
  3. Insertar C mensajes de fin. Se publican mediante las mismas operaciones que cualquier mensaje, fuera del mutex que protegió el contador.
  4. Salir al retirar un fin. Cada consumidor deja de retirar después de su propio FIN.
  5. Recoger y validar. El padre espera a todos antes de confirmar el trabajo.

Los fines se insertan después de todas las tareas reales, aunque algunas todavía se estén calculando. FIFO impide retirarlos antes que tareas aún en cola. Esperar a los consumidores garantiza que también terminaron los cálculos de las tareas ya retiradas.

Un consumidor que retira FIN no vuelve a tomar otro. Por eso C fines permiten terminar a C consumidores, incluidos los que no recibieron ninguna tarea. Los mensajes de fin tienen campos numéricos cero y una clase distinta de TAREA.

No se insertan fines por cada productor: un productor que termine temprano no puede autorizar el cierre de todos los consumidores mientras los demás todavía publican.

8. Supervisión y presupuesto monotónico

El padre no espera bloqueado un PID elegido de antemano. Revisa todos los pendientes con waitpid y WNOHANG, detecta terminaciones fallidas y consulta un reloj monotónico. Cuando no termina nadie, deja un intervalo corto entre revisiones.

El presupuesto comienza después de validar argumentos y antes de preparar la región. Se compara contra una misma fecha monotónica durante toda la supervisión; los trabajadores usan esperas bloqueantes sobre los semáforos.

Así una ausencia de progreso no necesita que cada hijo implemente una fecha de calendario separada. La duración se observa con CLOCK_MONOTONIC, conforme a clock_gettime(2).

El padre atiende SIGINT y SIGTERM como solicitudes de cancelación. Se bloquean antes de fork; los hijos las conservan bloqueadas y el padre restaura su máscara para recibirlas. La cancelación real de los hijos pendientes se realiza mediante SIGKILL.

El intervalo de revisión es de unos 10 ms, no una garantía de tiempo de respuesta exacto. La planificación y la recolección posterior pueden retrasar la salida. Si todos ya terminaron al revisarlos, el programa puede aceptar el resultado antes de evaluar otra espera.

9. Política de fallo y limpieza

La cola no intenta continuar tras una modificación parcial, una publicación fallida o la muerte de un trabajador. Un sem_post de emergencia podría crear permisos que no corresponden a datos y romper el contrato.

SituaciónPolíticaRetorno
Todos terminan y se valida el estado.Aceptar resultados y limpiar.0.
Error de preparación, hijo fallido o validación incorrecta.Cancelar pendientes y descartar.1.
Presupuesto agotado.Cancelar pendientes y descartar.2.
Cancelación solicitada durante supervisión.Cancelar pendientes y descartar.128 + señal.

Antes de destruir un semáforo se confirma la terminación de todos los hijos creados. Si la preparación falló antes de lanzar usuarios, solo se destruyen los objetos cuya inicialización tuvo éxito.

El padre conserva qué PID ya recogió. Envía cancelación únicamente a los pendientes, primero a todos y luego los espera. No intenta señalizar un PID que ya pudo dejar de pertenecer al hijo original.

sem_destroy no cancela a esperadores y no se utiliza con ellos activos. La precondición de destrucción se describe en sem_destroy(3). La política de fallo no convierte la región descartada en un estado recuperado.

10. Código de la región y sus operaciones

Guarda buffer30.h. La cabecera define la estructura nativa, límites, operaciones del anillo y funciones auxiliares. No se copia sem_t después de inicializar; los mensajes son estructuras simples sin punteros.

buffer30.h · región común, reserva de permisos y actualización de índices
#ifndef BUFFER30_H
#define BUFFER30_H
#define _DEFAULT_SOURCE
#include <errno.h>
#include <inttypes.h>
#include <semaphore.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#define MAX_TAREAS 10000u
#define MAX_P 4u
#define MAX_C 8u
#define MAX_CAP 64u
#define TAREA 1u
#define FIN 2u

struct mensaje { unsigned clase, id, valor; };
struct resultado { unsigned cantidad; uint64_t suma; };
struct config {
    unsigned tareas, productores, consumidores, capacidad, demora_ms, plazo_ms;
};
struct region {
    sem_t huecos, elementos, mutex;
    unsigned entrada, salida, usados, productores_activos;
    unsigned inserciones, retiradas;
    struct mensaje cola[MAX_CAP];
    unsigned producidas[MAX_P];
    struct resultado resultados[MAX_C];
    unsigned char visto[MAX_TAREAS + 1];
};
struct hijo { pid_t pid; int recogido; };

static inline int numero(const char *s, unsigned min, unsigned max, unsigned *v)
{
    if (!*s) return -1;
    for (const char *p = s; *p; ++p) if (*p < '0' || *p > '9') return -1;
    errno = 0;
    char *fin;
    unsigned long n = strtoul(s, &fin, 10);
    if (errno || *fin || n < min || n > max) return -1;
    *v = (unsigned)n;
    return 0;
}

static inline int esperar(sem_t *s)
{
    int r;
    do { r = sem_wait(s); } while (r == -1 && errno == EINTR);
    return r;
}

static inline int insertar(struct region *r, unsigned cap, struct mensaje m)
{
    if (esperar(&r->huecos) == -1) return -1;
    if (esperar(&r->mutex) == -1) return -1;
    if (r->entrada >= cap || r->usados >= cap) { errno = EPROTO; return -1; }
    r->cola[r->entrada] = m;
    r->entrada = (r->entrada + 1) % cap;
    ++r->usados;
    ++r->inserciones;
    if (sem_post(&r->mutex) == -1) return -1;
    return sem_post(&r->elementos);
}

static inline int retirar(struct region *r, unsigned cap, struct mensaje *m)
{
    if (esperar(&r->elementos) == -1) return -1;
    if (esperar(&r->mutex) == -1) return -1;
    if (r->salida >= cap || r->usados == 0 || r->usados > cap) {
        errno = EPROTO; return -1;
    }
    *m = r->cola[r->salida];
    r->salida = (r->salida + 1) % cap;
    --r->usados;
    ++r->retiradas;
    if (sem_post(&r->mutex) == -1) return -1;
    return sem_post(&r->huecos);
}

static inline int demorar(unsigned ms)
{
    struct timespec t = {(time_t)(ms / 1000), (long)(ms % 1000) * 1000000L};
    while (nanosleep(&t, &t) == -1) if (errno != EINTR) return -1;
    return 0;
}

static inline int64_t ahora_ms(void)
{
    struct timespec t;
    if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
    if (t.tv_sec < 0 || (uint64_t)t.tv_sec > (uint64_t)(INT64_MAX - 999) / 1000) {
        errno = EOVERFLOW; return -1;
    }
    return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}

int producir(struct region *r, const struct config *c, unsigned indice);
int consumir(struct region *r, const struct config *c, unsigned indice);
#endif

La capacidad se valida en el supervisor y todos los hijos heredan el mismo valor. No se calcula el módulo con cero ni se accede fuera de la reserva activa. Los controles internos detectan algunos desacuerdos de estado, pero no sustituyen el protocolo.

Si una adquisición o publicación falla, la operación puede haber dejado una reserva en tránsito o el mutex ocupado. No devuelve permisos especulativos: retorna error y provoca fallo total. Una publicación fallida no debe ocultarse, conforme a sem_post(3).

Las estructuras representan procesos del mismo ejecutable y ABI. La cola no se entrega a un programa independiente como un archivo portable. El mapeo y la herencia se apoyan en mmap(2).

11. Código de productores y consumidores

Guarda trabajadores30.c. Cada productor genera un subconjunto distinto de identificadores. Cada consumidor valida el mensaje, calcula fuera de la cola y registra la confirmación antes de continuar.

trabajadores30.c · reparto, confirmación y cierre por el último productor
#include "buffer30.h"

int producir(struct region *r, const struct config *c, unsigned indice)
{
    unsigned cantidad = 0;
    for (unsigned id = indice + 1; id <= c->tareas; id += c->productores) {
        struct mensaje m = {TAREA, id, id};
        if (insertar(r, c->capacidad, m) == -1) return 2;
        ++cantidad;
    }
    /* Un escritor por casilla; el padre la consulta despues de recoger. */
    r->producidas[indice] = cantidad;
    if (esperar(&r->mutex) == -1) return 3;
    if (r->productores_activos == 0) return 4;
    --r->productores_activos;
    int ultimo = r->productores_activos == 0;
    if (sem_post(&r->mutex) == -1) return 5;

    /* Nunca esperar huecos mientras se conserva mutex. */
    if (ultimo) {
        for (unsigned i = 0; i < c->consumidores; ++i) {
            struct mensaje m = {FIN, 0, 0};
            if (insertar(r, c->capacidad, m) == -1) return 6;
        }
    }
    return 0;
}

int consumir(struct region *r, const struct config *c, unsigned indice)
{
    struct resultado local = {0, 0};
    for (;;) {
        struct mensaje m;
        if (retirar(r, c->capacidad, &m) == -1) return 2;
        if (m.clase == FIN) {
            if (m.id != 0 || m.valor != 0) return 3;
            break;
        }
        if (m.clase != TAREA || m.id == 0 || m.id > c->tareas || m.valor != m.id)
            return 4;
        if (c->demora_ms && demorar(c->demora_ms) == -1) return 5;
        uint64_t cuadrado = (uint64_t)m.valor * m.valor;

        if (esperar(&r->mutex) == -1) return 6;
        if (r->visto[m.id] != 0) return 7;
        r->visto[m.id] = 1;
        if (sem_post(&r->mutex) == -1) return 8;
        ++local.cantidad;
        local.suma += cuadrado;
    }
    r->resultados[indice] = local;
    return 0;
}

La confirmación se protege porque varios consumidores podrían intentar marcar el mismo identificador si hubiera una anomalía. Rechazar un duplicado evita que una repetición oculte una tarea ausente. En condiciones normales, cada mensaje retirado pertenece a un único consumidor.

Las estadísticas por productor y consumidor tienen un escritor propio. El padre las lee solo después de recoger a todos. No son indicadores que se sondeen mientras cambian.

El último productor libera mutex antes de insertar fines. De lo contrario, cuando el búfer se llenara con mensajes de fin, podría esperar huecos conservando el bloqueo que los consumidores necesitan para retirar.

12. Código del supervisor

Guarda buffer30.c. El supervisor prepara datos y semáforos antes de fork, conserva todos los PID y verifica el estado completo. El bucle de espera no accede a los campos mutables de la región.

buffer30.c · supervisión, validación y destrucción sin usuarios
#include "buffer30.h"

static volatile sig_atomic_t senal = 0;

static void solicitar(int signo) { senal = signo; }

static int supervisar(struct hijo *h, unsigned n, int64_t limite)
{
    for (;;) {
        if (senal) return 128 + (int)senal;
        unsigned terminados = 0;
        for (unsigned i = 0; i < n; ++i) {
            if (h[i].recogido) { ++terminados; continue; }
            int estado;
            pid_t pid;
            do { pid = waitpid(h[i].pid, &estado, WNOHANG); }
            while (pid == -1 && errno == EINTR);
            if (pid == -1) { perror("waitpid"); return 1; }
            if (pid == 0) continue;
            h[i].recogido = 1;
            ++terminados;
            if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
                fprintf(stderr, "Hijo %ld fallido: se descarta la ejecucion\n",
                        (long)h[i].pid);
                return 1;
            }
        }
        if (terminados == n) return 0;
        int64_t ahora = ahora_ms();
        if (ahora == -1) { perror("reloj monotono"); return 1; }
        if (ahora >= limite) {
            fprintf(stderr, "Presupuesto de supervision agotado\n");
            return 2;
        }
        if (demorar(10) == -1) { perror("pausa supervision"); return 1; }
    }
}

static int validar(const struct region *r, const struct config *c)
{
    unsigned mensajes = c->tareas + c->consumidores;
    if (r->usados != 0 || r->productores_activos != 0 ||
        r->inserciones != mensajes || r->retiradas != mensajes ||
        r->entrada != mensajes % c->capacidad || r->salida != r->entrada)
        return -1;
    for (unsigned id = 1; id <= c->tareas; ++id)
        if (r->visto[id] != 1) return -1;
    for (unsigned i = 0; i < c->productores; ++i) {
        unsigned esperado = c->tareas > i ?
            (c->tareas - 1 - i) / c->productores + 1 : 0;
        if (r->producidas[i] != esperado) return -1;
    }
    unsigned cantidad = 0;
    uint64_t suma = 0;
    for (unsigned i = 0; i < c->consumidores; ++i) {
        cantidad += r->resultados[i].cantidad;
        suma += r->resultados[i].suma;
    }
    uint64_t n = c->tareas;
    uint64_t esperado = n * (n + 1) * (2 * n + 1) / 6;
    return cantidad == c->tareas && suma == esperado ? 0 : -1;
}

int main(int argc, char **argv)
{
    struct config c = {0, 0, 0, 0, 0, 10000};
    if (argc < 5 || argc > 7 ||
        numero(argv[1], 1, MAX_TAREAS, &c.tareas) == -1 ||
        numero(argv[2], 1, MAX_P, &c.productores) == -1 ||
        numero(argv[3], 1, MAX_C, &c.consumidores) == -1 ||
        numero(argv[4], 1, MAX_CAP, &c.capacidad) == -1 ||
        (argc >= 6 && numero(argv[5], 0, 20, &c.demora_ms) == -1) ||
        (argc == 7 && numero(argv[6], 100, 60000, &c.plazo_ms) == -1)) {
        fprintf(stderr, "Uso: %s tareas(1..10000) productores(1..4) "
                        "consumidores(1..8) capacidad(1..64) "
                        "[demora_ms(0..20)] [plazo_ms(100..60000)]\n", argv[0]);
        return 1;
    }
    struct sigaction a;
    memset(&a, 0, sizeof a);
    a.sa_handler = solicitar;
    sigset_t bloqueadas, anterior;
    if (sigemptyset(&a.sa_mask) == -1 ||
        sigaction(SIGINT, &a, NULL) == -1 || sigaction(SIGTERM, &a, NULL) == -1 ||
        sigemptyset(&bloqueadas) == -1 || sigaddset(&bloqueadas, SIGINT) == -1 ||
        sigaddset(&bloqueadas, SIGTERM) == -1 ||
        sigprocmask(SIG_BLOCK, &bloqueadas, &anterior) == -1) {
        perror("preparar senales"); return 1;
    }
    int mascara_bloqueada = 1, salida = 1;
    unsigned inicializados = 0, creados = 0;
    struct hijo hijos[MAX_P + MAX_C];
    struct resultado resumen[MAX_C] = {{0, 0}};
    struct region *r = MAP_FAILED;
    sem_t *semaforos[3] = {NULL, NULL, NULL};
    int64_t inicio = ahora_ms();
    if (inicio == -1 || inicio > INT64_MAX - c.plazo_ms) {
        fprintf(stderr, "No se pudo construir presupuesto monotono\n"); goto fin;
    }
    int64_t limite = inicio + c.plazo_ms;
    r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
             MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (r == MAP_FAILED) { perror("mmap"); goto fin; }
    r->entrada = r->salida = r->usados = 0;
    r->inserciones = r->retiradas = 0;
    r->productores_activos = c.productores;
    memset(r->producidas, 0, sizeof r->producidas);
    memset(r->resultados, 0, sizeof r->resultados);
    memset(r->visto, 0, sizeof r->visto);
    semaforos[0] = &r->huecos;
    semaforos[1] = &r->elementos;
    semaforos[2] = &r->mutex;
    unsigned valores[3] = {c.capacidad, 0, 1};
    for (unsigned i = 0; i < 3; ++i) {
        if (sem_init(semaforos[i], 1, valores[i]) == -1) {
            perror("sem_init"); goto fin;
        }
        ++inicializados;
    }
    for (unsigned i = 0; i < c.productores + c.consumidores; ++i) {
        pid_t pid = fork();
        if (pid == -1) { perror("fork"); goto fin; }
        if (pid == 0) {
            int codigo = i < c.productores ? producir(r, &c, i) :
                consumir(r, &c, i - c.productores);
            if (munmap(r, sizeof *r) == -1) codigo = 9;
            _exit(codigo);
        }
        hijos[creados++] = (struct hijo){pid, 0};
    }
    if (sigprocmask(SIG_SETMASK, &anterior, NULL) == -1) {
        perror("restaurar mascara"); goto fin;
    }
    mascara_bloqueada = 0;
    printf("Inicio PID %ld: %u tareas, %u productores, %u consumidores, capacidad %u\n",
           (long)getpid(), c.tareas, c.productores, c.consumidores, c.capacidad);
    if (fflush(stdout) == EOF) goto fin;
    salida = supervisar(hijos, creados, limite);
    if (salida == 0) {
        if (validar(r, &c) == -1) {
            fprintf(stderr, "Estado final invalido\n"); salida = 1;
        } else {
            for (unsigned i = 0; i < c.consumidores; ++i)
                resumen[i] = r->resultados[i];
        }
    }

fin:
    if (mascara_bloqueada && sigprocmask(SIG_SETMASK, &anterior, NULL) == -1) {
        perror("restaurar mascara al limpiar"); salida = 1;
    }
    if (salida != 0) {
        for (unsigned i = 0; i < creados; ++i)
            if (!hijos[i].recogido && kill(hijos[i].pid, SIGKILL) == -1 &&
                errno != ESRCH) perror("kill hijo pendiente");
    }
    int sin_usuarios = 1;
    for (unsigned i = 0; i < creados; ++i) {
        if (hijos[i].recogido) continue;
        int estado;
        pid_t pid;
        do { pid = waitpid(hijos[i].pid, &estado, 0); }
        while (pid == -1 && errno == EINTR);
        if (pid == -1) {
            perror("waitpid limpieza"); sin_usuarios = 0; salida = 1;
        } else hijos[i].recogido = 1;
    }
    if (sin_usuarios) {
        while (inicializados > 0) {
            --inicializados;
            if (sem_destroy(semaforos[inicializados]) == -1) {
                perror("sem_destroy"); salida = 1;
            }
        }
    } else {
        fprintf(stderr, "No se destruye sin confirmar la salida de usuarios\n");
    }
    if (r != MAP_FAILED && munmap(r, sizeof *r) == -1) {
        perror("munmap padre"); salida = 1;
    }
    if (salida == 0) {
        uint64_t suma = 0;
        for (unsigned i = 0; i < c.consumidores; ++i) {
            printf("Consumidor %u: %u tareas\n", i + 1, resumen[i].cantidad);
            suma += resumen[i].suma;
        }
        printf("Completadas: %u; hijos recogidos: %u; mensajes: %u\n",
               c.tareas, creados, c.tareas + c.consumidores);
        printf("Suma de cuadrados: %" PRIu64 "; bufer final vacio\n", suma);
    } else fprintf(stderr, "Ejecucion descartada; salida %d\n", salida);
    if (fflush(stdout) == EOF || ferror(stdout)) salida = 1;
    return salida;
}

La validación comprueba cada visto[id], las cantidades que debió generar cada productor y el total calculado por consumidores. Verifica también inserciones y retiradas incluyendo FIN, la ocupación cero y la posición final de los índices.

La suma de cuadrados se calcula en uint64_t. Con N igual a 10000 vale 333383335000 y sus productos intermedios también caben. La posición final de entrada y salida es (N + C) módulo capacidad, porque los mensajes de fin también recorren el anillo.

La supervisión usa los PID concretos de esta ejecución y no recoge hijos ajenos. La condición y los retornos de WNOHANG se documentan en wait(2). En la cancelación se señalizan solo hijos directos pendientes, conforme a kill(2).

13. Compilar y observar el resultado

Bash en Linux o WSL · tres archivos en el mismo directorio
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic buffer30.c trabajadores30.c -o buffer30 -pthread
$ ./buffer30 24 2 3 4 1
Inicio PID ...: 24 tareas, 2 productores, 3 consumidores, capacidad 4
Consumidor 1: 8 tareas
Consumidor 2: 8 tareas
Consumidor 3: 8 tareas
Completadas: 24; hijos recogidos: 5; mensajes: 27
Suma de cuadrados: 4900; bufer final vacio

El reparto 8, 8 y 8 es ilustrativo. Puede aparecer otro reparto, incluso un consumidor sin tareas. Las condiciones estables son 24 confirmaciones válidas, cinco hijos recogidos, 27 mensajes retirados y suma 4900.

La demora de un milisegundo representa coste de cálculo y favorece observar competencia, pero no sincroniza procesos ni garantiza equidad. El presupuesto por defecto es de diez segundos y la demora por defecto es cero.

Los hijos no imprimen durante la sección crítica ni durante el cálculo. El padre presenta estadísticas estables después de la recolección, la validación y la limpieza.

14. Probar capacidad y reparto

Bash · capacidad mínima, trabajo abundante y trabajadores sin tareas
$ ./buffer30 10000 4 8 1
... Completadas: 10000; hijos recogidos: 12; mensajes: 10008
Suma de cuadrados: 333383335000; bufer final vacio
$ ./buffer30 1 4 8 1
... Completadas: 1; hijos recogidos: 12; mensajes: 9
Suma de cuadrados: 1; bufer final vacio
$ ./buffer30 10000 1 1 64
... Completadas: 10000; hijos recogidos: 2; mensajes: 10001
Suma de cuadrados: 333383335000; bufer final vacio

Con capacidad uno, todos los mensajes reutilizan la misma posición y cada reserva de hueco es relevante. La solución debe seguir progresando porque nadie espera capacidad conservando mutex.

Con una tarea y cuatro productores, tres no generan trabajo real. Aun así deben declararse terminados correctamente, y un único último productor debe enviar ocho fines. Los consumidores sin tareas también salen.

Una capacidad mayor reduce algunas esperas entre ráfagas, pero no cambia la capacidad de cálculo de los consumidores. Si el trabajo es lento, los productores acabarán bloqueados por huecos: esa contrapresión limita el trabajo pendiente en la cola.

No uses estos números como un benchmark general de IPC. La marca por identificador, el cálculo diminuto, la demora y las revisiones del supervisor forman parte del coste del laboratorio.

15. Probar cancelación, plazo y caídas

Agotar el presupuesto

Bash · trabajo deliberadamente más largo que la ventana
$ ./buffer30 10000 2 1 4 20 100
Inicio PID ...: 10000 tareas, 2 productores, 1 consumidores, capacidad 4
Presupuesto de supervision agotado
Ejecucion descartada; salida 2
$ echo $?
2

La salida no debe incluir «Completadas» como si se hubiera aceptado un prefijo. El programa descarta el conjunto, cancela a todos los pendientes y los recoge. La recolección puede extender el tiempo de salida más allá del presupuesto observado.

Solicitar cancelación al supervisor

Bash · esperar a observar «Inicio» antes de enviar la señal
$ ./buffer30 10000 2 2 4 20 60000 > corrida30.txt &
$ supervisor=$!
$ cat corrida30.txt
Inicio PID ...: ...
$ kill -TERM "$supervisor"
$ wait "$supervisor"
$ echo $?
143

Si el mensaje todavía no apareció, vuelve a observarlo antes de enviar la señal. No se usa un sleep estimado para asumir que la política ya está instalada. En una terminal interactiva, Ctrl+C después del inicio solicita la cancelación del grupo mediante el padre.

Los hijos conservan bloqueadas SIGINT y SIGTERM. La prueba de caída de un trabajador debe utilizar SIGKILL sobre un hijo propio, o una variante de código que termine con error. El supervisor detectará esa terminación y cancelará al resto.

Inyectar fallos controlados

No alteres los semáforos de una ejecución ajena ni fabriques publicaciones para desbloquear pruebas. Cada ensayo debe controlar sus procesos y tener un límite externo de observación y limpieza.

16. Explorar la vuelta de los índices

Este modelo representa un productor y un consumidor por pasos, con las mismas cinco fases de las operaciones de cola. Puedes intercalar las fases y observar reservas que todavía no se publicaron. Las operaciones de varios productores del proyecto se serializan sobre los mismos índices mediante mutex.

Posiciones físicas[0: vacía] [1: vacía] [2: vacía] [3: vacía]

Índices y ocupaciónentrada 0; salida 0; usados 0

Permisos disponibleshuecos 4; elementos 0

ExclusiónMutex libre

ProductorEsperar huecos

ConsumidorEsperar elementos

Reservas en tránsitoproductor 0; consumidor 0

Comprobación de capacidad4 + 0 + 0 + 0 = 4

Inserta hasta llenar, retira y vuelve a insertar para ver la vuelta de los índices.

«Completar» avanza únicamente la operación actual hasta terminar o encontrar una espera que no puede progresar. El modelo no conserva mutex mientras espera capacidad. Prueba dejar una reserva adquirida antes de publicar y observa que huecos + elementos puede ser menor que la capacidad.

Las reservas en tránsito completan el balance del modelo: huecos disponibles + elementos disponibles + reserva del productor + reserva del consumidor = capacidad. La ocupación física cambia cuando se escribe o retira bajo mutex, no cuando se reserva el primer permiso.

La copia que ya retiró el consumidor se muestra localmente, aunque la casilla aparezca vacía. El modelo no simula mensajes FIN, cálculo ni supervisión; estudia el anillo y las fases de sus dos operaciones.

17. Diagnóstico y límites del diseño

SíntomaPosible errorQué revisar
Todo se bloquea con capacidad uno.Se espera huecos o elementos conservando mutex.Capacidad primero y exclusión después en ambos roles.
Se repiten o pierden tareas.Índices sin protección o lectura desde una casilla reutilizada.Copiar bajo mutex y calcular desde la copia local.
Los consumidores salen demasiado pronto.Un productor publica fines sin esperar al resto.Único cierre por el último productor confirmado.
Queda un consumidor esperando.Faltan mensajes de fin o un trabajador falló.Un fin por consumidor y supervisión de todos los PID.
Un total correcto oculta un fallo.Se comprueba solo suma o cantidad.Identificadores únicos, valores, estadísticas y estado final.
Se cree que terminó al ver la cola vacía.Hay tareas retiradas todavía calculándose.Esperar a los usuarios y comprobar confirmaciones.
Semáforos incoherentes tras una caída.Hay permisos en tránsito y datos parcialmente modificados.Descartar la generación; no reconstruir por consultas aisladas.
No se respeta la cancelación del padre.La política de señales y las máscaras no coinciden.Padre receptor y cancelación de hijos pendientes.

Observar operaciones del sistema

Bash · traza pequeña, con pocos mensajes
$ strace -f -e trace=mmap,munmap,futex,clone,fork,vfork,wait4,kill ./buffer30 6 2 2 2

La traza ayuda a relacionar creación de procesos, esperas internas, recolección y cancelación. La inserción de una estructura en la región es un acceso a memoria y no aparece como una llamada write de un mensaje IPC.

Un sem_wait sin contención puede resolverse sin una llamada al núcleo visible. Añadir impresiones dentro del bloqueo o trazar una carga grande cambia la planificación y puede alterar el reparto, sin cambiar qué contrato se exige.

Alcance de la recuperación

La tabla visto es acotada y solo representa esta tanda. Un servicio de duración indefinida necesitaría otro seguimiento, así como reglas de reciclado de identificadores y de resultados.

La confirmación significa que se calculó el cuadrado dentro del programa. Si la tarea enviara un correo, escribiera una base de datos o produjera otro efecto externo, la caída entre ese efecto y la confirmación exigiría idempotencia o un protocolo transaccional.

El presupuesto monotónico se aplica a la supervisión completa desde su inicio, pero se observa mediante revisiones. No interrumpe una llamada de preparación en el núcleo ni garantiza la duración de la limpieza. Una caída del supervisor por SIGKILL no ejecuta su cancelación y puede dejar hijos vivos: este proyecto no promete un supervisor externo del supervisor.

Qué validar automáticamente

Compila con advertencias y prueba capacidad uno, capacidad máxima, más procesos que tareas, productores múltiples y cargas que obliguen a dar varias vueltas. La prueba debe aceptar cualquier reparto que conserve identificadores y resultados.

Para fallos, inyecta errores de inicialización y creación de procesos en copias controladas, y fuerza la salida de un trabajador con un permiso adquirido. Comprueba el retorno, la ausencia de un resumen aceptado y la terminación de todos los hijos creados.

Una prueba del supervisor debe imponer su propio límite externo y comprobar procesos residuales. Probar que «el padre retornó error» no basta para demostrar que recogió a todos.

18. Resumen

19. Preguntas de repaso y ampliaciones

Responde antes de desplegar las explicaciones. Relaciona cada regla con las funciones insertar, retirar y producir.

1. ¿Por qué los índices vuelven a cero?

Porque la posición siguiente se calcula módulo capacidad. Las plazas se reutilizan solo después de que los permisos autoricen otra escritura.

2. ¿Entrada igual a salida significa vacío?

No por sí solo. Puede ocurrir también después de llenar todas las posiciones. El proyecto mantiene ocupación explícita y permisos con funciones distintas.

3. ¿Por qué hay tres semáforos?

Dos representan capacidad y mensajes disponibles; mutex evita actualizaciones conflictivas sobre índices y otros metadatos. Las funciones no se sustituyen entre sí.

4. ¿Qué pasa si se toma mutex antes de esperar huecos?

Un productor podría esperar capacidad conservando el bloqueo que un consumidor necesita para retirar y devolverla, creando una espera circular.

5. ¿Por qué el cálculo se hace sobre una copia local?

La posición compartida puede reutilizarse después de retirar y publicar huecos. La copia conserva el mensaje durante el cálculo sin impedir nuevas inserciones.

6. ¿La FIFO impone identificadores ordenados?

Conserva el orden efectivo de inserción, que depende de la competencia de productores. No impone orden numérico ni orden de terminación de cálculos.

7. ¿Por qué huecos más elementos puede ser menor que la capacidad?

Porque algunos permisos pueden estar reservados por operaciones en curso que todavía no publicaron el permiso de la fase siguiente.

8. ¿Quién inserta los mensajes de fin?

Un único productor: el último que decrementa productores_activos a cero bajo mutex, después de terminar todas sus inserciones reales.

9. ¿Por qué se envía un fin por consumidor?

Cada consumidor termina al retirar el suyo y no vuelve a consumir. Eso permite salir también a quienes no procesaron tareas.

10. ¿Una cola vacía demuestra trabajo completo?

No. Puede haber cálculos de mensajes ya retirados. El padre recoge a todos y valida sus confirmaciones y resultados.

11. ¿Por qué se conserva una marca por identificador?

Una suma o cantidad puede ocultar duplicados y ausencias. La marca permite rechazar repeticiones y comprobar que no falta ninguna tarea.

12. ¿Por qué el supervisor consulta todos los PID pendientes?

Para detectar fallos sin quedar bloqueado esperando a otro hijo que conserva una espera pendiente. Además puede revisar señales y presupuesto.

13. ¿Qué hace el programa si muere alguien con mutex adquirido?

El padre detecta la terminación, cancela a los otros pendientes y descarta el estado. No publica ni reinicializa para continuar sobre la misma región.

14. ¿El presupuesto garantiza la salida exacta en ese tiempo?

No. Se observa durante la supervisión y la planificación o recolección puede retrasar la salida. No es una interrupción exacta de toda operación del sistema.

15. ¿Qué debe ocurrir antes de sem_destroy?

La inicialización de ese objeto debe haber tenido éxito y debe confirmarse que todos los usuarios conocidos terminaron, sin participantes externos que puedan seguir operando.

Para practicar y ampliar

  1. Traza diez inserciones y retiradas con capacidad tres e identifica cada vuelta de los índices.
  2. Usa el simulador para dejar un permiso reservado antes de publicarlo y explica el balance de capacidad.
  3. Ejecuta una tarea con cuatro productores y ocho consumidores; comprueba la terminación de los procesos sin trabajo.
  4. Compara capacidad uno y 64 con la misma tanda, sin exigir un reparto uniforme.
  5. Comprueba qué validaciones detectan un identificador duplicado, un FIN incorrecto y una suma alterada.
  6. Simula el fallo del tercer sem_init y de un fork intermedio, revisando la destrucción y la recolección.
  7. Fuerza la muerte de un trabajador con mutex adquirido y verifica que no se acepta un resultado parcial.
  8. Solicita cancelación y agota un presupuesto corto en pruebas separadas; comprueba ambos retornos.
  9. Diseña un resultado de tarea más complejo sin introducir punteros hacia memoria privada.
  10. Propón una variante de servicio con participantes independientes y explica inicialización, generaciones, cierre y responsabilidad sobre los nombres.
Próximo paso

Con este proyecto termina el bloque de semáforos POSIX. El tema 31 comenzará los sockets de dominio Unix: familia AF_UNIX y diferencias entre SOCK_STREAM, SOCK_DGRAM y SOCK_SEQPACKET dentro del mismo equipo.