DataPower disclosure report

lance-csr 0.5.1

Non-standard result. This run departs from DP-2026.1 in 7 ways, listed in section 9. Rank its figure only beside runs with the same departures.

Run 2026-11-01T21-25-05Z-standard-sf1m-s-lance-csr · scenario standard-sf1m-s-lance-csr · repetition 1 of 1 · spec DP-2026.1

12DP
dp-core SF-1M, envelope S, on the standard mix, blended 80% typical, 15% off-index, 5% worst-case
DP = (E × T) / (R × O) = (1.00 × 35.73) / (2.156 × 1.350)
1.00E · million data elements
35.73T · effective ops/s at k* = 1
2.156R · 2 cores + 1.25 GiB / 8 + 0.04 GiB / 200
1.350O · 1 + 0.05 × 7 surface points

2. Factors

FactorValue
Disk at rest / after work0.02 / 0.04 GiB
Bytes per element39.6
Log share of disk0.0%
Write amplification0.00
Memory ready, after import / repetition0.29 / 0.12 GiB
Peak memory1.33 GiB
Memory charge (M)1.25 GiB
Memory elasticity0.12
Held memory: ready / peak / charge0.12 / 1.23 / 1.18 GiB
Held memory elasticity0.06
Memory after the kernel reclaims1.18 GiB of 1.23
Memory floor (in-memory)2.00 GiB
CPU per standard operation20.57 ms
CPU throttled0.0%

Memory composition

Held memory is memory.current less the page cache, which the kernel hands to another tenant when the host needs it. The score charges memory.current, as spec section 8.5 says.

WhenTotalAnonymousSharedPage cacheKernel
idle1.231.170.000.030.02
peak1.331.200.000.100.02
ready0.290.270.000.020.00
ready_repetition0.120.110.000.000.00

Latency, warm single client

ClassOperationp50 msp99 msTarget ms
R1point10.1413.4110
R2filter7.349.14200
R3neighbourhood22.5629.9850
R4deep16.8519.07500
R5path10.3010.57500
R6pattern37.7638.982,000
R7analytic35.7737.705,000
W1insert22.5124.0920
W2insert edge6.077.0010
W3batch12.2614.93500
U1modify40.8344.5120
U2rewire12.8613.7930
D1delete edge27.5828.1620
D2delete cascade114.43259.20100
O1person by email11.1912.9320
O2accounts by opening date3.244.25200
O3people by surname and city15.6116.38100
S1amount band24.8027.181,000
S3text search17.5018.672,000
J4neighbours alike28.6929.95500
R1wpoint, worst case8.209.0810
R2wfilter, worst case6.9313.17200
R3wneighbourhood, worst case29.3633.6350
R4wdeep, worst case18.8023.50500
R5wpath, worst case7.588.29500
R6wpattern, worst case33.3835.812,000
R7wanalytic, worst case29.8231.155,000

Operational surface: 7 points

ItemPointsSource
runtime dependency: python31audited
setting: maintain_every_s = 101audited
setting: use_csr = true1audited
maintenance task: compaction2declared
maintenance task: version cleanup2declared

3. Host and system

Systemlance-csr 0.5.1, adapter lance-csr
Imagelocalhost/dpbench-lance-csr@sha256:66104e648b57be906b355533a6b5e1a7371afb82527129f8dc914fcdd70b8fda
EnvelopeS: 2 cores, 8 GiB limit
HostAMD EPYC 7502P 32-Core Processor, 64 cores, SMT off, 252 GiB
Kernel and disk6.12.67 · /dev/md0, xfs
Runtimepodman 4.3.1, cgroup v2

4. Adapter manifest, DDL and configuration diff

# lance-csr 0.5.1, the openCypher engine over Lance datasets, with pylance
# 13.0.0 for writes, served by dp-lance-csr (adapters/lance-csr/server).
#
# lance-csr is an embedded engine that a Python program drives, so the
# adapter brings the smallest program that puts it on a network, and runs it
# inside the SUT's container: one CypherEngine over the Lance datasets on the
# data volume, shared by every connection, each connection on its own
# thread. lance-csr releases the GIL while a query runs, so connections run
# their queries at the same time. The writes go through pylance 13.0.0, the
# Lance lance-csr pins, and each refreshes the engine before it returns.
#
# The configuration is the one lance-csr's README presents for Lance on
# disk: every dataset read lazily, with the CSR index. Every read is Cypher;
# none needs lance-csr's SQL engine.
#
# lance-csr publishes no image, so the adapter builds one on the engine's
# host: `adapters/lance-csr/build-image.sh` (Containerfile beside this file)
# builds localhost/dpbench-lance-csr and prints its digest. The image is
# local, so `image` pins the digest that build printed. lance-csr 0.5.1
# publishes a Linux wheel for x86-64 only, so the host must be linux/amd64.
#
# THE DIGEST BELOW IS A PLACEHOLDER. Run build-image.sh on the engine's host
# and put the digest it prints here; until then P0 cannot find the image.
name: lance-csr
system: lance-csr
version: "0.5.1"
image: localhost/dpbench-lance-csr@sha256:66104e648b57be906b355533a6b5e1a7371afb82527129f8dc914fcdd70b8fda
model: property-graph
protocols: [json-lines]
query_language: cypher

# A Lance commit is not durable when it returns, and nothing makes it so.
# Lance 13.0.0 writes to a local path through object_store's LocalFileSystem,
# which syncs nothing unless built with with_fsync(true), and Lance never
# builds it so (lance-io, FileStoreProvider::new_store). Data, deletion and
# transaction files go through Lance's LocalWriter, which flushes its buffer
# and renames the file into place without sync_all (lance-io,
# object_writer.rs, LocalWriter::persist). The manifest that commits a
# version goes through ConditionalPutCommitHandler, which hard-links it into
# place through the same unsynced LocalFileSystem (lance-table,
# io/commit.rs; object_store 0.14.1, local.rs, finish_staged_hard_link). So
# every commit returns from the page cache, and the run records a deviation.
durability:
  settings: {}
  deferred: "Lance 13.0.0 calls no fsync: a commit returns once its data files and manifest are in the page cache, so a power loss can lose acknowledged writes, or keep a manifest whose data files never reached the disk"

# Lance commits one dataset at a time. Each commit is atomic, and a commit
# that races another on the same dataset rebases onto it or fails with a
# conflict the driver retries. Lance has no transaction across datasets: W1
# writes person, account and knows in three commits, and D2 deletes from nine
# datasets in nine. A query reads the dataset versions of the engine's last
# refresh, so a refresh between two of those commits shows a reader part of
# the write. The run records that as a deviation.
isolation: per-dataset snapshot

declared_surface:
  services: 1
  # The server is a Python program, and lance-csr is a Python package.
  runtime_dependencies: [python3]
  # The graph mapping names each label's key and each relationship's
  # endpoint columns, which are the canonical schema. With use_csr the
  # engine builds a CSR adjacency per relationship type and a node index per
  # label on its own, from that mapping alone: defaults, as Neo4j's token
  # indexes are. No dataset holds a Lance index.
  secondary_indexes: []
  hand_sized_caches: []
  non_default_settings:
    # CypherEngine(..., use_csr=True): each hop of a traversal reads the CSR
    # where it would join tables. lance-csr's default is False; its README and
    # benchmarks run with True.
    use_csr: "true"
    # How often the maintenance job below runs: every 10 s. Each append and
    # update commits a new fragment, and every write a new version. With the
    # standard mix at 16 clients on SF-1M, throughput fell from about 300 to
    # about 130 operations a second within 10 s of writes as fragments piled
    # up, and came back each time compaction merged them; over a minute it
    # fell to 50 with no compaction at all.
    maintain_every_s: "10"
  # Lance compacts nothing and removes no version on its own. The server
  # runs compact_files on every dataset, retrying one that a concurrent
  # update or delete preempts, then cleanup_old_versions for the versions
  # more than a minute old, every maintain_every_s seconds, and once when
  # the lifecycle calls maintenance.
  maintenance_tasks: [compaction, version cleanup]
  storage_areas: [data]
  manual_steps: []

envelope:
  size: S
  memory_limit_gib: 8

plugin: lance-csr
container:
  port: 6544
  data_path: /data
  dataset_path: /dataset
  # The image's entrypoint names the harness's port and paths. Every setting
  # an operator chose is here.
  args: ["-use-csr", "-maintain-every", "10"]

Executed DDL

lance.write_dataset(<no rows: id int64 not null, name string not null, type string not null, part_of int64>, '/data/place.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, first_name string not null, last_name string not null, birth_date date32[day] not null, created_at int64 not null, risk_score double not null, email string, lives_in int64 not null>, '/data/person.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, name string not null, type string not null, founded date32[day] not null, located_in int64 not null>, '/data/organization.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, owner_id int64 not null, org_id int64, opened_at int64 not null, balance int64 not null, status string not null, country string not null>, '/data/account.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, kind string not null, os string not null, first_seen int64 not null, fingerprint string not null>, '/data/device.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, name string not null, class string not null>, '/data/tag.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, author_id int64 not null, tag_id int64, created_at int64 not null, length int64 not null, language string not null, content string not null>, '/data/post.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, src_id int64 not null, dst_id int64 not null, since date32[day] not null, strength double not null>, '/data/knows.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, src_id int64 not null, dst_id int64 not null, from_date date32[day] not null, role string not null>, '/data/works_at.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, src_id int64 not null, dst_id int64 not null, first_seen int64 not null, last_seen int64 not null>, '/data/uses.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, src_id int64 not null, dst_id int64 not null, ts int64 not null, amount int64 not null, currency string not null, channel string not null>, '/data/transfer.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, src_id int64 not null, dst_id int64 not null, weight double not null>, '/data/interested_in.lance', mode='create');
lance.write_dataset(<no rows: id int64 not null, src_id int64 not null, dst_id int64 not null, ts int64 not null>, '/data/likes.lance', mode='create');
GraphConfig.builder()
    .node_table('Place', 'id')  # place
    .node_table('Person', 'id')  # person
    .node_table('Organization', 'id')  # organization
    .node_table('Account', 'id')  # account
    .node_table('Device', 'id')  # device
    .node_table('Tag', 'id')  # tag
    .node_table('Post', 'id')  # post
    .rel_table('PART_OF', 'Place', 'Place', 'id', 'part_of')  # place
    .rel_table('LIVES_IN', 'Person', 'Place', 'id', 'lives_in')  # person
    .rel_table('LOCATED_IN', 'Organization', 'Place', 'id', 'located_in')  # organization
    .rel_table('OWNED_BY', 'Account', 'Person', 'id', 'owner_id')  # account
    .rel_table('HELD_AT', 'Account', 'Organization', 'id', 'org_id')  # account
    .rel_table('HAS_AUTHOR', 'Post', 'Person', 'id', 'author_id')  # post
    .rel_table('ABOUT', 'Post', 'Tag', 'id', 'tag_id')  # post
    .rel_table('KNOWS', 'Person', 'Person', 'src_id', 'dst_id')  # knows
    .rel_table('WORKS_AT', 'Person', 'Organization', 'src_id', 'dst_id')  # works_at
    .rel_table('USES', 'Person', 'Device', 'src_id', 'dst_id')  # uses
    .rel_table('TRANSFER', 'Account', 'Account', 'src_id', 'dst_id')  # transfer
    .rel_table('INTERESTED_IN', 'Person', 'Tag', 'src_id', 'dst_id')  # interested_in
    .rel_table('LIKES', 'Person', 'Post', 'src_id', 'dst_id')  # likes
    .build();
lance.write_dataset(</dataset/data/place.csv, read with pyarrow.csv>, "place.lance", mode='append');
lance.write_dataset(</dataset/data/person.csv, read with pyarrow.csv>, "person.lance", mode='append');
lance.write_dataset(</dataset/data/organization.csv, read with pyarrow.csv>, "organization.lance", mode='append');
lance.write_dataset(</dataset/data/account.csv, read with pyarrow.csv>, "account.lance", mode='append');
lance.write_dataset(</dataset/data/device.csv, read with pyarrow.csv>, "device.lance", mode='append');
lance.write_dataset(</dataset/data/tag.csv, read with pyarrow.csv>, "tag.lance", mode='append');
lance.write_dataset(</dataset/data/post.csv, read with pyarrow.csv>, "post.lance", mode='append');
lance.write_dataset(</dataset/data/knows.csv, read with pyarrow.csv>, "knows.lance", mode='append');
lance.write_dataset(</dataset/data/works_at.csv, read with pyarrow.csv>, "works_at.lance", mode='append');
lance.write_dataset(</dataset/data/uses.csv, read with pyarrow.csv>, "uses.lance", mode='append');
lance.write_dataset(</dataset/data/transfer.csv, read with pyarrow.csv>, "transfer.lance", mode='append');
lance.write_dataset(</dataset/data/interested_in.csv, read with pyarrow.csv>, "interested_in.lance", mode='append');
lance.write_dataset(</dataset/data/likes.csv, read with pyarrow.csv>, "likes.lance", mode='append');
CypherEngine(config, {label or type: lance.dataset(path)}, use_csr=<the server's -use-csr>);

Settings that differ from a fresh container of the same image

SettingImage defaultThis run
maintain_every_s010
use_csrfalsetrue

5. Queries

The adapter runs these statements, with parameters bound as $n.

J1

MATCH (:Person {id: $id})-[:KNOWS*1..4]->(x:Person)
WHERE x.id <> $id
RETURN count(DISTINCT x.id)

S1

MATCH ()-[t:TRANSFER]->()
WHERE t.ts >= $from AND t.ts < $to AND t.channel = $channel AND t.amount >= $lo AND t.amount <= $hi
RETURN count(t), coalesce(sum(t.amount), 0)

O1

MATCH (p:Person {email: $email})
OPTIONAL MATCH (a:Account)-[:OWNED_BY]->(p)
RETURN p.id, p.first_name, p.last_name, a.id, a.balance, a.status

J3

MATCH (p:Person {id: $id})-[:KNOWS]->(a:Person)-[:KNOWS]->(b:Person)-[:KNOWS]->(p)
WHERE a.id <> $id AND b.id <> $id AND a.id <> b.id
RETURN count(*)

S2

MATCH (p:Person)
WHERE p.risk_score >= $risk AND p.birth_date >= $from AND p.birth_date < $to
RETURN p.id

S4

MATCH ()-[t:TRANSFER]->()
WHERE t.ts >= $from AND t.ts < $to
RETURN t.currency, t.channel, count(t), sum(t.amount)

O3

MATCH (p:Person {last_name: $last})-[:LIVES_IN]->(:Place {id: $city})
OPTIONAL MATCH (a:Account)-[:OWNED_BY]->(p)
RETURN count(DISTINCT p.id), count(a), coalesce(sum(a.balance), 0)

J2

MATCH (:Person {id: $id})-[:KNOWS]->(:Person)<-[:OWNED_BY]-(:Account)-[t:TRANSFER]->(b:Account)
WHERE t.ts >= $from AND t.ts < $to
MATCH (b)-[:OWNED_BY]->(:Person)-[:LIVES_IN]->(:Place)-[:PART_OF]->(region:Place)
WITH region, count(t) AS n, sum(t.amount) AS total
RETURN region.name, n, total

O2

MATCH (a:Account)
WHERE a.opened_at >= $from AND a.opened_at < $to AND a.balance >= $lo
RETURN a.id

S3

MATCH (p:Post)
WHERE p.language = $language AND p.created_at >= $from AND p.created_at < $to AND p.content CONTAINS '<word>'
RETURN count(p)

J5

MATCH (:Account {id: $id})-[t1:TRANSFER]->(:Account)-[t2:TRANSFER]->(:Account)-[t3:TRANSFER]->(:Account)-[t4:TRANSFER]->(:Account)
WHERE t1.ts >= $from AND t1.ts < $to AND t2.ts > t1.ts AND t3.ts > t2.ts AND t4.ts > t3.ts
  AND t4.ts < t1.ts + 2592000
RETURN count(*)

J4

MATCH (p:Person {id: $id})-[:LIVES_IN]->(:Place)<-[:LIVES_IN]-(o:Person)
WHERE o.id <> $id AND EXISTS { MATCH (o)-[:WORKS_AT]->(:Organization) }
  AND EXISTS { MATCH (p)-[:INTERESTED_IN]->(:Tag)<-[:INTERESTED_IN]-(o) }
RETURN count(DISTINCT o.id)

R1

MATCH (p:Person {id: $id})
OPTIONAL MATCH (a:Account)-[:OWNED_BY]->(p)
RETURN p.id, p.first_name, p.last_name, a.id, a.balance, a.status

R2

MATCH (a:Account)
WHERE a.country = $country AND a.status = 'open' AND a.balance >= $lo AND a.balance <= $hi
RETURN a.id

R3

MATCH (:Person {id: $id})-[:KNOWS]->(f:Person)
OPTIONAL MATCH (a:Account)-[:OWNED_BY]->(f)
OPTIONAL MATCH (a)-[t:TRANSFER]->()
WHERE t.ts >= $from AND t.ts < $to
RETURN f.id, coalesce(sum(t.amount), 0)

R4

MATCH (:Account {id: $id})-[t1:TRANSFER]->(x:Account)
WHERE t1.ts >= $from AND t1.ts < $to AND x.id <> $id
RETURN DISTINCT x.id AS x
UNION
MATCH (:Account {id: $id})-[t1:TRANSFER]->(a1:Account)
WHERE t1.ts >= $from AND t1.ts < $to
WITH DISTINCT a1
MATCH (a1)-[t2:TRANSFER]->(x:Account)
WHERE t2.ts >= $from AND t2.ts < $to AND x.id <> $id
RETURN DISTINCT x.id AS x
UNION
MATCH (:Account {id: $id})-[t1:TRANSFER]->(a1:Account)
WHERE t1.ts >= $from AND t1.ts < $to
WITH DISTINCT a1
MATCH (a1)-[t2:TRANSFER]->(a2:Account)
WHERE t2.ts >= $from AND t2.ts < $to
WITH DISTINCT a2
MATCH (a2)-[t3:TRANSFER]->(x:Account)
WHERE t3.ts >= $from AND t3.ts < $to AND x.id <> $id
RETURN DISTINCT x.id AS x

R5

MATCH (a:Person {id: $src}), (b:Person {id: $dst})
MATCH p = shortestPath((a)-[:KNOWS*..6]->(b))
RETURN length(p)

R6

CALL {
MATCH (:Account {id: $id})-[t1:TRANSFER]->(m1:Account)-[t2:TRANSFER]->(m2:Account)-[t3:TRANSFER]->(:Account {id: $id})
WHERE t1.ts >= $from AND t1.ts < $to AND t2.ts >= $from AND t2.ts < $to AND t3.ts >= $from AND t3.ts < $to
  AND m1.id <> $id AND m2.id <> $id AND m1.id <> m2.id
RETURN count(*) AS n
UNION ALL
MATCH (:Account {id: $id})-[t1:TRANSFER]->(m1:Account)-[t2:TRANSFER]->(m2:Account)-[t3:TRANSFER]->(m3:Account)-[t4:TRANSFER]->(:Account {id: $id})
WHERE t1.ts >= $from AND t1.ts < $to AND t2.ts >= $from AND t2.ts < $to AND t3.ts >= $from AND t3.ts < $to
  AND t4.ts >= $from AND t4.ts < $to
  AND m1.id <> $id AND m2.id <> $id AND m3.id <> $id AND m1.id <> m2.id AND m1.id <> m3.id AND m2.id <> m3.id
RETURN count(*) AS n
UNION ALL
MATCH (:Account {id: $id})-[t1:TRANSFER]->(m1:Account)-[t2:TRANSFER]->(m2:Account)-[t3:TRANSFER]->(m3:Account)-[t4:TRANSFER]->(m4:Account)-[t5:TRANSFER]->(:Account {id: $id})
WHERE t1.ts >= $from AND t1.ts < $to AND t2.ts >= $from AND t2.ts < $to AND t3.ts >= $from AND t3.ts < $to
  AND t4.ts >= $from AND t4.ts < $to AND t5.ts >= $from AND t5.ts < $to
  AND m1.id <> $id AND m2.id <> $id AND m3.id <> $id AND m4.id <> $id
  AND m1.id <> m2.id AND m1.id <> m3.id AND m1.id <> m4.id AND m2.id <> m3.id AND m2.id <> m4.id AND m3.id <> m4.id
RETURN count(*) AS n
}
RETURN sum(n)

R7

MATCH (o:Organization)<-[:HELD_AT]-(:Account)
WITH o, count(*) AS held ORDER BY held DESC, o.id ASC LIMIT 20
MATCH (o)<-[:HELD_AT]-(sa:Account)-[t:TRANSFER]->(da:Account)
WHERE t.ts >= $from AND t.ts < $to
RETURN substring(toString(datetime(t.ts * 1000000000)), 0, 7), sa.country, da.country, sum(t.amount)

W1

person: append 1 row; account: append 1 row; knows: append 3 rows; refresh

W2

transfer: append 1 row; refresh

W3

transfer: append 1,000 rows in one commit; refresh

U1

account: update balance, status where id = $id; refresh

U2

works_at: merge_insert on id, inserting the new row and deleting the rows where src_id = $id that it does not match, in one commit; refresh

D1

transfer: delete where id = $id; refresh

D2

MATCH (p:Person {id: $id})
OPTIONAL MATCH (a:Account)-[:OWNED_BY]->(p)
WITH p, collect(a.id) AS accounts
OPTIONAL MATCH (post:Post)-[:HAS_AUTHOR]->(p)
RETURN accounts, collect(post.id) AS posts
-- then, one delete per dataset: transfer where src_id or dst_id IN accounts; likes where src_id = $id or dst_id IN posts; knows where src_id = $id or dst_id = $id; works_at, uses, interested_in where src_id = $id; post where author_id = $id; account where owner_id = $id; person where id = $id; refresh

6. Concurrency ladder, mixed

kX ops/sQX × Q
1 k*57.90.61735.7
490.30.33530.2
1684.30.1068.9
6482.80.0292.4

7. Memory over the duty cycle

memory.current of the median repetition, sampled every 100 ms. Shaded bands are the busy windows; the rest is idle.

0.0 GiB1.0 GiB2.0 GiB 0 s60 s120 s180 s240 s

8. Validation

0 invalid operation instances.

Write validation read back 200 account, 190 batch, 200 person alive, 100 person deleted, 200 transfer alive, 200 transfer deleted, 200 works, with 0 kinds failing.

9. Deviations

10. Phase detail

Import (P2): 712,614 rows in 0.6 s: load 0.4 s, keys 0.0 s, indexes 0.2 s. Peak memory during load 0.29 GiB.

Repetitions (P7, P8)

nTk*Q at k*M GiBAfter work GiB
135.710.6171.250.04

Coefficient of variation of DataPower across repetitions: 0.0%.

Memory floor (P9)

Limit GiBQOutcome
80.617ran
40.880ran
20.718ran
10.000failed

Cold (P3) and warm (P5) single-client latency, ms

ClassOperationCold p50Cold p99Warm p50Warm p99
R1point6.9014.3410.1413.41
R2filter4.744.777.349.14
R3neighbourhood18.6921.7022.5629.98
R4deep12.8613.6816.8519.07
R5path6.967.5110.3010.57
R6pattern34.4040.7337.7638.98
R7analytic30.8636.8035.7737.70
W1insert14.3840.1922.5124.09
W2insert edge4.975.396.077.00
W3batch10.4110.7812.2614.93
U1modify28.0571.8740.8344.51
U2rewire13.0214.7812.8613.79
D1delete edge19.2521.3327.5828.16
D2delete cascade82.9489.02114.43259.20
O1person by email11.4114.0911.1912.93
O2accounts by opening date3.904.203.244.25
O3people by surname and city15.4016.2715.6116.38
S1amount band25.9729.0924.8027.18
S3text search18.9824.9617.5018.67
J4neighbours alike27.4928.3428.6929.95
R1wpoint, worst case6.938.138.209.08
R2wfilter, worst case7.658.626.9313.17
R3wneighbourhood, worst case27.3930.5029.3633.63
R4wdeep, worst case20.0925.1518.8023.50
R5wpath, worst case6.366.967.588.29
R6wpattern, worst case34.5941.9833.3835.81
R7wanalytic, worst case31.9835.2329.8231.15

Ladder (P6): read

kX ops/sErrorsDriver CPU
178.200.7%
4130.201.1%
16126.600.9%
64115.800.8%

Ladder (P6): insert

kX ops/sErrorsDriver CPU
155.000.5%
490.400.7%
1697.000.5%
6462.600.3%

Ladder (P6): modify-delete

kX ops/sErrorsDriver CPU
111.000.1%
422.600.1%
1633.400.2%
6415.400.0%

Ladder (P6): write

kX ops/sErrorsDriver CPU
148.000.3%
444.200.3%
1668.400.5%
6426.700.2%

11. Run timeline

The run from its first phase to its last, every second. The driver counts every operation, ramps and warm-ups included, and the probe samples the SUT's cgroup every 100 ms. Bands mark the phases; P3, the cold run, and P4, the warm-up, stand out in teal. After the duty cycle the run asks the kernel to reclaim everything the SUT holds, and the drop in memory shows what the system gives back.

Throughput Valid operations per second, ramps and warm-ups included. Invalid and failed operations show in red.
validinvalid or failed
P0P1P2P3P3P4P5P6P6P7P7P9P9P10P11P12050100150200ops/s0:002:004:006:008:0010:00
Latency p99 of every operation in each second, all classes together, on a log scale.
P0P1P2P3P3P4P5P6P6P7P7P9P9P10P11P1210100100010k100kms0:002:004:006:008:0010:00
Memory The SUT's cgroup memory, stacked: what the processes hold, shared memory such as a buffer pool, and the page cache the kernel can reclaim. The envelope allows 8 GiB.
process (anon)shared memorypage cachekernel
P0P1P2P3P3P4P5P6P6P7P7P9P9P10P11P120246GiB0:002:004:006:008:0010:00kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
P0P1P2P3P3P4P5P6P6P7P7P9P9P10P11P120123cores0:002:004:006:008:0010:00envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
P0P1P2P3P3P4P5P6P6P7P7P9P9P10P11P12050100150MB/s0:002:004:006:008:0010:00readwritten
PhaseStartsSecondsOperationsops/sCPU coresPeak GiBPage cache at end GiB
P0 environment check0 s0.700.00.000.000.00
P1 schema definition1 s1.000.00.000.000.00
P2 import2 s8.400.00.060.290.00
P3 cold single-client run10 s21.023111.00.730.740.48
P4 warm-up31 s10.784178.71.841.050.50
P5 warm single-client run42 s12.961847.91.191.140.51
P6 read, write and modify ladders55 s204.89,14644.71.494.880.62
P7 mixed ladder260 s307.311,57637.70.803.880.00
P9 memory floor search567 s23.71,19550.41.011.250.04
P10 validation reads591 s10.100.01.810.310.08
P11 final footprint and surface audit601 s2.200.00.770.390.09
P12 teardown603 s1.900.00.000.390.09

12. From the cold restart

P3 restarts the SUT with an empty page cache and runs every class from one client. P4 warms the system up under load, and P5 runs every class again. These charts start at the restart, so they show how long the system takes to reach its warm speed and what it holds while it gets there.

Every single-client operation Each dot is one operation, on a log scale. P3 runs every class in turn on an empty page cache; P5 runs them again after the warm-up.
P3 coldP5 warm
1310301003001000ms0:000:100:200:300:40
Throughput Valid operations per second, ramps and warm-ups included.
coldcoldwarm-upwarm-upwarmwarm050100150ops/s0:000:100:200:300:40
Latency p99 of every operation in each second, all classes together, on a log scale.
coldcoldwarm-upwarm-upwarmwarm10301003001000ms0:000:100:200:300:40
Memory The SUT's cgroup memory, stacked: what the processes hold, shared memory such as a buffer pool, and the page cache the kernel can reclaim. The envelope allows 8 GiB.
process (anon)shared memorypage cachekernel
coldcoldwarm-upwarm-upwarmwarm00.511.5GiB0:000:100:200:300:40kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
coldcoldwarm-upwarm-upwarmwarm0123cores0:000:100:200:300:40envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
coldcoldwarm-upwarm-upwarmwarm0255075100MB/s0:000:100:200:300:40readwritten
Cold and warm medians Each class's p50 on an empty page cache (P3) and after the warm-up (P5), log scale. The longer the line, the more the class depends on a warm cache.
P3 coldP5 warm
1 ms3 ms10 ms30 ms100 ms300 ms1000 msR1R1 warm p50 10.14 msR1 cold p50 6.90 msR1wR1w warm p50 8.20 msR1w cold p50 6.93 msR2R2 warm p50 7.34 msR2 cold p50 4.74 msR2wR2w warm p50 6.93 msR2w cold p50 7.65 msR3R3 warm p50 22.56 msR3 cold p50 18.69 msR3wR3w warm p50 29.36 msR3w cold p50 27.39 msR4R4 warm p50 16.85 msR4 cold p50 12.86 msR4wR4w warm p50 18.80 msR4w cold p50 20.09 msR5R5 warm p50 10.30 msR5 cold p50 6.96 msR5wR5w warm p50 7.58 msR5w cold p50 6.36 msR6R6 warm p50 37.76 msR6 cold p50 34.40 msR6wR6w warm p50 33.38 msR6w cold p50 34.59 msR7R7 warm p50 35.77 msR7 cold p50 30.86 msR7wR7w warm p50 29.82 msR7w cold p50 31.98 msS1S1 warm p50 24.80 msS1 cold p50 25.97 msS3S3 warm p50 17.50 msS3 cold p50 18.98 msJ4J4 warm p50 28.69 msJ4 cold p50 27.49 msO1O1 warm p50 11.19 msO1 cold p50 11.41 msO2O2 warm p50 3.24 msO2 cold p50 3.90 msO3O3 warm p50 15.61 msO3 cold p50 15.40 msW1W1 warm p50 22.51 msW1 cold p50 14.38 msW2W2 warm p50 6.07 msW2 cold p50 4.97 msW3W3 warm p50 12.26 msW3 cold p50 10.41 msU1U1 warm p50 40.83 msU1 cold p50 28.05 msU2U2 warm p50 12.86 msU2 cold p50 13.02 msD1D1 warm p50 27.58 msD1 cold p50 19.25 msD2D2 warm p50 114.43 msD2 cold p50 82.94 ms