Benchmarks

Measured results, with their boundaries

Historical runs on fixed datasets and configurations. Figures were recomputed from the stored JSON results for this audit, and 30 result files matched the hashes in their historical build receipts. A cell says either not shown — the figure exists but is not reproduced here — or not measured, which means the study never produced it.

Order-book storage

results/b15 · storage.json

1,048,576 Bybit level rows from 7,265 events, 32 blocks or row groups. One warm-up, six measured rounds, medians. Warm page cache, one host. File-sync counted; directory sync, atomic publication and physical power-loss qualification not.

FormatBytesWrite + file-syncFull read
GQODB3,703,770198.361740 ms39.972222 ms
Parquet dictionary-LZ45,950,242313.210893 ms41.620335 ms
Parquet delta-LZ49,242,314248.710886 ms56.811581 ms

Against dictionary-LZ4: −37.7543% bytes, −36.6683% write, −3.9599% read, using 100 × (1 − GQODB / reference). This is an order-book measurement, not a tick or trade storage measurement, and it excludes the original collector envelope — so it is not evidence that the same saving holds for all original source bytes. Nothing here is a claim about cold disk, network access or a full database replacement.

Order-book codec, in memory

results/b11

Two pre-selected Bybit level samples, Arrow → bytes → Arrow in memory, one warm-up and nine measured passes per codec. No full file I/O.

SampleCodecMBEncodeDecode
hour06Previous GQODB adaptive7.350206.842 ms43.348 ms
hour06GQODB book3.693179.077 ms40.016 ms
hour06Parquet dictionary-LZ45.995298.941 ms34.941 ms
hour07Previous GQODB adaptive6.901204.962 ms40.480 ms
hour07GQODB book3.529178.008 ms39.289 ms
hour07Parquet dictionary-LZ46.183299.867 ms34.372 ms

48.9–49.8% smaller than the previous GQODB codec and 38.4–42.9% smaller than dictionary-LZ4 Parquet, at 14.3–14.5% longer decode than that Parquet baseline. Note what this does not say: the new codec decodes faster than the old GQODB one — it is Parquet that decodes faster than both. B11 and B15 are different source versions and different measurement boundaries.

News storage: latency

engine benchmark · news storage, held-out set

2,000 real AG News documents, 6,000 records with synthetic revisions and arrival times; five rounds of 1,024 queries per engine. GQO reads from an already-loaded embedded archive; PostgreSQL and MongoDB include client, driver and TCP cost. This is not a comparison of five equivalent network servers.

EngineRead p99Durable write p99
GQO resident3.967 µs2,039.667 µs
PostgreSQL pglz116.370 µs998.859 µs
PostgreSQL lz4156.490 µs1,008.402 µs
MongoDB Snappy989.414 µs2,216.059 µs
MongoDB Zstd773.916 µs2,150.121 µs

Opening, decompressing and validating the compact-wide archive costs a warm median of 95.923 ms — so the 3.967 µs query is not the total time of a fresh CLI process. PostgreSQL is faster at individual durable writes here. The small write differences against MongoDB are not a general ranking.

News storage: bytes

engine benchmark · news storage, held-out set and originals
Stored formHeldout, 6,000 recordsOriginals, 2,000 records
GQO compact-wide archive379,451 B245,996 B
GQO raw + compact-wide4,618,086 B1,582,053 B
PostgreSQL data + indices5,734,400 B1,818,624 B
MongoDB Snappy data + indices2,031,616 B692,224 B
MongoDB Zstd data + indices1,396,736 B483,328 B

Keeping the raw bytes and the archive is smaller than the PostgreSQL relation storage and larger than both MongoDB variants on these samples. Shared WAL, journal and cluster allocations are not a fair per-dataset measure and are outside this table. PostgreSQL effectively did not compress these short payloads, which proves nothing about its compression on long articles.

Model and artifact storage

engine benchmark · model storage
FileOriginalCompact archiveSaved
One UBJ model341,702 B59,727 B82.5207%
One predictor file117,919,359 B20,342,194 B82.7491%

Exact restore was verified in the historical run. The second file is a predictor artifact, not a large weight model. Both source files were recomputed from existing receipts for this audit rather than reopened; that run's output lived on tmpfs. No claim about inference, training, quantisation or disk power loss.

Local IPC, including the Redis counter-test

engine benchmark · shared-memory bus, quotes at 100,000 events/s

p99 minimum to maximum across three runs, measured from scheduled offer to usable receive.

Routep99Conditions
Shared memory0.895 – 0.912 µsActively polling endpoints — costs CPU
Unix socket7.893 – 14.443 µsDifferent waiting behaviour
Redis Pub/Sub over Unix socket49.082 – 51.062 µsSame binary payload, no TCP, no AOF or snapshot persistence, bounded PUBLISH pipeline
TCP network or durable busnot measuredNo equivalent comparison exists

A local Redis comparison exists — it is simply not an equal CPU, durability and network contract. B08 measured 64-byte shared-memory messages at 500k/s at 0.964–0.990 µs scheduled-to-usable p99, which does not extend to every payload or rate. The B09 L10 case cycles 744 real snapshots for load.

Bus stability, baseline vs speed mode

engine benchmark · bus stability, recounted from all five result files
VariantTrialsMeasured eventsSequence / payload errorsTrials with scheduled p99 ≤ 1 µs
Baseline205,200,0000 / 03
Speed mode205,200,0000 / 05
Together4010,400,0000 / 08

Zero detected errors is an observation in these runs, not a guarantee of lossless delivery after a crash. Speed mode is not consistently better, and the largest single latency in the assessment is 292.345 µs.

Engine latency, with its measurement boundary

engine benchmark · features and quality
Pathp99 across three runsWhat it measures
Feature Engine::process0.551 – 0.553 µsA local computation with synthetic times on already-normalised input
Quality spin try_submit0.521 – 0.527 µsOffering work to a separate worker thread — the check is not necessarily finished
Quality spin, report retrieved2.225 – 2.405 µsCaller plus worker plus fetching the result

Only the feature path is a single local engine call; the quality figures involve a caller and a worker thread. The quality study keeps one job outstanding at a time, so it does not establish streaming capacity under saturation, and spin can occupy a logical CPU continuously. Real clock acquisition, the feed, raw fsync and downstream publication are all outside these numbers — and none of them is a theoretical floor for other implementations.

The runtime chain, end to end

engine benchmark · runtime chain on ext4

An engineering baseline, not a release comparison: 1,000 synthetic records — 500 trades and 500 L10 snapshots — through raw and ledger sync with real quality, feature and compression workers on ext4. The host was running concurrent builds and checks at the time.

MeasureObservation
Input2,658,033 B
Native derived files2,654,936 B
Valid records / feature frames1,000 / 1,000
Capture duration18.522 s
Capture rate53.989 records/s
Consecutive receipt interval p9938.900 ms
Capture plus background completion18.554 s

The output bytes above exclude raw journals and quality and feature reports, so total storage exceeds input: this small-block run shows no meaningful net compression win. The receipt interval is not a bus hop and not full upstream event latency. The run predates part of the group-commit and metadata work in the audited copy, so no untested improvement should be credited to it. This belongs beside the favourable microbenchmarks, not behind them.

Still not measured

engine · release readiness
MeasurementResultStatus
Controlled release benchmark of the full chainnot measuredAn engineering baseline exists; an equal-workload, equal-durability comparison does not
kdb+ / q comparisonnot measuredProtocol written; never run
Cold disk, full disk, large datasetsnot measuredEvery storage figure above is warm-cache
Physical power lossnot measuredFault injection is tested; a physically cut machine is not
Long-running load, multiple consumers, source reconnectsnot measuredIncluding receipt ambiguity and producer deduplication
Current group-commit and metadata worknot measuredHistorical per-record figures must not be swapped for it without a new run
Installed-suite chain from an empty prefixnot measuredFixture install is tested; a published suite install is not