Java

Start the two in either order, in two terminals: Fipc.connectStream waits up to its timeout for a server to create the stream and accept. With the jar on the class path, the source launcher runs each file as it is: java --enable-native-access=ALL-UNNAMED -cp fipc-1.0.0.jar Server.java. 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.

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import io.github.fastipc.Listener;

public class Server {
    public static void main(String[] args) {
        // rings of 1 MiB each way; accept() waits for a client
        try (Listener listener =
                 Fipc.createStream("my_channel", 1 << 20);
             Connection conn = listener.accept()) {
            String text = new String(conn.receive());
            conn.send(text.toUpperCase().getBytes());
        }
    }
}

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import java.time.Duration;

public class Client {
    public static void main(String[] args) {
        try (Connection conn = Fipc.connectStream("my_channel",
                 Duration.ofSeconds(5))) {
            conn.send("ping".getBytes());
            byte[] reply = conn.receive();
            System.out.println(new String(reply));  // PING
        }
    }
}

A connection carries messages: send takes a message of any size, and receive returns each one whole in a new array (or fills your buffer). This server echoes every message back until its client leaves, which ends its next receive with DISCONNECTED.

import io.github.fastipc.*;

public class EchoServer {
    public static void main(String[] args) {
        // rings of 1 MiB each way: a power of two, 1 KiB to 2 GiB
        try (Listener listener = Fipc.createStream("demo", 1 << 20);
             Connection conn = listener.accept()) {
            while (true) {
                conn.send(conn.receive());   // echo, any size
            }
        } catch (FipcException e) {
            if (e.result() != Result.DISCONNECTED) throw e;
            System.out.println("client gone");
        }
    }
}

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import java.time.Duration;

public class EchoClient {
    public static void main(String[] args) {
        try (Connection conn =
                 Fipc.connectStream("demo", Duration.ofSeconds(5))) {
            for (String word : new String[] {"hello", "shared", "memory"}) {
                conn.send(word.getBytes());
                System.out.println(new String(conn.receive()));
            }
        }
    }
}

Write into a MemorySegment of the ring and commit; read a read-only MemorySegment of the ring and release it. A segment is valid until its commit or release and confined to the thread that acquired it: touching it afterwards, or from another thread, throws instead of reaching memory that is no longer yours.

MemorySegment room = conn.sendAcquire(5);   // in the ring
room.copyFrom(MemorySegment.ofArray("hello".getBytes()));
conn.sendCommit(5);

MemorySegment message = conn.receiveAcquire();  // read-only, in the ring
handle(message);
conn.receiveRelease();                          // 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 (maxPiece()). Fipc.createBroadcast returns the publisher's Connection, the broadcast's one handle. The publisher's process admits subscribers by itself, so no thread of yours waits for them: the publisher waits for the first one (publisher.waitForMembers(1); at a TIMEOUT the exception's memberCount() holds the count) before it sends tick 1 to tick 3; closing the publisher ends the broadcast and frees the name. The subscriber joins gated (Fipc.joinBroadcast with SubscriberRole.GATED), so it misses nothing (the publisher waits for it), may receive in place (receiveAcquire()), and receives until DISCONNECTED, which comes after the last message. A lossy subscriber (SubscriberRole.LOSSY) never holds the publisher back: one that falls a lap behind gets OVERRUN, and the exception's lostMessages(), a long, says how many messages it lost. A gated one that holds the publisher back for the broadcast's maxStall is unsubscribed (UNSUBSCRIBED).

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import java.time.Duration;

public class Publisher {
    public static void main(String[] args) {
        // 64 KiB of messages, up to 8 subscribers; one that
        // holds the publisher back 5 s is dropped
        try (Connection publisher = Fipc.createBroadcast(
                 "my_broadcast", 1 << 16, 8, Duration.ofSeconds(5))) {
            publisher.waitForMembers(1);  // waits for the first one
            for (int i = 1; i <= 3; i++) {
                publisher.send(("tick " + i).getBytes());
            }
        }
        // closing the publisher ends the broadcast: subscribers
        // get DISCONNECTED after the ticks
    }
}

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import io.github.fastipc.FipcException;
import io.github.fastipc.Result;
import io.github.fastipc.SubscriberRole;
import java.time.Duration;

public class Subscriber {
    public static void main(String[] args) {
        // gated: misses nothing (the publisher waits for it)
        try (Connection sub = Fipc.joinBroadcast("my_broadcast",
                 SubscriberRole.GATED, Duration.ofSeconds(5))) {
            while (true) {
                byte[] tick = sub.receive();
                System.out.println(new String(tick));  // tick 1..3
            }
        } catch (FipcException e) {
            // DISCONNECTED: the publisher closed
            if (e.result() != Result.DISCONNECTED) throw e;
        }
    }
}

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 (maxPiece()), 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.createQueue returns a WorkQueue), joins it as a producer (Fipc.joinQueue with QueueRole.PRODUCER), sends job 1 to job 3, which wait in the queue, and waits for the consumer to join (queue.waitForMembers(QueueRole.CONSUMER, 1)). The owner's process admits every producer and consumer by itself, the owner's own too. queue.close() ends the queue: the consumer receives what is left, then DISCONNECTED, and a producer's sends throw DISCONNECTED from then on; a producer's or a consumer's close never ends it. A queue lives until close() or the end of its process; dropping the object doesn't end it: unlike the other handles, a WorkQueue has no Cleaner, as its use lives in its members.

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import io.github.fastipc.QueueRole;
import io.github.fastipc.WorkQueue;

public class Producer {
    public static void main(String[] args) {
        // 4 KiB of messages per producer, 1 producer and 1
        // consumer: this process owns the queue and is its
        // producer
        try (WorkQueue queue = Fipc.createQueue("my_queue", 4096,
                 1, 1)) {
            try (Connection producer = Fipc.joinQueue("my_queue",
                     QueueRole.PRODUCER)) {
                for (int i = 1; i <= 3; i++) {
                    // waits in the queue until a consumer takes it
                    producer.send(("job " + i).getBytes());
                }
                // waits for the consumer to join
                queue.waitForMembers(QueueRole.CONSUMER, 1);
            }
        }
        // closing the queue ends it: the consumer gets
        // DISCONNECTED after the jobs
    }
}

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import io.github.fastipc.FipcException;
import io.github.fastipc.QueueRole;
import io.github.fastipc.Result;
import java.time.Duration;

public class Consumer {
    public static void main(String[] args) {
        try (Connection consumer = Fipc.joinQueue("my_queue",
                 QueueRole.CONSUMER, Duration.ofSeconds(5))) {
            while (true) {
                byte[] job = consumer.receive();
                System.out.println(new String(job));  // job 1..3
            }
        } catch (FipcException e) {
            // DISCONNECTED: the queue ended
            if (e.result() != Result.DISCONNECTED) throw e;
        }
    }
}

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 the reply goes back to the client that sent it. A server waits for the requests of every client at once (one receive), and the servers of a pool share the load: each takes the next request of any client. Each client has a ring of its own, which holds its requests and the room for their replies, so a server never waits for a client. Requests and replies are of one piece, 1 to maxMessage bytes, the owner's choice (maxPiece()). Here the server creates the service (Fipc.createService returns a Service), joins it as its server (Fipc.joinService with ServiceRole.SERVER: the owner's process admits every joiner by itself, its own included) and answers three requests with their uppercase. The client joins (ServiceRole.CLIENT) and calls ping 1 to ping 3: call sends a request and returns its reply. The service's close() ends it: clients' sends and servers' receives throw DISCONNECTED, and a client receives the replies that came before the end, then DISCONNECTED; a client's or a server's close never ends the service (a server's answers the request it holds ABANDONED). A Service, as a WorkQueue, has no Cleaner: a service lives until close() or the end of its process, and dropping the object doesn't end it.

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import io.github.fastipc.Service;
import io.github.fastipc.ServiceRole;
import java.time.Duration;

public class ServiceServer {
    public static void main(String[] args) {
        // 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
        try (Service service = Fipc.createService("my_service",
                 4096, 256, 1, 1)) {
            try (Connection server = Fipc.joinService("my_service",
                     ServiceRole.SERVER, Duration.ofSeconds(5))) {
                // three requests, then the end
                for (int i = 1; i <= 3; i++) {
                    // the next request of any client
                    String request = new String(server.receive());
                    // the reply goes to its client, and never waits
                    server.send(request.toUpperCase().getBytes());
                }
            }
        }
        // closing the service ends it: the client still
        // receives the replies sent
    }
}

import io.github.fastipc.Connection;
import io.github.fastipc.Fipc;
import io.github.fastipc.ServiceRole;
import java.time.Duration;

public class ServiceClient {
    public static void main(String[] args) {
        try (Connection client = Fipc.joinService("my_service",
                 ServiceRole.CLIENT, Duration.ofSeconds(5))) {
            for (int i = 1; i <= 3; i++) {
                // sends the request and returns its reply; throws
                // FipcException (ABANDONED) if the server ended
                // before it replied
                byte[] reply = client.call(("ping " + i).getBytes());
                System.out.println(new String(reply));  // PING 1..3
            }
        }
    }
}

• A client's replies come in the order of its requests. send(request) sends a request, and receive (into a new array, a buffer or a segment, or in place receiveAcquire until receiveRelease) receives the reply to its oldest request whose reply it hasn't received yet, whichever server replies first. A client may send several requests before it receives (as many as its ring has room for: each holds its length rounded up to 64 bytes, plus maxMessage rounded up to 64, until its reply has been received), 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.
• call(request, timeout) never returns another request's reply. The connection keeps count of the replies still owed: a call whose receive timed out or was cancelled leaves its reply owed, and the next call first receives and drops that reply (at most one is owed, since every call drops it first; an ABANDONED in its place counts too), within its own timeout and before it sends. A call checks its request first: INVALID for an empty one, TOO_LARGE over maxPiece(), at once, even while a reply is owed. Then a call on a cancelled connection throws CANCELLED at once, whatever its timeout, and sends nothing: it could never receive the reply. A call that had to drop an owed reply first sends its request only if its timeout has time left: once a positive timeout has run out, it throws TIMEOUT without sending, so no server sees that request; with a zero timeout no step waits, and it sends if there is room. After a call that gave up, a plain receive returns that call's late reply (or ABANDONED) first: replies come in request order. A call throws INVALID while a request sent with send (or sendCommit) still has its reply to be received: that reply is yours, so receive it first; on any connection other than a service's client it throws INVALID too. A call sends and receives, so no other thread may send or receive on the connection meanwhile.
• A server holds one request at a time. receive takes the next request of any client (each client's in the order it sent them), and send(reply) replies to it and never waits; until then its receives throw INVALID, and a reply with no request held throws INVALID. A request received in place stays the server's until the reply's send or sendCommit, and the reply may be written from it in place. The reply invalidates the segment, as do receiveRelease (which leaves the request held until its reply), the next receive and close() on the receiving thread; another thread's reply throws WrongThreadException while the segment is valid, so release it before replying there. A server's close answers a request it hasn't replied to ABANDONED: one held in place, at its segment's end. A reply to a client that has left is dropped. A server may receive on one thread and reply on another.
• ABANDONED: a client's receive (or call) throws it when the server that took the request ended before it replied: it closed its connection, or its process ended. The request counts as answered, and the next receive returns the next reply. An abandoned request may or may not have been carried out; the service never sends it again, and the client decides whether to.
• The owner's service: service.waitForMembers(role, atLeast, timeout) waits until that many members of the role (ServiceRole.CLIENT or ServiceRole.SERVER; without one, both) have joined, and returns the count; service.cancel() makes its waits throw CANCELLED, from any thread. Clients wait while no server is joined, and servers while no client is.
• Not covered: a server that hangs while its process runs (there are no timeouts, by design: its client waits, within its own timeouts); the owner's process, with which the service ends.

The Server and Client above work with a peer in any of the ten languages: every pair of languages is tested.

Measured through this binding, copied 16-byte messages run at 14 to 15 million per second between two processes on the x86-64 baseline machine and 27 to 35 million on Apple's M1, after the JIT's warm-up (details).