Loongson 3A6000 Benchmarks

中文版

Goblin Core versus Redis 7.2.4, Redis 8.8.0, Valkey 9.1.0, and Dragonfly v1.39.0 on a Loongson 3A6000 (Kylin, loongarch64). Same methodology as BENCHMARKS: allocator parity within each engine family, redis-parity.conf for the Redis line, one serving thread per engine.

Measured 2026-07-07 on host loongson. Artifacts: ~/loongson-bench-work/results/.

Dragonfly has no loongarch64 release binary; it was built from source on this host (see Dragonfly build). It is run with taskset -c 0 and a single proactor thread, matching the one-core budget of the single-threaded engines.

---

Host

Goblin requires LD_LIBRARY_PATH=/opt/loongson-gcc-15.2.0/lib at runtime.

Pinning (latency runs): server taskset -c 0, client probe taskset -c 1. Throughput runs use redis-benchmark -c 1 -P 16 without explicit server taskset; the box was otherwise idle.

---

Memory methodology

Memory tables report absolute structure bytes per element after load — not RSS deltas over an empty-server baseline.

Workload: one key, N elements, scattered scores (zsets) or 16-byte field names/values (hashes, hashtable encoding). Goblin runs GOBLIN.OPTIMIZE after load. Sweep 500K–2M members/fields.

Fragmentation (optional context): process RSS after load ÷ engine-reported used_memory. Values near 1.0 mean resident set tracks structure bytes; higher values mean allocator-retained pages (not extra structure).

---

Allocators

Do not substitute system jemalloc for the Redis-family engines.

---

Sorted-set memory (structure bytes/member)

Goblin Core is leanest at every size (~49 B/member, tightening to 48.6 at 2M). Dragonfly is second (~55 B/member, flat). Redis 8.8.0 is ~24% leaner than 7.2.4 (~78 vs ~103 B/member). Valkey sits between Redis 8.8 and 7.2.4.

Fragmentation (RSS ÷ used_memory) after load:

Goblin and the Redis family tighten toward ~1.2 by 2M. Dragonfly's mimalloc arenas keep RSS well above used_memory on this port (ratio ~4–13).

---

Hash memory (structure bytes/field)

16-byte field names and values, hashtable encoding (redis-parity.conf).

Goblin Core is leanest (~46 B/field, flat). Redis 8.8.0 is next (~55 B/field). Dragonfly and Valkey cluster around ~67–77 B/field. Redis 7.2.4 is heaviest (~81 B/field).

Fragmentation (RSS ÷ used_memory) after load:

---

Sorted-set throughput

redis-benchmark, 1M-member keyspace, best of 3, -c 1 -P 16.

Goblin leads every zset throughput metric on the 3A6000 (~+35% ZADD vs Redis 7.2.4). Dragonfly trails the field on Loongson — the opposite of the x86 story — likely reflecting a fresh loongarch64 source port (SIMDe for SSE intrinsics, no tuned assembly paths) rather than Dragonfly's x86/aarch64 binaries.

---

Hash throughput

1M-field keyspace, same redis-benchmark settings.

Goblin leads on every hash op (~+29% HSET vs Redis 7.2.4). Dragonfly is slowest on writes and range reads here.

---

Latency

C probe write_tail_latency (200K samples) + redis-benchmark PING at 1 / 50 / 500 clients (100K samples each). Server core 0, client core 1.

Depth-1 PING (probe, µs):

PING throughput / p50 by client count (redis-benchmark -P 1):

Goblin is fastest on depth-1 PING. Dragonfly leads at 500 saturated clients (50K / 4.90ms).

---

Write-path tail latency

200K individually-timed ZADDs growing one set (same C probe), microseconds:

Goblin wins through p99; the max is a Swiss-table rehash on the final large insert (~20 ms). The Redis family shows lower tail max on this hardware.

---

Persistence

1M-member zset; SAVE / GOBLIN.SAVE, then cold load. Load is wall-clock startup with data present minus empty-server startup (absolute times for each step; load column is the incremental cost of restoring data).

Goblin saves and loads fastest. Redis-family and Dragonfly write smaller on-disk files (24.8 MB vs Goblin 37.0 MB). Dragonfly loads faster than Redis/Valkey (0.438s) but not Goblin (0.050s).

---

Dragonfly build

No official loongarch64 release exists; this is a best-effort source build for comparative measurement, not a supported Dragonfly target.

---

Reproduce

# on loongson — does not modify ~/dev/packrat sources
~/loongson-bench-work/build_engines.sh
~/loongson-bench-work/build_dragonfly.sh   # optional; long build
/opt/loongson-gcc-15.2.0/bin/g++ -O2 -std=c++20 \
  -o ~/loongson-bench-work/write_tail_latency \
  ~/dev/packrat/benchmarks/write_tail_latency.cpp
export LD_LIBRARY_PATH=/opt/loongson-gcc-15.2.0/lib
~/loongson-bench-work/run_all.sh

Benchmark scripts with Dragonfly support live in ~/loongson-bench-work/benchmarks/ (copies of the packrat suite; the loongson ~/dev/packrat tree is older and lacks Dragonfly hooks).

Engine binaries:

---

Cross-host pitch: Goblin on Loongson vs incumbents on x86

Cross-host read for domestic-silicon deployments: Goblin Core on the 3A6000 (this document) versus Redis 7.2.4, Redis 8.8.0, Valkey 9.1.0, Dragonfly, and Goblin Core on the x86 reference host in BENCHMARKS — AMD Ryzen Threadripper PRO 5995WX (64 cores × 2 threads, GCC 16.1.0). Different CPU, clock, and memory bandwidth — not a same-machine comparison.

Verdict: Goblin on Loongson is often ~75–90% of Redis on the Threadripper on hot-path ops, beats every competitor on the same Loongson box, and beats x86 Redis on snapshot load. It is not reference-host-class versus Goblin on x86 (~50–75% throughput). The honest hook: not “make Loongson into a Threadripper,” but remove the Redis-on-Loongson performance penalty — and on load plus memory, beat what teams get from Redis on x86.

Throughput (ops/s, pipelined -P 16)

On writes and rank (ZADD, ZRANK), Goblin on the 3A6000 is within ~10–15% of legacy Redis on the 5995WX — credible for a 2 GHz 3A6000 vs a workstation-class part. Versus Redis 8.8 / Valkey on x86: ~70–85%. Versus Goblin on x86: ~52% (ZADD) to ~74% (HGET).

Latency (µs)

Latency is fine but not x86-class — a few microseconds slower than Redis on the Threadripper host, still best on the Loongson box (PING p50 22.9 vs Redis 25.9–28.9).

Persistence and memory (1M zset load; 2M structure bytes)

Goblin on Loongson loads faster than Redis on the x86 host (~6–7×). Memory advantage does not shrink on Loongson — same packed layout, leanest in both columns. x86 figures from BENCHMARKS (same used_memory metric as the Loongson tables above).

Same Loongson box (why the engine choice matters)

Redis on Loongson is only ~64% of Redis-on-x86 (153K vs 239K). Goblin on Loongson is ~87% of Redis-on-x86. Switching Redis → Goblin on Loongson recovers most of the ISA gap relative to running Redis on x86.

Pitch guide (for domestic-silicon teams)

Strong (defensible):

On Loongson 3A6000, single-core ZADD/ZRANK with Goblin reaches ~85–90% of

Redis 7.2.4 on the Threadripper reference host, while beating Redis/Valkey on

the same machine by ~35–50%; snapshot load is an order of magnitude faster

than x86 Redis.

Medium:

Loongson + Redis drops sharply; Loongson + Goblin pulls hot paths back toward

“near x86 Redis” territory with the leanest memory footprint.

Weak (do not claim):

Goblin on Loongson equals Goblin on x86 — throughput is roughly half.

Dragonfly on Loongson is viable — it trails badly here (115K ZADD vs Goblin

207K).

Claim checklist

Caveats: Dragonfly on Loongson is a best-effort source port; do not extrapolate x86 Dragonfly results to loongarch64. Goblin-only in-process microbenchmarks are useful for silicon bring-up but not a substitute for this cross-engine suite (~/loongson-bench-work/results/microbench-100k.json).