1. Definir trabajo, límites y garantía de éxito
El supervisor prepara vectores de enteros y cada trabajador calcula su suma. La operación no tiene efectos externos, por lo que un fallo no exige revertir archivos ni reconstruir transacciones. Permite concentrarse en reparto, identidad, publicación y recuperación de capacidad.
Una tarea termina cuando el supervisor adquiere la publicación del resultado, valida su identidad y verifica el valor. Extraer el mensaje de la cola no equivale a terminar la tarea.
| Elemento | Contrato del proyecto |
|---|---|
| Participantes. | Un supervisor y dos hijos propios creados con fork. |
| Tareas. | De 1 a 256; identificadores consecutivos desde uno. |
| Entrada por tarea. | De 1 a 1024 uint32; dato[j]=(id+j) módulo 1000. |
| Resultado. | Suma uint64, identidad de tarea, generación y PID de trabajador. |
| Capacidad. | Cuatro ranuras compartidas y dos mensajes en la cola. |
| Tiempo. | Ocho segundos absolutos para preparación de hijos, trabajo y finalización cooperativa. |
| Éxito. | Todas las tareas verificadas, parada normal de ambos hijos y recursos cerrados antes de emitir CSV. |
No hay garantía de reparto equitativo entre trabajadores. Uno puede completar muchas más tareas que otro. El resultado correcto exige que cada identidad aparezca una vez, no que los PIDs alternen.
La suma esperada se calcula en el supervisor mediante una fórmula de prefijos, independiente del recorrido del vector que hace el trabajador. El verificador Python volverá a calcularla con otra implementación para contrastar el archivo final.
2. Separar cola, datos, resultados y control
supervisor ── escribe vector ──► ranura compartida
│ │
│ publica listo │ lee tras adquirir listo
▼ ▼
cola POSIX: indice, generacion, id → trabajador disponible
│
calcula y escribe resultado
│
publica terminado
▼
supervisor adquiere, valida y libera la ranura para otra generacionLa cola contiene mensajes pequeños con metadatos, no los vectores completos. La región contiene entradas y resultados. Los semáforos establecen cuándo otro proceso puede consumir cada conjunto de campos.
El supervisor mantiene el estado de planificación en memoria privada: libre, pendiente de envío o enviada. Los trabajadores no modifican esos estados privados. Cada uno recibe una tarea de la cola y usa únicamente la ranura cuya publicación consiguió.
SIGINT y SIGTERM solicitan cancelar todo el proyecto; SIGCHLD despierta al supervisor para revisar waitpid. El programa no usa señales como contador exacto de tareas terminadas.
El coste adicional de sondear semáforos se hace explícito: cuando no hay progreso, se espera hasta dos milisegundos antes de revisar de nuevo, con reloj monotónico y control de cancelación. Es una solución acotada para cuatro ranuras; una implementación mayor puede agregar una notificación por descriptor sin sustituir la autoridad de los semáforos.
3. Diseñar la región compartida
El supervisor crea un objeto POSIX con shm_open, fija su tamaño con ftruncate y lo mapea con MAP_SHARED. Inicializa semáforos con pshared distinto de cero. La región se hereda por fork; los hijos no necesitan abrirla de nuevo por nombre.
| Zona | Escritor | Consumidor y sincronización |
|---|---|---|
| Identidad y vector de entrada. | Supervisor, solo en una ranura libre. | Trabajador después de tomar listo. |
| Identidad y valor de resultado. | Trabajador que recibió esa tarea. | Supervisor después de tomar terminado. |
| Semáforo listo por ranura. | Supervisor publica una vez por preparación. | Un trabajador consume el permiso de esa generación. |
| Semáforo terminado por ranura. | Trabajador publica al final. | Supervisor consume una vez antes de reutilizar. |
| Semáforo preparados. | Cada hijo publica una vez tras su inicialización. | Supervisor acumula dos confirmaciones de arranque. |
No se guardan punteros privados en mensajes. Los índices y generaciones identifican posiciones acordadas. La estructura compartida usa el mismo binario y ABI en padre e hijos; no es un formato persistente ni un contrato entre programas compilados con layouts incompatibles.
El ciclo de objetos y mapeos POSIX se describe en shm_overview(7). El requisito de ubicar semáforos entre procesos en memoria compartida está en sem_init(3).
El programa retira los nombres de cola y memoria antes de crear hijos, cuando ya conserva las referencias necesarias. Los objetos siguen vivos por sus referencias y mapeos. Eso evita dejar nombres publicados durante el trabajo y no convierte la memoria en almacenamiento durable.
4. Propiedad de una ranura y generaciones
LIBRE → preparar id y generacion → PENDIENTE
│ listo ya publicado
│ mq_send exitoso
▼
ENVIADA
│ trabajador toma listo
│ calcula y publica terminado
▼
supervisor toma terminado y valida
│
└─────────────► LIBREEl índice se repite al reutilizar una ranura; la generación se incrementa. Un resultado que solo dice «ranura 2» no prueba que corresponda a la tarea actual de esa ranura. Se comparan índice del mensaje, generación, ID y cantidad de elementos.
La identidad del resultado se escribe separada de la identidad de entrada. El supervisor no acepta un valor solo porque el vector todavía conserve su ID original: comprueba lo que el trabajador publicó como resultado.
El trabajador deja de tocar la ranura después de sem_post(terminado). El supervisor puede reutilizarla en cuanto adquiere ese permiso y valida los campos. Guardar un puntero a la ranura para seguir usándolo después de publicar rompería la transferencia de propiedad.
El máximo de tareas impide alcanzar el desbordamiento de generación en este proyecto; aun así, se comprueba antes de incrementarla. No se permite volver silenciosamente a una identidad antigua.
5. Protocolo de tareas y parada
Cada mensaje ocupa exactamente 24 bytes. Se serializa explícitamente: marca P050, versión 1, tipo, dos bytes reservados cero y cuatro uint32 big endian. No se envía una struct de C con padding dependiente de plataforma.
| Campo | TAREA, tipo 1 | PARAR, tipo 2 |
|---|---|---|
| Índice. | De cero a tres. | Cero. |
| Generación. | Positiva y correspondiente a la ranura. | Cero. |
| ID. | De uno al total solicitado. | Cero. |
| Cantidad. | De uno a 1024; coincide con la entrada publicada. | Cero. |
| Prioridad. | Cero. | Cero. |
La cola se crea con capacidad para dos mensajes de 24 bytes, O_NONBLOCK y modo 0600. Al recibir se comprueban tamaño exacto, prioridad, marca, versión, tipo y rangos antes de usar un índice.
mq_receive conserva mensajes y exige un buffer de al menos mq_msgsize; si la cola está vacía con O_NONBLOCK, informa EAGAIN. Estas reglas se documentan en mq_receive(3).
Los dos PARAR se envían únicamente después de verificar todos los resultados. Cada hijo consume uno y termina, por lo que no puede llevarse ambos. No se elevan sus prioridades para adelantar tareas: el cierre normal no debe descartar trabajo pendiente.
Los descriptores de cola heredados comparten propiedades de su descripción abierta. El programa mantiene O_NONBLOCK en todas las ramas y no cambia mq_flags desde un hijo. La vida y prioridades de las colas se explican en mq_overview(7).
6. Ordenar publicación, consumo y resultado
- El supervisor toma una ranura privada marcada libre y prepara su siguiente generación.
- Escribe identidad, cantidad y vector; limpia los campos de resultado anteriores.
- Publica listo una sola vez y conserva el mensaje como pendiente.
- Tras mq_send exitoso cambia el estado privado a enviada.
- El trabajador recibe el mensaje, toma listo y compara metadatos con la entrada compartida.
- Calcula la suma, escribe identidad, valor y PID de resultado.
- Publica terminado como su último acceso a esa ranura.
- El supervisor toma terminado, valida, copia el resultado a memoria privada y libera la ranura.
La sincronización del cuerpo se establece con los semáforos. No se supone que enviar metadatos por la cola sustituya implícitamente ese protocolo de memoria. La publicación de resultado tampoco se usa como prueba de que el proceso ya salió: eso se confirma con waitpid.
La cola no necesita un mutex global de aplicación para que dos trabajadores extraigan mensajes distintos. Los campos de una ranura sí necesitan la propiedad definida. Evitar un mutex global no significa acceder libremente a estructuras compartidas.
Si el mensaje lleva una generación equivocada, un trabajador puede haber consumido el permiso de una publicación que no le corresponde. La política es fallar y abandonar toda la ejecución, no intentar reparar ese permiso sobre la marcha.
7. Capacidad, cola llena y reintentos locales
Hay cuatro ranuras y solo dos posiciones en cola. Preparar una ranura no garantiza poder encolar su mensaje inmediatamente. El supervisor conserva la fase pendiente si mq_send informa EAGAIN y sigue revisando resultados, procesos y control.
Al reintentar ese envío no vuelve a escribir la entrada ni publica otro listo. El cuerpo ya tiene una identidad y una publicación pendiente. Duplicar sem_post por cada EAGAIN crearía permisos sobrantes que otra generación podría consumir.
Un envío exitoso cambia a enviada exactamente una vez. No se reenvía por no haber resultado todavía: el trabajador pudo haber recibido y estar calculando. El reintento local de un mq_send que no aceptó el mensaje es distinto de repetir una tarea ya aceptada.
El padre revisa todas las ranuras, prepara las libres y hace intentos no bloqueantes. Si hubo progreso, vuelve a revisar sin una pausa artificial; si no, espera hasta dos milisegundos. En cada vuelta comprueba plazo y señales, incluso cuando el trabajo avanza.
El hijo espera de forma acotada cuando la cola está vacía. No se usan mq_timedreceive ni sem_timedwait con fechas de reloj de pared para el presupuesto global: los reintentos no bloqueantes se limitan con CLOCK_MONOTONIC.
8. Arranque, plazos y recogida de trabajadores
Antes de fork se crean todos los recursos y se inicializan los nueve semáforos: uno de preparación y dos por ranura. Se registra cuántos se inicializaron correctamente para limpiar también un arranque parcial.
Cada hijo restablece sus señales de terminación, deja de conservar el signalfd del supervisor y publica preparado. El padre espera dos permisos, revisa posibles salidas y anuncia los PIDs por stderr. Solo después comienza a distribuir tareas.
Durante trabajo, una salida de hijo es fallo aunque su código sea cero. Durante cierre, se esperan códigos cero después de PARAR. SIGCHLD solo indica revisar; el supervisor conserva los dos PIDs y usa waitpid con WNOHANG.
Ante error, cancelación o plazo agotado, se termina a los hijos propios todavía no recogidos y se consumen sus estados antes de destruir semáforos, cerrar la cola y desmontar la región. No se devuelve una ranura libre mientras un trabajador pudiera seguir usándola.
El límite de ocho segundos gobierna la espera cooperativa. SIGKILL no ejecuta limpieza y una espera no interrumpible del núcleo puede retrasar la recogida efectiva. Ninguna rutina de aplicación promete hacer desaparecer instantáneamente un proceso en cualquier estado del sistema.
9. Proyecto completo en C
Guarda trabajadores50.c. El proyecto usa Linux para signalfd y banderas de creación, además de APIs POSIX de cola, memoria y semáforos. Los objetos se crean con O_EXCL y nombres nuevos derivados de un directorio privado; no se borran objetos ajenos para resolver una colisión.
#define _GNU_SOURCE
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/signalfd.h>
#include <sys/wait.h>
#include <mqueue.h>
#include <semaphore.h>
#include <poll.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define HIJOS50 2u
#define RANURAS50 4u
#define ELEMENTOS50 1024u
#define TAREAS50 256u
#define MSG50 24u
enum fase50 { LIBRE50, PENDIENTE50, ENVIADA50 };
struct ranura50 {
sem_t listo, terminado;
uint32_t id, generacion, cantidad;
uint32_t datos[ELEMENTOS50];
uint32_t resultado_id, resultado_generacion, resultado_cantidad;
uint64_t suma;
pid_t trabajador;
};
struct region50 {
sem_t preparados;
struct ranura50 ranuras[RANURAS50];
};
struct local50 {
enum fase50 fase;
uint32_t id, generacion, cantidad;
uint64_t esperado;
};
struct registro50 {
uint32_t id, indice, generacion;
pid_t trabajador;
uint64_t suma;
};
static int cerrar50(int *fd)
{
if (*fd < 0) return 0;
int n = *fd; *fd = -1;
if (close(n) == -1) { perror("close"); return -1; }
return 0;
}
static int numero50(const char *s, unsigned maximo, unsigned *v)
{
if (!*s) return -1;
for (const char *p = s; *p; ++p) if (*p < '0' || *p > '9') return -1;
errno = 0; char *fin;
unsigned long n = strtoul(s, &fin, 10);
if (errno || *fin || n < 1 || n > maximo) return -1;
*v = (unsigned)n; return 0;
}
static uint32_t obtener50(const unsigned char *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | p[3];
}
static void poner50(unsigned char *p, uint32_t n)
{
for (unsigned i = 0; i < 4; ++i) p[i] = (unsigned char)(n >> (24u - 8u * i));
}
static void mensaje50(unsigned char *b, unsigned tipo, uint32_t indice,
uint32_t generacion, uint32_t id, uint32_t cantidad)
{
memset(b, 0, MSG50); memcpy(b, "P050", 4); b[4] = 1; b[5] = (unsigned char)tipo;
poner50(b + 8, indice); poner50(b + 12, generacion);
poner50(b + 16, id); poner50(b + 20, cantidad);
}
static int64_t ahora50(void)
{
struct timespec t;
if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
/* control=-1 en hijos. ms=0 comprueba plazo y control sin pausa. */
static int pausa50(int control, int64_t limite, int ms)
{
int64_t ahora = ahora50();
if (ahora < 0) return -1;
if (ahora >= limite) { errno = ETIMEDOUT; return -1; }
if (limite - ahora < ms) ms = (int)(limite - ahora);
struct pollfd p = { .fd = control, .events = POLLIN };
int r = poll(&p, 1, ms);
if (r == -1) return errno == EINTR ? 0 : -1;
if (p.revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
if (p.revents & POLLIN) for (;;) {
struct signalfd_siginfo s;
ssize_t n = read(control, &s, sizeof s);
if (n == (ssize_t)sizeof s) {
if (s.ssi_signo == SIGINT || s.ssi_signo == SIGTERM) {
errno = ECANCELED; return -1;
}
} else if (n == -1 && errno == EINTR) continue;
else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) break;
else { errno = EIO; return -1; }
}
return 0;
}
static int tomar50(sem_t *s, int64_t limite)
{
for (;;) {
if (sem_trywait(s) == 0) return 0;
if (errno == EINTR) continue;
if (errno != EAGAIN || pausa50(-1, limite, 2) == -1) return -1;
}
}
static uint64_t prefijo50(uint64_t x)
{
uint64_t r = x % 1000u;
return (x / 1000u) * UINT64_C(499500) + (r ? r * (r - 1u) / 2u : 0);
}
static int trabajar50(mqd_t cola, struct region50 *r, unsigned total, int64_t limite)
{
if (sem_post(&r->preparados) == -1) return -1;
for (;;) {
if (pausa50(-1, limite, 0) == -1) return -1;
unsigned char b[MSG50];
unsigned prioridad = 0;
ssize_t n = mq_receive(cola, (char *)b, sizeof b, &prioridad);
if (n == -1) {
if (errno == EINTR) continue;
if (errno == EAGAIN) {
if (pausa50(-1, limite, 2) == -1) return -1;
continue;
}
return -1;
}
if (n != MSG50 || prioridad != 0 || memcmp(b, "P050", 4) != 0 ||
b[4] != 1 || b[6] != 0 || b[7] != 0) { errno = EPROTO; return -1; }
uint32_t i = obtener50(b + 8), gen = obtener50(b + 12);
uint32_t id = obtener50(b + 16), cantidad = obtener50(b + 20);
if (b[5] == 2) {
if (i || gen || id || cantidad) { errno = EPROTO; return -1; }
return 0;
}
if (b[5] != 1 || i >= RANURAS50 || gen == 0 || id == 0 || id > total ||
cantidad == 0 || cantidad > ELEMENTOS50) { errno = EPROTO; return -1; }
struct ranura50 *s = &r->ranuras[i];
if (tomar50(&s->listo, limite) == -1) return -1;
if (s->id != id || s->generacion != gen || s->cantidad != cantidad) {
errno = EPROTO; return -1;
}
uint64_t suma = 0;
for (uint32_t j = 0; j < cantidad; ++j) suma += s->datos[j];
s->resultado_id = id; s->resultado_generacion = gen;
s->resultado_cantidad = cantidad; s->suma = suma; s->trabajador = getpid();
if (sem_post(&s->terminado) == -1) return -1;
/* No volver a acceder a s: el supervisor ya puede reutilizarla. */
}
}
static int revisar50(pid_t hijos[HIJOS50], int recogidos[HIJOS50],
int terminando, unsigned *vivos)
{
for (unsigned i = 0; i < HIJOS50; ++i) {
if (hijos[i] <= 0 || recogidos[i]) continue;
int estado;
pid_t p;
do { p = waitpid(hijos[i], &estado, WNOHANG); } while (p == -1 && errno == EINTR);
if (p == hijos[i]) {
recogidos[i] = 1; --*vivos;
if (!terminando || !WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
errno = ECHILD; return -1;
}
} else if (p == -1) {
if (errno == ECHILD) recogidos[i] = 1;
return -1;
}
}
return 0;
}
int main(int argc, char **argv)
{
unsigned total, cantidad;
if (argc != 3 || numero50(argv[1], TAREAS50, &total) == -1 ||
numero50(argv[2], ELEMENTOS50, &cantidad) == -1) {
fprintf(stderr, "Uso: %s tareas(1..256) elementos(1..1024)\n", argv[0]);
return EXIT_FAILURE;
}
sigset_t mascara;
sigemptyset(&mascara); sigaddset(&mascara, SIGINT); sigaddset(&mascara, SIGTERM);
sigaddset(&mascara, SIGCHLD);
if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
signal(SIGCHLD, SIG_DFL) == SIG_ERR || signal(SIGPIPE, SIG_IGN) == SIG_ERR ||
sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) {
perror("senales"); return EXIT_FAILURE;
}
int control = -1, fd = -1, directorio = 0, nombre_m = 0, nombre_q = 0;
unsigned inicializados = 0, vivos = 0, completados = 0;
int salida = EXIT_FAILURE;
mqd_t cola = (mqd_t)-1;
struct region50 *r = MAP_FAILED;
char dir[] = "/tmp/ipc50.XXXXXX", nm[64] = {0}, nq[64] = {0};
pid_t hijos[HIJOS50] = {0};
int recogidos[HIJOS50] = {0};
struct local50 locales[RANURAS50] = {0};
static struct registro50 resultados[TAREAS50];
control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
if (control == -1 || mkdtemp(dir) == NULL) { perror("preparar"); goto fin; }
directorio = 1;
const char *sufijo = strrchr(dir, '.') + 1;
int lm = snprintf(nm, sizeof nm, "/p50m_%jd_%s", (intmax_t)getpid(), sufijo);
int lq = snprintf(nq, sizeof nq, "/p50q_%jd_%s", (intmax_t)getpid(), sufijo);
if (lm < 0 || lq < 0 || (size_t)lm >= sizeof nm || (size_t)lq >= sizeof nq) goto fin;
fd = shm_open(nm, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, 0600);
if (fd == -1) { perror("shm_open"); goto fin; }
nombre_m = 1;
if (shm_unlink(nm) == -1) { perror("shm_unlink"); goto fin; }
nombre_m = 0;
if (ftruncate(fd, sizeof *r) == -1) { perror("ftruncate"); goto fin; }
r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (r == MAP_FAILED || cerrar50(&fd) == -1) { perror("mapear/cerrar"); goto fin; }
struct mq_attr a = { .mq_maxmsg = 2, .mq_msgsize = MSG50 };
cola = mq_open(nq, O_CREAT | O_EXCL | O_RDWR | O_NONBLOCK | O_CLOEXEC, 0600, &a);
if (cola == (mqd_t)-1) { perror("mq_open"); goto fin; }
nombre_q = 1;
struct mq_attr real;
if (mq_getattr(cola, &real) == -1) { perror("mq_getattr"); goto fin; }
if (real.mq_msgsize != MSG50 || real.mq_maxmsg != 2 || !(real.mq_flags & O_NONBLOCK)) {
errno = EPROTO; perror("atributos de cola"); goto fin;
}
if (mq_unlink(nq) == -1) { perror("mq_unlink"); goto fin; }
nombre_q = 0;
if (sem_init(&r->preparados, 1, 0) == -1) goto fin;
inicializados = 1;
for (unsigned i = 0; i < RANURAS50; ++i) {
if (sem_init(&r->ranuras[i].listo, 1, 0) == -1) goto fin;
++inicializados;
if (sem_init(&r->ranuras[i].terminado, 1, 0) == -1) goto fin;
++inicializados;
}
if (rmdir(dir) == -1) { perror("rmdir inicial"); goto fin; }
directorio = 0;
int64_t limite = ahora50();
if (limite < 0) goto fin;
limite += 8000;
for (unsigned i = 0; i < HIJOS50; ++i) {
pid_t p = fork();
if (p == -1) { perror("fork"); goto fin; }
if (p == 0) {
sigset_t vacia; sigemptyset(&vacia);
if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
sigprocmask(SIG_SETMASK, &vacia, NULL) == -1 ||
cerrar50(&control) == -1) _exit(2);
int codigo = trabajar50(cola, r, total, limite);
if (codigo == -1) perror("trabajador");
if (mq_close(cola) == -1) codigo = -1;
if (munmap(r, sizeof *r) == -1) codigo = -1;
_exit(codigo == 0 ? 0 : 3);
}
hijos[i] = p; ++vivos;
}
unsigned preparados = 0;
while (preparados < HIJOS50) {
if (revisar50(hijos, recogidos, 0, &vivos) == -1) goto error;
if (sem_trywait(&r->preparados) == 0) ++preparados;
else if (errno != EINTR && errno != EAGAIN) goto error;
if (pausa50(control, limite, preparados == HIJOS50 ? 0 : 2) == -1) goto error;
}
if (fprintf(stderr, "P50 listo padre=%jd hijos=%jd,%jd ranuras=4 tareas=%u elementos=%u\n",
(intmax_t)getpid(), (intmax_t)hijos[0], (intmax_t)hijos[1], total, cantidad) < 0 ||
fflush(stderr) == EOF) goto error;
unsigned siguiente = 1, paradas = 0;
int terminando = 0;
while (vivos > 0) {
if (pausa50(control, limite, 0) == -1 ||
revisar50(hijos, recogidos, terminando, &vivos) == -1) goto error;
if (!vivos) break;
int avance = 0;
for (unsigned i = 0; i < RANURAS50; ++i) {
struct local50 *l = &locales[i];
struct ranura50 *s = &r->ranuras[i];
if (l->fase == ENVIADA50) {
if (sem_trywait(&s->terminado) == 0) {
if (s->resultado_id != l->id || s->resultado_generacion != l->generacion ||
s->resultado_cantidad != l->cantidad || s->suma != l->esperado ||
(s->trabajador != hijos[0] && s->trabajador != hijos[1]) ||
completados >= total) { errno = EPROTO; goto error; }
resultados[completados++] = (struct registro50) {
.id = l->id, .indice = i, .generacion = l->generacion,
.trabajador = s->trabajador, .suma = s->suma
};
l->fase = LIBRE50; avance = 1;
} else if (errno != EINTR && errno != EAGAIN) goto error;
}
if (l->fase == LIBRE50 && siguiente <= total) {
if (l->generacion == UINT32_MAX) { errno = EOVERFLOW; goto error; }
++l->generacion; l->id = siguiente++; l->cantidad = cantidad;
l->esperado = prefijo50((uint64_t)l->id + cantidad) - prefijo50(l->id);
s->id = l->id; s->generacion = l->generacion; s->cantidad = cantidad;
s->resultado_id = s->resultado_generacion = s->resultado_cantidad = 0;
s->suma = 0; s->trabajador = 0;
for (unsigned j = 0; j < cantidad; ++j) s->datos[j] = (l->id + j) % 1000u;
if (sem_post(&s->listo) == -1) goto error;
l->fase = PENDIENTE50; avance = 1;
}
if (l->fase == PENDIENTE50) {
unsigned char b[MSG50];
mensaje50(b, 1, i, l->generacion, l->id, l->cantidad);
if (mq_send(cola, (const char *)b, sizeof b, 0) == 0) {
l->fase = ENVIADA50; avance = 1;
} else if (errno != EINTR && errno != EAGAIN) goto error;
}
}
if (completados == total) terminando = 1;
while (terminando && paradas < HIJOS50) {
unsigned char b[MSG50]; mensaje50(b, 2, 0, 0, 0, 0);
if (mq_send(cola, (const char *)b, sizeof b, 0) == 0) {
++paradas; avance = 1;
} else if (errno == EINTR || errno == EAGAIN) break;
else goto error;
}
if (pausa50(control, limite, avance ? 0 : 2) == -1) goto error;
}
if (completados != total || paradas != HIJOS50) { errno = EPROTO; goto error; }
struct mq_attr final;
if (mq_getattr(cola, &final) == -1) goto error;
if (final.mq_curmsgs != 0) { errno = EPROTO; goto error; }
salida = EXIT_SUCCESS;
goto fin;
error:
perror("supervisor");
fin:
for (unsigned i = 0; i < HIJOS50; ++i)
if (hijos[i] > 0 && !recogidos[i])
if (kill(hijos[i], SIGKILL) == -1 && errno != ESRCH) perror("kill propio");
for (unsigned i = 0; i < HIJOS50; ++i) if (hijos[i] > 0 && !recogidos[i]) {
int estado; pid_t p;
do { p = waitpid(hijos[i], &estado, 0); } while (p == -1 && errno == EINTR);
if (p != hijos[i]) salida = EXIT_FAILURE;
recogidos[i] = 1;
}
if (cola != (mqd_t)-1 && mq_close(cola) == -1) salida = EXIT_FAILURE;
if (nombre_q && mq_unlink(nq) == -1) salida = EXIT_FAILURE;
if (r != MAP_FAILED) {
for (unsigned i = 0; i < RANURAS50; ++i) {
if (inicializados >= 2u * i + 2u && sem_destroy(&r->ranuras[i].listo) == -1) salida = EXIT_FAILURE;
if (inicializados >= 2u * i + 3u && sem_destroy(&r->ranuras[i].terminado) == -1) salida = EXIT_FAILURE;
}
if (inicializados >= 1 && sem_destroy(&r->preparados) == -1) salida = EXIT_FAILURE;
if (munmap(r, sizeof *r) == -1) salida = EXIT_FAILURE;
}
if (cerrar50(&fd) == -1) salida = EXIT_FAILURE;
if (cerrar50(&control) == -1) salida = EXIT_FAILURE;
if (nombre_m && shm_unlink(nm) == -1) salida = EXIT_FAILURE;
if (directorio && rmdir(dir) == -1) salida = EXIT_FAILURE;
if (salida == EXIT_SUCCESS) {
puts("tarea,ranura,generacion,trabajador,elementos,suma");
for (unsigned i = 0; i < completados; ++i)
printf("%u,%u,%u,%jd,%u,%" PRIu64 "\n", resultados[i].id, resultados[i].indice,
resultados[i].generacion, (intmax_t)resultados[i].trabajador, cantidad, resultados[i].suma);
if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
}
return salida;
}10. Leer el supervisor y los caminos de error
locales pertenece al padre y conserva el estado de cada ranura. La región r contiene únicamente el intercambio sincronizado. resultados es otra tabla privada, acotada al máximo de tareas, que conserva los valores ya validados hasta poder emitir el CSV final.
El padre primero recoge publicaciones, después prepara las ranuras libres y finalmente intenta enviar las pendientes. Una ranura puede completar una tarea y preparar otra generación en la misma vuelta, pero únicamente después de adquirir terminado y copiar el resultado.
| Observación | Acción | Dato conservado |
|---|---|---|
| mq_send devuelve EAGAIN. | Mantener pendiente y reintentar después. | La misma entrada, generación y publicación listo. |
| terminado no disponible. | Revisar otras ranuras y procesos. | No leer campos de resultado todavía. |
| Resultado válido. | Copiar a resultados y marcar libre. | Identidad y valor confirmados de esa generación. |
| Resultado incorrecto o hijo caído. | Abandonar y recoger a todos. | Evidencia de error; no publicar un CSV de éxito parcial. |
| Todas las tareas verificadas. | Enviar dos PARAR y esperar salidas normales. | Los resultados permanecen privados hasta completar limpieza. |
Después de recoger a ambos hijos también se comprueba que la cola quedó vacía. No basta haber intentado enviar dos PARAR: un hijo que saliera sin consumir el suyo dejaría un mensaje residual y haría fallar el cierre.
La salida se conserva en memoria privada para evitar que escribir un CSV largo forme parte del ciclo de distribución. El archivo se emite después de confirmar tareas, hijos y cierre de recursos. Un fallo de escritura del propio stdout todavía puede producir un archivo incompleto y retorno no cero; el verificador comprueba ese retorno.
Los nueve semáforos se destruyen según el contador de inicializaciones exitosas. No se reinicializa una ranura al reutilizarla: solo cambian sus campos y sus publicaciones, después de consumir los permisos de la tarea anterior.
11. Compilar y ejecutar el conjunto
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 trabajadores50.c -o trabajadores50 -pthread -lrt
./trabajadores50 24 1024 > resultados50.csv
cat resultados50.csvLa línea P50 listo aparece en stderr con los PIDs del supervisor y ambos hijos. stdout contiene exclusivamente la cabecera y las filas CSV después de un cierre exitoso. Por eso redirigir stdout no oculta el anuncio de preparación ni los errores.
El orden de filas es el orden en que el padre recogió resultados, no necesariamente el orden de ID ni el instante exacto en que terminó cada cálculo. Conservar identidad permite reconstruir la relación sin exigir un reparto específico entre los trabajadores.
| Columna | Significado |
|---|---|
| tarea. | ID único entre uno y el total solicitado. |
| ranura. | Índice reutilizable, de cero a tres. |
| generacion. | Uso sucesivo de esa ranura, empezando en uno. |
| trabajador. | PID de uno de los dos hijos anunciados. |
| elementos. | Longitud del vector solicitado para esa corrida. |
| suma. | Resultado uint64 validado por el padre. |
Prueba también 1 1, 7 17 y 256 1024. La última carga cruza el límite módulo 1000 en sus vectores y reutiliza ranuras muchas veces. Una máquina muy cargada puede agotar el plazo: ese ensayo falla, no reduce la cantidad de resultados para declarar éxito.
Se requiere soporte de colas POSIX y semáforos compartidos. El ejemplo no monta sistemas de archivos ni modifica límites del equipo para forzar su ejecución. Si falla la creación, revisa el error y el entorno antes de cambiar políticas del sistema.
12. Verificar el CSV desde Python
Guarda verificar50.py. El controlador inicia un grupo propio, drena stdout y stderr a la vez y aplica un límite externo de doce segundos. Contrasta todas las tareas y calcula sus sumas directamente, sin copiar la fórmula de prefijos del programa C.
import argparse
import csv
import io
import json
import os
from pathlib import Path
import re
import signal
import subprocess
import sys
CAMPOS = ["tarea", "ranura", "generacion", "trabajador", "elementos", "suma"]
def ejecutar(exe, total, elementos):
proceso = subprocess.Popen([str(exe), str(total), str(elementos)],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
text=True, start_new_session=True)
try:
salida, errores = proceso.communicate(timeout=12)
except BaseException:
try:
os.killpg(proceso.pid, signal.SIGKILL)
except ProcessLookupError:
pass
proceso.communicate()
raise
if proceso.returncode != 0:
raise ValueError("ejecucion fallida: " + errores.strip())
anuncios = re.findall(
r"^P50 listo padre=([0-9]+) hijos=([0-9]+),([0-9]+) ranuras=4 tareas=([0-9]+) elementos=([0-9]+)$",
errores, re.MULTILINE)
if len(anuncios) != 1:
raise ValueError("anuncio de preparacion incompatible")
padre, a, b, tareas, longitud = map(int, anuncios[0])
hijos = {a, b}
if padre != proceso.pid or len(hijos) != 2 or min(hijos) <= 0 or padre in hijos:
raise ValueError("identidades de procesos incorrectas")
if tareas != total or longitud != elementos:
raise ValueError("carga anunciada incorrecta")
lector = csv.DictReader(io.StringIO(salida))
filas = list(lector)
if lector.fieldnames != CAMPOS or len(filas) != total:
raise ValueError("cabecera o cantidad de resultados incorrecta")
vistos = set()
generaciones = [0] * 4
for fila in filas:
if None in fila or any(v is None for v in fila.values()):
raise ValueError("columnas incompletas o adicionales")
for campo in CAMPOS:
fila[campo] = int(fila[campo])
ident, indice = fila["tarea"], fila["ranura"]
if not 1 <= ident <= total or ident in vistos or not 0 <= indice < 4:
raise ValueError("tarea repetida, ausente o ranura invalida")
if fila["generacion"] != generaciones[indice] + 1:
raise ValueError("generacion fuera de secuencia")
if fila["trabajador"] not in hijos or fila["elementos"] != elementos:
raise ValueError("trabajador o carga incorrectos")
esperado = sum((ident + j) % 1000 for j in range(elementos))
if fila["suma"] != esperado:
raise ValueError("resultado incorrecto")
generaciones[indice] = fila["generacion"]
vistos.add(ident)
if vistos != set(range(1, total + 1)):
raise ValueError("faltan identidades de tarea")
return filas
def main():
p = argparse.ArgumentParser()
p.add_argument("ejecutable", type=Path)
p.add_argument("--tareas", type=int, default=24)
p.add_argument("--elementos", type=int, default=1024)
p.add_argument("--salida", type=Path, required=True)
a = p.parse_args()
if not 1 <= a.tareas <= 256 or not 1 <= a.elementos <= 1024:
raise ValueError("carga fuera de rango")
exe = a.ejecutable.resolve(strict=True)
with a.salida.open("x", newline="", encoding="utf-8") as archivo:
filas = ejecutar(exe, a.tareas, a.elementos)
escritor = csv.DictWriter(archivo, fieldnames=CAMPOS)
escritor.writeheader()
escritor.writerows(filas)
print(json.dumps({"tareas_verificadas": len(filas), "elementos": a.elementos,
"trabajadores_observados": sorted({f["trabajador"] for f in filas}),
"ranuras_usadas": len({f["ranura"] for f in filas}),
"generacion_maxima": max(f["generacion"] for f in filas)}))
if __name__ == "__main__":
try:
main()
except (ValueError, OSError, subprocess.TimeoutExpired) as error:
print(error, file=sys.stderr)
sys.exit(1)python3 verificar50.py ./trabajadores50 --tareas 24 --elementos 1024 --salida verificados50.csvEl archivo se crea con modo exclusivo: usa otro nombre si ya existe. Si el proceso falla antes de completar la validación, el archivo puede quedar vacío. La confirmación del controlador aparece únicamente cuando validó todo el conjunto y guardó las filas.
Para cada ranura, las generaciones deben aparecer consecutivas en el orden de recogida. Cada ID debe aparecer una vez y el PID debe pertenecer a los dos hijos de esa corrida. El verificador permite que solo uno haya calculado tareas; el otro pudo recibir únicamente PARAR.
Los PIDs del anuncio se usan para validar pertenencia, no para enviar señales por separado. El controlador termina únicamente el grupo que acaba de crear si una excepción o timeout impide completar la ejecución.
13. Caídas y cancelación sin reparación ficticia
| Punto de caída | Estado posible | Política del proyecto |
|---|---|---|
| Después de reservar una ranura. | Entrada preparada pero mensaje pendiente. | Abandonar la instancia si falla el supervisor; no hay servicio externo persistente. |
| Después de recibir el mensaje. | La tarea salió de la cola, pero no hay resultado. | Detectar salida del trabajador o vencer plazo; no reenviar a ciegas. |
| Después de tomar listo. | El permiso ya no está disponible y el cálculo puede estar incompleto. | Terminar al grupo y descartar la región. |
| Después de escribir el valor pero antes de terminado. | Hay bytes de resultado que el padre todavía no puede consumir. | No leer sin adquirir la publicación. |
| Después de publicar terminado. | El valor puede ser válido, pero el proceso todavía no fue recogido. | Verificar resultado y también la vida del trabajador. |
| Durante parada. | Puede quedar PARAR sin consumir o un hijo sin salir. | Comprobar cola vacía, códigos de salida y plazo. |
Un semáforo no registra un dueño recuperable del permiso. Si un trabajador muere después de tomar listo, incrementar listo «para compensar» no demuestra que la ranura esté libre ni que otro proceso no haya ejecutado parte del trabajo.
El proyecto decide abandonar toda la región ante un fallo. Reparar una instancia de larga vida requeriría estados verificables, dueños, generaciones, detección de muerte y una política para resultados desconocidos. No se obtiene agregando un sem_post en el manejador de SIGCHLD.
SIGINT y SIGTERM al supervisor producen fallo y recogida, sin emitir datos de éxito. Los trabajadores restablecen la terminación ordinaria, y la limpieza de error del padre usa SIGKILL sobre hijos todavía propios que no hayan sido recogidos.
Si el supervisor recibe SIGKILL, no ejecuta esa recogida. Los nombres ya retirados no quedan publicados, y los hijos tienen un plazo propio para sus esperas; aun así, un gestor del conjunto debe cubrir la muerte del supervisor y administrar los procesos restantes. Retirar nombres no equivale a detener procesos.
Las entradas y resultados no son durables. El tema 46 explica la diferencia entre publicación visible y estado recuperable. Si las tareas tuvieran efectos externos, necesitarían identidad de operación, deduplicación y reglas de recuperación además de este reparto.
14. Pruebas de identidad, publicación y limpieza
| Ensayo | Resultado esperado | Propiedad |
|---|---|---|
| Una tarea y cargas que reutilizan ranuras. | Todos los IDs una vez y sumas correctas. | Admisión y reciclado de capacidad. |
| Demorar un trabajador. | El otro puede consumir más tareas; no se exige alternancia. | Reparto independiente del orden de PIDs. |
| Forzar EAGAIN antes de aceptar varios mq_send. | Se conserva pendiente sin duplicar publicaciones. | Reintento local correcto. |
| Introducir EINTR sin transferir un mensaje. | La tarea se envía o recibe una vez cuando la llamada real progresa. | No inventar éxito ni duplicar mensajes. |
| Mensaje corto, marca o índice inválidos. | Trabajador falla; supervisor abandona sin CSV. | Validación antes de usar memoria. |
| Generación o ID de tarea equivocados. | Rechazo al contrastar la publicación. | Identidad de ranura y de operación. |
| Alterar entrada antes de publicar. | La suma no pasa la verificación independiente. | Consumo real del vector. |
| Alterar resultado, cantidad, PID o generación. | El padre rechaza la publicación. | No aceptar cualquier permiso como resultado válido. |
| Omitir listo o terminado. | Vence el plazo y se recoge a todos. | Una publicación perdida no produce espera infinita. |
| Hijo muerto o detenido. | Fallo observado o timeout; limpieza de los demás. | Inventario y cancelación del conjunto. |
| Segundo fork o sem_init intermedio falla. | Recoger hijos ya creados y destruir solo recursos inicializados. | Arranque parcial. |
| Hijo sale sin consumir su PARAR. | Cierre fallido por salida inesperada o mensaje residual. | No confundir envío de parada con parada consumida. |
Las inyecciones se hacen en copias de prueba con recursos propios. Para comprobar EAGAIN, devuelve -1 antes de llamar realmente mq_send; no envíes el mensaje y luego simules que no fue aceptado, porque eso cambiaría la semántica que se está probando.
Para corromper un mensaje, transmite realmente una cabecera alterada o una longitud corta admisible por la cola. Para corromper un resultado, cambia el campo antes de sem_post(terminado). El momento de inyección debe permitir atribuir el fallo a una frontera concreta.
Para cancelación y caída, una copia instrumentada puede anunciar preparado y detener al trabajador antes de recibir. El controlador espera el anuncio con plazo y actúa sobre PIDs de su ejecución. Se pueden reducir los ocho segundos en copias dedicadas a timeout.
Compara nombres de objetos antes y después de las pruebas, pero no elimines otros objetos por prefijos amplios. La exclusividad y el retiro temprano permiten comprobar que esta ejecución no deja nombres publicados durante el trabajo normal.
15. Simular ranuras, generaciones y resultados
El modelo reducido tiene dos ranuras, dos trabajadores y una posición de cola. Prepara más de una tarea para observar pendiente frente a enviada. Un resultado solo libera capacidad después de publicarse y ser validado por el supervisor.
Ranura 0—
Ranura 1—
Cola de tareas—
Trabajador A—
Trabajador B—
Resultados validados—
Estado de la ejecución—
Grupo y recursos—
—
El modelo elige la primera ranura y trabajador disponibles para que la secuencia se pueda seguir. El sistema real no garantiza ese orden. Los botones representan transiciones ya sincronizadas, no operaciones de memoria ejecutadas por el navegador.
La inyección de generación antigua publica un resultado incompatible en una ranura activa. Al validar, la instancia falla y se abandona. Recoger el grupo representa detener y consumir la salida de todos; solo después el modelo marca destruidos los recursos.
16. Observar procesos y objetos sin nombre
padre=12345 # reemplazar
hijo_a=12346 # reemplazar
hijo_b=12347 # reemplazar
ps -o pid,ppid,stat,wchan:24,cmd -p "$padre,$hijo_a,$hijo_b"
ls -l "/proc/$padre/fd"
cat "/proc/$padre/maps"Una corrida normal puede terminar antes de inspeccionarla. Usa una copia de prueba con un punto de pausa confirmado, no una espera arbitraria para suponer que todavía vive. La pausa también debe quedar bajo un límite del controlador.
La región mapeada puede aparecer asociada a un objeto retirado y los descriptores de cola siguen abiertos aunque su nombre ya no esté publicado. No encontrar un nombre en /dev/shm o /dev/mqueue no demuestra que no existan referencias vivas. La vista también depende del ámbito y de si ese sistema de archivos está montado.
ensayo=$(mktemp -d)
strace -ff -tt -T -yy -s 32 -o "$ensayo/traza" -e trace=mq_open,mq_unlink,mq_timedsend,mq_timedreceive,mq_getsetattr,openat,ftruncate,mmap,munmap,unlink,rmdir,clone,clone3,signalfd4,poll,read,futex,wait4,kill,close ./trabajadores50 24 1024En Linux, llamadas de biblioteca mq_send y mq_receive pueden aparecer mediante syscalls con otros nombres, incluidas variantes timed. Las operaciones de semáforo pueden resolverse en espacio de usuario y no generar siempre un futex observable. No cuentes tareas a partir del número de esas syscalls.
Relaciona creación exclusiva, retiro de nombres, fork, mensajes y recogida. La evidencia de resultado está en las publicaciones y validaciones del protocolo, no en que aparezca una línea de log. El tema 44 explica cómo interpretar las capturas y separar diagnóstico de rendimiento.
17. Conectar trabajadores con el servidor local
El servidor del tema 49 conserva una generación por conexión. Este proyecto conserva otra por ranura. Son identidades de recursos distintos: un resultado puede pertenecer a una ranura válida y aun así referirse a un cliente que ya cerró.
solicitud aceptada:
conexion_indice + conexion_generacion + solicitud_id
ranura_indice + ranura_generacion
resultado:
verificar publicacion de ranura
comprobar que conexion y solicitud siguen pendientes
formar respuesta bajo limite de salida
liberar ranura bajo su propio protocoloEl bucle epoll no debe esperar bloqueado a que termine un trabajador. Debe conservar solicitudes pendientes y recibir una notificación de resultados que le permita revisar las publicaciones. Un eventfd o canal de control puede despertar el bucle; el semáforo sigue estableciendo qué resultado puede consumir.
Cuando se llenan ranuras o cola, el servidor aplica contrapresión o rechazo según su contrato. Seguir leyendo clientes y acumulando tareas sin límite trasladaría la saturación desde el cálculo hacia la memoria del supervisor.
Una desconexión no permite reutilizar inmediatamente una ranura que otro proceso sigue leyendo. Puede abandonarse la respuesta para ese cliente y mantener el trabajo hasta una condición segura, o implementar una cancelación cooperativa con confirmación. Cambiar el fd del cliente no cancela memoria de un trabajador.
La unión de ambos proyectos requiere también cierre: detener admisión, decidir qué trabajo completar, recoger resultados o abandonarlos bajo reglas, parar trabajadores y retirar recursos. No consiste en llamar mq_send dentro de un manejador y olvidar la relación con la conexión.
18. Revisar límites y posibles extensiones
| Invariante | Qué lo sostiene | Qué lo rompería |
|---|---|---|
| Una generación por preparación. | Estado privado libre y contador comprobado. | Reescribir pendiente al volver a intentar envío. |
| Una publicación listo por tarea. | Separar preparación de mq_send. | sem_post en cada EAGAIN. |
| Resultado estable hasta consumo. | Último acceso del trabajador antes de terminado y adquisición del padre. | Seguir escribiendo tras publicar. |
| No destruir con participantes activos. | Inventario de PIDs y waitpid antes de limpieza. | munmap o sem_destroy al observar solo un timeout. |
| Trabajo completo antes de salida de éxito. | IDs verificados, PARAR, cola vacía, códigos cero y cierre. | Tomar un permiso o encolar una parada como prueba suficiente. |
Para más trabajadores o ranuras, revisa memoria total, profundidad de cola, costo de escaneo y frecuencia de notificaciones. Aumentar procesos puede aumentar contención o costo de planificación; no garantiza escalado del cálculo.
Una cola reparable de larga vida necesita más metadatos que este proyecto. Debe decidir cómo reconocer un dueño muerto y distinguir trabajo no empezado, en curso y resultado producido. La operación de suma es repetible; otras operaciones pueden necesitar un registro durable de identidad.
Para medir, separa preparación de objetos, fork, distribución, cálculo, recogida y cierre. No retires validación para conseguir una cifra mayor. El tema 48 aporta el criterio para comparar mecanismos conservando el contrato.
La pausa de dos milisegundos es una política visible del ejemplo. Para menor latencia puede reemplazarse el sondeo por notificaciones y un bucle de eventos, conservando la lectura autoritativa de semáforos y el tratamiento de avisos agrupados.
19. Resumen, repaso y práctica
El supervisor distribuye metadatos por cola POSIX y conserva los cuerpos en memoria compartida. Las generaciones identifican cada uso de una ranura y los semáforos publican entrada y resultado. Los procesos se recogen antes de destruir sincronización; un fallo abandona la instancia sin fingir que los permisos reparan trabajo desconocido.
- Capacidad: cuatro ranuras y dos mensajes, ambos límites explícitos.
- Identidad: tarea, índice y generación se comprueban en cada frontera.
- Publicación: listo y terminado significan fases distintas.
- Finalización: resultado verificado, parada consumida y proceso recogido son condiciones separadas.
- Fallo: terminar participantes antes de abandonar recursos compartidos.
Preguntas de repaso
1. ¿Qué lleva la cola?
Mensajes de 24 bytes con índice, generación, ID y cantidad, o una orden PARAR. Los vectores y resultados están en la región compartida.
2. ¿Por qué no enviar un puntero a la ranura?
La dirección virtual no es un identificador portable entre procesos. El protocolo usa índices validados dentro de una región acordada.
3. ¿Qué publica listo?
La entrada completa de una generación. El trabajador la consume después de adquirir ese permiso.
4. ¿Qué publica terminado?
Un resultado completo que el supervisor puede validar. No confirma que el trabajador ya haya salido.
5. ¿Se publica otro listo si mq_send devuelve EAGAIN?
No. Se conserva la misma tarea pendiente y se reintenta solo el envío que no fue aceptado.
6. ¿Por qué una ranura necesita generación?
El índice se reutiliza. La generación distingue su tarea actual de mensajes o resultados de un uso anterior.
7. ¿Puede un trabajador seguir usando la ranura después de terminado?
No. Su publicación permite que el padre adquiera y reutilice la ranura después de validar.
8. ¿Hay reparto equitativo garantizado?
No. Los trabajadores compiten por mensajes y uno puede hacer casi todo el trabajo. La corrección no exige alternancia.
9. ¿Por qué retirar nombres antes de fork?
Las referencias ya existen y se heredan. Los objetos siguen vivos, pero no quedan publicados para aperturas independientes durante el trabajo.
10. ¿Cómo se confirma la preparación?
Cada hijo publica una vez en preparados; el padre consume dos permisos y vigila salidas antes de comenzar la distribución.
11. ¿Qué ocurre si un trabajador cae con una tarea tomada?
El supervisor falla, termina al resto y recoge a todos. No reenvía ni repone permisos a ciegas.
12. ¿Por qué comprobar la cola vacía al final?
Enviar PARAR no demuestra que se consumió. Después de ambas salidas normales no deben quedar mensajes residuales.
13. ¿Los resultados compartidos son durables?
No. Su publicación permite cooperación en esta ejecución, no recuperación frente a pérdida de estado volátil.
14. ¿Qué identidad adicional necesita el servidor epoll?
Índice y generación de conexión, más identidad de solicitud, además de la identidad de ranura de trabajo.
15. ¿Qué se debe hacer antes de sem_destroy?
Confirmar que los participantes ya no pueden utilizar el semáforo; aquí se termina y recoge a todos los hijos primero.
Para practicar y ampliar
- Dibuja una tarea desde libre hasta el siguiente uso de la misma ranura.
- Ejecuta cargas mínimas y máximas y verifica todas las columnas del CSV.
- Fuerza varios EAGAIN y comprueba que no se duplican publicaciones.
- Introduce mensajes de tamaño incorrecto y generaciones antiguas.
- Corrompe un vector o un campo de resultado antes de su publicación.
- Omite listo y terminado en copias con plazo reducido.
- Detén a un trabajador y verifica cancelación y recogida.
- Falla el segundo fork y una inicialización intermedia de semáforo.
- Comprueba que no quedan nombres publicados durante una pausa confirmada.
- Diseña una notificación de resultados para un bucle epoll.
- Relaciona generación de conexión y generación de ranura sin reutilizar referencias caducadas.
- Define qué necesitaría una recuperación durable de tareas con efectos externos.
El tema 51 prueba los proyectos bajo fallos: mensajes fragmentados, clientes lentos, señales y verificación de limpieza. Las garantías de estos dos proyectos se convertirán en ensayos reproducibles.