← Comunicación entre Procesos Bloque 1 · Fundamentos y entorno de trabajo · Tema 2 de 52

Tema 2

Elegir un mecanismo de IPC

¿Una señal, una tubería, una cola o memoria compartida? La respuesta empieza por describir el intercambio: quién participa, dónde se ejecuta, qué envía y qué debe ocurrir si el receptor se retrasa o desaparece. En este tema construirás un criterio de elección, comprobarás en C la diferencia entre un flujo y un transporte que conserva mensajes, y calcularás por qué el volumen y las copias pueden cambiar el diseño.

1. Describir el intercambio antes de elegir

En el tema anterior el hijo enviaba un texto al padre y cerraba el canal. Una tubería era suficiente: un emisor, un receptor, una dirección y un fin claro. Si ahora el padre debe enviar órdenes al hijo, aparecen clientes nuevos o hay que conservar tareas después de un reinicio, ya no estamos resolviendo exactamente el mismo problema.

La pregunta «¿cuál es el IPC más rápido?» no alcanza para diseñar una solución. Una herramienta veloz puede carecer de una propiedad imprescindible. Antes de mirar funciones, escribe un pequeño contrato:

PreguntaEjemplo de requisito concreto
¿Quiénes participan?Un supervisor y cuatro trabajadores creados por él.
¿Dónde están?En la misma instalación Linux, sin cruzar equipos.
¿Qué se intercambia?Solicitudes de hasta 256 bytes y resultados de tamaño variable.
¿En qué dirección?El supervisor envía tareas y recibe respuestas identificadas.
¿Qué carga se espera?Un promedio de 200 solicitudes por segundo, con ráfagas de 1000.
¿Qué sucede al saturarse?Se admiten hasta 500 pendientes; después se rechazan nuevas tareas.
¿Qué significa confirmar?La respuesta de éxito indica que el resultado se guardó, según el contrato del servicio.

Esos números no son una recomendación universal: convierten palabras vagas como «pequeño», «rápido» y «muchos» en condiciones que se pueden comprobar. Un contrato así permite descartar opciones y después medir las restantes.

2. Alcance y forma de encontrarse

Procesos relacionados

Si un proceso crea a los demás, puede preparar canales antes de fork. Los hijos heredan los descriptores y no hace falta publicar una ruta para encontrarse. Una tubería es una buena candidata para un flujo en una dirección; socketpair crea dos extremos conectados que pueden conversar en ambas direcciones.

El parentesco no es una propiedad mágica del transporte. La pregunta real es cómo obtiene cada participante una referencia al mismo objeto. Más adelante verás que también se pueden entregar descriptores a otros procesos por un socket Unix.

Programas que se inician por separado

Dos programas independientes necesitan un punto de encuentro: una ruta de FIFO, un nombre de cola POSIX, un objeto de memoria compartida o una dirección de socket Unix. Hay que decidir quién lo crea, cuándo está listo, qué permisos tiene y quién lo retira. Un nombre conocido resuelve el descubrimiento; no resuelve la autenticación ni el protocolo.

Procesos en equipos diferentes

La memoria compartida POSIX y los sockets de dominio Unix son mecanismos locales. Si los participantes deben ejecutarse en equipos distintos, considera sockets de Internet y un protocolo sobre TCP o UDP, u otro servicio de comunicación adecuado. Tampoco debes suponer que dos contenedores comparten automáticamente rutas, objetos y espacios de nombres: el despliegue forma parte del alcance.

Separar la necesidad actual de una posibilidad futura

Que algún día un componente pueda ser remoto no obliga a introducir una infraestructura de red completa hoy. Sí conviene separar el formato de las peticiones del transporte, para que cambiar el canal no implique reescribir las reglas del servicio.

3. Notificaciones, flujos, mensajes y estado

Notificación: ocurrió algo

«Solicita terminar» o «hay que revisar el estado» pueden expresarse como eventos. Una señal encaja cuando el destinatario es conocido y el evento tiene una semántica de señal. No conviene usar señales estándar como contador exacto de tareas: varias ocurrencias pendientes pueden agruparse. Las señales en tiempo real tienen otras reglas y límites; tampoco sustituyen sin más una cola de trabajo con protocolo.

Flujo: una sucesión de bytes

Una tubería, una FIFO y un socket SOCK_STREAM ofrecen un flujo. Resulta natural para texto, archivos o datos que se procesan progresivamente. El receptor debe reconstruir las unidades lógicas: separarlas por delimitadores, por tamaños fijos o por un campo de longitud. No puede deducir dónde terminaba cada envío a partir de una lectura.

Mensaje: una unidad delimitada

Una cola POSIX y ciertos tipos de socket conservan unidades de mensaje. Eso evita implementar una parte del enmarcado, pero todavía debes definir los campos y validar el tamaño. Además, un búfer insuficiente puede producir un error o una truncación según la interfaz; «conserva mensajes» no significa «acepta cualquier tamaño».

Estado compartido: consultar o actualizar lo mismo

Si muchos procesos consultan repetidamente una tabla grande, una región compartida puede evitar reenviarla completa en cada consulta. A cambio necesitas estructuras válidas para todos, un protocolo de inicialización y sincronización. Un puntero ordinario guardado en la región puede carecer de sentido en otro proceso si la región se mapea en una dirección distinta; suele ser mejor usar offsets o índices.

Elige primero la semántica del intercambio: evento, flujo, mensaje o estado compartido. Después decide cómo descubrir el objeto, controlar el acceso, coordinar la espera y gestionar su vida útil.

4. Una matriz para comparar

Esta tabla resume propiedades relevantes en el entorno Linux del curso. No asigna una puntuación global: el requisito que importa depende de la aplicación.

MecanismoUnidad y direcciónCómo se accedeQué añade la aplicación
SeñalEvento dirigido a un proceso o grupo.Identidad del destino y permisos para señalizar.Acción segura, estado y reglas de confirmación si hacen falta.
Tubería anónimaFlujo unidireccional.Descriptores heredados o transferidos.Enmarcado, cierre de extremos y política de saturación.
FIFOFlujo unidireccional.Ruta del sistema de archivos.Descubrimiento, aperturas, enmarcado y respuestas si se necesitan.
Cola POSIXMensajes con prioridad.Nombre y descriptor de cola.Esquema de tarea, respuesta, límites y retirada del nombre.
Memoria compartidaBytes accesibles por los participantes autorizados.Objeto mapeado en cada proceso.Estructura de datos, sincronización, inicialización y recuperación.
Semáforo POSIXContador y operaciones de espera y señalización.Nombre o ubicación compartida, según el tipo.El almacenamiento de los datos y el significado del contador.
Socket Unix de flujoFlujo bidireccional.Dirección local o par creado con socketpair.Protocolo, enmarcado y estado por conexión.
Socket Unix de mensajesDatagramas o paquetes secuenciados, según el tipo.Direcciones o extremos conectados.Tamaño máximo, recepción completa y tratamiento de errores.

Una cola POSIX entrega primero los mensajes de mayor prioridad y, con igual prioridad, por orden de llegada. No implementa un sistema de suscripción en el que cada consumidor reciba una copia. Sus nombres, prioridades y vida útil se describen en mq_overview(7).

En Linux, los sockets Unix admiten SOCK_STREAM, SOCK_DGRAM y SOCK_SEQPACKET. Los dos últimos conservan límites de mensaje; el último combina conexión y entrega de paquetes en orden. Las características de la familia y sus direcciones están documentadas en unix(7).

5. Dirección y número de participantes

La dirección cambia el diseño. Para un productor que alimenta un filtro basta un canal de ida. Para petición y respuesta necesitas un camino de vuelta: dos tuberías o un socket bidireccional son opciones. En el segundo caso cada participante debe saber si está esperando una petición, una respuesta o el cierre; poder escribir en ambos sentidos no elimina los interbloqueos.

Con varios consumidores, distingue repartir de difundir. Si cada tarea debe ejecutarse una sola vez por algún trabajador, una cola compartida puede servir para competir por tareas. Si todos deben recibir cada actualización, necesitas replicar el envío o mantener un historial y una posición de lectura por consumidor. Ni una cola común ni una tubería con varios lectores proporcionan automáticamente difusión.

Una tubería compartida por varios lectores no es una cola genérica de estructuras: un lector puede consumir solo parte de los bytes que otro necesitaba. Las garantías de atomicidad de ciertas escrituras no convierten las lecturas en extracciones de registros completos. Con varios escritores también hay que distinguir «no mezclar escrituras pequeñas» de «conservar mensajes».

Finalmente, decide quién mantiene la identidad de cada solicitud. En una conexión dedicada puede ser implícita; en una cola de respuesta común suele hacer falta un identificador y una forma de dirigir la respuesta al solicitante correcto.

6. Experimento en C: flujo frente a mensajes

Vamos a enviar dos unidades: ABC y DEFGHI. El receptor tendrá un búfer de cuatro bytes. Primero usaremos un socket Unix de flujo; después, uno de paquetes secuenciados. socketpair crea dos extremos que ya están conectados, de modo que podemos estudiar la recepción sin introducir todavía nombres, escucha y aceptación de clientes.

El experimento utiliza ambos extremos en un mismo proceso para aislar la semántica del transporte. En un intercambio real se entregarían los extremos a procesos diferentes, por ejemplo mediante fork. Enviamos solo nueve bytes antes de leer: esta secuencia acotada sirve para el laboratorio, pero no es un patrón general para transferencias grandes, que necesitan consumo concurrente para no llenar los búferes.

formas_ipc.c · la misma información con dos semánticas
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <unistd.h>

static int enviar_unidad(int fd, const char *texto)
{
    size_t longitud = strlen(texto);
    ssize_t n;
    do {
        n = send(fd, texto, longitud, 0);
    } while (n == -1 && errno == EINTR);

    if (n == -1) {
        perror("send");
        return -1;
    }
    if ((size_t)n != longitud) {
        /* El laboratorio aborta: no supone que un envio parcial sea completo. */
        fprintf(stderr, "Envio parcial: %zd de %zu bytes\n", n, longitud);
        return -1;
    }
    return 0;
}

static int probar(int tipo, const char *nombre)
{
    int par[2];
    if (socketpair(AF_UNIX, tipo, 0, par) == -1) {
        perror("socketpair");
        return -1;
    }

    int resultado = -1;
    if (enviar_unidad(par[0], "ABC") == -1 ||
        enviar_unidad(par[0], "DEFGHI") == -1)
        goto finalizar;
    if (shutdown(par[0], SHUT_WR) == -1) {
        perror("shutdown");
        goto finalizar;
    }

    printf("%s\n", nombre);
    size_t total = 0;
    for (;;) {
        char buffer[4];
        struct iovec vector = { .iov_base = buffer, .iov_len = sizeof buffer };
        struct msghdr mensaje = {0};
        mensaje.msg_iov = &vector;
        mensaje.msg_iovlen = 1;

        ssize_t n = recvmsg(par[1], &mensaje, 0);
        if (n == -1) {
            if (errno == EINTR)
                continue;
            perror("recvmsg");
            goto finalizar;
        }
        if (n == 0)
            break; /* No enviamos mensajes de longitud cero en esta prueba. */

        printf("  lectura: [%.*s], %zd bytes%s\n", (int)n, buffer, n,
               (mensaje.msg_flags & MSG_TRUNC) ? " (mensaje truncado)" : "");
        total += (size_t)n;
    }
    printf("  total recibido: %zu bytes\n", total);
    resultado = 0;

finalizar:
    close(par[0]);
    close(par[1]);
    return resultado;
}

int main(void)
{
    if (probar(SOCK_STREAM, "SOCK_STREAM") == -1)
        return EXIT_FAILURE;
    if (probar(SOCK_SEQPACKET, "SOCK_SEQPACKET") == -1)
        return EXIT_FAILURE;
    return EXIT_SUCCESS;
}
terminal · ejemplo de salida en Linux
$ gcc -std=c17 -Wall -Wextra -Wpedantic formas_ipc.c -o formas_ipc
$ ./formas_ipc
SOCK_STREAM
  lectura: [ABCD], 4 bytes
  lectura: [EFGH], 4 bytes
  lectura: [I], 1 bytes
  total recibido: 9 bytes
SOCK_SEQPACKET
  lectura: [ABC], 3 bytes
  lectura: [DEFG], 4 bytes (mensaje truncado)
  total recibido: 7 bytes

La división concreta de las lecturas del flujo no debe convertirse en una promesa del protocolo. El patrón importante es que todos los bytes del flujo se recuperan al seguir leyendo, aunque la primera lectura mezcle el final de un envío con el principio del siguiente.

En el segundo caso se mantiene el primer mensaje de tres bytes. El siguiente tiene seis y no cabe: se copian cuatro, aparece MSG_TRUNC en los flags de salida de recvmsg y se descarta el resto de ese paquete. Otra lectura no recuperará HI. No pasamos MSG_TRUNC como argumento de entrada: consultamos el indicador que devuelve la recepción.

La creación del par está documentada en socketpair(2). El ejemplo comprueba errores y aborta si detecta un envío parcial: en un flujo de producción normalmente se acumularía lo enviado y se continuaría desde ese punto. En un transporte de mensajes no debes dividir a ciegas una unidad en nuevos envíos, porque cambiarías las fronteras.

Un límite conservado también exige un límite acordado

Un flujo requiere reconstruir mensajes; un transporte de mensajes requiere asegurar que el receptor pueda alojarlos o rechazarlos de una forma definida. Cambiar de API no elimina la necesidad de un protocolo.

7. Volumen, copias y latencia

Enviar una orden de 32 bytes no plantea el mismo problema que enviar imágenes de 16 MiB cientos de veces por segundo. En el primer caso pueden dominar el número de llamadas al sistema, las esperas y el tiempo de procesamiento. En el segundo, mover datos entre búferes puede convertirse en una parte sustancial del coste.

Un modelo simplificado de un canal con búfer en el núcleo tiene dos movimientos del contenido: del emisor al canal y del canal al receptor. Si además la aplicación serializa a otro búfer y después lo vuelve a copiar, añade tráfico. No es una cuenta universal del kernel: las implementaciones, el mecanismo y las optimizaciones pueden cambiar esos recorridos.

Dos diseños para datos grandesEn un diseño con copias, el bloque pasa del emisor al canal y al receptor. En otro, ambos procesos acceden a una región compartida y necesitan sincronización. Búfer del emisorCanalBúfer del receptor Región compartida + coordinación Compartir acceso evita ciertos envíos, pero introduce un protocolo de uso
El coste depende de dónde se producen, almacenan y consumen los datos.

La memoria compartida permite producir o consumir directamente en una región común, pero no garantiza que desaparezcan todas las copias ni que el resultado sea más rápido. Siguen existiendo accesos a memoria, efectos de caché, sincronización y posibles esperas. Una estructura con mucha contención puede rendir peor que un canal sencillo.

Distingue también latencia, el tiempo de una operación, de caudal, la cantidad de trabajo completado por unidad de tiempo. Agrupar tareas puede mejorar el caudal y empeorar la espera de la primera. Por eso debes medir mensajes pequeños, datos grandes y distintas cantidades de participantes según tu carga real.

8. Calcular un presupuesto de copias

Supón un bloque de tamaño S, una frecuencia R de bloques por segundo y C copias completas por bloque. El volumen lógico es S × R; el trabajo de copia del modelo es S × R × C. Si B es la velocidad efectiva de copia, el tiempo atribuible a esas copias por bloque se aproxima a S × C / B.

Usaremos MiB = 220 bytes y GiB = 230 bytes. Una velocidad efectiva de copia expresa bytes de contenido copiados por segundo: no es lo mismo que el tráfico bruto del bus, que puede incluir tanto lecturas como escrituras.

Presupuesto idealizado: no es una prueba de rendimiento

Volumen lógico1,563 GiB/s

Trabajo de copia3,125 GiB/s

Tiempo de copia por bloque1,953 ms

Fracción del presupuesto de copia39,1 %

El trabajo de copia cabe en la velocidad configurada; todavía faltan otros costes del sistema.

Duplica la frecuencia: el trabajo por segundo se duplica, pero el coste de copia por bloque permanece igual. Después duplica el tamaño: aumentan ambos. Por último reduce de dos copias a una; eso representa una hipótesis sobre el diseño, no una propiedad garantizada por seleccionar memoria compartida.

Si el porcentaje supera el 100 %, la demanda excede la velocidad de copia elegida en este modelo. Por debajo del 100 % tampoco has demostrado que el sistema alcance esa carga: faltan serialización, llamadas al sistema, planificación, sincronización y procesamiento. El tiempo mostrado es una estimación de un componente, no la latencia extremo a extremo.

9. Qué cambia con memoria compartida

Compartir bytes cambia la responsabilidad del programa. En un canal, el receptor obtiene los bytes que la operación de recepción le entrega. En una región común, debes acordar cuándo una celda está libre, cuándo contiene un dato completo y quién puede modificarla.

  1. Reservar una posición libre. El productor no debe pisar un resultado que el consumidor todavía usa.
  2. Escribir el contenido. Completar datos y metadatos de esa posición.
  3. Publicar que está lista. Usar la sincronización adecuada para que el consumidor observe el contenido preparado.
  4. Consumir y devolver la posición. El consumidor avisa cuándo el productor puede reutilizarla.

Un búfer circular con semáforos puede representar huecos y elementos disponibles. Si hay varios productores o consumidores, también debes proteger los índices y las operaciones que lo requieran. La colocación del semáforo y su configuración deben permitir compartirlo entre procesos; un semáforo privado creado en la memoria de cada uno no coordina una región común.

No sustituyas este protocolo por una variable ordinaria listo = 1 consultada sin sincronización. Tampoco uses volatile como reemplazo de exclusión mutua u orden de publicación. Las primitivas y garantías de memoria se estudiarán en los bloques 6 y 7.

La API POSIX separa creación, tamaño, mapeo y retirada del nombre; esa distinción se documenta en shm_overview(7). Poder abrir la misma región no significa que una estructura esté inicializada o que su contenido sea consistente.

10. Capacidad, contrapresión y fallos

Una cola puede absorber una ráfaga, pero no arregla una sobrecarga permanente. Si llegan 120 tareas por segundo y los trabajadores completan 100, el atraso crece en 20 tareas por segundo. Una capacidad libre de 200 tareas se agotaría en aproximadamente diez segundos bajo esas tasas constantes. Aumentar el búfer retrasa el problema y puede aumentar la latencia.

Elige qué sucede al alcanzar el límite: bloquear al productor, rechazar solicitudes, descartar elementos según una política o enviar a almacenamiento persistente. El modo no bloqueante no elimina la saturación: hace que tu programa deba gestionar un resultado como EAGAIN y decidir cuándo reintentar.

También debes definir qué significa que una operación haya tenido éxito. Escribir en un canal puede indicar que el sistema aceptó bytes, sin probar que el consumidor los procesó. Extraer una tarea de una cola no garantiza que se complete si el trabajador muere inmediatamente después. Si necesitas recuperación, hacen falta confirmaciones, registro de trabajo o reasignación según el caso.

Un reintento puede repetir un efecto

Un cliente envía «descontar 10», el servidor lo aplica y cae antes de responder. Al vencer el tiempo límite, el cliente no sabe si se ejecutó. Reintentar sin identificadores ni deduplicación podría descontar dos veces. Ningún mecanismo local de IPC elimina por sí solo esta ambigüedad.

No atribuyas a una cola POSIX las garantías de un intermediario durable. Que un objeto del núcleo pueda seguir existiendo tras cerrar un programa no significa que sobreviva a un reinicio del sistema ni que implemente confirmaciones y reentregas. La durabilidad es un requisito que puede exigir almacenamiento y un protocolo adicional.

11. Permisos, vida útil y portabilidad

La facilidad de crear un objeto es solo una parte del coste. Para cada diseño conviene responder quién lo crea, quién puede abrirlo, cómo se anuncia que está listo y quién lo limpia. Un nombre abandonado puede impedir un arranque nuevo o hacer que se abra un objeto con configuración antigua.

Portabilidad también significa disponibilidad y comportamiento. POSIX define muchas de estas interfaces, pero los límites configurables, algunas opciones de sockets y la integración con multiplexación pueden variar. epoll es específico de Linux; el espacio abstracto de sockets Unix también lo es. Comprueba las propiedades que tu diseño necesita en cada plataforma objetivo.

Finalmente, distingue sincronización de recuperación: un semáforo usado como exclusión no debe suponerse liberado automáticamente si muere su propietario. Diseña una política de supervisión y reinicialización, o elige primitivas con las propiedades de recuperación necesarias.

12. Elegir en seis situaciones concretas

Selecciona un escenario para ver una decisión razonada y qué cambio de requisitos llevaría a reconsiderarla. Son puntos de partida para el análisis, no un algoritmo que encuentre una única solución.

Tubería anónima

La shell conoce ambos participantes y conecta un flujo de salida con una entrada.

Reconsidera el diseño si necesitas mensajes independientes o una respuesta por solicitud.

1. Un comando filtra la salida de otro

Tubería anónima. Hay un flujo unidireccional, los descriptores los prepara la shell y EOF indica fin de entrada. Usar memoria compartida añadiría un protocolo de gestión de búferes para una tarea que ya encaja con la entrada y salida estándar.

2. Un supervisor solicita una parada

Señal, como SIGTERM, si encaja con el contrato del proceso. El supervisor conoce el PID y comunica un evento de control. Si hay que transmitir un motivo, vaciar trabajos y devolver una confirmación detallada, un mensaje por el canal de control puede expresar mejor la secuencia. SIGKILL no permite al destinatario ejecutar una limpieza propia.

3. Trabajadores compiten por tareas pequeñas

Cola POSIX, como candidata. Conserva unidades de tarea y permite prioridades. Hay que acordar el tamaño máximo y cómo se devuelven resultados. Si el requisito es reentrega durable tras una caída, añade almacenamiento y confirmaciones o elige un sistema que las proporcione; no se deduce esa propiedad de tener una cola.

4. Clientes independientes consultan un servicio local

Socket Unix. Permite un punto de encuentro local y conversaciones bidireccionales. Con SOCK_STREAM debes enmarcar peticiones; con SOCK_SEQPACKET, verificar compatibilidad y límites. Multiplexar clientes con poll o epoll ayuda a atenderlos, pero no cambia el significado de sus mensajes.

5. Procesos intercambian imágenes grandes a alta frecuencia

Memoria compartida más un canal de control y sincronización, si las mediciones lo justifican. El contenido puede residir en un conjunto de posiciones compartidas; el canal transmite un índice, longitud y versión. No se reutiliza una posición hasta que el consumidor la libera. Para una carga menor, una tubería o un socket puede ser más sencillo y suficiente.

6. Los participantes están en equipos distintos

Transporte de red con un protocolo apropiado. No se resuelve abriendo un objeto POSIX local con el mismo nombre en ambas máquinas. Este curso aporta criterios de enmarcado, capacidad y fallos que siguen siendo útiles al pasar a TCP, UDP u otros servicios de comunicación.

13. Un método de decisión y medición

  1. Fijar restricciones obligatorias. Alcance, plataformas, participantes, permisos, tamaño y garantías requeridas.
  2. Elegir la semántica. Evento, flujo, mensaje o estado compartido. Definir si se reparte o se difunde.
  3. Proponer una solución sencilla. Escribir el protocolo, la política de saturación y la vida útil de cada recurso.
  4. Construir una prueba representativa. Usar tamaños y cantidades de clientes semejantes a los del caso real; incluir el coste de sincronización y procesamiento relevante.
  5. Medir y provocar fallos. Observar caudal, percentiles de latencia, CPU, memoria y espera. Probar consumidores lentos, desconexiones y reinicios.
  6. Cambiar con evidencia. Introducir otro transporte o memoria compartida cuando resuelva un límite observado, y repetir la medición con el mismo contrato.

Una prueba que envía mensajes de un byte no decide qué conviene para imágenes de 16 MiB. Una comparación que excluye la sincronización de memoria compartida tampoco mide el mismo servicio. Mantén iguales los datos, el número de participantes y el significado de «operación terminada».

Al medir latencia, un promedio puede ocultar esperas largas durante las ráfagas. Registra también percentiles, como p95 y p99, y distingue el tiempo en cola del tiempo de ejecución. Los detalles de medición y diagnóstico se desarrollarán en el tema 44.

Ejemplo de una decisión documentada

«Usaremos un socket Unix de flujo porque los clientes son locales, independientes y necesitan respuestas. Limitaremos cada petición a 64 KiB, la precederemos con una longitud y acotaremos el trabajo pendiente. Revisaremos memoria compartida si las copias aparecen como un coste dominante en las pruebas». Esta decisión declara motivo, protocolo y condición de revisión.

14. Resumen

15. Preguntas de repaso y práctica

Responde antes de abrir cada explicación.

1. ¿Por qué «el más rápido» no es un criterio suficiente?

Porque una opción puede carecer de alcance, semántica, permisos o garantías obligatorias. Solo tiene sentido comparar rendimiento entre soluciones que satisfacen el contrato requerido.

2. ¿Puede una tubería comunicar procesos sin parentesco?

Lo decisivo es obtener referencias a sus extremos. Heredarlos es lo habitual, pero también pueden transferirse descriptores. Para programas independientes, una FIFO o un socket con dirección suele simplificar el encuentro.

3. ¿Por qué no contar tareas con señales estándar pendientes?

Porque varias ocurrencias de la misma señal pueden agruparse mientras está pendiente. Una notificación puede indicar que hay que consultar trabajo, pero no sustituye necesariamente su almacenamiento y conteo.

4. ¿Qué demuestra el experimento con el búfer de cuatro bytes?

El flujo permite recuperar los nueve bytes leyendo sucesivamente, sin conservar los envíos. SOCK_SEQPACKET mantiene unidades, pero el segundo paquete se trunca al no caber y su parte restante se descarta.

5. ¿Una cola común difunde cada mensaje a todos los trabajadores?

No. Los consumidores compiten por extraer mensajes. Difundir requiere replicar envíos o diseñar otro esquema con seguimiento por consumidor.

6. ¿Qué coste modelan 8 MiB × 200 bloques/s × 2 copias?

Un trabajo de copia de 3200 MiB/s, es decir, 3,125 GiB/s. Con una velocidad efectiva de 8 GiB/s ocupa aproximadamente el 39,1 % del presupuesto de copia.

7. ¿Ese 39,1 % equivale a uso de CPU?

No. Compara el trabajo de copia solicitado con una velocidad efectiva elegida. No estima directamente el uso de CPU, el tráfico físico completo de memoria ni la latencia total.

8. ¿Basta con una región compartida y una variable listo?

No. Hace falta sincronización que establezca cuándo una posición está completa, quién puede acceder y cuándo se puede reutilizar, además de un protocolo de inicialización.

9. Llegan 120 tareas/s y se completan 100. ¿Qué cambia al ampliar la cola?

Se retrasa la saturación, pero el atraso sigue creciendo en 20 tareas/s mientras se mantengan esas tasas. Hay que reducir la entrada, aumentar la capacidad de procesamiento o definir rechazo y espera.

10. ¿Extraer una tarea garantiza que se completará?

No. El trabajador puede morir después de extraerla. La recuperación requiere un protocolo adicional de registro, confirmación o reasignación según las garantías buscadas.

11. ¿La memoria compartida POSIX es almacenamiento durable?

No se debe asumir que lo sea. La vida del objeto en el núcleo y la permanencia del contenido tras un reinicio son propiedades diferentes. La durabilidad requiere un diseño de almacenamiento apropiado.

12. ¿Qué conviene mantener igual al comparar dos diseños?

Los datos, la carga, los participantes y el significado de operación completada. Deben incluirse los costes de enmarcado y sincronización necesarios en cada solución.

Para practicar

  1. Compila formas_ipc.c y cambia el búfer a 8 bytes. Predice el total recibido en ambos transportes y comprueba si aparece truncación.
  2. Repite con un búfer de 2 bytes. Indica qué información conserva el flujo y qué parte se pierde en cada paquete.
  3. Propón un formato con longitud e identificador para enviar varias solicitudes por un flujo. Define también una longitud máxima y qué ocurre si se supera.
  4. Usa la calculadora con 16 MiB, 500 bloques/s, dos copias y 8 GiB/s. Calcula primero a mano el porcentaje y explica por qué supera el presupuesto.
  5. Diseña una cola con capacidad para 300 tareas: llegan 150/s y salen 120/s. ¿Cuánto tarda en llenarse desde vacía bajo el modelo de tasas constantes? Respuesta para comprobar: 10 segundos.
  6. Compara una cola común de trabajos con un sistema en el que cada consumidor debe recibir todas las actualizaciones. Dibuja la topología y anota qué seguimiento requiere cada uno.
  7. Escribe una decisión de IPC para un servicio local de conversión de imágenes. Incluye alternativa, límites, permisos, limpieza y una condición medible para revisar la elección.
  8. Describe el fallo «se ejecutó, pero se perdió la respuesta» y diseña una petición con identificador que permita reconocer un reintento.