Files
mtusi2026lab2/experiments/track2/run.py
T
celis cac37bddec ЛР 2 — БПИ2303 — Морару — на 5 (трек 2)
TypeScript/Node API на PostgreSQL с сессиями в Valkey (AOF), миграции,
compose-стенд, restart hook, тесты уровня 4 и эксперимент трека 2
(планы запроса на 240k сообщений, стоимость записи, backup/restore).
2026-10-29 20:58:56 +03:00

294 lines
16 KiB
Python

#!/usr/bin/env python3
"""Track 2: history query plans on >=100k messages, index write cost, backup -> restore -> reconcile.
Runs against the compose stack (service postgres). Changes ONLY the secondary indexes of `messages`
during the experiment and always ends with the migration index. Adds synthetic track2_* data once.
python3 experiments/track2/run.py # results -> evidence/track2/
python3 experiments/track2/run.py --render # rebuild results.md from results.json
"""
import json
import re
import secrets
import statistics
import subprocess
import sys
import threading
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
OUT = ROOT / 'evidence' / 'track2'
IMAGE = 'postgres:17.6-alpine3.22'
PSQL = ['psql', '-U', 'messenger', '-X', '-q', '-At', '-v', 'ON_ERROR_STOP=1']
SRC = ['docker', 'compose', 'exec', '-T', 'postgres']
RESTORE = 'messenger-track2-restore'
RUNS = 5
VARIANTS = { # secondary index of messages; PK(id) is always there
'V0 PK only': None,
'V1 (chat_id)': 'CREATE INDEX exp_idx ON messages (chat_id)',
'V2 (chat_id, created_at)': 'CREATE INDEX exp_idx ON messages (chat_id, created_at)',
'V3 (chat_id, created_at, id)': 'CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id)',
}
COLS = 'SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = {chat} '
QUERIES = {
# the API query (pg sends it as an unnamed prepared statement -> custom plan with these values)
'first page (API)': COLS + "AND (created_at, id) > ('-infinity'::timestamptz, '00000000-0000-0000-0000-000000000000'::uuid) "
'ORDER BY created_at, id LIMIT 51',
'middle page keyset (API)': COLS + 'AND (created_at, id) > ({ts}::timestamptz, {id}::uuid) ORDER BY created_at, id LIMIT 51',
'middle page keyset + created_at >=': COLS + 'AND created_at >= {ts}::timestamptz '
'AND (created_at, id) > ({ts}::timestamptz, {id}::uuid) ORDER BY created_at, id LIMIT 51',
'middle page OFFSET': COLS + 'ORDER BY created_at, id OFFSET {offset} LIMIT 51',
}
PGBENCH = ("\\set k random(1, 300)\n"
"INSERT INTO messages (chat_id, sender_id, text) SELECT chat_id, sender_id, 'bench' FROM track2_pairs WHERE k = :k;\n")
BULK = ("INSERT INTO messages (chat_id, sender_id, text) SELECT p.chat_id, p.sender_id, 'bench' "
'FROM generate_series(1, 50000) g JOIN track2_pairs p ON p.k = 1 + g % 300;')
FINGERPRINT = """SET TimeZone = 'UTC';
SELECT 'users', count(*), md5(string_agg(id::text || username || display_name || password_hash || created_at::text, ',' ORDER BY id)) FROM users
UNION ALL SELECT 'chats', count(*), md5(string_agg(id::text || title || created_at::text, ',' ORDER BY id)) FROM chats
UNION ALL SELECT 'chat_members', count(*), md5(string_agg(chat_id::text || user_id::text, ',' ORDER BY chat_id, user_id)) FROM chat_members
UNION ALL SELECT 'messages', count(*), md5(string_agg(id::text || chat_id::text || sender_id::text || md5(text) || created_at::text, ',' ORDER BY id))
FROM messages WHERE text <> 'during-dump'
UNION ALL SELECT 'schema_migrations', count(*), md5(string_agg(version, ',' ORDER BY version)) FROM schema_migrations;
SELECT 'sample', id, chat_id, sender_id, md5(text), created_at FROM messages WHERE text <> 'during-dump' ORDER BY md5(id::text) LIMIT 20;
"""
def run(cmd, stdin=None):
return subprocess.run(cmd, cwd=ROOT, input=stdin, capture_output=True, text=True, check=True).stdout
def sql(query, prefix=SRC, db='messenger'):
return run(prefix + PSQL + ['-d', db], stdin=query).strip()
def lit(value):
return "'" + str(value).replace("'", "''") + "'"
def shape(node):
name = node['Node Type'] + (' ' + node['Index Name'] if 'Index Name' in node else '')
kids = node.get('Plans', [])
return name + (' > ' + ' + '.join(shape(k) for k in kids) if kids else '')
def rows_touched(node):
"""Rows read by scan nodes (returned + filtered out); per-loop figures times loops."""
own = 0
if 'Scan' in node['Node Type'] and node['Node Type'] != 'Bitmap Index Scan':
own = (node['Actual Rows'] + node.get('Rows Removed by Filter', 0)
+ node.get('Rows Removed by Index Recheck', 0)) * node['Actual Loops']
return round(own + sum(rows_touched(k) for k in node.get('Plans', [])))
def explain(query, prefix=SRC):
times = []
for _ in range(RUNS):
plan = json.loads(sql('EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ' + query, prefix))[0]
times.append(plan['Execution Time'])
top = plan['Plan']
return {'median_ms': round(statistics.median(times), 3), 'min_ms': round(min(times), 3),
'buffers': top['Shared Hit Blocks'] + top['Shared Read Blocks'], 'rows_touched': rows_touched(top),
'plan': shape(top)}
def set_variant(ddl):
sql('DROP INDEX IF EXISTS exp_idx, messages_chat_created_id_idx;')
if ddl is None:
return 0.0, 0
started = time.monotonic()
sql(ddl + ';')
build = time.monotonic() - started
sql('ANALYZE messages;')
name = 'messages_chat_created_id_idx' if 'messages_chat_created_id_idx' in ddl else 'exp_idx'
return round(build, 3), int(sql("SELECT pg_relation_size('%s')" % name))
def cleanup_bench():
sql("DELETE FROM messages WHERE text = 'bench'; VACUUM ANALYZE messages;")
def write_cost():
bulk = []
for _ in range(3):
out = sql('\\timing on\n' + BULK)
bulk.append(float(re.search(r'Time: ([0-9.]+) ms', out).group(1)))
cleanup_bench()
tps, latency = [], []
run(SRC + ['sh', '-c', 'cat > /tmp/track2_insert.sql'], stdin=PGBENCH)
for _ in range(3):
out = run(SRC + ['pgbench', '-n', '-U', 'messenger', '-d', 'messenger', '-f', '/tmp/track2_insert.sql',
'-T', '10', '-c', '8', '-j', '4'])
tps.append(float(re.search(r'tps = ([0-9.]+)', out).group(1)))
latency.append(float(re.search(r'latency average = ([0-9.]+) ms', out).group(1)))
cleanup_bench()
return {'bulk_50k_ms_median': round(statistics.median(bulk), 1), 'bulk_50k_ms': bulk,
'pgbench_tps_median': round(statistics.median(tps), 1), 'pgbench_tps': tps,
'pgbench_latency_ms_median': round(statistics.median(latency), 3)}
def dataset():
if sql("SELECT count(*) FROM chats WHERE title = 'track2-1'") == '0':
started = time.monotonic()
sql((Path(__file__).parent / 'generate.sql').read_text())
print('generated dataset in %.1fs' % (time.monotonic() - started), flush=True)
sizes = [int(x) for x in sql("SELECT count(*) FROM messages m JOIN chats c ON c.id = m.chat_id "
"WHERE c.title LIKE 'track2-%' GROUP BY c.id ORDER BY 1 DESC").split()]
return {'messages_total': int(sql('SELECT count(*) FROM messages')), 'track2_chats': len(sizes),
'chat_size_max': sizes[0], 'chat_size_p50': sizes[len(sizes) // 2], 'chat_size_min': sizes[-1],
'top10_share': round(sum(sizes[:10]) / sum(sizes), 3),
'messages_table_bytes': int(sql("SELECT pg_table_size('messages')")),
'pk_index_bytes': int(sql("SELECT pg_relation_size('messages_pkey')"))}
def targets():
out = {}
for label, k in (('large', 1), ('medium', 30), ('small', 300)):
chat, size = sql("SELECT c.id, count(*) FROM chats c JOIN messages m ON m.chat_id = c.id "
"WHERE c.title = 'track2-%d' GROUP BY c.id" % k).split('|')
ts, mid = sql("SELECT created_at, id FROM messages WHERE chat_id = '%s' ORDER BY created_at, id "
"OFFSET %d LIMIT 1" % (chat, int(size) // 2)).split('|')
out[label] = {'chat': lit(chat), 'ts': lit(ts), 'id': lit(mid), 'offset': int(size) // 2, 'size': int(size)}
return out
def plans_and_writes(chats):
results = {}
for variant, ddl in VARIANTS.items(): # V3 last: the database ends in the migration state
build_s, index_bytes = set_variant(ddl)
row = {'index_build_s': build_s, 'index_bytes': index_bytes, 'queries': {}}
for qname, template in QUERIES.items():
for label, t in chats.items():
row['queries'][qname + ' / ' + label] = explain(template.format(**t))
row['write'] = write_cost()
results[variant] = row
print('done', variant, flush=True)
# human-readable plan of the API query on the largest chat for every variant
text = sql('EXPLAIN (ANALYZE, BUFFERS) ' + QUERIES['middle page keyset (API)'].format(**chats['large']))
(OUT / ('explain_api_middle_page_%s.txt' % variant.split()[0])).write_text(text + '\n')
return results
def wait_restore_ready():
deadline = time.monotonic() + 120
while True:
logs = subprocess.run(['docker', 'logs', RESTORE], capture_output=True, text=True)
ready = subprocess.run(['docker', 'exec', RESTORE, 'pg_isready', '-U', 'messenger', '-d', 'messenger'],
capture_output=True).returncode == 0
if ready and 'PostgreSQL init process complete' in logs.stdout + logs.stderr:
return
if time.monotonic() > deadline:
raise SystemExit('restore container did not initialise')
time.sleep(0.5)
def backup_restore(chats):
dump = ROOT / 'backups' / 'track2.dump'
dump.parent.mkdir(exist_ok=True)
before = int(sql('SELECT count(*) FROM messages'))
stop, written = threading.Event(), [0]
def writer(): # commits that race with pg_dump: show the data-loss boundary of a logical dump
while not stop.is_set():
sql("INSERT INTO messages (chat_id, sender_id, text) SELECT chat_id, sender_id, 'during-dump' FROM track2_pairs WHERE k = 1;")
written[0] += 1
started = time.monotonic()
with dump.open('wb') as f:
proc = subprocess.Popen(SRC + ['pg_dump', '-U', 'messenger', '-d', 'messenger', '-Fc'], cwd=ROOT, stdout=f)
thread = threading.Thread(target=writer)
thread.start()
code = proc.wait()
dump_s = time.monotonic() - started
stop.set()
thread.join()
assert code == 0, 'pg_dump failed'
subprocess.run(['docker', 'rm', '-f', RESTORE], capture_output=True)
subprocess.run(['docker', 'volume', 'rm', RESTORE + '-data'], capture_output=True)
# new storage: fresh container + fresh named volume, no network at all
run(['docker', 'run', '-d', '--name', RESTORE, '--network', 'none', '-v', RESTORE + '-data:/var/lib/postgresql/data',
'-e', 'POSTGRES_USER=messenger', '-e', 'POSTGRES_DB=messenger', '-e', 'POSTGRES_PASSWORD=' + secrets.token_urlsafe(18),
IMAGE])
wait_restore_ready()
run(['docker', 'cp', str(dump), RESTORE + ':/tmp/track2.dump'])
target = ['docker', 'exec', '-i', RESTORE]
restore_s = {}
for jobs, db in ((1, 'restore_j1'), (4, 'messenger')):
if db != 'messenger':
run(target + ['createdb', '-U', 'messenger', db])
t0 = time.monotonic()
run(target + ['pg_restore', '-U', 'messenger', '-d', db, '--no-owner', '-j', str(jobs), '/tmp/track2.dump'])
restore_s['jobs_%d' % jobs] = round(time.monotonic() - t0, 2)
src_fp, dst_fp = sql(FINGERPRINT), sql(FINGERPRINT, target)
t = chats['large']
page = QUERIES['middle page keyset (API)'].format(**t)
src_page, dst_page = sql(page), sql(page, target)
return {
'dump_bytes': dump.stat().st_size, 'dump_s': round(dump_s, 2), 'restore_s': restore_s,
'messages_before_dump': before, 'during_dump_committed_in_source': written[0],
'during_dump_in_restore': int(sql("SELECT count(*) FROM messages WHERE text = 'during-dump'", target)),
'fingerprint_equal': src_fp == dst_fp, 'api_page_equal': src_page == dst_page and src_page.count('\n') == 50,
'fingerprint': [line.split('|') for line in dst_fp.splitlines() if not line.startswith('sample')],
'restored_plan_middle_page_large': explain(page, target)['plan'],
}
def render(r):
names = list(r['variants'])
lines = ['# Track 2 results', '', 'Generated by experiments/track2/run.py from results.json. Environment: %s; PostgreSQL %s, '
'shared_buffers %s, synchronous_commit %s.' % (r['env']['docker'], r['env']['postgres'], r['env']['shared_buffers'],
r['env']['synchronous_commit']),
'', 'Dataset: %(messages_total)d messages, %(track2_chats)d synthetic chats, sizes max %(chat_size_max)d / '
'median %(chat_size_p50)d / min %(chat_size_min)d, top-10 chats hold %(top10_share)s of track2 messages, '
'table %(messages_table_bytes)d B.' % r['dataset'], '',
'## Read: median ms of %d EXPLAIN ANALYZE runs / shared buffers / rows read by scans' % RUNS, '',
'| query / chat | ' + ' | '.join(names) + ' |', '|---' * (len(names) + 1) + '|']
for q in r['variants'][names[0]]['queries']:
cells = ['%.2f / %d / %d' % (v['queries'][q]['median_ms'], v['queries'][q]['buffers'], v['queries'][q]['rows_touched'])
for v in r['variants'].values()]
lines.append('| ' + q + ' | ' + ' | '.join(cells) + ' |')
lines += ['', 'Plans of the API query (middle page, large chat):', '']
lines += ['- %s: `%s`' % (n, v['queries']['middle page keyset (API) / large']['plan']) for n, v in r['variants'].items()]
lines += ['', '## Write cost', '', '| variant | index size, MiB | build, s | bulk 50k INSERT, ms (median of 3) | '
'pgbench 1-row INSERT, TPS (median of 3x10 s, 8 clients) | avg latency, ms |', '|---|---|---|---|---|---|']
for n, v in r['variants'].items():
w = v['write']
lines.append('| %s | %.1f | %.2f | %.0f | %.0f | %.3f |' % (n, v['index_bytes'] / 2 ** 20, v['index_build_s'],
w['bulk_50k_ms_median'], w['pgbench_tps_median'], w['pgbench_latency_ms_median']))
b = r['backup_restore']
lines += ['', '## Backup -> restore into new storage -> reconcile', '',
'- pg_dump -Fc: %.2f s, %d B; pg_restore into a new container + new volume: %s' % (b['dump_s'], b['dump_bytes'], b['restore_s']),
'- fingerprints (count + md5 of every table, 20 sampled messages) equal: %s; API page of the large chat equal: %s'
% (b['fingerprint_equal'], b['api_page_equal']),
'- writes committed during pg_dump: %d in source, %d in restore' % (b['during_dump_committed_in_source'], b['during_dump_in_restore']),
'- restored plan of the API query: `%s`' % b['restored_plan_middle_page_large'], '',
'| table | rows | md5 |', '|---|---|---|']
lines += ['| %s | %s | %s |' % tuple(f) for f in b['fingerprint']]
(OUT / 'results.md').write_text('\n'.join(lines) + '\n')
def main():
OUT.mkdir(parents=True, exist_ok=True)
if sys.argv[1:] == ['--render']:
return render(json.loads((OUT / 'results.json').read_text()))
env = {'postgres': sql('SHOW server_version'), 'shared_buffers': sql('SHOW shared_buffers'),
'synchronous_commit': sql('SHOW synchronous_commit'),
'docker': run(['docker', 'info', '--format', '{{.OperatingSystem}}, {{.NCPU}} CPU, {{.MemTotal}} B RAM']).strip()}
data = dataset()
print(json.dumps(data), flush=True)
chats = targets()
results = {'env': env, 'dataset': data, 'chats': {k: {'size': v['size'], 'offset': v['offset']} for k, v in chats.items()},
'variants': plans_and_writes(chats)}
results['backup_restore'] = backup_restore(chats)
(OUT / 'results.json').write_text(json.dumps(results, ensure_ascii=False, indent=2) + '\n')
render(results)
print(json.dumps(results['backup_restore'], ensure_ascii=False, indent=2))
run(['docker', 'rm', '-f', RESTORE]) # throwaway restore target; its volume stays for inspection
if __name__ == '__main__':
main()