forked from mtusi2026/mtusi2026lab2
TypeScript/Node API на PostgreSQL с сессиями в Valkey (AOF), миграции, compose-стенд, restart hook, тесты уровня 4 и эксперимент трека 2 (планы запроса на 240k сообщений, стоимость записи, backup/restore).
294 lines
16 KiB
Python
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()
|