C

Run the server in one process, then the client in another; fipc_stream_connect waits up to its timeout for a server to create the stream and accept. The pair makes the exchange every example on this site makes, the message ping, answered in upper case: this client works with any language's server, and this server with any language's client (every pair of languages is tested).

#include <ctype.h>
#include <fipc.h>

int main(void)
{
    fipc_listener_t* listener;
    if (fipc_stream_create("my_channel", 1 << 20, &listener) != FIPC_OK) /* rings of 1 MiB each way */
        return 1;
    fipc_conn_t* conn;
    if (fipc_stream_accept(listener, &conn, FIPC_FOREVER) == FIPC_OK) /* waits for a client */
    {
        char buf[256];
        size_t len;
        if (fipc_recv(conn, buf, sizeof buf, &len, FIPC_FOREVER) == FIPC_OK)
        {
            for (size_t i = 0; i < len; i++)
                buf[i] = (char) toupper((unsigned char) buf[i]);
            fipc_send(conn, buf, len, FIPC_FOREVER);
        }
        fipc_close(conn);
    }
    fipc_listener_close(listener);
    return 0;
}

#include <fipc.h>
#include <stdio.h>

int main(void)
{
    fipc_conn_t* conn;
    fipc_result_t result = fipc_stream_connect("my_channel", &conn, 5000);
    if (result != FIPC_OK)
    {
        fprintf(stderr, "connect: %s\n", fipc_result_str(result));
        return 1;
    }
    char buf[256];
    size_t len;
    if (fipc_send(conn, "ping", 4, FIPC_FOREVER) == FIPC_OK
        && fipc_recv(conn, buf, sizeof buf, &len, FIPC_FOREVER) == FIPC_OK)
        printf("%.*s\n", (int) len, buf); /* PING */
    fipc_close(conn);
    return 0;
}

Reserve room in the ring, write the message there, publish it. On the other side, read it where it lies and release it. Pointers are 16-byte aligned. fipc_max_piece is the ring's capacity less 64 bytes; anything longer goes through fipc_send.

void* out;
if (fipc_send_acquire(conn, 64, &out,
                      FIPC_FOREVER) == FIPC_OK) {
    int n = snprintf(out, 64, "tick %d", tick);
    fipc_send_commit(conn, (size_t) n); /* publish n bytes */
}

const void* data;
size_t len;
if (fipc_recv_acquire(conn, &data, &len,
                      FIPC_FOREVER) == FIPC_OK) {
    handle(data, len);       /* read-only, in the ring */
    fipc_recv_release(conn); /* frees its room */
}

A broadcast sends every message of one publisher to each of its subscribers, in any processes of the user; each message is stored once, in memory every subscriber maps. Messages are of one piece, up to a quarter of the capacity. fipc_broadcast_create returns the publisher's connection; the publisher's process admits the subscribers on a thread of the library's, so no thread of yours waits for them. The publisher waits for the first one (fipc_broadcast_wait_for_members) before it sends tick 1 to tick 3; its close ends the broadcast and frees the name. The subscriber joins gated (fipc_broadcast_join with FIPC_SUBSCRIBER_GATED), so it misses nothing (the publisher waits for it), and receives until FIPC_DISCONNECTED, which comes after the last message. A lossy subscriber (FIPC_SUBSCRIBER_LOSSY) never holds the publisher back: one that falls a lap behind gets FIPC_OVERRUN, with the number of messages lost in *out_len. A gated one that holds the publisher back for the broadcast's max_stall_ms is unsubscribed (FIPC_UNSUBSCRIBED).

#include <fipc.h>
#include <stdio.h>

int main(void)
{
    fipc_conn_t* publisher;
    /* 64 KiB of messages, up to 8 subscribers; one that holds the publisher back 5 s is dropped */
    if (fipc_broadcast_create("my_broadcast", 1 << 16, 8, 5000, &publisher) != FIPC_OK)
        return 1;
    uint32_t count;
    /* waits for the first subscriber */
    if (fipc_broadcast_wait_for_members(publisher, 1, &count, FIPC_FOREVER) == FIPC_OK)
    {
        for (int i = 1; i <= 3; i++)
        {
            char tick[16];
            int len = snprintf(tick, sizeof tick, "tick %d", i);
            fipc_send(publisher, tick, (size_t) len, FIPC_FOREVER);
        }
    }
    fipc_close(publisher); /* ends the broadcast: subscribers get FIPC_DISCONNECTED after the ticks */
    return 0;
}

#include <fipc.h>
#include <stdio.h>

int main(void)
{
    fipc_conn_t* subscriber;
    /* gated: misses nothing (the publisher waits for it) */
    fipc_result_t result = fipc_broadcast_join("my_broadcast", FIPC_SUBSCRIBER_GATED, &subscriber, 5000);
    if (result != FIPC_OK)
    {
        fprintf(stderr, "join: %s\n", fipc_result_str(result));
        return 1;
    }
    char buf[256];
    size_t len;
    while ((result = fipc_recv(subscriber, buf, sizeof buf, &len, FIPC_FOREVER)) == FIPC_OK)
        printf("%.*s\n", (int) len, buf); /* tick 1, tick 2, tick 3 */
    fipc_close(subscriber);
    return result == FIPC_DISCONNECTED ? 0 : 1; /* the publisher closed */
}

A work queue takes messages from up to 63 producers and hands each to one of up to 64 consumers, in any processes of the user. Each producer has a ring of its own; a consumer takes a message of any producer, and the queue promises no order. Messages are of one piece, up to a quarter of the capacity, and wait in the queue until a consumer takes them. Each message goes to one consumer, and again, to another, only if that consumer's process ends before acknowledging it (delivery, below). Here the producer creates the queue (fipc_queue_create: a fipc_queue_t) and joins it as its producer with fipc_queue_join, as any process does: the owner's process admits every joiner on a thread of the library's, so the thread that created the queue may join it. It sends job 1 to job 3, waits for the consumer (fipc_queue_wait_for_members) and closes the queue (fipc_queue_close), which ends it: the consumer receives what is left, then FIPC_DISCONNECTED. Producers and consumers of other processes join with fipc_queue_join (FIPC_PRODUCER, FIPC_CONSUMER); a producer's or a consumer's close never ends the queue.

#include <fipc.h>
#include <stdio.h>

int main(void)
{
    fipc_queue_t* queue;
    fipc_conn_t* producer = NULL;
    /* 4 KiB of messages per producer, 1 producer and 1 consumer: this process owns the queue and is its producer */
    if (fipc_queue_create("my_queue", 4096, 1, 1, &queue) != FIPC_OK)
        return 1;
    fipc_result_t result = fipc_queue_join("my_queue", FIPC_PRODUCER, &producer, 5000);
    for (int i = 1; i <= 3 && result == FIPC_OK; i++)
    {
        char job[16];
        int len = snprintf(job, sizeof job, "job %d", i);
        result = fipc_send(producer, job, (size_t) len, FIPC_FOREVER); /* waits in the queue for a consumer */
    }
    uint32_t count;
    /* waits for the consumer to join */
    if (result == FIPC_OK)
        result = fipc_queue_wait_for_members(queue, FIPC_CONSUMER, 1, &count, FIPC_FOREVER);
    fipc_close(producer);
    fipc_queue_close(queue); /* ends the queue: the consumer gets FIPC_DISCONNECTED after the jobs */
    return result == FIPC_OK ? 0 : 1;
}

#include <fipc.h>
#include <stdio.h>

int main(void)
{
    fipc_conn_t* consumer;
    fipc_result_t result = fipc_queue_join("my_queue", FIPC_CONSUMER, &consumer, 5000);
    if (result != FIPC_OK)
    {
        fprintf(stderr, "join: %s\n", fipc_result_str(result));
        return 1;
    }
    char buf[256];
    size_t len;
    while ((result = fipc_recv(consumer, buf, sizeof buf, &len, FIPC_FOREVER)) == FIPC_OK)
        printf("%.*s\n", (int) len, buf); /* job 1, job 2, job 3 */
    fipc_close(consumer);
    return result == FIPC_DISCONNECTED ? 0 : 1; /* the queue ended */
}

Delivery. Each message goes to one consumer. It goes again, to another consumer, only if the process of the consumer that took it ends before acknowledging it, and when a consumer acknowledges is its own choice, not the queue's. A message received in place is acknowledged at its release (or the consumer's next receive, or its close).

• Choose by the work, per consumer. Work that may safely run twice (rendering, a computation, re-indexing, converting a file) acknowledges after it; work whose effects must never repeat (a payment, an email, a motor command) acknowledges before it.
• Not covered: a consumer that hangs while its process runs (there are no timeouts, by design); the owner's process, with which the queue ends; a reboot. A consumer holds at most one unacknowledged message at a time, the one received in place.
• A message that goes again comes in no set order, after messages its producer sent later: the queue promises no order anyway.
• A message held in place holds back its producer's room until its release: a consumer that acknowledges after a long job keeps that message's room, and so the room of the producer's messages after it, until then.
• A message that crashes every consumer that takes it, acknowledged after the work, goes to each consumer in turn, with no limit: acknowledge before the work where that can happen.

A service takes requests from up to 64 clients and hands each to one of up to 64 servers, in any processes of the user; the server that took a request replies to it, and a client receives its replies in the order of its requests. Here the server creates the service (fipc_service_create: a fipc_service_t) and joins it as its server with fipc_service_join (FIPC_SERVER), answers three requests with their uppercase and closes the service (fipc_service_close), which ends it; the client joins (FIPC_CLIENT), sends ping 1 to ping 3 and prints each reply. A request whose server ended before it replied gets FIPC_ABANDONED.

#include <ctype.h>
#include <fipc.h>

int main(void)
{
    fipc_service_t* service;
    fipc_conn_t* server = NULL;
    /* 4 KiB per client, requests and replies of up to 256 bytes, 1 client and 1 server: this process owns the service
       and is its server */
    if (fipc_service_create("my_service", 4096, 256, 1, 1, &service) != FIPC_OK)
        return 1;
    fipc_result_t result = fipc_service_join("my_service", FIPC_SERVER, &server, 5000);
    for (int i = 1; i <= 3 && result == FIPC_OK; i++) /* three requests, then the end */
    {
        char buf[256];
        size_t len;
        result = fipc_recv(server, buf, sizeof buf, &len, FIPC_FOREVER); /* the next request of any client */
        for (size_t j = 0; result == FIPC_OK && j < len; j++)
            buf[j] = (char) toupper((unsigned char) buf[j]);
        if (result == FIPC_OK)
            result = fipc_send(server, buf, len, FIPC_NO_WAIT); /* the reply goes to its client, and never waits */
    }
    fipc_close(server);
    fipc_service_close(service); /* ends the service: the client still receives the replies sent */
    return result == FIPC_OK ? 0 : 1;
}

#include <fipc.h>
#include <stdio.h>

int main(void)
{
    fipc_conn_t* client;
    fipc_result_t result = fipc_service_join("my_service", FIPC_CLIENT, &client, 5000);
    if (result != FIPC_OK)
    {
        fprintf(stderr, "join: %s\n", fipc_result_str(result));
        return 1;
    }
    for (int i = 1; i <= 3 && result == FIPC_OK; i++)
    {
        char buf[256];
        size_t len = (size_t) snprintf(buf, sizeof buf, "ping %d", i);
        result = fipc_send(client, buf, len, FIPC_FOREVER); /* a request: a server takes it */
        if (result == FIPC_OK)
            result = fipc_recv(client, buf, sizeof buf, &len, FIPC_FOREVER); /* its reply */
        if (result == FIPC_OK)
            printf("%.*s\n", (int) len, buf); /* PING 1, PING 2, PING 3 */
    }
    if (result != FIPC_OK) /* FIPC_ABANDONED: the server ended before it replied */
        fprintf(stderr, "request: %s\n", fipc_result_str(result));
    fipc_close(client);
    return result == FIPC_OK ? 0 : 1;
}

The calls. A service's connections use the calls every connection has; what each does depends on the role. Requests and replies are of one piece, 1 to max_message bytes, the owner's choice at fipc_service_create (1 to a quarter of the capacity), and fipc_max_piece returns it on both roles, so a buffer of that size takes every request and every reply.

• Replies come back in the order of the requests, so the n-th reply a client receives answers its n-th request, and a request carries no id. A client may send several requests before it receives, as many as its ring has room for, and the servers work on them at once. A receive that times out or is cancelled leaves its reply to come: the next receive returns it. Servers take each client's requests in the order it sent them, and the requests of different clients in no set order.
• A server never waits for a client. A request takes room in its client's ring for itself and for its reply: its length rounded up to 64 bytes, plus max_message rounded up to 64, from its send until its reply has been received. A client that keeps sending without receiving waits for room its own replies hold (with one thread, it times out).
• A server holds one request at a time: until it replies, its receives return FIPC_INVALID. It may receive on one thread and reply on another. A pool is several servers, each a connection of its own, on threads or in processes; each takes the next request of any client. A reply to a client that has left is dropped and returns FIPC_OK.
• A request is answered once: by its reply, or with FIPC_ABANDONED if the server that took it ended before it replied (its process ended, or it closed its connection). An abandoned request may or may not have been carried out; the service never sends it again, and the client decides whether to. Not covered: a server that hangs while its process runs (there are no timeouts: its client waits within its own timeouts), and the owner's process, with which the service ends.
• The owner's handle. fipc_service_wait_for_members counts the joined clients (FIPC_CLIENT), servers (FIPC_SERVER) or both (0), and waits for at least a given number; fipc_service_cancel ends those waits; fipc_service_close ends the service. The owner joins its own service, as either role, from any thread. A member's close, or the end of its process, never ends the service: clients wait while no server is joined, and servers while no client is.
• The end (fipc_service_close, or the owner's process ending): clients' sends and servers' receives return FIPC_DISCONNECTED; a client receives the replies that came before the end, in order, then FIPC_DISCONNECTED; a server's reply returns FIPC_DISCONNECTED. A reply that returned FIPC_OK is always received by a client that receives.