DataPower disclosure report

PostgreSQL 16.15

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

Run 2026-11-01T20-01-49Z-standard-sf3m-s-postgres · scenario standard-sf3m-s-postgres · repetition 1 of 1 · spec DP-2026.1

198DP
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 × 230.13) / (2.056 × 1.700)
3.00E · million data elements
230.13T · effective ops/s at k* = 4
2.056R · 2 cores + 0.41 GiB / 8 + 0.91 GiB / 200
1.700O · 1 + 0.05 × 14 surface points

2. Factors

FactorValue
Disk at rest / after work0.59 / 0.91 GiB
Bytes per element325.3
Log share of disk0.0%
Write amplification0.00
Memory ready, after import / repetition0.96 / 0.08 GiB
Peak memory0.62 GiB
Memory charge (M)0.41 GiB
Memory elasticity0.10
Held memory: ready / peak / charge0.08 / 0.60 / 0.38 GiB
Held memory elasticity0.11
Memory after the kernel reclaims0.38 GiB of 0.42
Memory floor (in-memory)1.00 GiB
CPU per standard operation7.54 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
idle0.430.010.370.050.00
peak0.460.030.370.050.01
ready0.960.010.280.660.01
ready_repetition0.080.010.070.000.00

Latency, warm single client

ClassOperationp50 msp99 msTarget ms
R1point0.141.7810
R2filter0.350.97200
R3neighbourhood0.471.4250
R4deep0.170.65500
R5path0.6612.73500
R6pattern0.130.652,000
R7analytic120.00129.735,000
W1insert0.733.0720
W2insert edge0.410.6110
W3batch21.3422.99500
U1modify0.851.0420
U2rewire3.123.9830
D1delete edge0.550.7220
D2delete cascade52.8362.69100
O1person by email13.4915.6220
O2accounts by opening date13.8714.80200
O3people by surname and city14.6716.14100
S1amount band60.7064.861,000
S3text search32.0635.872,000
J4neighbours alike14.1317.36500
R1wpoint, worst case0.110.2410
R2wfilter, worst case2.9410.18200
R3wneighbourhood, worst case3.158.0450
R4wdeep, worst case0.691.56500
R5wpath, worst case6.0922.40500
R6wpattern, worst case0.150.302,000
R7wanalytic, worst case120.64121.535,000

Operational surface: 14 points

ItemPointsSource
index dp_account_owner_id: CREATE INDEX dp_account_owner_id ON public.account USING btree (owner_id)1audited
index dp_account_country_status_balance: CREATE INDEX dp_account_country_status_balance ON public.account USING btree (country, status, balance)1audited
index dp_transfer_src_id_ts: CREATE INDEX dp_transfer_src_id_ts ON public.transfer USING btree (src_id, ts)1audited
index dp_transfer_dst_id: CREATE INDEX dp_transfer_dst_id ON public.transfer USING btree (dst_id)1audited
index dp_knows_src_id: CREATE INDEX dp_knows_src_id ON public.knows USING btree (src_id)1audited
index dp_knows_dst_id: CREATE INDEX dp_knows_dst_id ON public.knows USING btree (dst_id)1audited
setting: max_connections = 3001audited
hand-sized cache: shared_buffers = 2GB2audited
maintenance task: autovacuum2declared
maintenance task: analyze2declared
manual step: ANALYZE after import1declared

3. Host and system

SystemPostgreSQL 16.15, adapter postgres
Imagedocker.io/library/postgres@sha256:ca0bd484cb98bf4b24eb1010e73fb3fcbd6714d240fbc1a10eea5b7dbecb641d
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

# 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

SettingImage defaultThis run
max_connections100300
shared_buffers128MB2GB

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

kX ops/sQX × Q
1180.61.000180.6
4 k*258.00.892230.1
16276.80.401110.9
64282.40.14540.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.

0.0 GiB0.2 GiB0.5 GiB 0 s60 s120 s180 s240 s

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

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)

nTk*Q at k*M GiBAfter work GiB
1230.140.8920.410.91

Coefficient of variation of DataPower across repetitions: 0.0%.

Memory floor (P9)

Limit GiBQOutcome
80.892ran
40.941ran
20.902ran
10.940ran

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

ClassOperationCold p50Cold p99Warm p50Warm p99
R1point1.0911.990.141.78
R2filter10.3421.580.350.97
R3neighbourhood2.5710.970.471.42
R4deep1.674.200.170.65
R5path4.28262.400.6612.73
R6pattern1.251.880.130.65
R7analytic126.97849.41120.00129.73
W1insert1.788.280.733.07
W2insert edge1.011.960.410.61
W3batch20.8923.6021.3422.99
U1modify0.791.300.851.04
U2rewire2.929.293.123.98
D1delete edge0.380.460.550.72
D2delete cascade49.57183.8152.8362.69
O1person by email13.9539.0113.4915.62
O2accounts by opening date14.2616.0313.8714.80
O3people by surname and city15.6318.2914.6716.14
S1amount band55.8763.3360.7064.86
S3text search34.1139.1332.0635.87
J4neighbours alike15.6136.5414.1317.36
R1wpoint, worst case0.290.380.110.24
R2wfilter, worst case4.075.242.9410.18
R3wneighbourhood, worst case11.3418.943.158.04
R4wdeep, worst case0.861.500.691.56
R5wpath, worst case5.5032.936.0922.40
R6wpattern, worst case0.200.410.150.30
R7wanalytic, worst case120.89122.81120.64121.53

Ladder (P6): read

kX ops/sErrorsDriver CPU
1145.801.0%
4190.001.3%
16230.401.7%
64202.801.8%

Ladder (P6): insert

kX ops/sErrorsDriver CPU
1566.602.8%
41,415.005.9%
161,652.206.4%
64722.403.4%

Ladder (P6): modify-delete

kX ops/sErrorsDriver CPU
1203.201.0%
4464.602.1%
16470.002.4%
64491.002.2%

Ladder (P6): write

kX ops/sErrorsDriver CPU
1307.001.9%
4798.002.7%
16886.402.9%
64493.602.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.

Throughput Valid operations per second, ramps and warm-ups included.
P0P1P1P2P2P3P3P4P5P6P6P7P7P9P9P10P11P120500100015002000ops/s0:002:004:006:008:00
Latency p99 of every operation in each second, all classes together, on a log scale.
P0P1P1P2P2P3P3P4P5P6P6P7P7P9P9P10P11P1210301003001000300010kms0:002:004:006:008: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
P0P1P1P2P2P3P3P4P5P6P6P7P7P9P9P10P11P120123GiB0:002:004:006:008:00kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
P0P1P1P2P2P3P3P4P5P6P6P7P7P9P9P10P11P120123cores0:002:004:006:008:00envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
P0P1P1P2P2P3P3P4P5P6P6P7P7P9P9P10P11P120200400600800MB/s0:002:004:006:008:00readwritten
PhaseStartsSecondsOperationsops/sCPU coresPeak GiBPage cache at end GiB
P0 environment check0 s0.800.00.000.000.00
P1 schema definition1 s30.500.00.760.180.10
P2 import31 s15.000.00.590.970.66
P3 cold single-client run46 s20.841019.70.560.620.30
P4 warm-up67 s10.62,496235.11.900.730.31
P5 warm single-client run78 s10.363261.31.200.660.33
P6 read, write and modify ladders88 s117.865,076552.41.682.291.44
P7 mixed ladder206 s293.941,820142.31.112.150.00
P9 memory floor search500 s23.05,366233.61.820.470.06
P10 validation reads523 s0.600.00.970.440.06
P11 final footprint and surface audit523 s2.700.00.180.440.06
P12 teardown526 s1.700.00.040.440.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 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.010.11101001000ms0:000:100:200:300:40
Throughput Valid operations per second, ramps and warm-ups included.
coldcoldwarm-upwarm-upwarmwarm0100200300400ops/s0:000:100:200:300:40
Latency p99 of every operation in each second, all classes together, on a log scale.
coldcoldwarm-upwarm-upwarmwarm10301003001000300010kms0:000:100:200:300:40
Memory The SUT's cgroup memory, stacked: what the processes hold, shared memory such as a buffer pool, and the page cache the kernel can reclaim. The envelope allows 8 GiB.
process (anon)shared memorypage cachekernel
coldcoldwarm-upwarm-upwarmwarm00.20.40.60.8GiB0:000:100:200:300:40kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
coldcoldwarm-upwarm-upwarmwarm0123cores0:000:100:200:300:40envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
coldcoldwarm-upwarm-upwarmwarm0100200300MB/s0:000:100:200:300:40readwritten
Cold and warm medians Each class's p50 on an empty page cache (P3) and after the warm-up (P5), log scale. The longer the line, the more the class depends on a warm cache.
P3 coldP5 warm
0.1 ms1 ms10 ms100 ms1000 msR1R1 warm p50 0.14 msR1 cold p50 1.09 msR1wR1w warm p50 0.11 msR1w cold p50 0.29 msR2R2 warm p50 0.35 msR2 cold p50 10.34 msR2wR2w warm p50 2.94 msR2w cold p50 4.07 msR3R3 warm p50 0.47 msR3 cold p50 2.57 msR3wR3w warm p50 3.15 msR3w cold p50 11.34 msR4R4 warm p50 0.17 msR4 cold p50 1.67 msR4wR4w warm p50 0.69 msR4w cold p50 0.86 msR5R5 warm p50 0.66 msR5 cold p50 4.28 msR5wR5w warm p50 6.09 msR5w cold p50 5.50 msR6R6 warm p50 0.13 msR6 cold p50 1.25 msR6wR6w warm p50 0.15 msR6w cold p50 0.20 msR7R7 warm p50 120.00 msR7 cold p50 126.97 msR7wR7w warm p50 120.64 msR7w cold p50 120.89 msS1S1 warm p50 60.70 msS1 cold p50 55.87 msS3S3 warm p50 32.06 msS3 cold p50 34.11 msJ4J4 warm p50 14.13 msJ4 cold p50 15.61 msO1O1 warm p50 13.49 msO1 cold p50 13.95 msO2O2 warm p50 13.87 msO2 cold p50 14.26 msO3O3 warm p50 14.67 msO3 cold p50 15.63 msW1W1 warm p50 0.73 msW1 cold p50 1.78 msW2W2 warm p50 0.41 msW2 cold p50 1.01 msW3W3 warm p50 21.34 msW3 cold p50 20.89 msU1U1 warm p50 0.85 msU1 cold p50 0.79 msU2U2 warm p50 3.12 msU2 cold p50 2.92 msD1D1 warm p50 0.55 msD1 cold p50 0.38 msD2D2 warm p50 52.83 msD2 cold p50 49.57 ms