Goblin Core Pub/Sub Performance Benchmark

Generated by the native C++ harness on the dedicated benchmark host on July 15, 2026.

Summary

With one publisher and one subscriber, Goblin Core's typed SBE path over a 4 KiB shared-memory ring delivers a 16-byte message in 0.301 us at p50 and 0.391 us at p99. That is 39.8x and 39.3x faster, respectively, than the fastest incumbent result. The closed-loop workload completes 2.63 million fully acknowledged and delivered publications per second, 32.7x the fastest incumbent.

The advantage survives fanout: at 64 listeners, the ring reaches the last listener in 12.704 us at p50 and completes 77,042 publications/s, 12.8x and 13.7x the fastest incumbent results. Literal-channel lookup stays flat at 0.311-0.321 us from one through 16,384 subscriptions.

Pattern matching is a second win, not just a transport win. With 8,192 patterns, Goblin's RESP2/UDS path reaches the matching subscriber in 62.709 us, 3.95x faster than the fastest incumbent; SBE/ring reduces that to 43.512 us, 5.69x faster. Goblin's conventional RESP2/UDS path remains within 5% of the fastest incumbent on the one-listener literal cases, so the ring result is not hiding a slow server behind a fast transport.

Goblin also has the lowest total server RSS in every comparable large subscription topology here. Its incremental subscription structures are not always the smallest: Redis 7.2.4 has the lowest delta at 16,384 literal channels, while Redis 8.8 and Valkey lead the 32-client deltas. Both total RSS and baseline-subtracted deltas are reported below.

Method

• benchmarks/pubsub_benchmark.cpp is a native C++23 publisher and subscriber harness. Python, redis-cli, and redis-benchmark are absent from the measured path.
• The publisher issues one PUBLISH, waits for its integer acknowledgement and every expected delivery, then issues the next publication. There is no pipelining or backlog. The reported publication rate is this complete closed-loop cycle rate.
• Acknowledgement latency runs from the publisher's send until the PUBLISH reply. Delivery latency runs from the same start timestamp until the final subscriber receives and validates the channel and payload. A delivery may precede the publisher acknowledgement; Dragonfly exhibits this in several rows.
• The one-to-one group measures 100,000 publications after 10,000 warmups. Fanout and ordinary routing rows measure 20,000 after 2,000 warmups. The 8,192-pattern rows use 5,000 samples after 500 warmups.
• Every scenario starts a fresh server, and engines run one at a time. Goblin, Redis, Valkey, and mini-redis-go use server CPU 2; Dragonfly manages its own affinity with one proactor. The publisher uses CPU 3, and subscriber reader threads start on CPU 4. The 64-listener case avoids the server and publisher's SMT siblings.
• The host is a quiet AMD Ryzen Threadripper PRO 5995WX with 64 cores. Results were collected from Release AVX2 builds on Linux. Timing uses rdtscp, calibrated against the monotonic clock.
• Goblin is measured twice: typed SBE over shared-memory rings and RESP2 over a Unix-domain socket. Every incumbent uses RESP2/UDS through the same native RESP encoder, parser, validation, and timer.
• Every Goblin ring is exactly 4 KiB. Large subscription setup requests are split into 32-name batches outside the timed region. A 4,096-byte payload plus SBE and ring framing cannot fit in a 4 KiB ring, so that cell is n/a rather than a smaller, incomparable payload.
• Goblin uses an 8 KiB per-client unsolicited-output allocation in this run. Messages are drained synchronously, so the benchmark never relies on queueing up to that limit.
• Redis and Valkey use benchmarks/redis-parity.conf. Dragonfly uses one proactor thread for single-core parity. mini-redis-go uses GOMAXPROCS=1, with AOF and metrics disabled.
• RSS is read from the launched server PID, never from a server-reported memory field. mini-redis-go uses ps -o rss=; the other engines use Linux /proc/<pid>/status as VmRSS + HugetlbPages.
• Incumbents are treated strictly as black-box servers. Their source code is not inspected.

All latency columns below are microseconds. Lower latency is better; higher publication rate is better.

One Publisher, One Subscriber

The payload is delivered to one literal subscriber. p99 and p99.9 are shown for the 16-byte hot-path case; the final columns show payload scaling at p50.

The ring's median changes by only 0.020 us between 16- and 256-byte payloads. On the shared UDS path, Goblin is 4.6% behind Dragonfly's fastest 16-byte median, but has the lowest p99.9 of every socket row.

Literal Fanout

Each publication targets one literal channel shared by every listener. Delivery latency ends when the last listener receives the message.

At 64 listeners, Goblin SBE/ring is 12.8x faster at p50 and 11.5x faster at p99 than the best incumbent cells. Goblin RESP2/UDS tracks the Redis-family implementations closely and has the tightest socket p99.9 in this row.

Literal Routing Scale

One client subscribes to the listed number of distinct literal channels. Every publication targets the same subscribed channel, so this isolates lookup cost as the channel table grows.

Goblin's literal lookup is flat on both transports. At 16,384 channels, the ring is 37.3x faster at p50 and 35.4x faster at p99 than the best incumbent.

Pattern Routing

Pattern subscriptions use Redis-compatible glob matching. Pattern count is the scaling variable, the hit target matches one pattern, and Goblin examines every registered pattern for each publication. mini-redis-go at the tested revision does not implement PSUBSCRIBE, so its pattern cells are n/a.

Matching Publication

Unmatched Publication

With no delivery to wait for, this table reports the PUBLISH acknowledgement latency. It directly exposes the cost of scanning patterns and finding no match.

Pattern cost is still linear; Goblin has a substantially lower constant factor. At 8,192 patterns, Goblin RESP2/UDS is 3.95x faster than the best incumbent hit median and 2.63x faster on a miss. The ring extends the hit lead to 5.69x.

Many Clients and Subscriptions

Thirty-two subscribers each hold 32 private subscriptions plus one shared subscription. The publication targets the shared literal channel or shared pattern, producing 32 validated deliveries.

SBE/ring completes the literal topology 13.0x faster at p50 and the pattern topology 10.3x faster than the best incumbent. Goblin RESP2/UDS is 5.3% behind Dragonfly's literal p50 while completing 1.89x as many closed-loop publications; on patterns, Goblin RESP2/UDS leads the best incumbent p50 by 1.29x.

Server Memory

Each cell is total RSS / RSS delta in MiB after constructing the topology. The delta subtracts that fresh server's empty baseline. Total RSS is the fair view of the complete process; the delta helps isolate subscription growth. Goblin ring mappings exist before the baseline, while client output buffers are activated by subscription, so neither number should be read without the other. Small RSS deltas are also subject to page granularity and allocator reuse.

Goblin has the lowest total server RSS in all four topologies. Redis and Valkey sometimes allocate less incremental memory after their larger baselines, which is why both sides of the slash are retained.

What This Benchmark Does Not Claim

• It is a synchronous latency and complete-delivery-rate test, not an asynchronous maximum-ingress test. A publisher allowed to build a queue would measure buffering policy and backpressure as much as Pub/Sub execution.
• SBE/ring is a Goblin-specific low-latency capability. Goblin RESP2/UDS is the apples-to-apples compatibility row for the incumbent comparison.
• The 4 KiB ring deliberately trades maximum message size for a tiny mapped footprint. Larger rings can carry the 4,096-byte case; this report holds the requested 4 KiB capacity fixed.
• Pattern matching scans every registered pattern. The tables show its linear scaling rather than implying constant-time glob routing.
• These are single-host Unix-domain-socket and shared-memory results. TCP, cross-host networking, subscriber application work, and client deserialization beyond the native harness are outside this measurement.

Reproducing

Build the server and native driver, then run the matrix:

cmake -S . -B build-rel -DCMAKE_BUILD_TYPE=Release \
  -DGOBLIN_CORE_ARCH=avx2 -DGOBLIN_CORE_BUILD_BENCHMARKS=ON
cmake --build build-rel -j --target \
  goblin_core_server goblin_core_pubsub_benchmark
bash benchmarks/pubsub_benchmark.sh

The launcher paths are environment-overridable; no machine-specific binary paths are required by the benchmark source. It writes the complete 26-column CSV, including minimum, p50, p90, p99, p99.9, mean, publication rate, baseline RSS, subscribed RSS, and RSS delta.

The command behavior is documented in the Pub/Sub reference. The low-latency transport and wire format are documented in ring buffers and the SBE protocol.

Tested Servers

• goblin-sbe-ring-4kb
• goblin-resp-uds
• redis-7.2.4
• redis-8.8
• valkey-9.1
• dragonfly
• mini-redis-go-55178df