DataPower disclosure report

Neo4j Community 5.26

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-01T20-10-37Z-standard-sf3m-s-neo4j · scenario standard-sf3m-s-neo4j · repetition 1 of 1 · spec DP-2026.1

67DP
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 × 54.86) / (2.228 × 1.100)
3.00E · million data elements
54.86T · effective ops/s at k* = 4
2.228R · 2 cores + 1.67 GiB / 8 + 3.92 GiB / 200
1.100O · 1 + 0.05 × 2 surface points

2. Factors

FactorValue
Disk at rest / after work3.92 / 2.02 GiB
Bytes per element1,402.3
Log share of disk0.0%
Write amplification11.89
Memory ready, after import / repetition1.48 / 0.50 GiB
Peak memory1.69 GiB
Memory charge (M)1.67 GiB
Memory elasticity0.00
Held memory: ready / peak / charge0.31 / 1.42 / 1.41 GiB
Held memory elasticity0.00
Memory after the kernel reclaims1.41 GiB of 1.69
Memory floor (hybrid)2.00 GiB
CPU per standard operation25.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
idle1.691.400.000.280.01
peak1.691.400.000.280.01
ready1.481.050.000.410.01
ready_repetition0.500.300.000.190.01

Latency, warm single client

ClassOperationp50 msp99 msTarget ms
R1point0.872.0410
R2filter2.385.17200
R3neighbourhood1.187.7450
R4deep0.992.42500
R5path1.482.97500
R6pattern1.157.362,000
R7analytic222.34256.255,000
W1insert4.3313.4120
W2insert edge2.152.8810
W3batch74.50119.36500
U1modify2.605.3920
U2rewire3.507.4830
D1delete edge2.918.7020
D2delete cascade4.3314.60100
O1person by email65.3470.3320
O2accounts by opening date102.72115.14200
O3people by surname and city0.833.07100
S1amount band593.92613.381,000
S3text search116.48120.582,000
J4neighbours alike1.593.19500
R1wpoint, worst case0.701.1210
R2wfilter, worst case36.86155.52200
R3wneighbourhood, worst case9.6324.4350
R4wdeep, worst case5.5210.88500
R5wpath, worst case1.473.35500
R6wpattern, worst case1.809.212,000
R7wanalytic, worst case220.03232.455,000

Operational surface: 2 points

ItemPointsSource
runtime dependency: java1audited
index index_f8efaa80: RANGE index on Account(country, status, balance)1audited

3. Host and system

SystemNeo4j Community 5.26, adapter neo4j
Imagedocker.io/library/neo4j@sha256:0a6e7aedf54a531f76286032d4365ead65b11cca05e4a15cdf23b8e53d6db02b
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

# Neo4j 5.26 Community Edition, the LTS line (spec §11.3).
#
# The image is pinned by digest (spec §5.3): the multi-architecture index of
# docker.io/library/neo4j:5.26-community as of 20 October 2026, so each host
# pulls the same release built for its own architecture.
name: neo4j
system: Neo4j Community
version: "5.26"
image: docker.io/library/neo4j@sha256:0a6e7aedf54a531f76286032d4365ead65b11cca05e4a15cdf23b8e53d6db02b
model: property-graph
protocols: [bolt]
query_language: cypher

# Neo4j flushes its transaction log on every commit by default, so commits
# are durable without settings (spec §9.2). Its isolation is read
# committed, weaker than the snapshot isolation the spec asks for; the run
# records that as a deviation.
durability:
  settings: {}
isolation: read-committed

# The graph mapping of spec §7.2 brings a uniqueness constraint, with its
# index, on every node and relationship id. Beyond those, R2's filter needs
# one composite index. Neo4j sizes its heap and page cache from the
# container's memory by default, so nothing is sized by hand.
declared_surface:
  services: 1
  runtime_dependencies: [java]
  secondary_indexes:
    - "Account(country, status, balance)"
  hand_sized_caches: []
  non_default_settings: {}
  maintenance_tasks: []
  storage_areas: [data]
  manual_steps: []

envelope:
  size: S
  memory_limit_gib: 8

plugin: neo4j
container:
  port: 7687
  data_path: /data
  # The image reads an /import mount without changing its ownership, and
  # points LOAD CSV at it.
  dataset_path: /import
  log_paths: [transactions]
  env:
    NEO4J_AUTH: neo4j/dpbench-neo4j
client:
  user: neo4j
  password: dpbench-neo4j
  database: neo4j

Executed DDL

CREATE CONSTRAINT place_id FOR (n:Place) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT person_id FOR (n:Person) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT organization_id FOR (n:Organization) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT account_id FOR (n:Account) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT device_id FOR (n:Device) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT tag_id FOR (n:Tag) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT post_id FOR (n:Post) REQUIRE n.id IS UNIQUE;
CREATE CONSTRAINT knows_id FOR ()-[r:KNOWS]-() REQUIRE r.id IS UNIQUE;
CREATE CONSTRAINT works_at_id FOR ()-[r:WORKS_AT]-() REQUIRE r.id IS UNIQUE;
CREATE CONSTRAINT uses_id FOR ()-[r:USES]-() REQUIRE r.id IS UNIQUE;
CREATE CONSTRAINT transfer_id FOR ()-[r:TRANSFER]-() REQUIRE r.id IS UNIQUE;
CREATE CONSTRAINT interested_in_id FOR ()-[r:INTERESTED_IN]-() REQUIRE r.id IS UNIQUE;
CREATE CONSTRAINT likes_id FOR ()-[r:LIKES]-() REQUIRE r.id IS UNIQUE;
LOAD CSV WITH HEADERS FROM 'file:///data/place.csv' AS r
CALL { WITH r CREATE (:Place {id: toInteger(r.id), name: r.name, type: r.type}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/person.csv' AS r
CALL { WITH r CREATE (:Person {id: toInteger(r.id), first_name: r.first_name, last_name: r.last_name, birth_date: date(r.birth_date), created_at: datetime(r.created_at), risk_score: toFloat(r.risk_score), email: r.email}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/organization.csv' AS r
CALL { WITH r CREATE (:Organization {id: toInteger(r.id), name: r.name, type: r.type, founded: date(r.founded)}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/account.csv' AS r
CALL { WITH r CREATE (:Account {id: toInteger(r.id), opened_at: datetime(r.opened_at), balance: CASE WHEN r.balance IS NULL THEN null ELSE (CASE WHEN r.balance STARTS WITH '-' THEN -1 ELSE 1 END) * (toInteger(replace(split(r.balance, '.')[0], '-', '')) * 100 + toInteger(split(r.balance, '.')[1])) END, status: r.status, country: r.country}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/device.csv' AS r
CALL { WITH r CREATE (:Device {id: toInteger(r.id), kind: r.kind, os: r.os, first_seen: datetime(r.first_seen), fingerprint: r.fingerprint}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/tag.csv' AS r
CALL { WITH r CREATE (:Tag {id: toInteger(r.id), name: r.name, class: r.class}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/post.csv' AS r
CALL { WITH r CREATE (:Post {id: toInteger(r.id), created_at: datetime(r.created_at), length: toInteger(r.length), language: r.language, content: r.content}) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/place.csv' AS r
CALL { WITH r WITH r WHERE r.part_of IS NOT NULL MATCH (a:Place {id: toInteger(r.id)}) MATCH (b:Place {id: toInteger(r.part_of)}) CREATE (a)-[:PART_OF]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/person.csv' AS r
CALL { WITH r WITH r WHERE r.lives_in IS NOT NULL MATCH (a:Person {id: toInteger(r.id)}) MATCH (b:Place {id: toInteger(r.lives_in)}) CREATE (a)-[:LIVES_IN]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/organization.csv' AS r
CALL { WITH r WITH r WHERE r.located_in IS NOT NULL MATCH (a:Organization {id: toInteger(r.id)}) MATCH (b:Place {id: toInteger(r.located_in)}) CREATE (a)-[:LOCATED_IN]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/account.csv' AS r
CALL { WITH r WITH r WHERE r.owner_id IS NOT NULL MATCH (a:Account {id: toInteger(r.id)}) MATCH (b:Person {id: toInteger(r.owner_id)}) CREATE (a)-[:OWNED_BY]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/account.csv' AS r
CALL { WITH r WITH r WHERE r.org_id IS NOT NULL MATCH (a:Account {id: toInteger(r.id)}) MATCH (b:Organization {id: toInteger(r.org_id)}) CREATE (a)-[:HELD_AT]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/post.csv' AS r
CALL { WITH r WITH r WHERE r.author_id IS NOT NULL MATCH (a:Post {id: toInteger(r.id)}) MATCH (b:Person {id: toInteger(r.author_id)}) CREATE (a)-[:HAS_AUTHOR]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/post.csv' AS r
CALL { WITH r WITH r WHERE r.tag_id IS NOT NULL MATCH (a:Post {id: toInteger(r.id)}) MATCH (b:Tag {id: toInteger(r.tag_id)}) CREATE (a)-[:ABOUT]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/knows.csv' AS r
CALL { WITH r MATCH (a:Person {id: toInteger(r.src_id)}) MATCH (b:Person {id: toInteger(r.dst_id)}) CREATE (a)-[:KNOWS {id: toInteger(r.id), since: date(r.since), strength: toFloat(r.strength)}]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/works_at.csv' AS r
CALL { WITH r MATCH (a:Person {id: toInteger(r.src_id)}) MATCH (b:Organization {id: toInteger(r.dst_id)}) CREATE (a)-[:WORKS_AT {id: toInteger(r.id), from_date: date(r.from_date), role: r.role}]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/uses.csv' AS r
CALL { WITH r MATCH (a:Person {id: toInteger(r.src_id)}) MATCH (b:Device {id: toInteger(r.dst_id)}) CREATE (a)-[:USES {id: toInteger(r.id), first_seen: datetime(r.first_seen), last_seen: datetime(r.last_seen)}]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/transfer.csv' AS r
CALL { WITH r MATCH (a:Account {id: toInteger(r.src_id)}) MATCH (b:Account {id: toInteger(r.dst_id)}) CREATE (a)-[:TRANSFER {id: toInteger(r.id), ts: datetime(r.ts), amount: CASE WHEN r.amount IS NULL THEN null ELSE (CASE WHEN r.amount STARTS WITH '-' THEN -1 ELSE 1 END) * (toInteger(replace(split(r.amount, '.')[0], '-', '')) * 100 + toInteger(split(r.amount, '.')[1])) END, currency: r.currency, channel: r.channel}]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/interested_in.csv' AS r
CALL { WITH r MATCH (a:Person {id: toInteger(r.src_id)}) MATCH (b:Tag {id: toInteger(r.dst_id)}) CREATE (a)-[:INTERESTED_IN {id: toInteger(r.id), weight: toFloat(r.weight)}]->(b) } IN TRANSACTIONS OF 20000 ROWS;
LOAD CSV WITH HEADERS FROM 'file:///data/likes.csv' AS r
CALL { WITH r MATCH (a:Person {id: toInteger(r.src_id)}) MATCH (b:Post {id: toInteger(r.dst_id)}) CREATE (a)-[:LIKES {id: toInteger(r.id), ts: datetime(r.ts)}]->(b) } IN TRANSACTIONS OF 20000 ROWS;
CREATE INDEX FOR (x:Account) ON (x.country, x.status, x.balance);
CALL db.awaitIndexes(3600);

Settings that differ from a fresh container of the same image

None.

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), count(a), coalesce(sum(a.balance), 0)

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]->()-[t2:TRANSFER]->()-[t3:TRANSFER]->()-[t4:TRANSFER]->()
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 + duration({days: 30})
RETURN count(*)

J3

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

J1

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

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

J4

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

S2

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

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

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, sum(t.amount)

R4

MATCH (s:Account {id: $id})-[ts:TRANSFER*1..3]->(x:Account)
WHERE all(t IN ts WHERE t.ts >= $from AND t.ts < $to) AND x <> s
RETURN DISTINCT x.id

R5

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

R6

MATCH p = (a:Account {id: $id})-[ts:TRANSFER*3..5]->(a)
WHERE all(t IN ts WHERE t.ts >= $from AND t.ts < $to)
WITH a, nodes(p)[1..-1] AS mid
WHERE NOT a IN mid AND all(i IN range(0, size(mid) - 2) WHERE NOT mid[i] IN mid[i + 1..])
RETURN count(*)

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(t.ts), 0, 7), sa.country, da.country, sum(t.amount)

W1

CREATE (p:Person {id: $pid, first_name: $fn, last_name: $ln, birth_date: date('1990-01-01'), created_at: $ts, risk_score: 0.5})
WITH p MATCH (home:Place {id: 1}) CREATE (p)-[:LIVES_IN]->(home)
CREATE (:Account {id: $aid, opened_at: $ts, balance: 0, status: 'open', country: 'ZZ'})-[:OWNED_BY]->(p)
WITH p UNWIND $knows AS k
MATCH (d:Person {id: k.dst})
CREATE (p)-[:KNOWS {id: k.id, since: date($ts), strength: 0.5}]->(d)

W2

MATCH (s:Account {id: $src}) MATCH (d:Account {id: $dst})
CREATE (s)-[:TRANSFER {id: $id, ts: $ts, amount: $amount, currency: $currency, channel: $channel}]->(d)

W3

UNWIND $batch AS b
MATCH (s:Account {id: b.src}) MATCH (d:Account {id: b.dst})
CREATE (s)-[:TRANSFER {id: b.id, ts: b.ts, amount: b.amount, currency: b.currency, channel: b.channel}]->(d)

U1

MATCH (a:Account {id: $id}) SET a.balance = $balance, a.status = $status

U2

MATCH (p:Person {id: $id})
OPTIONAL MATCH (p)-[w:WORKS_AT]->()
DELETE w
WITH DISTINCT p
MATCH (o:Organization {id: $org})
CREATE (p)-[:WORKS_AT {id: $wid, from_date: date($ts), role: 'engineer'}]->(o)

D1

MATCH ()-[t:TRANSFER {id: $id}]->() DELETE t

D2

MATCH (p:Person {id: $id})
OPTIONAL MATCH (a:Account)-[:OWNED_BY]->(p)
OPTIONAL MATCH (post:Post)-[:HAS_AUTHOR]->(p)
WITH p, collect(DISTINCT a) + collect(DISTINCT post) AS owned
FOREACH (n IN owned | DETACH DELETE n)
DETACH DELETE p

6. Concurrency ladder, mixed

kX ops/sQX × Q
135.60.71325.4
4 k*75.50.72754.9
1680.40.28422.8
6485.10.0544.6

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 s121 s181 s241 s

8. Validation

0 invalid operation instances.

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

9. Deviations

10. Phase detail

Import (P2): 3,000,000 rows in 116.1 s: load 21.0 s, keys 93.4 s, indexes 1.5 s. Peak memory during load 2.19 GiB.

Repetitions (P7, P8)

nTk*Q at k*M GiBAfter work GiB
154.940.7271.672.02

Coefficient of variation of DataPower across repetitions: 0.0%.

Memory floor (P9)

Limit GiBQOutcome
80.727ran
40.930ran
20.931ran
10.000failed

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

ClassOperationCold p50Cold p99Warm p50Warm p99
R1point12.592,136.060.872.04
R2filter38.21248.062.385.17
R3neighbourhood17.25356.351.187.74
R4deep16.77250.500.992.42
R5path10.00231.041.482.97
R6pattern19.71181.891.157.36
R7analytic282.112,185.22222.34256.25
W1insert12.71672.254.3313.41
W2insert edge5.90127.942.152.88
W3batch173.69752.1374.50119.36
U1modify6.5292.222.605.39
U2rewire8.57192.253.507.48
D1delete edge4.1960.192.918.70
D2delete cascade10.48153.094.3314.60
O1person by email75.65318.4665.3470.33
O2accounts by opening date99.52187.13102.72115.14
O3people by surname and city15.26117.180.833.07
S1amount band569.86833.53593.92613.38
S3text search109.76289.54116.48120.58
J4neighbours alike19.34238.591.593.19
R1wpoint, worst case1.996.450.701.12
R2wfilter, worst case46.2751.6836.86155.52
R3wneighbourhood, worst case25.0747.109.6324.43
R4wdeep, worst case13.8917.185.5210.88
R5wpath, worst case5.266.011.473.35
R6wpattern, worst case8.7816.571.809.21
R7wanalytic, worst case226.18243.46220.03232.45

Ladder (P6): read

kX ops/sErrorsDriver CPU
131.901.6%
466.403.6%
1660.502.9%
6447.702.0%

Ladder (P6): insert

kX ops/sErrorsDriver CPU
1306.002.8%
4588.604.4%
16670.404.7%
64428.203.2%

Ladder (P6): modify-delete

kX ops/sErrorsDriver CPU
1847.004.3%
42,075.409.2%
164,354.2016.2%
645,113.6016.6%

Ladder (P6): write

kX ops/sErrorsDriver CPU
1511.203.6%
41,068.406.3%
161,251.606.6%
64517.403.6%

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.
P0P1P2P2P3P3P4P5P5P6P6P7P7P9P9P10P11P120200040006000ops/s0:002:004:006:008:0010:0012:0014:00
Latency p99 of every operation in each second, all classes together, on a log scale.
P0P1P2P2P3P3P4P5P5P6P6P7P7P9P9P10P11P12110100100010k100kms0:002:004:006:008:0010:0012:0014: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
P0P1P2P2P3P3P4P5P5P6P6P7P7P9P9P10P11P1201234GiB0:002:004:006:008:0010:0012:0014:00kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
P0P1P2P2P3P3P4P5P5P6P6P7P7P9P9P10P11P120123cores0:002:004:006:008:0010:0012:0014:00envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
P0P1P2P2P3P3P4P5P5P6P6P7P7P9P9P10P11P120100200300400MB/s0:002:004:006:008:0010:0012:0014:00writtenread
PhaseStartsSecondsOperationsops/sCPU coresPeak GiBPage cache at end GiB
P0 environment check0 s0.800.00.000.000.00
P1 schema definition1 s11.900.01.750.620.28
P2 import13 s142.800.01.392.080.00
P3 cold single-client run155 s44.12235.11.621.620.70
P4 warm-up200 s12.468255.01.851.820.71
P5 warm single-client run212 s30.756018.31.031.850.73
P6 read, write and modify ladders243 s165.9126,747763.91.642.920.97
P7 mixed ladder409 s359.016,00844.61.232.870.00
P9 memory floor search768 s40.21,76644.01.791.120.09
P10 validation reads808 s5.100.01.950.920.21
P11 final footprint and surface audit813 s22.100.00.110.820.21
P12 teardown835 s7.000.00.010.820.21

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
0.1110100100010kms0:000:301:001:30
Throughput Valid operations per second, ramps and warm-ups included.
coldcoldwarm-upwarm-upwarmwarm050100150ops/s0:000:301:001:30
Latency p99 of every operation in each second, all classes together, on a log scale.
coldcoldwarm-upwarm-upwarmwarm10301003001000300010kms0:000:301:001:30
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.52GiB0:000:301:001:30kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
coldcoldwarm-upwarm-upwarmwarm0123cores0:000:301:001:30envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
coldcoldwarm-upwarm-upwarmwarm0100200300400MB/s0:000:301:001:30readwritten
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
0.1 ms1 ms10 ms100 ms1000 msR1R1 warm p50 0.87 msR1 cold p50 12.59 msR1wR1w warm p50 0.70 msR1w cold p50 1.99 msR2R2 warm p50 2.38 msR2 cold p50 38.21 msR2wR2w warm p50 36.86 msR2w cold p50 46.27 msR3R3 warm p50 1.18 msR3 cold p50 17.25 msR3wR3w warm p50 9.63 msR3w cold p50 25.07 msR4R4 warm p50 0.99 msR4 cold p50 16.77 msR4wR4w warm p50 5.52 msR4w cold p50 13.89 msR5R5 warm p50 1.48 msR5 cold p50 10.00 msR5wR5w warm p50 1.47 msR5w cold p50 5.26 msR6R6 warm p50 1.15 msR6 cold p50 19.71 msR6wR6w warm p50 1.80 msR6w cold p50 8.78 msR7R7 warm p50 222.34 msR7 cold p50 282.11 msR7wR7w warm p50 220.03 msR7w cold p50 226.18 msS1S1 warm p50 593.92 msS1 cold p50 569.86 msS3S3 warm p50 116.48 msS3 cold p50 109.76 msJ4J4 warm p50 1.59 msJ4 cold p50 19.34 msO1O1 warm p50 65.34 msO1 cold p50 75.65 msO2O2 warm p50 102.72 msO2 cold p50 99.52 msO3O3 warm p50 0.83 msO3 cold p50 15.26 msW1W1 warm p50 4.33 msW1 cold p50 12.71 msW2W2 warm p50 2.15 msW2 cold p50 5.90 msW3W3 warm p50 74.50 msW3 cold p50 173.69 msU1U1 warm p50 2.60 msU1 cold p50 6.52 msU2U2 warm p50 3.50 msU2 cold p50 8.57 msD1D1 warm p50 2.91 msD1 cold p50 4.19 msD2D2 warm p50 4.33 msD2 cold p50 10.48 ms