Goblin Core HSET Speed and Memory Benchmark

Generated by the native C++ harness on a dedicated benchmark host at 2026-07-16T19:07:13Z.

Summary

At 1,000,000 fields, the leanest Goblin row uses 48.67 RSS bytes/field, 20.1% less than Redis 8.8 and 45.0% less than Redis 7.2.4. The Goblin rows beat the fastest incumbent in 7 of 8 existing-field small-hash HSET comparisons. Goblin wins the million-field construction race: goblin-rt-resp-uds is 9.7% ahead of dragonfly. RT mixed p99.9 is 16.14 us, versus 16.71-22.71 us for the incumbents and 2293.39 us for efficient Goblin.

Method

• Every scenario starts a fresh server; engines run one at a time.
• Linux affinity: server core 2, client/load-generator core 3 (-1 means unpinned).
• Before the empty-server baseline, every engine constructs and deletes a 2,048-field fixed-width hash, then settles.
• RT's fixed prefaulted index pool is charged back into RSS and used_memory deltas instead of being hidden as empty-server overhead.
• RSS is read from the launched server PID: mini-redis-go uses ps -o rss=, while other engines use /proc/<pid>/status as VmRSS + HugetlbPages; no server-reported RSS field is used.
• Every engine uses RESP2 over a Unix-domain socket. The HSET suite has no TCP, SBE, or shared-memory-ring rows; transport is not a benchmark variable.
• Bulk workloads, response validation, point throughput, mixed latency, process control, aggregation, and report generation run in this native C++ executable.
• The benchmark client's application receive buffer is 65,536 bytes. Goblin's per-client application receive buffer is explicitly 16,384 bytes; incumbent server internals and kernel UDS buffers remain at their engine/OS defaults.
• Bulk loads use multi-field HSET batches of 128. Every point-throughput row uses RESP pipeline depth 256. Timing includes native client encoding. Point rates use 500,000 requests and the median of 3 probes in each of 3 fresh servers.
• Redis and Valkey use benchmarks/redis-parity.conf; Dragonfly uses one proactor thread for single-core parity. mini-redis-go runs as an external binary with GOMAXPROCS=1, AOF disabled, and metrics disabled.
• Unsupported point commands are reported as n/a; error replies are never timed as successful operations.
• goblin-efficient-* uses the default memory-efficient hash representation. goblin-rt-* passes --hash-implementation rt; the keyspace index remains unchanged so the rows isolate the HSET implementation.
• Goblin uses default string encoding and its configured compact-hash policy. Incumbents are exercised strictly as black-box RESP servers.

One Large Hash

1,000,000 distinct 18-byte fields start with 16-byte values and then grow to 64 bytes.

Speed

H* Point Throughput

All hit/existing-field probes target the same populated large hash. HMGET returns four hits. HINCRBY uses a dedicated one-field numeric hash. HDEL is covered by the mixed mutation latency table below because a stationary delete workload must restore fields. When a report retains older incumbent rows, this matrix remains Goblin-only because those runs predate the added probes.

Every row uses RESP/UDS with pipeline depth 256, a 65,536-byte client receive buffer, and no shared-memory ring.

Memory With 16-Byte Values

Goblin is sampled after GOBLIN.OPTIMIZE.

Memory After Growing Every Value to 64 Bytes

Goblin Large-Hash Internals

For RT rows, index MiB is the live bucket/directory storage attributed to this key. RSS and used_memory charge the entire shared fixed pool once, including free headroom; its committed capacity is exposed by INFO as realtime_hash_index_pool_bytes.

Many Hashes

Each shape holds approximately 500,000 total fields. Keys are 14 bytes, fields are 5 bytes, and values are 16 bytes.

Speed

Memory

Sampled key bytes are the mean of the first, middle, and last hash. RT process deltas include the shared fixed pool, so its configured capacity is deliberately most visible in smaller datasets.

Goblin Full-Hash Relocation Density

Goblin uses --hash-listpack-max-entries 0. Each row is the median of 1 fresh-server rounds over 100,000 fields.

Mixed Hash Write Latency

A seeded depth-one workload starts with 100,000 fields, warms 1,000 operations, and measures 10,000 unpipelined RESP/UDS round trips in C++. The client receive buffer is 65,536 bytes; this sample count provides about 10 p99.9 observations and 1 p99.99 observations per round.

The medium-hash representation crossover is measured separately in HASH-THRESHOLD-SWEEP.

Tested Servers

• goblin-efficient-resp-uds
• goblin-rt-resp-uds
• redis-7.2.4
• redis-8.8
• valkey-9.1
• dragonfly
• mini-redis-go-55178df