Ktema SystemsCorpus HubMeasurementsRequest a demoCorpus View

Measurements

HostKtema

What an open, a point read and an index cost from a thousand records to a million, in one table per store.

One record, three stores, one machine. The record is three 60-byte addresses, an origin, a media type and a payload of about 55 bytes, so the differences below are the formats.

Memory to answer by addressThe index each engine must hold. The bare log builds a map entry per record, 256 MB at five million. The engine's optional structural index is a fixed array of about 354 kB, not built in this run. A database keeps its index in a file, so its memory is the page cache that file is read through, about 8 MB.
  • Ktema, optional index
  • Append log
  • SQLite
Ktema, optional indexAppend logSQLite
1k0.3460.0630.051
10k0.3460.50.321
100k0.34642.998
1M0.346648.348
OpenMaking the volume answerable. The log rebuilds its address map here; the engine reads the trailer a stop wrote.
  • Ktema
  • Append log
  • SQLite
KtemaAppend logSQLite
1k0.2550.083257.458
10k0.542515220.875
100k0.7927,711.208225.625
1M1.5120,768.958227.417
One record by addressOne record by its own address. The log keeps the whole address map in memory, so its lookup is constant. The engine holds no map, so it probes the segments, and that read grows from 2.7 kB at a thousand records to 19.9 kB at a million.
  • Ktema
  • Append log
  • SQLite
KtemaAppend logSQLite
1k0.9590.0422.5
10k1.1250.0422.5
100k1.3330.0422.5
1M1.7920.0422.625
A tenth of the records by addressA contiguous tenth of the addresses, enumerated rather than counted: about 100 records at a thousand and about 100,000 at a million. The engine's path carries no index, so it walks the log.
  • Ktema
  • Append log
  • SQLite
KtemaAppend logSQLite
1k106.7925.257.708
10k1,421.2541.16759.042
100k23,944.625494.583587.083
1M322,745.3335,313.37511,916.542
Bytes read from the medium to answerThe bytes each store asked the medium for. The engine counts its reads; the database counts the pages its pager fetched at 4 kB, on a connection opened for the read. A point read is 2.7 kB for the engine and 12.0 kB for the database at a thousand records, 19.9 kB and 24.0 kB at a million; a tenth of the range is 1.5 GB against 27.9 MB. The append log maps its file and issues no read call.
  • Ktema, point read
  • Ktema, a tenth
  • SQLite, point read
  • SQLite, a tenth
Ktema, point readKtema, a tenthSQLite, point readSQLite, a tenth
1k0.0030.5510.0120.039
10k0.0077.9320.0160.293
100k0.01104.550.022.813
1M0.0191,548.7350.02327.922

What the three are

Ktema Append log SQLite
What it is An addressable history, written where the event happened A record of what happened, and nothing else Rows a program queries and changes
Operating system Not required Required Required
Filesystem Not required; the medium is the volume Required Required
How an address is found Computed from the record itself A map entry per record, rebuilt at every mount An index on disk, walked at each read
Bytes per record, at 1M 495 257 293
Index the volume holds, at 1M 354 kB, optional; not built in this run 64 MB, one entry per record 8.3 MB, page cache
Append one record, at 100k 5.0 µs 1.7 µs 12.8 µs
Open, at 100k 0.79 µs 7.71 ms 225.63 µs
One record by address, at 100k 1.33 µs, reading 11 kB 0.04 µs 2.50 µs, reading 20 kB
A tenth, by address, at 100k 24 ms, reading 2.2 times the volume 0.49 ms 0.59 ms, reading 2.8 MB
Where it stops A volume of 4 GiB, about 8,676,701 records When the address map no longer fits the memory it has Where its filesystem does not exist
Right tool when The host has no operating system and the history is the product The only question is what happened, on a host of a few kilobytes The data changes and the questions are not known in advance

Reading the times

The host rows are the engine’s reference path: no record maps, no block cache, no index, so a box query walks the log. A tenth of the addresses at a hundred thousand records reads 2.2 times the volume, which is where its time comes from.

The peers run with an operating system, a filesystem and a warm page cache. Neither runs on a part without one, and the log’s address map stops fitting before the volumes it serves. The engine’s case is that tier.

The append figure is where runs spread widest: at a hundred thousand records the engine lands near 5 µs and the database near 12, while the other three times stayed within a tenth of their value.

The path this page does not measure

A volume opens two ways. The reference path answers by reading the log, which is what every number here measures. The cached path builds record maps at 394 to 406 bytes a record on a 32-bit target, with the structural index at about 354 kB, so a read comes from memory. A part with 64 kB cannot take it.

Both paths hold the same record in the same format. The choice moves the cost between the medium and the memory.

A box on any axis

A multi-dimensional query fixes ranges on some axes and asks for the records inside. One box over a tenth of one axis, at a million records, through each store’s own query path:

ShapeAnswersTimeBytes readIndex
Ktema, the leading axis98,968322.7 ms1.5 GBnone
Ktema, an inner axis111,720323.6 ms1.5 GBnone
SQLite, the key range100,00011.9 ms27.9 MBnone
SQLite, an inner axis119,160235.6 ms279.0 MBnone
SQLite, an inner axis, indexed119,16070.2 ms41.4 MB135.3 MB
What the rate costs to holdAnswers a second across, bytes of index held up. The engine sits on the floor at either axis: 307 thousand and 345 thousand answers a second at zero state. The database answers the ordered shape at 8.4 million from the table it already stores; the shape that table does not carry costs 279.0 MB of reads and 235.6 ms as a scan, or 135.3 MB of index to answer in 70.2 ms.
  • Ktema
  • SQLite
KtemaSQLite
Ktema, either axis00
00

What a box costs to hold

The engine answers both shapes in one pass and the same bytes, because the address is computed. The database’s inner-axis row costs 10.0 times the reads and 19.8 times the time, and an index of 135.3 MB on a 279.0 MB volume makes it cheap again.

The engine’s flat cost is the namespace, walked once per query: 1.5 GB at a million records. A listing compares each key once per segment, and a listing begins at a prefix, which a set of ranges is not.

Per answer: 16.0 kB read against 0.3 kB.

A volume stops at 4 GiB, 8,676,701 records at 495 bytes each. A particle-physics ntuple is about a hundred times that, so the unit here is the volume.

What a read costs the medium

The engine counts the reads it asks the medium for. The count is 1 framing read and 3 fact reads at any volume, and a prefix read does not read a record.

Reads a question costs the mediumOne record read at 64 records and at 11,172. Neither count moves: a point read asks the medium for the same four regions at any volume, and the listing reads no record. The bytes behind them follow the volume.
  • 64 records
  • 11172 records
64 records11172 records
Framing11
Fact33
Listing00
RecordsFraming readFact readListing
641 read3 reads0 byte reads
111721 read3 reads0 byte reads

The read contract

174 times the volume changes neither count. The listing issues no byte read, which is the contract’s “does not read a record”; the directory walk is not a call this counter sees. The bytes behind the reads do grow, from 2.7 kB at a thousand records to 19.9 kB at a million.

ktema 8b5e3a3+, ktema-bench 1000 10000 100000 1000000 and bench/8f7da4a+/host/peer-baselines/2026-11-21T10:56:43Z · Apple arm64, 8 Performance cores, macOS 15.7.1 · 2026-11-21 · median of 51 samples · SQLite 3.43.2, WAL, synchronous=NORMAL, cache_size=8 MB. The append log is a fixed-width frame per record plus an address map, which is what an integrator writes without a database. The engine's rows are the corpus record bench/8b5e3a3+/host/volume-sweep/2026-11-21T10:53:53Z.