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.
When
Total
Anonymous
Shared
Page cache
Kernel
idle
0.43
0.01
0.37
0.05
0.00
peak
0.46
0.03
0.37
0.05
0.01
ready
0.96
0.01
0.28
0.66
0.01
ready_repetition
0.08
0.01
0.07
0.00
0.00
Latency, warm single client
Class
Operation
p50 ms
p99 ms
Target ms
R1
point
0.14
1.78
10
R2
filter
0.35
0.97
200
R3
neighbourhood
0.47
1.42
50
R4
deep
0.17
0.65
500
R5
path
0.66
12.73
500
R6
pattern
0.13
0.65
2,000
R7
analytic
120.00
129.73
5,000
W1
insert
0.73
3.07
20
W2
insert edge
0.41
0.61
10
W3
batch
21.34
22.99
500
U1
modify
0.85
1.04
20
U2
rewire
3.12
3.98
30
D1
delete edge
0.55
0.72
20
D2
delete cascade
52.83
62.69
100
O1
person by email
13.49
15.62
20
O2
accounts by opening date
13.87
14.80
200
O3
people by surname and city
14.67
16.14
100
S1
amount band
60.70
64.86
1,000
S3
text search
32.06
35.87
2,000
J4
neighbours alike
14.13
17.36
500
R1w
point, worst case
0.11
0.24
10
R2w
filter, worst case
2.94
10.18
200
R3w
neighbourhood, worst case
3.15
8.04
50
R4w
deep, worst case
0.69
1.56
500
R5w
path, worst case
6.09
22.40
500
R6w
pattern, worst case
0.15
0.30
2,000
R7w
analytic, worst case
120.64
121.53
5,000
Operational surface: 14 points
Item
Points
Source
index dp_account_owner_id: CREATE INDEX dp_account_owner_id ON public.account USING btree (owner_id)
1
audited
index dp_account_country_status_balance: CREATE INDEX dp_account_country_status_balance ON public.account USING btree (country, status, balance)
1
audited
index dp_transfer_src_id_ts: CREATE INDEX dp_transfer_src_id_ts ON public.transfer USING btree (src_id, ts)
1
audited
index dp_transfer_dst_id: CREATE INDEX dp_transfer_dst_id ON public.transfer USING btree (dst_id)
1
audited
index dp_knows_src_id: CREATE INDEX dp_knows_src_id ON public.knows USING btree (src_id)
1
audited
index dp_knows_dst_id: CREATE INDEX dp_knows_dst_id ON public.knows USING btree (dst_id)
# PostgreSQL 16, the first reference adapter (spec §11.3).
#
# The image is pinned by digest (spec §5.3): the multi-architecture index of
# docker.io/library/postgres:16.15 as of 20 October 2026, so each host pulls
# the same release built for its own architecture.
name: postgres
system: PostgreSQL
version: "16.15"
image: docker.io/library/postgres@sha256:ca0bd484cb98bf4b24eb1010e73fb3fcbd6714d240fbc1a10eea5b7dbecb641d
model: relational
protocols: [pgwire]
query_language: sql
# Every commit is durable on success (spec §9.2). These are PostgreSQL's
# defaults, and exempt from the surface count. Each session runs at
# REPEATABLE READ, PostgreSQL's snapshot isolation, set by the client.
durability:
settings: { fsync: "on", synchronous_commit: "on" }
isolation: snapshot
# What this configuration asks of an operator. Each line costs surface
# points (spec §10.4), and the audit checks every line against the running
# server.
declared_surface:
services: 1
runtime_dependencies: []
# Each index serves a read or keeps a cascading delete off a full scan:
# owner_id for R1 and R3, (country, status, balance) for R2,
# transfer(src_id, ts) for R3, R4 and R6, transfer(dst_id) for D2's
# cascade, knows(src_id) for R3 and R5, knows(dst_id) for R5 and D2.
secondary_indexes:
- "account(owner_id)"
- "account(country, status, balance)"
- "transfer(src_id, ts)"
- "transfer(dst_id)"
- "knows(src_id)"
- "knows(dst_id)"
hand_sized_caches: [shared_buffers]
# A quarter of the 8 GiB envelope for shared_buffers, as the PostgreSQL
# manual suggests; 300 connections, for the ladder's 256 clients.
non_default_settings:
shared_buffers: "2GB"
max_connections: "300"
maintenance_tasks: [autovacuum, analyze]
storage_areas: [data]
manual_steps: ["ANALYZE after import"]
envelope:
size: S
memory_limit_gib: 8
plugin: postgres
container:
port: 5432
data_path: /var/lib/postgresql/data
log_paths: [pg_wal]
# Parallel query uses /dev/shm; the container default of 64 MB is too
# small for a 2 GB buffer pool's parallel hash joins.
shm_size: 1g
env:
POSTGRES_PASSWORD: dpbench
args: ["-c", "shared_buffers=2GB", "-c", "max_connections=300"]
client:
user: postgres
password: dpbench
database: postgres
Executed DDL
CREATE TABLE "place" (
"id" bigint NOT NULL,
"name" text NOT NULL,
"type" text NOT NULL,
"part_of" bigint
);
CREATE TABLE "person" (
"id" bigint NOT NULL,
"first_name" text NOT NULL,
"last_name" text NOT NULL,
"birth_date" date NOT NULL,
"created_at" timestamptz NOT NULL,
"risk_score" double precision NOT NULL,
"email" text,
"lives_in" bigint NOT NULL
);
CREATE TABLE "organization" (
"id" bigint NOT NULL,
"name" text NOT NULL,
"type" text NOT NULL,
"founded" date NOT NULL,
"located_in" bigint NOT NULL
);
CREATE TABLE "account" (
"id" bigint NOT NULL,
"owner_id" bigint NOT NULL,
"org_id" bigint,
"opened_at" timestamptz NOT NULL,
"balance" numeric(17,2) NOT NULL,
"status" text NOT NULL,
"country" text NOT NULL
);
CREATE TABLE "device" (
"id" bigint NOT NULL,
"kind" text NOT NULL,
"os" text NOT NULL,
"first_seen" timestamptz NOT NULL,
"fingerprint" text NOT NULL
);
CREATE TABLE "tag" (
"id" bigint NOT NULL,
"name" text NOT NULL,
"class" text NOT NULL
);
CREATE TABLE "post" (
"id" bigint NOT NULL,
"author_id" bigint NOT NULL,
"tag_id" bigint,
"created_at" timestamptz NOT NULL,
"length" bigint NOT NULL,
"language" text NOT NULL,
"content" text NOT NULL
);
CREATE TABLE "knows" (
"id" bigint NOT NULL,
"src_id" bigint NOT NULL,
"dst_id" bigint NOT NULL,
"since" date NOT NULL,
"strength" double precision NOT NULL
);
CREATE TABLE "works_at" (
"id" bigint NOT NULL,
"src_id" bigint NOT NULL,
"dst_id" bigint NOT NULL,
"from_date" date NOT NULL,
"role" text NOT NULL
);
CREATE TABLE "uses" (
"id" bigint NOT NULL,
"src_id" bigint NOT NULL,
"dst_id" bigint NOT NULL,
"first_seen" timestamptz NOT NULL,
"last_seen" timestamptz NOT NULL
);
CREATE TABLE "transfer" (
"id" bigint NOT NULL,
"src_id" bigint NOT NULL,
"dst_id" bigint NOT NULL,
"ts" timestamptz NOT NULL,
"amount" numeric(17,2) NOT NULL,
"currency" text NOT NULL,
"channel" text NOT NULL
);
CREATE TABLE "interested_in" (
"id" bigint NOT NULL,
"src_id" bigint NOT NULL,
"dst_id" bigint NOT NULL,
"weight" double precision NOT NULL
);
CREATE TABLE "likes" (
"id" bigint NOT NULL,
"src_id" bigint NOT NULL,
"dst_id" bigint NOT NULL,
"ts" timestamptz NOT NULL
);
COPY "place" ("id", "name", "type", "part_of") FROM '/dataset/data/place.csv' WITH (FORMAT csv, HEADER true);
COPY "person" ("id", "first_name", "last_name", "birth_date", "created_at", "risk_score", "email", "lives_in") FROM '/dataset/data/person.csv' WITH (FORMAT csv, HEADER true);
COPY "organization" ("id", "name", "type", "founded", "located_in") FROM '/dataset/data/organization.csv' WITH (FORMAT csv, HEADER true);
COPY "account" ("id", "owner_id", "org_id", "opened_at", "balance", "status", "country") FROM '/dataset/data/account.csv' WITH (FORMAT csv, HEADER true);
COPY "device" ("id", "kind", "os", "first_seen", "fingerprint") FROM '/dataset/data/device.csv' WITH (FORMAT csv, HEADER true);
COPY "tag" ("id", "name", "class") FROM '/dataset/data/tag.csv' WITH (FORMAT csv, HEADER true);
COPY "post" ("id", "author_id", "tag_id", "created_at", "length", "language", "content") FROM '/dataset/data/post.csv' WITH (FORMAT csv, HEADER true);
COPY "knows" ("id", "src_id", "dst_id", "since", "strength") FROM '/dataset/data/knows.csv' WITH (FORMAT csv, HEADER true);
COPY "works_at" ("id", "src_id", "dst_id", "from_date", "role") FROM '/dataset/data/works_at.csv' WITH (FORMAT csv, HEADER true);
COPY "uses" ("id", "src_id", "dst_id", "first_seen", "last_seen") FROM '/dataset/data/uses.csv' WITH (FORMAT csv, HEADER true);
COPY "transfer" ("id", "src_id", "dst_id", "ts", "amount", "currency", "channel") FROM '/dataset/data/transfer.csv' WITH (FORMAT csv, HEADER true);
COPY "interested_in" ("id", "src_id", "dst_id", "weight") FROM '/dataset/data/interested_in.csv' WITH (FORMAT csv, HEADER true);
COPY "likes" ("id", "src_id", "dst_id", "ts") FROM '/dataset/data/likes.csv' WITH (FORMAT csv, HEADER true);
ALTER TABLE "place" ADD PRIMARY KEY ("id");
ALTER TABLE "person" ADD PRIMARY KEY ("id");
ALTER TABLE "organization" ADD PRIMARY KEY ("id");
ALTER TABLE "account" ADD PRIMARY KEY ("id");
ALTER TABLE "device" ADD PRIMARY KEY ("id");
ALTER TABLE "tag" ADD PRIMARY KEY ("id");
ALTER TABLE "post" ADD PRIMARY KEY ("id");
ALTER TABLE "knows" ADD PRIMARY KEY ("id");
ALTER TABLE "works_at" ADD PRIMARY KEY ("id");
ALTER TABLE "uses" ADD PRIMARY KEY ("id");
ALTER TABLE "transfer" ADD PRIMARY KEY ("id");
ALTER TABLE "interested_in" ADD PRIMARY KEY ("id");
ALTER TABLE "likes" ADD PRIMARY KEY ("id");
ALTER TABLE "place" ADD FOREIGN KEY ("part_of") REFERENCES "place" ("id") ON DELETE CASCADE;
ALTER TABLE "person" ADD FOREIGN KEY ("lives_in") REFERENCES "place" ("id") ON DELETE CASCADE;
ALTER TABLE "organization" ADD FOREIGN KEY ("located_in") REFERENCES "place" ("id") ON DELETE CASCADE;
ALTER TABLE "account" ADD FOREIGN KEY ("owner_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "account" ADD FOREIGN KEY ("org_id") REFERENCES "organization" ("id") ON DELETE CASCADE;
ALTER TABLE "post" ADD FOREIGN KEY ("author_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "post" ADD FOREIGN KEY ("tag_id") REFERENCES "tag" ("id") ON DELETE CASCADE;
ALTER TABLE "knows" ADD FOREIGN KEY ("src_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "knows" ADD FOREIGN KEY ("dst_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "works_at" ADD FOREIGN KEY ("src_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "works_at" ADD FOREIGN KEY ("dst_id") REFERENCES "organization" ("id") ON DELETE CASCADE;
ALTER TABLE "uses" ADD FOREIGN KEY ("src_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "uses" ADD FOREIGN KEY ("dst_id") REFERENCES "device" ("id") ON DELETE CASCADE;
ALTER TABLE "transfer" ADD FOREIGN KEY ("src_id") REFERENCES "account" ("id") ON DELETE CASCADE;
ALTER TABLE "transfer" ADD FOREIGN KEY ("dst_id") REFERENCES "account" ("id") ON DELETE CASCADE;
ALTER TABLE "interested_in" ADD FOREIGN KEY ("src_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "interested_in" ADD FOREIGN KEY ("dst_id") REFERENCES "tag" ("id") ON DELETE CASCADE;
ALTER TABLE "likes" ADD FOREIGN KEY ("src_id") REFERENCES "person" ("id") ON DELETE CASCADE;
ALTER TABLE "likes" ADD FOREIGN KEY ("dst_id") REFERENCES "post" ("id") ON DELETE CASCADE;
CREATE INDEX "dp_account_owner_id" ON "account" ("owner_id");
CREATE INDEX "dp_account_country_status_balance" ON "account" ("country", "status", "balance");
CREATE INDEX "dp_transfer_src_id_ts" ON "transfer" ("src_id", "ts");
CREATE INDEX "dp_transfer_dst_id" ON "transfer" ("dst_id");
CREATE INDEX "dp_knows_src_id" ON "knows" ("src_id");
CREATE INDEX "dp_knows_dst_id" ON "knows" ("dst_id");
Settings that differ from a fresh container of the same image
Setting
Image default
This run
max_connections
100
300
shared_buffers
128MB
2GB
5. Queries
The adapter runs these statements, with parameters bound as $n.
J5
SELECT count(*)
FROM transfer t1
JOIN transfer t2 ON t2.src_id = t1.dst_id AND t2.ts > t1.ts
JOIN transfer t3 ON t3.src_id = t2.dst_id AND t3.ts > t2.ts
JOIN transfer t4 ON t4.src_id = t3.dst_id AND t4.ts > t3.ts AND t4.ts < t1.ts + interval '30 days'
WHERE t1.src_id = $1 AND t1.ts >= $2 AND t1.ts < $3
O1
SELECT p.id, p.first_name, p.last_name, a.id, a.balance, a.status
FROM person p LEFT JOIN account a ON a.owner_id = p.id
WHERE p.email = $1
J1
WITH RECURSIVE r(id, depth) AS (
SELECT $1::bigint, 0
UNION
SELECT k.dst_id, r.depth + 1 FROM r JOIN knows k ON k.src_id = r.id WHERE r.depth < 4
)
SELECT count(DISTINCT id) FROM r WHERE id <> $1
S4
SELECT currency, channel, count(*), sum(amount) FROM transfer
WHERE ts >= $1 AND ts < $2
GROUP BY currency, channel
J2
SELECT region.name, count(*), sum(t.amount)
FROM knows k
JOIN account a ON a.owner_id = k.dst_id
JOIN transfer t ON t.src_id = a.id AND t.ts >= $2 AND t.ts < $3
JOIN account b ON b.id = t.dst_id
JOIN person o ON o.id = b.owner_id
JOIN place city ON city.id = o.lives_in
JOIN place region ON region.id = city.part_of
WHERE k.src_id = $1
GROUP BY region.id, region.name
J3
SELECT count(*)
FROM knows k1
JOIN knows k2 ON k2.src_id = k1.dst_id
JOIN knows k3 ON k3.src_id = k2.dst_id AND k3.dst_id = k1.src_id
WHERE k1.src_id = $1 AND k1.dst_id <> $1 AND k2.dst_id <> $1 AND k2.dst_id <> k1.dst_id
S2
SELECT id FROM person
WHERE risk_score >= $1 AND birth_date >= $2::date AND birth_date < $3::date
S1
SELECT count(*), COALESCE(sum(amount), 0) FROM transfer
WHERE ts >= $1 AND ts < $2 AND channel = $3 AND amount BETWEEN $4::bigint::numeric / 100 AND $5::bigint::numeric / 100
J4
SELECT count(DISTINCT o.id)
FROM person p
JOIN person o ON o.lives_in = p.lives_in AND o.id <> p.id
WHERE p.id = $1
AND EXISTS (SELECT 1 FROM works_at w WHERE w.src_id = o.id)
AND EXISTS (SELECT 1 FROM interested_in io JOIN interested_in ip ON ip.dst_id = io.dst_id
WHERE io.src_id = o.id AND ip.src_id = p.id)
O3
SELECT count(DISTINCT p.id), count(a.id), COALESCE(sum(a.balance), 0)
FROM person p LEFT JOIN account a ON a.owner_id = p.id
WHERE p.last_name = $1 AND p.lives_in = $2
O2
SELECT id FROM account
WHERE opened_at >= $1 AND opened_at < $2 AND balance >= $3::bigint::numeric / 100
S3
SELECT count(*) FROM post
WHERE language = $1 AND created_at >= $2 AND created_at < $3 AND strpos(content, $4) > 0
R1
SELECT p.id, p.first_name, p.last_name, a.id, a.balance, a.status
FROM person p LEFT JOIN account a ON a.owner_id = p.id
WHERE p.id = $1
R2
SELECT id FROM account
WHERE country = $1 AND status = 'open' AND balance BETWEEN $2::bigint::numeric / 100 AND $3::bigint::numeric / 100
R3
SELECT k.dst_id, COALESCE(SUM(t.amount), 0)
FROM knows k
LEFT JOIN account a ON a.owner_id = k.dst_id
LEFT JOIN transfer t ON t.src_id = a.id AND t.ts >= $2 AND t.ts < $3
WHERE k.src_id = $1
GROUP BY k.dst_id
R4
WITH RECURSIVE r(id, depth) AS (
SELECT $1::bigint, 0
UNION
SELECT t.dst_id, r.depth + 1 FROM r JOIN transfer t ON t.src_id = r.id
WHERE r.depth < 3 AND t.ts >= $2 AND t.ts < $3
)
SELECT DISTINCT id FROM r WHERE id <> $1
R5
WITH RECURSIVE
f(id, d) AS (
SELECT $1::bigint, 0
UNION
SELECT k.dst_id, f.d + 1 FROM f JOIN knows k ON k.src_id = f.id WHERE f.d < 3
),
b(id, d) AS (
SELECT $2::bigint, 0
UNION
SELECT k.src_id, b.d + 1 FROM b JOIN knows k ON k.dst_id = b.id WHERE b.d < 3
)
SELECT min(f.d + b.d) FROM f JOIN b ON f.id = b.id HAVING count(*) > 0
R6
WITH RECURSIVE p(acc, path, len) AS (
SELECT t.dst_id, ARRAY[$1::bigint, t.dst_id], 1
FROM transfer t WHERE t.src_id = $1 AND t.ts >= $2 AND t.ts < $3
UNION ALL
SELECT t.dst_id, p.path || t.dst_id, p.len + 1
FROM p JOIN transfer t ON t.src_id = p.acc
WHERE p.len < 5 AND p.acc <> $1 AND t.ts >= $2 AND t.ts < $3
AND (t.dst_id = $1 OR NOT t.dst_id = ANY(p.path))
)
SELECT count(*) FROM p WHERE acc = $1 AND len >= 3
R7
WITH top AS (
SELECT org_id FROM account WHERE org_id IS NOT NULL
GROUP BY org_id ORDER BY count(*) DESC, org_id LIMIT 20
)
SELECT to_char(date_trunc('month', t.ts AT TIME ZONE 'UTC'), 'YYYY-MM'), sa.country, da.country, SUM(t.amount)
FROM transfer t
JOIN account sa ON sa.id = t.src_id
JOIN account da ON da.id = t.dst_id
WHERE sa.org_id IN (SELECT org_id FROM top) AND t.ts >= $1 AND t.ts < $2
GROUP BY 1, 2, 3
W1
INSERT INTO person (id, first_name, last_name, birth_date, created_at, risk_score, email, lives_in)
VALUES ($1, $2, $3, '1990-01-01', $4, 0.5, NULL, 1);
INSERT INTO account (id, owner_id, org_id, opened_at, balance, status, country)
VALUES ($1, $2, NULL, $3, 0, 'open', 'ZZ');
INSERT INTO knows (id, src_id, dst_id, since, strength)
SELECT id, $1, dst, $2::timestamptz::date, 0.5 FROM unnest($3::bigint[], $4::bigint[]) AS k(id, dst)
W2
INSERT INTO transfer (id, src_id, dst_id, ts, amount, currency, channel)
VALUES ($1, $2, $3, $4, $5::bigint::numeric / 100, $6, $7)
W3
INSERT INTO transfer (id, src_id, dst_id, ts, amount, currency, channel)
SELECT id, src, dst, ts, amt::numeric / 100, cur, chan
FROM unnest($1::bigint[], $2::bigint[], $3::bigint[], $4::timestamptz[], $5::bigint[], $6::text[], $7::text[])
AS b(id, src, dst, ts, amt, cur, chan)
U1
UPDATE account SET balance = $2::bigint::numeric / 100, status = $3 WHERE id = $1
U2
DELETE FROM works_at WHERE src_id = $1;
INSERT INTO works_at (id, src_id, dst_id, from_date, role) VALUES ($2, $1, $3, $4::timestamptz::date, 'engineer')
D1
DELETE FROM transfer WHERE id = $1
D2
DELETE FROM person WHERE id = $1
6. Concurrency ladder, mixed
k
X ops/s
Q
X × Q
1
180.6
1.000
180.6
4 k*
258.0
0.892
230.1
16
276.8
0.401
110.9
64
282.4
0.145
40.9
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, 400 batch, 200 person alive, 200 person deleted, 200 transfer alive, 200 transfer deleted, 200 works, with 0 kinds failing.
9. Deviations
dataset.scale: 3M is not a DP-Core scale factor (spec §6.6)
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
warm-up before P5 runs at 16 clients: spec §9.5 says k*, which only P7 finds
10. Phase detail
Import (P2): 2,137,843 rows in 7.4 s: load 3.1 s, keys 1.8 s, indexes 1.3 s. Peak memory during load 0.97 GiB.
Repetitions (P7, P8)
n
T
k*
Q at k*
M GiB
After work GiB
1
230.1
4
0.892
0.41
0.91
Coefficient of variation of DataPower across repetitions: 0.0%.
Memory floor (P9)
Limit GiB
Q
Outcome
8
0.892
ran
4
0.941
ran
2
0.902
ran
1
0.940
ran
Cold (P3) and warm (P5) single-client latency, ms
Class
Operation
Cold p50
Cold p99
Warm p50
Warm p99
R1
point
1.09
11.99
0.14
1.78
R2
filter
10.34
21.58
0.35
0.97
R3
neighbourhood
2.57
10.97
0.47
1.42
R4
deep
1.67
4.20
0.17
0.65
R5
path
4.28
262.40
0.66
12.73
R6
pattern
1.25
1.88
0.13
0.65
R7
analytic
126.97
849.41
120.00
129.73
W1
insert
1.78
8.28
0.73
3.07
W2
insert edge
1.01
1.96
0.41
0.61
W3
batch
20.89
23.60
21.34
22.99
U1
modify
0.79
1.30
0.85
1.04
U2
rewire
2.92
9.29
3.12
3.98
D1
delete edge
0.38
0.46
0.55
0.72
D2
delete cascade
49.57
183.81
52.83
62.69
O1
person by email
13.95
39.01
13.49
15.62
O2
accounts by opening date
14.26
16.03
13.87
14.80
O3
people by surname and city
15.63
18.29
14.67
16.14
S1
amount band
55.87
63.33
60.70
64.86
S3
text search
34.11
39.13
32.06
35.87
J4
neighbours alike
15.61
36.54
14.13
17.36
R1w
point, worst case
0.29
0.38
0.11
0.24
R2w
filter, worst case
4.07
5.24
2.94
10.18
R3w
neighbourhood, worst case
11.34
18.94
3.15
8.04
R4w
deep, worst case
0.86
1.50
0.69
1.56
R5w
path, worst case
5.50
32.93
6.09
22.40
R6w
pattern, worst case
0.20
0.41
0.15
0.30
R7w
analytic, worst case
120.89
122.81
120.64
121.53
Ladder (P6): read
k
X ops/s
Errors
Driver CPU
1
145.8
0
1.0%
4
190.0
0
1.3%
16
230.4
0
1.7%
64
202.8
0
1.8%
Ladder (P6): insert
k
X ops/s
Errors
Driver CPU
1
566.6
0
2.8%
4
1,415.0
0
5.9%
16
1,652.2
0
6.4%
64
722.4
0
3.4%
Ladder (P6): modify-delete
k
X ops/s
Errors
Driver CPU
1
203.2
0
1.0%
4
464.6
0
2.1%
16
470.0
0
2.4%
64
491.0
0
2.2%
Ladder (P6): write
k
X ops/s
Errors
Driver CPU
1
307.0
0
1.9%
4
798.0
0
2.7%
16
886.4
0
2.9%
64
493.6
0
2.4%
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.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.8
0
0.0
0.00
0.00
0.00
P1 schema definition
1 s
30.5
0
0.0
0.76
0.18
0.10
P2 import
31 s
15.0
0
0.0
0.59
0.97
0.66
P3 cold single-client run
46 s
20.8
410
19.7
0.56
0.62
0.30
P4 warm-up
67 s
10.6
2,496
235.1
1.90
0.73
0.31
P5 warm single-client run
78 s
10.3
632
61.3
1.20
0.66
0.33
P6 read, write and modify ladders
88 s
117.8
65,076
552.4
1.68
2.29
1.44
P7 mixed ladder
206 s
293.9
41,820
142.3
1.11
2.15
0.00
P9 memory floor search
500 s
23.0
5,366
233.6
1.82
0.47
0.06
P10 validation reads
523 s
0.6
0
0.0
0.97
0.44
0.06
P11 final footprint and surface audit
523 s
2.7
0
0.0
0.18
0.44
0.06
P12 teardown
526 s
1.7
0
0.0
0.04
0.44
0.06
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.