DataPower disclosure report

lance-csr 0.5.1

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

Run 2026-11-01T21-45-24Z-standard-sf3m-s-lance-csr · scenario standard-sf3m-s-lance-csr · repetition 1 of 1 · spec DP-2026.1

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

2. Factors

FactorValue
Disk at rest / after work0.05 / 0.11 GiB
Bytes per element38.8
Log share of disk0.0%
Write amplification249.01
Memory ready, after import / repetition0.53 / 0.29 GiB
Peak memory3.50 GiB
Memory charge (M)3.31 GiB
Memory elasticity0.11
Held memory: ready / peak / charge0.23 / 3.22 / 3.09 GiB
Held memory elasticity0.07
Memory after the kernel reclaims3.07 GiB of 3.24
Memory floor (in-memory)4.00 GiB
CPU per standard operation27.89 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
idle3.243.060.000.140.02
peak3.503.180.000.280.02
ready0.530.440.000.050.00
ready_repetition0.290.230.000.060.00

Latency, warm single client

ClassOperationp50 msp99 msTarget ms
R1point9.9912.4210
R2filter13.6215.46200
R3neighbourhood21.0929.6650
R4deep17.5524.48500
R5path11.0512.28500
R6pattern38.5642.242,000
R7analytic82.0592.865,000
W1insert29.5437.1820
W2insert edge6.168.8110
W3batch14.0719.44500
U1modify68.54254.8520
U2rewire14.5720.4030
D1delete edge83.9091.8420
D2delete cascade183.94199.55100
O1person by email22.4324.8820
O2accounts by opening date7.098.45200
O3people by surname and city27.6029.21100
S1amount band83.5293.891,000
S3text search43.6245.312,000
J4neighbours alike40.0349.31500
R1wpoint, worst case12.6513.8210
R2wfilter, worst case14.8831.42200
R3wneighbourhood, worst case50.0272.4550
R4wdeep, worst case30.6734.62500
R5wpath, worst case13.3115.33500
R6wpattern, worst case34.7867.392,000
R7wanalytic, worst case82.3088.005,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.

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)

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)

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)

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(*)

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

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(*)

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

O2

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

S2

MATCH (p:Person)
WHERE p.risk_score >= $risk AND p.birth_date >= $from AND p.birth_date < $to
RETURN p.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)

J1

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

S4

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

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*42.40.65427.7
465.20.23515.3
1660.40.0885.3
6461.10.0241.5

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 GiB2.5 GiB5.0 GiB 0 s60 s120 s180 s240 s

8. Validation

0 invalid operation instances.

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

9. Deviations

10. Phase detail

Import (P2): 2,137,843 rows in 1.7 s: load 1.1 s, keys 0.0 s, indexes 0.6 s. Peak memory during load 0.53 GiB.

Repetitions (P7, P8)

nTk*Q at k*M GiBAfter work GiB
127.710.6543.310.11

Coefficient of variation of DataPower across repetitions: 0.0%.

Memory floor (P9)

Limit GiBQOutcome
80.654ran
40.537ran
20.000failed

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

ClassOperationCold p50Cold p99Warm p50Warm p99
R1point9.2917.549.9912.42
R2filter10.4210.9713.6215.46
R3neighbourhood20.5629.3921.0929.66
R4deep13.8716.9917.5524.48
R5path11.8612.4511.0512.28
R6pattern31.9535.8438.5642.24
R7analytic77.2581.4782.0592.86
W1insert21.6651.8729.5437.18
W2insert edge4.545.846.168.81
W3batch10.6812.0114.0719.44
U1modify61.70104.7068.54254.85
U2rewire13.2315.9414.5720.40
D1delete edge30.6633.5383.9091.84
D2delete cascade120.13125.31183.94199.55
O1person by email19.1221.4422.4324.88
O2accounts by opening date7.378.457.098.45
O3people by surname and city23.7426.7327.6029.21
S1amount band67.3382.6983.5293.89
S3text search48.5455.5243.6245.31
J4neighbours alike32.9935.2640.0349.31
R1wpoint, worst case8.6410.4112.6513.82
R2wfilter, worst case19.3023.5214.8831.42
R3wneighbourhood, worst case46.5957.5350.0272.45
R4wdeep, worst case33.8536.2930.6734.62
R5wpath, worst case10.2710.9713.3115.33
R6wpattern, worst case42.9455.0434.7867.39
R7wanalytic, worst case71.1071.5582.3088.00

Ladder (P6): read

kX ops/sErrorsDriver CPU
147.200.6%
478.201.1%
1675.700.8%
6467.700.8%

Ladder (P6): insert

kX ops/sErrorsDriver CPU
153.400.5%
462.600.5%
1689.000.4%
6442.000.0%

Ladder (P6): modify-delete

kX ops/sErrorsDriver CPU
111.200.1%
417.200.1%
1618.600.1%
6410.000.0%

Ladder (P6): write

kX ops/sErrorsDriver CPU
115.800.1%
419.600.1%
1662.000.4%
6432.400.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
P0P1P2P3P3P4P5P5P6P6P7P7P9P10P11P12050100150ops/s0:002:004:006:008:0010:00
Latency p99 of every operation in each second, all classes together, on a log scale.
P0P1P2P3P3P4P5P5P6P6P7P7P9P10P11P1210100100010k100kms0: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
P0P1P2P3P3P4P5P5P6P6P7P7P9P10P11P1202.557.510GiB0:002:004:006:008:0010:00kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
P0P1P2P3P3P4P5P5P6P6P7P7P9P10P11P120123cores0:002:004:006:008:0010:00envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
P0P1P2P3P3P4P5P5P6P6P7P7P9P10P11P1201000200030004000MB/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 s9.500.00.180.530.00
P3 cold single-client run11 s22.92149.40.861.130.51
P4 warm-up34 s10.669665.61.821.890.54
P5 warm single-client run45 s22.351323.01.142.240.57
P6 read, write and modify ladders67 s230.96,99730.31.598.000.56
P7 mixed ladder298 s326.39,44128.90.867.000.00
P9 memory floor search624 s14.038927.71.003.220.06
P10 validation reads638 s6.700.01.790.510.07
P11 final footprint and surface audit645 s2.200.00.000.510.07
P12 teardown647 s1.800.00.000.510.07

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:400:501:00
Throughput Valid operations per second, ramps and warm-ups included.
coldcoldwarm-upwarm-upwarmwarm0255075100ops/s0:000:100:200:300:400:501:00
Latency p99 of every operation in each second, all classes together, on a log scale.
coldcoldwarm-upwarm-upwarmwarm10301003001000300010kms0:000:100:200:300:400:501: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
coldcoldwarm-upwarm-upwarmwarm0123GiB0:000:100:200:300:400:501:00kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
coldcoldwarm-upwarm-upwarmwarm0123cores0:000:100:200:300:400:501:00envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
coldcoldwarm-upwarm-upwarmwarm02505007501000MB/s0:000:100:200:300:400:501:00readwritten
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 9.99 msR1 cold p50 9.29 msR1wR1w warm p50 12.65 msR1w cold p50 8.64 msR2R2 warm p50 13.62 msR2 cold p50 10.42 msR2wR2w warm p50 14.88 msR2w cold p50 19.30 msR3R3 warm p50 21.09 msR3 cold p50 20.56 msR3wR3w warm p50 50.02 msR3w cold p50 46.59 msR4R4 warm p50 17.55 msR4 cold p50 13.87 msR4wR4w warm p50 30.67 msR4w cold p50 33.85 msR5R5 warm p50 11.05 msR5 cold p50 11.86 msR5wR5w warm p50 13.31 msR5w cold p50 10.27 msR6R6 warm p50 38.56 msR6 cold p50 31.95 msR6wR6w warm p50 34.78 msR6w cold p50 42.94 msR7R7 warm p50 82.05 msR7 cold p50 77.25 msR7wR7w warm p50 82.30 msR7w cold p50 71.10 msS1S1 warm p50 83.52 msS1 cold p50 67.33 msS3S3 warm p50 43.62 msS3 cold p50 48.54 msJ4J4 warm p50 40.03 msJ4 cold p50 32.99 msO1O1 warm p50 22.43 msO1 cold p50 19.12 msO2O2 warm p50 7.09 msO2 cold p50 7.37 msO3O3 warm p50 27.60 msO3 cold p50 23.74 msW1W1 warm p50 29.54 msW1 cold p50 21.66 msW2W2 warm p50 6.16 msW2 cold p50 4.54 msW3W3 warm p50 14.07 msW3 cold p50 10.68 msU1U1 warm p50 68.54 msU1 cold p50 61.70 msU2U2 warm p50 14.57 msU2 cold p50 13.23 msD1D1 warm p50 83.90 msD1 cold p50 30.66 msD2D2 warm p50 183.94 msD2 cold p50 120.13 ms