Monday, 21 December 2020

Multi-Topic Broadcast in Babl WebSocket Server

As of version 0.10.0, Babl applications gained the ability to broadcast messages to multiple topics simultaneously. This new functionality makes publishing of market data even more efficient.

Using multi-topic broadcast, an application can send a single message to multiple topics, and transform that message for each receiving topic. The message is broadcast to all session containers via IPC, and will be picked up by those containers hosting sessions belonging to the relevant topics.

This specialisation is designed for situations where the same basic information needs to be sent to a large number of sessions, but with a slightly different view depending on the session.

The obvious example of this use-case is the publication of market data, where a single update needs to be sent to several subscribed sessions. Some of these sessions might be subscribing to the full depth of market data, while others might only require the top-of-book updates. 
Without multi-topic broadcast, it would be necessary to pre-render each of these updates (full-depth, top-of-book) on the application thread, and to publish over IPC to the session containers. Instead, it is possible to configure a topic for each view-type, and publish a single message over IPC. The work of transforming the message is then off-loaded to a message-transformer, running on the session container thread.

Multi-Topic Broadcast API


To use the API, an application must create and maintain membership of topics:

private static final class MarketDataApplication
    implements Application, BroadcastSource
    private Broadcast broadcast;
    private int[] topicIds;

    public void setBroadcast(final Broadcast broadcast)
        // store the Broadcast implementation
        this.broadcast = broadcast;
        this.topicIds = new int[] {
        // create a topic for broadcast

    public int onSessionConnected(final Session session)
        // add new sessions to the topic
        return SendResult.OK;

    public void onMarketDataUpdate(final MarketDataUpdate update)
        final DirectBuffer buffer = serialise(update);
        // send a message to all sessions registered on the topic
        broadcast.sendToTopics(topicIds, buffer, 0, buffer.capacity());

Application messages broadcast to multiple topics will be handed to the registered message transformer before being written to sessions. A message transformer simply creates a topic-dependent view based on the topic ID:

final class MarketDataTransformer
    implements MessageTransformer
    private final ExpandableArrayBuffer dst =
        new ExpandableArrayBuffer();
    private final TransformResult transformResult =
        new TransformResult();

    public TransformResult transform(
        final int topicId,
        final DirectBuffer input,
        final int offset,
        final int length)
        if (topicId == MARKET_DATA_TOP_OF_BOOK)
            transformResult.set(dst, 0, encodeTopOfBook(input, offset, length));
            transformResult.set(dst, 0, encodeFullDepth(input, offset, length));
        return transformResult;

The message transformer must be registered before server start-up using the configuration API:

new BablConfig().sessionContainerConfig()
    .messageTransformerFactory(topicId -> new MarketDataTransformer());

More Info

Babl source-code is available on Github, and releases are published to maven central and Docker hub.

Full documentation is available at

Enjoyed this post? You might be interested in subscribing to the Four Steps Newsletter, a monthly newsletter covering techniques for writing faster, more performant software.