DataPower disclosure report

SQLite 3.53.4

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-49-10Z-standard-sf300k-s-sqlite · scenario standard-sf300k-s-sqlite · repetition 1 of 1 · spec DP-2026.1

74DP
dp-core SF-300K, envelope S, on the standard mix, blended 80% typical, 15% off-index, 5% worst-case
DP = (E × T) / (R × O) = (0.30 × 742.80) / (2.011 × 1.500)
0.30E · million data elements
742.80T · effective ops/s at k* = 1
2.011R · 2 cores + 0.09 GiB / 8 + 0.07 GiB / 200
1.500O · 1 + 0.05 × 10 surface points

2. Factors

FactorValue
Disk at rest / after work0.02 / 0.07 GiB
Bytes per element250.1
Log share of disk0.0%
Write amplification82.98
Memory ready, after import / repetition0.03 / 0.01 GiB
Peak memory0.10 GiB
Memory charge (M)0.09 GiB
Memory elasticity0.04
Held memory: ready / peak / charge0.01 / 0.07 / 0.03 GiB
Held memory elasticity0.30
Memory after the kernel reclaims0.01 GiB of 0.10
Memory floor (in-memory)1.00 GiB
CPU per standard operation0.99 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.100.010.000.070.00
peak0.100.010.000.070.00
ready0.030.010.000.020.00
ready_repetition0.010.000.000.000.00

Latency, warm single client

ClassOperationp50 msp99 msTarget ms
R1point0.120.2510
R2filter0.220.45200
R3neighbourhood0.150.4050
R4deep0.510.72500
R5path1.353.32500
R6pattern0.220.472,000
R7analytic17.6124.345,000
W1insert1.163.6520
W2insert edge0.460.5710
W3batch20.8836.19500
U1modify0.841.3220
U2rewire1.161.5230
D1delete edge0.841.3820
D2delete cascade11.7115.33100
O1person by email1.011.6420
O2accounts by opening date0.991.39200
O3people by surname and city1.141.33100
S1amount band11.1211.901,000
S3text search4.424.682,000
J4neighbours alike3.194.82500
R1wpoint, worst case0.140.2110
R2wfilter, worst case0.571.41200
R3wneighbourhood, worst case0.511.5750
R4wdeep, worst case0.590.96500
R5wpath, worst case1.584.01500
R6wpattern, worst case0.180.352,000
R7wanalytic, worst case17.4718.675,000

Operational surface: 10 points

ItemPointsSource
index dp_account_country_status_balance: CREATE INDEX "dp_account_country_status_balance" ON "account" ("country", "status", "balance")1audited
index dp_account_owner_id: CREATE INDEX "dp_account_owner_id" ON "account" ("owner_id")1audited
index dp_knows_dst_id: CREATE INDEX "dp_knows_dst_id" ON "knows" ("dst_id")1audited
index dp_knows_src_id: CREATE INDEX "dp_knows_src_id" ON "knows" ("src_id")1audited
index dp_transfer_dst_id: CREATE INDEX "dp_transfer_dst_id" ON "transfer" ("dst_id")1audited
index dp_transfer_src_id_ts: CREATE INDEX "dp_transfer_src_id_ts" ON "transfer" ("src_id", "ts")1audited
setting: busy_timeout = 50001audited
setting: foreign_keys = 11audited
setting: journal_mode = wal1audited
manual step: ANALYZE after import1declared

3. Host and system

SystemSQLite 3.53.4, adapter sqlite
Imagelocalhost/dpbench-sqlite@sha256:e07b2b03bf92461e6d41d1a9e7d95437e0ab91affeced74b8130a25c5adb1467
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

# SQLite 3.53.4, the C library, served by dp-sqlite (adapters/sqlite/server).
#
# SQLite is a library with no server, so the adapter brings the smallest one
# that puts it on a network, and runs it inside the SUT's container: each TCP
# connection is one SQLite connection, so SQLite's CPU, memory and disk land
# in the container's cgroup like every other system's. The library is the
# amalgamation github.com/mattn/go-sqlite3 v1.14.52 bundles, SQLite 3.53.4
# (2026-07-24, source id bf7c7f30031888f4e796e429ab3978879485813aaca6f641c7b33e4e09459bcc),
# compiled with that package's options; dump_config reports every one as
# compile_options.
#
# SQLite publishes no image, so the adapter builds one on the engine's host:
# `adapters/sqlite/build-image.sh` (Containerfile beside this file) builds
# localhost/dpbench-sqlite and prints its digest. The image is local, so
# `image` pins the digest that build printed.
#
# 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: sqlite
system: SQLite
version: "3.53.4"
image: localhost/dpbench-sqlite@sha256:e07b2b03bf92461e6d41d1a9e7d95437e0ab91affeced74b8130a25c5adb1467
model: relational
protocols: [json-lines]
query_language: sql

# A commit is durable when it returns (spec §9.2). In WAL mode SQLite syncs
# the log on every commit at synchronous FULL, which is SQLite's default
# (SQLITE_DEFAULT_SYNCHRONOUS=2). This build lowers the default for WAL
# databases to NORMAL (SQLITE_DEFAULT_WAL_SYNCHRONOUS=1), where the last
# commits before a power loss can roll back, so the server keeps FULL and the
# arguments below say so; it is needed only for durability, and exempt.
# SQLite's transactions are serializable: one writer at a time, and each
# reader sees one snapshot.
durability:
  settings: { synchronous: "FULL" }
isolation: serializable

# 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:
# dump_config against a container started without the arguments below.
declared_surface:
  services: 1
  runtime_dependencies: []
  # The PostgreSQL adapter's indexes, for the same reasons: owner_id for R1,
  # R3 and D2's cascade, (country, status, balance) for R2,
  # transfer(src_id, ts) for R3, R4, R6, R7 and the cascade,
  # transfer(dst_id) for the cascade, knows(src_id) for R3 and R5,
  # knows(dst_id) for R5 and the cascade. The keys are the canonical schema's:
  # an INTEGER PRIMARY KEY is the rowid each table is ordered by, and every
  # reference is a foreign key that cascades on delete.
  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: []
  non_default_settings:
    # A write-ahead log, so readers never wait for the writer and the writer
    # never waits for readers. The default rollback journal is as durable,
    # but each commit then waits for every reader to finish, and new readers
    # wait for the commit; a reasonable operator of a database with more
    # than one client turns WAL on. It persists in the database file.
    journal_mode: "WAL"
    # SQLite allows one writer at a time. A connection that finds the write
    # lock taken waits up to 5 s for it, the timeout Python's sqlite3 module
    # and go-sqlite3 default to, instead of failing at once (SQLite's
    # default is 0). A write still waiting then fails with SQLITE_BUSY, which
    # the driver retries as a conflict; every retry and failure is counted.
    busy_timeout: "5000"
    # Enforce the canonical foreign keys, so D2's DELETE cascades as the
    # schema declares (spec §9.2). SQLite parses foreign keys but enforces
    # none unless told to; the alternative, deleting from every referencing
    # table inside D2, would leave every other write unchecked.
    foreign_keys: "ON"
  maintenance_tasks: []
  storage_areas: [data]
  # Without statistics SQLite's planner guesses each table's size; for R7 it
  # guesses a scan of every transfer over the top organizations' accounts.
  # With them it also skip-scans the account index for O2.
  manual_steps: ["ANALYZE after import"]

envelope:
  size: S
  memory_limit_gib: 8

plugin: sqlite
container:
  port: 6543
  data_path: /data
  dataset_path: /dataset
  # The write-ahead log beside the database. It exists while any connection
  # is open, as the adapter's is during every footprint.
  log_paths: [dp.sqlite-wal]
  # The image's entrypoint names the harness's paths and port. Every setting
  # an operator chose is here, applied by every connection when it opens.
  args: ["-pragma", "busy_timeout=5000", "-pragma", "journal_mode=WAL", "-pragma", "synchronous=FULL", "-pragma", "foreign_keys=ON"]

Executed DDL

CREATE TABLE "place" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "name" TEXT NOT NULL,
  "type" TEXT NOT NULL,
  "part_of" INTEGER REFERENCES "place" ("id") ON DELETE CASCADE
);
CREATE TABLE "person" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "first_name" TEXT NOT NULL,
  "last_name" TEXT NOT NULL,
  "birth_date" TEXT NOT NULL,
  "created_at" INTEGER NOT NULL,
  "risk_score" REAL NOT NULL,
  "email" TEXT,
  "lives_in" INTEGER NOT NULL REFERENCES "place" ("id") ON DELETE CASCADE
);
CREATE TABLE "organization" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "name" TEXT NOT NULL,
  "type" TEXT NOT NULL,
  "founded" TEXT NOT NULL,
  "located_in" INTEGER NOT NULL REFERENCES "place" ("id") ON DELETE CASCADE
);
CREATE TABLE "account" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "owner_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "org_id" INTEGER REFERENCES "organization" ("id") ON DELETE CASCADE,
  "opened_at" INTEGER NOT NULL,
  "balance" INTEGER NOT NULL,
  "status" TEXT NOT NULL,
  "country" TEXT NOT NULL
);
CREATE TABLE "device" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "kind" TEXT NOT NULL,
  "os" TEXT NOT NULL,
  "first_seen" INTEGER NOT NULL,
  "fingerprint" TEXT NOT NULL
);
CREATE TABLE "tag" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "name" TEXT NOT NULL,
  "class" TEXT NOT NULL
);
CREATE TABLE "post" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "author_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "tag_id" INTEGER REFERENCES "tag" ("id") ON DELETE CASCADE,
  "created_at" INTEGER NOT NULL,
  "length" INTEGER NOT NULL,
  "language" TEXT NOT NULL,
  "content" TEXT NOT NULL
);
CREATE TABLE "knows" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "src_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "dst_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "since" TEXT NOT NULL,
  "strength" REAL NOT NULL
);
CREATE TABLE "works_at" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "src_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "dst_id" INTEGER NOT NULL REFERENCES "organization" ("id") ON DELETE CASCADE,
  "from_date" TEXT NOT NULL,
  "role" TEXT NOT NULL
);
CREATE TABLE "uses" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "src_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "dst_id" INTEGER NOT NULL REFERENCES "device" ("id") ON DELETE CASCADE,
  "first_seen" INTEGER NOT NULL,
  "last_seen" INTEGER NOT NULL
);
CREATE TABLE "transfer" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "src_id" INTEGER NOT NULL REFERENCES "account" ("id") ON DELETE CASCADE,
  "dst_id" INTEGER NOT NULL REFERENCES "account" ("id") ON DELETE CASCADE,
  "ts" INTEGER NOT NULL,
  "amount" INTEGER NOT NULL,
  "currency" TEXT NOT NULL,
  "channel" TEXT NOT NULL
);
CREATE TABLE "interested_in" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "src_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "dst_id" INTEGER NOT NULL REFERENCES "tag" ("id") ON DELETE CASCADE,
  "weight" REAL NOT NULL
);
CREATE TABLE "likes" (
  "id" INTEGER NOT NULL PRIMARY KEY,
  "src_id" INTEGER NOT NULL REFERENCES "person" ("id") ON DELETE CASCADE,
  "dst_id" INTEGER NOT NULL REFERENCES "post" ("id") ON DELETE CASCADE,
  "ts" INTEGER NOT NULL
);
INSERT INTO "place" ("id", "name", "type", "part_of") VALUES (?, ?, ?, ?) -- each row of /dataset/data/place.csv;
INSERT INTO "person" ("id", "first_name", "last_name", "birth_date", "created_at", "risk_score", "email", "lives_in") VALUES (?, ?, ?, ?, ?, ?, ?, ?) -- each row of /dataset/data/person.csv;
INSERT INTO "organization" ("id", "name", "type", "founded", "located_in") VALUES (?, ?, ?, ?, ?) -- each row of /dataset/data/organization.csv;
INSERT INTO "account" ("id", "owner_id", "org_id", "opened_at", "balance", "status", "country") VALUES (?, ?, ?, ?, ?, ?, ?) -- each row of /dataset/data/account.csv;
INSERT INTO "device" ("id", "kind", "os", "first_seen", "fingerprint") VALUES (?, ?, ?, ?, ?) -- each row of /dataset/data/device.csv;
INSERT INTO "tag" ("id", "name", "class") VALUES (?, ?, ?) -- each row of /dataset/data/tag.csv;
INSERT INTO "post" ("id", "author_id", "tag_id", "created_at", "length", "language", "content") VALUES (?, ?, ?, ?, ?, ?, ?) -- each row of /dataset/data/post.csv;
INSERT INTO "knows" ("id", "src_id", "dst_id", "since", "strength") VALUES (?, ?, ?, ?, ?) -- each row of /dataset/data/knows.csv;
INSERT INTO "works_at" ("id", "src_id", "dst_id", "from_date", "role") VALUES (?, ?, ?, ?, ?) -- each row of /dataset/data/works_at.csv;
INSERT INTO "uses" ("id", "src_id", "dst_id", "first_seen", "last_seen") VALUES (?, ?, ?, ?, ?) -- each row of /dataset/data/uses.csv;
INSERT INTO "transfer" ("id", "src_id", "dst_id", "ts", "amount", "currency", "channel") VALUES (?, ?, ?, ?, ?, ?, ?) -- each row of /dataset/data/transfer.csv;
INSERT INTO "interested_in" ("id", "src_id", "dst_id", "weight") VALUES (?, ?, ?, ?) -- each row of /dataset/data/interested_in.csv;
INSERT INTO "likes" ("id", "src_id", "dst_id", "ts") VALUES (?, ?, ?, ?) -- each row of /dataset/data/likes.csv;
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
busy_timeout05000
foreign_keys01
journal_modedeletewal

5. Queries

The adapter runs these statements, with parameters bound as $n.

O2

SELECT id FROM account
WHERE opened_at >= ?1 AND opened_at < ?2 AND balance >= ?3

S1

SELECT count(*), COALESCE(sum(amount), 0) FROM transfer
WHERE ts >= ?1 AND ts < ?2 AND channel = ?3 AND amount BETWEEN ?4 AND ?5

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 o.id IN (SELECT src_id FROM works_at)
  AND o.id IN (SELECT io.src_id FROM interested_in io
               WHERE io.dst_id IN (SELECT dst_id FROM interested_in WHERE src_id = ?1))

J1

WITH RECURSIVE r(id, depth) AS (
  SELECT ?1, 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

S2

SELECT id FROM person
WHERE risk_score >= ?1 AND birth_date >= ?2 AND birth_date < ?3

S4

SELECT currency, channel, count(*), sum(amount) FROM transfer
WHERE ts >= ?1 AND ts < ?2
GROUP BY currency, channel

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 + 2592000
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

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

S3

SELECT count(*) FROM post
WHERE language = ?1 AND created_at >= ?2 AND created_at < ?3 AND instr(content, ?4) > 0

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

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

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 AND ?3

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, 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, 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, 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, ',' || ?1 || ',' || 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 instr(p.path, ',' || t.dst_id || ',') = 0)
)
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 strftime('%Y-%m', t.ts, 'unixepoch'), 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

BEGIN IMMEDIATE;
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) VALUES (?1, ?2, ?3, ?4, 0.5) -- once per edge;
COMMIT

W2

INSERT INTO transfer (id, src_id, dst_id, ts, amount, currency, channel)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)

W3

BEGIN IMMEDIATE;
INSERT INTO transfer (id, src_id, dst_id, ts, amount, currency, channel)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7) -- once per transfer, on one prepared statement;
COMMIT

U1

UPDATE account SET balance = ?2, status = ?3 WHERE id = ?1

U2

BEGIN IMMEDIATE;
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, 'engineer');
COMMIT

D1

DELETE FROM transfer WHERE id = ?1

D2

DELETE FROM person WHERE id = ?1

6. Concurrency ladder, mixed

kX ops/sQX × Q
1 k*742.81.000742.8
4593.00.476282.3
16813.00.282229.7
64837.60.209174.7

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.1 GiB0.1 GiB 0 s60 s120 s180 s240 s

8. Validation

0 invalid operation instances.

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

9. Deviations

10. Phase detail

Import (P2): 213,727 rows in 1.1 s: load 0.9 s, keys 0.0 s, indexes 0.1 s. Peak memory during load 0.04 GiB.

Repetitions (P7, P8)

nTk*Q at k*M GiBAfter work GiB
1742.811.0000.090.07

Coefficient of variation of DataPower across repetitions: 0.0%.

Memory floor (P9)

Limit GiBQOutcome
81.000ran
41.000ran
21.000ran
11.000ran

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

ClassOperationCold p50Cold p99Warm p50Warm p99
R1point0.561.490.120.25
R2filter0.310.720.220.45
R3neighbourhood0.691.700.150.40
R4deep1.486.330.510.72
R5path2.0017.341.353.32
R6pattern0.190.360.220.47
R7analytic16.3018.7717.6124.34
W1insert1.374.191.163.65
W2insert edge1.031.220.460.57
W3batch13.0214.3820.8836.19
U1modify1.531.820.841.32
U2rewire1.542.101.161.52
D1delete edge0.810.880.841.38
D2delete cascade11.7716.9311.7115.33
O1person by email0.992.421.011.64
O2accounts by opening date1.051.180.991.39
O3people by surname and city1.121.181.141.33
S1amount band5.335.4711.1211.90
S3text search4.514.664.424.68
J4neighbours alike3.954.613.194.82
R1wpoint, worst case0.250.290.140.21
R2wfilter, worst case0.580.830.571.41
R3wneighbourhood, worst case0.471.650.511.57
R4wdeep, worst case0.650.920.590.96
R5wpath, worst case1.982.541.584.01
R6wpattern, worst case0.220.220.180.35
R7wanalytic, worst case17.6117.8717.4718.67

Ladder (P6): read

kX ops/sErrorsDriver CPU
1883.802.5%
41,740.805.0%
161,754.804.4%
641,769.404.6%

Ladder (P6): insert

kX ops/sErrorsDriver CPU
1529.203.1%
4480.202.8%
16452.002.6%
64371.202.3%

Ladder (P6): modify-delete

kX ops/sErrorsDriver CPU
1621.601.8%
4604.801.5%
16586.401.7%
64549.001.5%

Ladder (P6): write

kX ops/sErrorsDriver CPU
1553.802.5%
4508.402.4%
16489.002.2%
64434.002.1%

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.
P0P1P2P3P3P4P4P5P6P6P7P7P9P9P11P120100020003000ops/s0:001:002:003:004:005:006:007:00
Latency p99 of every operation in each second, all classes together, on a log scale.
P0P1P2P3P3P4P4P5P6P6P7P7P9P9P11P12110100100010kms0:001:002:003:004:005:006:007: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
P0P1P2P3P3P4P5P6P6P7P7P9P9P11P1200.10.20.3GiB0:001:002:003:004:005:006:007:00kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
P0P1P2P3P3P4P4P5P6P6P7P7P9P9P11P120123cores0:001:002:003:004:005:006:007:00envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
P0P1P2P3P3P4P5P6P6P7P7P9P9P11P12050100150200MB/s0:001:002:003:004:005:006:007:00writtenread
PhaseStartsSecondsOperationsops/sCPU coresPeak GiBPage cache at end GiB
P0 environment check0 s0.800.00.000.000.00
P1 schema definition1 s0.700.00.000.000.00
P2 import1 s8.300.00.080.030.02
P3 cold single-client run10 s17.21357.80.000.010.00
P4 warm-up27 s11.58,720758.20.810.060.04
P5 warm single-client run38 s2.6280108.10.590.050.04
P6 read, write and modify ladders41 s116.286,712746.10.820.220.12
P7 mixed ladder157 s289.088,901307.60.470.140.00
P9 memory floor search446 s22.78,386369.70.790.080.06
P11 final footprint and surface audit469 s1.400.00.100.070.06
P12 teardown471 s1.500.00.000.070.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.1110100ms0:000:050:100:150:200:250:300:35
Throughput Valid operations per second, ramps and warm-ups included.
coldwarm-upwarm-upwarmwarm02505007501000ops/s0:000:050:100:150:200:250:300:35
Latency p99 of every operation in each second, all classes together, on a log scale.
coldwarm-upwarm-upwarmwarm10301003001000300010kms0:000:050:100:150:200:250:300:35
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
coldwarm-upwarm-upwarmwarm00.020.040.060.08GiB0:000:050:100:150:200:250:300:35kernelpage cacheshared memoryprocess (anon)
CPU Cores the SUT kept busy.
coldwarm-upwarm-upwarmwarm0123cores0:000:050:100:150:200:250:300:35envelope 2 cores
Disk Bytes the SUT read from and wrote to its block devices.
readwritten
coldwarm-upwarm-upwarmwarm050100150MB/s0:000:050:100:150:200:250:300:35readwritten
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 ms0.3 ms1 ms3 ms10 ms30 ms100 msR1R1 warm p50 0.12 msR1 cold p50 0.56 msR1wR1w warm p50 0.14 msR1w cold p50 0.25 msR2R2 warm p50 0.22 msR2 cold p50 0.31 msR2wR2w warm p50 0.57 msR2w cold p50 0.58 msR3R3 warm p50 0.15 msR3 cold p50 0.69 msR3wR3w warm p50 0.51 msR3w cold p50 0.47 msR4R4 warm p50 0.51 msR4 cold p50 1.48 msR4wR4w warm p50 0.59 msR4w cold p50 0.65 msR5R5 warm p50 1.35 msR5 cold p50 2.00 msR5wR5w warm p50 1.58 msR5w cold p50 1.98 msR6R6 warm p50 0.22 msR6 cold p50 0.19 msR6wR6w warm p50 0.18 msR6w cold p50 0.22 msR7R7 warm p50 17.61 msR7 cold p50 16.30 msR7wR7w warm p50 17.47 msR7w cold p50 17.61 msS1S1 warm p50 11.12 msS1 cold p50 5.33 msS3S3 warm p50 4.42 msS3 cold p50 4.51 msJ4J4 warm p50 3.19 msJ4 cold p50 3.95 msO1O1 warm p50 1.01 msO1 cold p50 0.99 msO2O2 warm p50 0.99 msO2 cold p50 1.05 msO3O3 warm p50 1.14 msO3 cold p50 1.12 msW1W1 warm p50 1.16 msW1 cold p50 1.37 msW2W2 warm p50 0.46 msW2 cold p50 1.03 msW3W3 warm p50 20.88 msW3 cold p50 13.02 msU1U1 warm p50 0.84 msU1 cold p50 1.53 msU2U2 warm p50 1.16 msU2 cold p50 1.54 msD1D1 warm p50 0.84 msD1 cold p50 0.81 msD2D2 warm p50 11.71 msD2 cold p50 11.77 ms