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.
# 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
Setting
Image default
This run
maintain_every_s
0
10
use_csr
false
true
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)
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
k
X ops/s
Q
X × Q
1 k*
57.9
0.617
35.7
4
90.3
0.335
30.2
16
84.3
0.106
8.9
64
82.8
0.029
2.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.
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
tiers: 15% off-index and 5% worst-case operations blended in; spec §9.3's mix is typical operations alone
profile: quick timings: ladders, duty cycle and warm-up are shorter than spec §8.5, §8.9 and §9.5 require
repetitions: 1; spec §9.5 publishes the median of 3
every container runs --privileged (DPBENCH_PRIVILEGED): the host's kernel has no BPF syscall, so the runtime cannot attach a cgroup v2 device filter; cpu, cpuset, memory and pids limits apply as before
the SUT runs at per-dataset snapshot isolation; spec §9.2 asks for snapshot isolation or stronger
commits are not durable when they return (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); spec §9.2 counts only durable writes
warm-up before P5 runs at 16 clients: spec §9.5 says k*, which only P7 finds
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)
n
T
k*
Q at k*
M GiB
After work GiB
1
35.7
1
0.617
1.25
0.04
Coefficient of variation of DataPower across repetitions: 0.0%.
Memory floor (P9)
Limit GiB
Q
Outcome
8
0.617
ran
4
0.880
ran
2
0.718
ran
1
0.000
failed
Cold (P3) and warm (P5) single-client latency, ms
Class
Operation
Cold p50
Cold p99
Warm p50
Warm p99
R1
point
6.90
14.34
10.14
13.41
R2
filter
4.74
4.77
7.34
9.14
R3
neighbourhood
18.69
21.70
22.56
29.98
R4
deep
12.86
13.68
16.85
19.07
R5
path
6.96
7.51
10.30
10.57
R6
pattern
34.40
40.73
37.76
38.98
R7
analytic
30.86
36.80
35.77
37.70
W1
insert
14.38
40.19
22.51
24.09
W2
insert edge
4.97
5.39
6.07
7.00
W3
batch
10.41
10.78
12.26
14.93
U1
modify
28.05
71.87
40.83
44.51
U2
rewire
13.02
14.78
12.86
13.79
D1
delete edge
19.25
21.33
27.58
28.16
D2
delete cascade
82.94
89.02
114.43
259.20
O1
person by email
11.41
14.09
11.19
12.93
O2
accounts by opening date
3.90
4.20
3.24
4.25
O3
people by surname and city
15.40
16.27
15.61
16.38
S1
amount band
25.97
29.09
24.80
27.18
S3
text search
18.98
24.96
17.50
18.67
J4
neighbours alike
27.49
28.34
28.69
29.95
R1w
point, worst case
6.93
8.13
8.20
9.08
R2w
filter, worst case
7.65
8.62
6.93
13.17
R3w
neighbourhood, worst case
27.39
30.50
29.36
33.63
R4w
deep, worst case
20.09
25.15
18.80
23.50
R5w
path, worst case
6.36
6.96
7.58
8.29
R6w
pattern, worst case
34.59
41.98
33.38
35.81
R7w
analytic, worst case
31.98
35.23
29.82
31.15
Ladder (P6): read
k
X ops/s
Errors
Driver CPU
1
78.2
0
0.7%
4
130.2
0
1.1%
16
126.6
0
0.9%
64
115.8
0
0.8%
Ladder (P6): insert
k
X ops/s
Errors
Driver CPU
1
55.0
0
0.5%
4
90.4
0
0.7%
16
97.0
0
0.5%
64
62.6
0
0.3%
Ladder (P6): modify-delete
k
X ops/s
Errors
Driver CPU
1
11.0
0
0.1%
4
22.6
0
0.1%
16
33.4
0
0.2%
64
15.4
0
0.0%
Ladder (P6): write
k
X ops/s
Errors
Driver CPU
1
48.0
0
0.3%
4
44.2
0
0.3%
16
68.4
0
0.5%
64
26.7
0
0.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.
ThroughputValid operations per second, ramps and warm-ups included. Invalid and failed operations show in red.
validinvalid or failed
Latencyp99 of every operation in each second, all classes together, on a log scale.MemoryThe 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
CPUCores the SUT kept busy.DiskBytes the SUT read from and wrote to its block devices.
readwritten
Phase
Starts
Seconds
Operations
ops/s
CPU cores
Peak GiB
Page cache at end GiB
P0 environment check
0 s
0.7
0
0.0
0.00
0.00
0.00
P1 schema definition
1 s
1.0
0
0.0
0.00
0.00
0.00
P2 import
2 s
8.4
0
0.0
0.06
0.29
0.00
P3 cold single-client run
10 s
21.0
231
11.0
0.73
0.74
0.48
P4 warm-up
31 s
10.7
841
78.7
1.84
1.05
0.50
P5 warm single-client run
42 s
12.9
618
47.9
1.19
1.14
0.51
P6 read, write and modify ladders
55 s
204.8
9,146
44.7
1.49
4.88
0.62
P7 mixed ladder
260 s
307.3
11,576
37.7
0.80
3.88
0.00
P9 memory floor search
567 s
23.7
1,195
50.4
1.01
1.25
0.04
P10 validation reads
591 s
10.1
0
0.0
1.81
0.31
0.08
P11 final footprint and surface audit
601 s
2.2
0
0.0
0.77
0.39
0.09
P12 teardown
603 s
1.9
0
0.0
0.00
0.39
0.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 operationEach 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
ThroughputValid operations per second, ramps and warm-ups included.Latencyp99 of every operation in each second, all classes together, on a log scale.MemoryThe 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
CPUCores the SUT kept busy.DiskBytes the SUT read from and wrote to its block devices.
readwritten
Cold and warm mediansEach 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.