1. Elegir la unidad de comunicación
En el tema 18 construimos registros de 256 bytes sobre una FIFO. La aplicación tuvo que acordar el tamaño, enviarlo sin entremezclar clientes y acumular lecturas hasta reconstruir cada petición. La FIFO seguía siendo un flujo; las fronteras pertenecían al protocolo.
Ahora estudiaremos mecanismos en los que el núcleo conserva la unidad enviada. Una tarea de cálculo, una orden de trabajo o un aviso con datos puede representarse como un mensaje que el receptor retira completo.
Un flujo de bytes ofrece una secuencia que la aplicación divide en unidades. Una cola de mensajes conserva las unidades de envío y permite recibir una por operación, según sus reglas de selección.
Esto simplifica parte del transporte, pero no define el significado del contenido, la identidad de la tarea, el resultado ni la recuperación de fallos. Las colas POSIX y System V son mecanismos de IPC del sistema; no equivalen por sí mismas a un servicio de mensajería durable con confirmaciones.
2. Qué conserva un flujo de bytes
En una tubería o FIFO no existe una marca que diga «aquí terminó el primer write». Un read puede recibir un prefijo, el resto de una escritura anterior o contenido de varias. No es pérdida de datos: es el contrato de un flujo.
Para reconstruir solicitudes sobre ese flujo puedes usar longitudes, delimitadores o registros fijos. Cada alternativa necesita límites y una política ante unidades incompletas. El tema 18 eligió registros fijos; otros protocolos prefieren longitudes para no enviar relleno.
3. Atomicidad y fronteras de recepción
PIPE_BUF responde a una pregunta sobre escritores concurrentes: qué tamaños pueden enviarse sin que sus bytes se entremezclen con los de otras escrituras. No convierte el canal en una cola ni impone el tamaño de read.
Dos escrituras atómicas AB y CDE pueden producir ABCDE y una lectura de tres bytes devolver ABC. Ninguna escritura se mezcló internamente, pero el consumidor cruzó su frontera.
En una cola, las operaciones de envío aceptan mensajes completos o fallan; no se usa el patrón de avanzar por un retorno positivo parcial de mq_send o msgsnd. Las lecturas de un flujo y las recepciones de mensajes requieren estrategias diferentes.
La distinción entre atomicidad y flujo se documenta en pipe(7). No traslades automáticamente una función escribir_todo a una API de mensajes: comprueba sus retornos y condiciones propias.
4. Qué conserva una cola de mensajes
Un envío define una unidad con una longitud. Una recepción normal retira una unidad elegible; no agrupa dos mensajes para llenar el búfer ni conserva una mitad para la siguiente recepción. Las reglas frente a un búfer pequeño dependen de la familia.
El contenido puede incluir bytes cero y no tiene por qué ser texto. La longitud retornada determina cuántos bytes son válidos; el núcleo no añade un terminador NUL para usar el resultado como una cadena de C.
La cola puede almacenar mensajes aunque en ese instante no haya un consumidor esperando, mientras conserve capacidad. No necesita el encuentro lector/escritor propio de la apertura de una FIFO. Esto desacopla los momentos de producción y consumo, dentro de sus límites de recursos.
En POSIX se obtiene un mqd_t con mq_open; System V utiliza un identificador entero obtenido con msgget. No se pueden intercambiar esos identificadores ni mezclar las funciones de ambas familias.
5. Mensajes vacíos y búferes insuficientes
| Situación | Cola POSIX | Cola System V |
|---|---|---|
| Recepción correcta. | Retira un mensaje y devuelve su longitud. | Retira el mensaje seleccionado y devuelve su longitud de contenido. |
| Búfer pequeño. | Debe poder contener mq_msgsize, aunque el siguiente mensaje sea menor; falla con EMSGSIZE si no cumple. | Si no cabe el mensaje seleccionado, falla con E2BIG y lo conserva. |
| Truncamiento explícito. | mq_receive no ofrece una opción equivalente. | MSG_NOERROR permite truncar y retirar el mensaje; el resto se pierde. |
| Mensaje de longitud cero. | Válido; recibirlo devuelve cero. | Válido; recibirlo devuelve cero, aunque conserva su tipo. |
| Sin mensaje elegible y sin espera. | EAGAIN con O_NONBLOCK. | ENOMSG con IPC_NOWAIT en recepción. |
Cero en una recepción de cola no es EOF: puede significar que se retiró un mensaje vacío. Sin un mensaje disponible, la operación espera o devuelve el error correspondiente. El cierre de los productores no genera un fin de flujo automático.
En POSIX se consulta mq_msgsize para reservar el búfer receptor. No basta con saber que «mis mensajes normales son pequeños». El contrato de tamaño está en mq_receive(3).
6. Prioridades POSIX y selección por tipo
POSIX entrega primero el mensaje de mayor prioridad numérica entre los pendientes. A igual prioridad se conserva el orden de envío a la cola. Para obtener un orden de recepción FIFO entre todos, utiliza la misma prioridad en todos los mensajes.
La prioridad no adelanta una tarea ya retirada ni aumenta la prioridad de planificación del proceso trabajador. Tampoco asegura equidad: una llegada sostenida de mensajes prioritarios puede retrasar indefinidamente los de menor prioridad. El criterio de inserción se documenta en mq_send(3).
| System V: valor de msgtyp al recibir | Selección habitual | Ejemplo |
|---|---|---|
| 0. | Primer mensaje de la cola. | Consumir sin filtrar por tipo. |
| Positivo t. | Primer mensaje cuyo tipo sea exactamente t. | Un trabajador consume solo tipo 5. |
| Negativo −t. | Mensaje del tipo numéricamente menor entre los tipos que no superan t; dentro de ese tipo, el primero. | Con tipos 5, 2 y 5, recibir con −5 elige el tipo 2. |
La tabla no utiliza extensiones de selección como MSG_EXCEPT o MSG_COPY. El tipo positivo de System V es una etiqueta que participa en la selección; no es la prioridad POSIX. No conviertas un número de prioridad en un tipo suponiendo que producirán el mismo orden.
7. Capacidad, contrapresión y límites
Una cola no es almacenamiento ilimitado. En POSIX se configuran un máximo de mensajes mq_maxmsg y un máximo de bytes por mensaje mq_msgsize. mq_curmsgs informa cuántos mensajes están pendientes. Un mensaje pequeño también ocupa una entrada de ese máximo.
En System V, msg_qbytes limita el contenido total pendiente y la implementación también evita una cantidad ilimitada de mensajes vacíos. Existen otros límites por mensaje, por sistema y por usuario. No supongas que el producto de dos atributos representa toda la memoria real consumida por el núcleo.
| Operación sin progreso | Modo bloqueante | Modo sin espera |
|---|---|---|
| Enviar a una cola llena. | Puede esperar espacio. | POSIX: EAGAIN; System V con IPC_NOWAIT: EAGAIN. |
| Recibir de una cola sin mensaje elegible. | Puede esperar una llegada compatible. | POSIX: EAGAIN; System V con IPC_NOWAIT: ENOMSG. |
| Mensaje mayor que el máximo admitido. | No se arregla esperando consumidores. | Es un error de tamaño/configuración, no una saturación temporal. |
La contrapresión sigue siendo necesaria. Si el productor acumula en memoria todo lo que no consigue enviar, solo mueve la cola ilimitada desde el núcleo hacia su proceso. Define límites, rechazo, espera o descarte según la aplicación.
8. Vida de la cola y ausencia de EOF
Una cola vacía no informa que todos los productores terminaron. No existe el EOF de una tubería por cierre del último escritor. El protocolo puede utilizar mensajes de parada, una cantidad conocida de tareas o una coordinación externa.
En POSIX, mq_close libera una referencia y mq_unlink retira el nombre. Una cola desvinculada sigue disponible a través de referencias existentes y se destruye al cerrarse la última. Si se deja nombrada, cerrar todos los procesos no basta para eliminarla. Es persistencia en el núcleo, no garantía de conservación tras reiniciar el sistema.
En System V, msgctl con IPC_RMID elimina la cola; las operaciones pendientes o posteriores sobre ese objeto no continúan como con una cola POSIX desvinculada. El efecto de la retirada se documenta en msgctl(2).
Un mensaje de parada con prioridad alta podría adelantarse a tareas pendientes. Un trabajador que lo reciba y salga puede dejar trabajo sin consumir. El protocolo de terminación debe definir el orden de parada y cuántos consumidores deben recibirla.
9. POSIX y System V: dos familias distintas
| Aspecto | POSIX | System V |
|---|---|---|
| Crear o localizar. | mq_open y un nombre como /curso19. | msgget con una clave; retorna un msqid. |
| Referencia de uso. | mqd_t. | Identificador entero de la cola. |
| Enviar y recibir. | mq_send / mq_receive. | msgsnd / msgrcv. |
| Metadato de orden/selección. | Prioridad separada del contenido. | long mtype positivo al inicio del objeto de envío. |
| Sin espera. | O_NONBLOCK en el estado de la apertura. | IPC_NOWAIT en cada operación. |
| Espera con plazo. | mq_timedsend / mq_timedreceive. | No hay un equivalente directo en msgsnd/msgrcv. |
| Administración. | mq_getattr, mq_setattr, mq_close, mq_unlink. | msgctl, incluyendo IPC_STAT e IPC_RMID. |
| Herramientas en Linux. | Sistema de archivos mqueue, habitualmente /dev/mqueue. | ipcs -q y /proc/sysvipc/msg. |
Las API son diferentes aunque ambas transporten mensajes. Este bloque desarrollará principalmente POSIX; System V se utiliza aquí para reconocer su modelo y evitar confundir sus reglas. La relación entre ambas familias se presenta en mq_overview(7).
No trates mqd_t como un descriptor ordinario en código portable. Linux ofrece posibilidades de integración específicas, pero el programa del curso utiliza las funciones mq_* de la interfaz.
10. Experimento: dos escrituras, otras lecturas
El programa coloca AB y CDE en una tubería antes de comenzar a leer. Solo son cinco bytes, por lo que no dependemos de una capacidad grande ni necesitamos otro proceso para consumir en paralelo.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
static int escribir_pequeno(int fd, const char *datos, size_t cantidad)
{
ssize_t n;
do {
n = write(fd, datos, cantidad);
} while (n == -1 && errno == EINTR);
return n == (ssize_t)cantidad ? 0 : -1;
}
int main(void)
{
int canal[2];
if (pipe(canal) == -1) { perror("pipe"); return EXIT_FAILURE; }
if (escribir_pequeno(canal[1], "AB", 2) == -1 ||
escribir_pequeno(canal[1], "CDE", 3) == -1) {
fprintf(stderr, "No se completaron las escrituras pequenas\n");
close(canal[0]); close(canal[1]);
return EXIT_FAILURE;
}
close(canal[1]);
char buffer[3];
int resultado = EXIT_SUCCESS;
for (;;) {
ssize_t n = read(canal[0], buffer, sizeof buffer);
if (n > 0) {
printf("read(3) devolvio %zd: ", n);
fwrite(buffer, 1, (size_t)n, stdout);
putchar('\n');
} else if (n == 0) {
puts("read devolvio 0: EOF del flujo");
break;
} else if (errno != EINTR) {
perror("read"); resultado = EXIT_FAILURE; break;
}
}
close(canal[0]);
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic observar_flujo.c -o observar_flujo
$ ./observar_flujo
read(3) devolvio 3: ABC
read(3) devolvio 2: DE
read devolvio 0: EOF del flujoEl código informa lo que devolvió cada read; no exige que toda plataforma o situación entregue exactamente esos grupos. La propiedad relevante es que no hay una frontera de mensaje asociada al primer write de dos bytes.
11. Experimento: mensajes y prioridades POSIX
Crearemos una cola temporal con capacidad para tres mensajes de hasta 16 bytes. El laboratorio utiliza una sola apertura de lectura/escritura no bloqueante, para fijar el estado antes de cada comprobación sin depender del planificador.
El nombre se crea con O_EXCL y se desvincula inmediatamente: el descriptor sigue siendo válido, pero otros procesos no pueden abrirla por ese nombre. No se retira una cola preexistente. La gestión detallada de nombres y atributos será el tema 20.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int enviar(mqd_t cola, const char *datos, size_t n, unsigned prioridad)
{
int r;
do { r = mq_send(cola, datos, n, prioridad); }
while (r == -1 && errno == EINTR);
return r;
}
static ssize_t recibir(mqd_t cola, char *datos, size_t n, unsigned *prioridad)
{
ssize_t r;
do { r = mq_receive(cola, datos, n, prioridad); }
while (r == -1 && errno == EINTR);
return r;
}
int main(void)
{
struct mq_attr atributos = {.mq_maxmsg = 3, .mq_msgsize = 16};
mqd_t cola = (mqd_t)-1;
char nombre[96];
for (int intento = 0; intento < 100; ++intento) {
snprintf(nombre, sizeof nombre, "/curso19_%ld_%d", (long)getpid(), intento);
cola = mq_open(nombre, O_CREAT | O_EXCL | O_RDWR | O_NONBLOCK,
0600, &atributos);
if (cola != (mqd_t)-1 || errno != EEXIST) break;
}
if (cola == (mqd_t)-1) { perror("mq_open"); return EXIT_FAILURE; }
int resultado = EXIT_FAILURE, desvinculada = 0;
if (mq_unlink(nombre) == -1) { perror("mq_unlink"); goto limpieza; }
desvinculada = 1;
if (enviar(cola, "normal-A", 8, 2) == -1 ||
enviar(cola, "urgente", 7, 9) == -1 ||
enviar(cola, "normal-B", 8, 2) == -1) {
perror("mq_send"); goto limpieza;
}
if (enviar(cola, "X", 1, 1) != -1 || errno != EAGAIN) goto inesperado;
puts("Cuarto mensaje: EAGAIN, cola llena");
char pequeno[8], buffer[16];
unsigned prioridad;
if (recibir(cola, pequeno, sizeof pequeno, &prioridad) != -1 ||
errno != EMSGSIZE) goto inesperado;
if (mq_getattr(cola, &atributos) == -1) { perror("mq_getattr"); goto limpieza; }
printf("Buffer de 8: EMSGSIZE; pendientes: %ld\n", atributos.mq_curmsgs);
if (atributos.mq_curmsgs != 3) goto inesperado;
for (int i = 0; i < 3; ++i) {
ssize_t n = recibir(cola, buffer, sizeof buffer, &prioridad);
if (n == -1) { perror("mq_receive"); goto limpieza; }
printf("Mensaje de %zd bytes, prioridad %u: %.*s\n",
n, prioridad, (int)n, buffer);
}
char excesivo[17] = {0};
if (enviar(cola, excesivo, sizeof excesivo, 0) != -1 ||
errno != EMSGSIZE) goto inesperado;
puts("Envio de 17 bytes: EMSGSIZE");
if (enviar(cola, "", 0, 0) == -1) { perror("mensaje vacio"); goto limpieza; }
if (recibir(cola, buffer, sizeof buffer, &prioridad) != 0) goto inesperado;
puts("Mensaje vacio recibido: 0 bytes, no EOF");
if (recibir(cola, buffer, sizeof buffer, &prioridad) != -1 ||
errno != EAGAIN) goto inesperado;
puts("Cola sin mensajes: EAGAIN");
resultado = EXIT_SUCCESS;
goto limpieza;
inesperado:
fprintf(stderr, "Resultado distinto del esperado\n");
limpieza:
if (mq_close(cola) == -1) { perror("mq_close"); resultado = EXIT_FAILURE; }
if (!desvinculada && mq_unlink(nombre) == -1) perror("mq_unlink limpieza");
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic observar_posix.c -o observar_posix -lrt
$ ./observar_posix
Cuarto mensaje: EAGAIN, cola llena
Buffer de 8: EMSGSIZE; pendientes: 3
Mensaje de 7 bytes, prioridad 9: urgente
Mensaje de 8 bytes, prioridad 2: normal-A
Mensaje de 8 bytes, prioridad 2: normal-B
Envio de 17 bytes: EMSGSIZE
Mensaje vacio recibido: 0 bytes, no EOF
Cola sin mensajes: EAGAINEl búfer de ocho bytes podría contener urgente, pero mq_receive exige capacidad para mq_msgsize, que vale 16. La recepción fallida no retira el mensaje. Las dos unidades de prioridad 2 mantienen su orden, y cada recepción devuelve una sola unidad.
El programa solicita recursos pequeños, pero aun así mq_open puede fallar por configuración, permisos o límites del entorno. No modifiques límites globales para ocultar el error: consulta la causa. El parámetro de atributos de creación se describe en mq_open(3).
12. Experimento: selección y truncamiento System V
Este laboratorio crea una cola nueva con IPC_PRIVATE. Esa constante solicita un objeto nuevo; no significa que su identificador constituya autenticación ni impide compartirlo con otro proceso. La creación se describe en msgget(2).
El objeto enviado comienza por long tipo. El tamaño pasado a msgsnd y msgrcv cuenta únicamente el contenido que sigue, no ese long. Por eso no se pasa sizeof del objeto completo.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct mensaje { long tipo; char datos[16]; };
static int enviar(int id, long tipo, const char *texto)
{
struct mensaje m = {.tipo = tipo};
size_t n = strlen(texto);
if (n > sizeof m.datos) { errno = EINVAL; return -1; }
memcpy(m.datos, texto, n);
int r;
do { r = msgsnd(id, &m, n, IPC_NOWAIT); }
while (r == -1 && errno == EINTR);
return r;
}
static ssize_t recibir(int id, struct mensaje *m, size_t capacidad,
long selector, int flags)
{
ssize_t r;
do { r = msgrcv(id, m, capacidad, selector, flags | IPC_NOWAIT); }
while (r == -1 && errno == EINTR);
return r;
}
int main(void)
{
int id = msgget(IPC_PRIVATE, 0600);
if (id == -1) { perror("msgget"); return EXIT_FAILURE; }
printf("Cola System V creada, id: %d\n", id);
int resultado = EXIT_FAILURE;
struct mensaje m;
if (enviar(id, 5, "tipo5-A") == -1 || enviar(id, 2, "tipo2") == -1 ||
enviar(id, 5, "tipo5-B") == -1) { perror("msgsnd"); goto limpieza; }
ssize_t n = recibir(id, &m, sizeof m.datos, -5, 0);
if (n == -1) { perror("msgrcv -5"); goto limpieza; }
printf("Selector -5: tipo %ld, %.*s\n", m.tipo, (int)n, m.datos);
n = recibir(id, &m, sizeof m.datos, 5, 0);
if (n == -1) { perror("msgrcv 5"); goto limpieza; }
printf("Selector 5: tipo %ld, %.*s\n", m.tipo, (int)n, m.datos);
if (recibir(id, &m, 2, 0, 0) != -1 || errno != E2BIG) goto inesperado;
struct msqid_ds estado;
if (msgctl(id, IPC_STAT, &estado) == -1) { perror("IPC_STAT"); goto limpieza; }
printf("Buffer de 2: E2BIG; pendientes: %lu\n", (unsigned long)estado.msg_qnum);
if (estado.msg_qnum != 1) goto inesperado;
n = recibir(id, &m, 2, 0, MSG_NOERROR);
if (n != 2) goto inesperado;
printf("Con MSG_NOERROR: %.*s; resto descartado\n", (int)n, m.datos);
if (recibir(id, &m, sizeof m.datos, 0, 0) != -1 ||
errno != ENOMSG) goto inesperado;
puts("Sin mensaje elegible: ENOMSG");
if (enviar(id, 3, "") == -1) { perror("mensaje vacio"); goto limpieza; }
if (recibir(id, &m, sizeof m.datos, 0, 0) != 0 || m.tipo != 3) goto inesperado;
puts("Mensaje vacio de tipo 3: 0 bytes, no EOF");
resultado = EXIT_SUCCESS;
goto limpieza;
inesperado:
fprintf(stderr, "Resultado distinto del esperado\n");
limpieza:
if (msgctl(id, IPC_RMID, NULL) == -1) {
perror("IPC_RMID"); resultado = EXIT_FAILURE;
}
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic observar_systemv.c -o observar_systemv
$ ./observar_systemv
Cola System V creada, id: ...
Selector -5: tipo 2, tipo2
Selector 5: tipo 5, tipo5-A
Buffer de 2: E2BIG; pendientes: 1
Con MSG_NOERROR: ti; resto descartado
Sin mensaje elegible: ENOMSG
Mensaje vacio de tipo 3: 0 bytes, no EOFEl tipo 2 se selecciona aunque no era el primero enviado. Después, la recepción exacta de tipo 5 retira el primero de ese tipo. E2BIG conserva la última unidad; MSG_NOERROR consume solo dos bytes visibles y descarta su resto. Las reglas de selección, tamaños y errores están en msgop(2).
13. Varios consumidores y tareas retiradas
Si varios trabajadores reciben de una cola, cada mensaje retirado correctamente se entrega a una recepción, no a todos los trabajadores. La cola sirve para repartir unidades; no implementa difusión automática.
El orden de retirada tampoco es el de finalización. Un trabajador puede recibir primero una tarea lenta y otro terminar antes una tarea posterior. Las prioridades se aplican a lo pendiente en la cola, no al trabajo que ya se está ejecutando.
Cuando mq_receive o msgrcv retira un mensaje, la cola no espera una confirmación de que el cálculo terminó. Si el trabajador cae después de recibirlo, el mensaje no reaparece automáticamente. Si debes recuperarlo, necesitas un protocolo de tareas en curso, confirmaciones, tiempos límite y reintentos.
Un reintento puede duplicar una operación que sí llegó a completarse antes de perder su respuesta. Para operaciones con efectos externos, identifica tareas y define idempotencia o deduplicación. «Una recepción por mensaje» no equivale a «un único efecto confirmado de negocio».
14. El formato del contenido sigue siendo tuyo
La frontera del mensaje sustituye parte del enmarcado, pero el contenido sigue necesitando un esquema. Por ejemplo:
versión | operación | identificador de tarea | longitud del texto | texto
Solicitud: versión 1, transformar, tarea 42, 4 bytes, hola
Resultado: versión 1, éxito, tarea 42, 4 bytes, HOLALa longitud externa de la cola informa cuántos bytes llegaron. Una longitud interna puede servir para validar campos y permitir versiones, pero debe contrastarse con el tamaño real recibido. Nunca confíes en un valor interno para leer fuera del mensaje.
No envíes punteros como si el receptor pudiera desreferenciarlos. Tampoco supongas que una estructura con padding, enteros nativos o un long tendrá la misma representación en cualquier proceso o arquitectura. Define tamaño, orden de bytes, límites y significado de cada campo.
El identificador de tarea y la ruta o cola de respuesta son decisiones de protocolo. La prioridad POSIX y el tipo System V no los reemplazan automáticamente. Una etiqueta usada para planificar no necesariamente identifica al cliente ni a una solicitud concreta.
15. Comparar los modelos en un simulador
Envía varias unidades y cambia la capacidad del búfer receptor. El modelo mantiene ambos participantes disponibles y usa operaciones sin espera. El flujo admite ocho bytes; POSIX admite tres mensajes de hasta ocho bytes; System V admite ocho bytes totales y hasta ocho mensajes, incluyendo vacíos.
Contenido pendienteSin contenido
Ocupación0/8 bytes
Envía dos unidades y compara sus fronteras al recibir.
Prueba AAA y BB en el flujo y recibe cuatro bytes. En POSIX, envíalos con prioridades 2 y 9 y aumenta el búfer a ocho. En System V, envía tipos 5 y 2 y selecciona el menor hasta 5. Finalmente, compara un mensaje vacío con la ausencia de mensajes.
16. Diagnosticar y elegir el mecanismo
| Necesidad o síntoma | Razonamiento |
|---|---|
| Conectar herramientas que procesan stdin/stdout. | Una tubería encaja naturalmente con su interfaz de flujo. |
| Repartir tareas acotadas entre trabajadores. | Una cola conserva la unidad y permite que cada recepción retire una tarea. |
| Transferir contenido muy grande. | No asumas que cabe en un mensaje; evalúa flujo, fragmentación o referencias a otra región de datos. |
| mq_receive falla aunque el siguiente texto parece caber. | Comprueba el mq_msgsize configurado, no solo el tamaño de ese texto. |
| msgrcv retorna ENOMSG aunque hay mensajes. | Puede no haber ninguno compatible con el selector de tipo. |
| Un mensaje desaparece después de recibir un prefijo. | Comprueba si se usó MSG_NOERROR, que descarta el resto. |
| El consumidor nunca detecta que acabaron los productores. | Las colas no generan EOF por ese cierre; falta un protocolo de fin. |
| Una tarea se pierde cuando cae el trabajador. | Recibir la retira; hace falta seguimiento y confirmación del procesamiento. |
En Linux puedes observar las colas System V con ipcs -q. El experimento imprime su identificador y ejecuta IPC_RMID al terminar por sus rutas normales de error o éxito. Si se interrumpe antes de limpiar, revisa únicamente ese objeto propio antes de retirarlo con una herramienta administrativa; cerrar el proceso no elimina la cola.
La cola POSIX del laboratorio se desvincula antes de las operaciones y desaparece al cerrar su referencia. Existe un pequeño intervalo entre crear y desvincular en el que una terminación abrupta puede dejar el nombre. Los temas siguientes desarrollarán la responsabilidad de creación y limpieza en programas independientes.
La ausencia de una entrada visible en /dev/mqueue no demuestra que un descriptor POSIX ya abierto haya dejado de funcionar. Del mismo modo, comprobar que una cola está vacía no demuestra que el trabajo retirado haya terminado.
17. Resumen
- Una tubería conserva bytes en orden; la aplicación reconstruye sus unidades.
- Una cola conserva mensajes y entrega una unidad elegible por recepción normal.
- Atomicidad de escritura y fronteras de recepción son propiedades distintas.
- POSIX ordena por prioridad; System V permite selección por tipo.
- El tamaño del búfer y el tratamiento del truncamiento dependen de la familia.
- Recibir cero bytes puede ser un mensaje vacío, no EOF.
- Las colas tienen capacidad finita y necesitan políticas de contrapresión y limpieza.
- Los consumidores compiten por tareas; no reciben automáticamente una copia de cada mensaje.
- Retirar una tarea no confirma su ejecución ni garantiza su recuperación ante fallos.
18. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones.
1. ¿Por qué una lectura de tres bytes puede devolver ABC tras escribir AB y CDE?
Porque la tubería ofrece el flujo ABCDE y no conserva fronteras de llamadas write para el receptor.
2. ¿PIPE_BUF convierte un registro en un mensaje?
No. Su garantía se refiere a evitar entremezclar escrituras bajo las condiciones de la interfaz. El lector sigue viendo bytes.
3. ¿mq_receive puede agrupar dos mensajes para llenar su búfer?
No. Retira un mensaje de la cola según su orden de selección.
4. ¿Por qué un búfer POSIX de ocho falla si el próximo mensaje ocupa siete?
Porque debe ser al menos tan grande como mq_msgsize, que en el laboratorio es 16. El mensaje no se retira por ese fallo.
5. ¿Qué diferencia E2BIG de MSG_NOERROR?
E2BIG conserva el mensaje System V que no cabe. Con MSG_NOERROR se permite truncarlo, retirarlo y perder el resto.
6. ¿Cero en mq_receive significa que todos los productores cerraron?
No. Es la longitud de un mensaje vacío recibido correctamente. No hay EOF automático por cerrar productores.
7. ¿Mayor prioridad POSIX significa que la tarea terminará antes?
No. Afecta la selección de mensajes pendientes, no la ejecución o finalización de tareas ya retiradas.
8. ¿El tipo System V es equivalente a la prioridad POSIX?
No. El receptor System V decide cómo seleccionar tipos; por ejemplo, un selector negativo elige el tipo numéricamente menor elegible.
9. ¿Se incluye long tipo en el tamaño de msgsnd?
No. El tamaño cuenta únicamente los bytes de contenido que siguen al campo de tipo.
10. ¿Una cola con varios trabajadores difunde cada tarea a todos?
No. Cada mensaje retirado corresponde a una recepción. La difusión requiere otro diseño.
11. ¿Por qué un mensaje de parada prioritario puede ser problemático?
Porque puede adelantarse a tareas que todavía están pendientes y hacer que un trabajador termine antes de procesarlas.
12. ¿La cola repone una tarea si el trabajador cae tras recibirla?
No automáticamente. La recepción ya la retiró. La recuperación necesita un protocolo adicional de confirmación y seguimiento.
Para practicar
- Ejecuta observar_flujo cambiando el búfer receptor a uno y luego a cuatro bytes. Identifica qué fronteras pertenecen al protocolo.
- Ejecuta observar_posix y asigna la misma prioridad a todos los mensajes. Comprueba el orden de recepción.
- Cambia el tamaño máximo POSIX y ajusta el búfer de recepción. Predice qué llamadas fallarán antes de ejecutar.
- En observar_systemv, cambia la primera selección a 0, luego a 5 y después a −5. Explica qué mensajes quedan en cada caso.
- Compara un fallo E2BIG con una recepción truncada. Comprueba el número de mensajes pendientes.
- Usa el simulador para llenar la cola POSIX con mensajes vacíos y explica por qué sigue agotándose su capacidad.
- Diseña un mensaje de tarea y otro de resultado con un identificador, versión y límites explícitos.
- Propón una parada para tres trabajadores que no se adelante al trabajo pendiente. Define cómo saber que no habrá nuevos productores.
- Dibuja el intervalo entre recibir una tarea y confirmar su resultado. Indica dónde puede caer un trabajador y qué tendría que recuperar el supervisor.
El tema 20 desarrollará la creación y apertura de colas POSIX con mq_open: nombres, atributos, permisos y la diferencia entre mq_close y mq_unlink.