Six durability experiments of 3 October 2026: results, raw output, the two prototypes, the runner
f8975ed verified | #!/usr/bin/env python3 | |
| """Run the six durability experiments on a Linux machine and write the raw results. | |
| run_experiments.py --go ./dspike-go --rust ./dspike-rust --tools ./tools --out ./results [--only 01,03] | |
| Each experiment has a pass bar, written here before it runs, and writes results/NN-name/result.json plus the | |
| raw output it judged. Nothing outside the scratch directory and the user's own systemd units is touched. | |
| Experiment 04 needs `yjob` and its unit template installed for the user (tools/yjob, tools/yjob@.service). | |
| These experiments kill processes. They do not cut the power: what survives a power cut depends on the | |
| file system and the drive as well, and is not measured here. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import os | |
| import platform | |
| import random | |
| import re | |
| import shutil | |
| import signal | |
| import sqlite3 | |
| import statistics | |
| import subprocess | |
| import sys | |
| import tempfile | |
| import time | |
| from pathlib import Path | |
| LANGS = ("go", "rust") | |
| WRITER = ''' | |
| import sqlite3, sys, time | |
| c = sqlite3.connect(sys.argv[1]); c.execute("PRAGMA journal_mode=WAL"); c.execute("create table if not exists t(x)") | |
| import os | |
| while not os.path.exists(sys.argv[2]): # until told to stop: about a hundred commits a second, so the file stays small | |
| c.executemany("insert into t values(?)", [(i,) for i in range(500)]); c.commit(); time.sleep(0.005) | |
| ''' | |
| def sh(cmd: list[str] | str, **kw) -> subprocess.CompletedProcess: | |
| return subprocess.run(cmd, shell=isinstance(cmd, str), capture_output=True, text=True, **kw) | |
| def save(out: Path, name: str, bar: str, verdict: str, data: dict, raw: dict[str, str] | None = None) -> None: | |
| d = out / name | |
| d.mkdir(parents=True, exist_ok=True) | |
| for fname, text in (raw or {}).items(): | |
| (d / fname).write_text(text) | |
| doc = {"experiment": name, "pass_bar": bar, "verdict": verdict, "ran": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), **data} | |
| (d / "result.json").write_text(json.dumps(doc, indent=1) + "\n") | |
| print(f"{name}: {verdict}") | |
| def calls(trace: str) -> list[str]: | |
| """The sync and rename calls of a strace file, in order, as short words.""" | |
| got = [] | |
| for line in trace.splitlines(): | |
| m = re.match(r"^\d+\s+(fsync|fdatasync|rename|renameat|renameat2)\(", line) | |
| if m: | |
| got.append("rename" if m.group(1).startswith("rename") else m.group(1)) | |
| return got | |
| # ---- 01 --------------------------------------------------------------------------------------------------- | |
| def exp01(bins: dict[str, str], work: Path, out: Path) -> None: | |
| bar = ("append: the file is synced (fsync or fdatasync) before the program exits. replace: the temporary file is " | |
| "synced, then renamed over the target, then the directory is synced, in that order. Both languages.") | |
| data, raw, ok = {}, {}, True | |
| for lang in LANGS: | |
| ta, tr = work / f"trace.{lang}.append", work / f"trace.{lang}.replace" | |
| sh(["strace", "-f", "-e", "trace=fsync,fdatasync,rename,renameat,renameat2", "-o", str(ta), bins[lang], "append", str(work / f"log.{lang}"), "a line"]) | |
| sh(["strace", "-f", "-e", "trace=fsync,fdatasync,rename,renameat,renameat2", "-o", str(tr), bins[lang], "replace", str(work / f"state.{lang}.json"), '{"v":1}']) | |
| a, r = calls(ta.read_text()), calls(tr.read_text()) | |
| good = bool(a) and a[-1] in ("fsync", "fdatasync") and r[-3:] == ["fsync", "rename", "fsync"] | |
| ok &= good | |
| data[lang] = {"append": a, "replace": r, "meets_bar": good} | |
| raw[f"strace-{lang}-append.txt"] = re.sub(str(work), "SCRATCH", ta.read_text()) | |
| raw[f"strace-{lang}-replace.txt"] = re.sub(str(work), "SCRATCH", tr.read_text()) | |
| save(out, "01-system-calls", bar, "pass" if ok else "fail", {"calls": data}, raw) | |
| # ---- 02 --------------------------------------------------------------------------------------------------- | |
| def judge_copy(path: Path) -> tuple[str, int]: | |
| try: | |
| c = sqlite3.connect(f"file:{path}?mode=ro", uri=True) | |
| if c.execute("PRAGMA integrity_check").fetchone()[0] != "ok": | |
| return "fails the integrity check", 0 | |
| n = c.execute("select count(*) from t").fetchone()[0] | |
| c.close() | |
| return ("whole" if n % 500 == 0 else "holds part of a transaction"), n | |
| except sqlite3.Error as e: | |
| return f"does not open ({str(e)[:40]})", 0 | |
| def exp02(bins: dict[str, str], work: Path, out: Path, rounds: int = 50) -> None: | |
| bar = (f"All {rounds} copies taken by each program while another process commits batches of 500 rows: open, pass " | |
| "integrity_check, and hold only whole batches; and the writer is alive and committing through every series. " | |
| "The two plain file copies are controls and have no bar.") | |
| live = work / "live.db" | |
| stop = work / "stop-writer" | |
| writer = subprocess.Popen([sys.executable, "-c", WRITER, str(live), str(stop)]) | |
| time.sleep(1.5) | |
| data: dict[str, dict] = {} | |
| ok = True | |
| def live_rows() -> int: | |
| c = sqlite3.connect(f"file:{live}?mode=ro", uri=True) | |
| n = c.execute("select count(*) from t").fetchone()[0] | |
| c.close() | |
| return n | |
| def series(name: str, make) -> None: | |
| nonlocal ok | |
| kinds: dict[str, int] = {} | |
| behind = [] | |
| first = live_rows() | |
| for i in range(rounds): | |
| before = live_rows() | |
| copy = work / f"copy.{name}.db" | |
| for f in (copy, Path(str(copy) + "-wal"), Path(str(copy) + "-shm")): | |
| f.unlink(missing_ok=True) | |
| make(copy) | |
| kind, n = judge_copy(copy) | |
| kinds[kind] = kinds.get(kind, 0) + 1 | |
| if kind == "whole": | |
| behind.append(max(0, before - n)) | |
| alive = writer.poll() is None | |
| ok &= alive # a series taken after the writer died proves nothing | |
| data[name] = {"copies": rounds, "outcomes": kinds, "writer_alive_throughout": alive, | |
| "rows_committed_during_the_series": live_rows() - first, | |
| "committed_rows_missing_from_whole_copies_median": int(statistics.median(behind)) if behind else None, | |
| "committed_rows_missing_max": max(behind) if behind else None} | |
| if name in LANGS: | |
| ok &= kinds == {"whole": rounds} | |
| for lang in LANGS: | |
| series(lang, lambda copy, b=bins[lang]: sh([b, "stage", str(live), str(copy)])) | |
| series("control-cp-main-file-only", lambda copy: shutil.copyfile(live, copy)) | |
| def cp_both(copy: Path) -> None: | |
| shutil.copyfile(live, copy) | |
| time.sleep(0.002) | |
| if Path(str(live) + "-wal").exists(): | |
| shutil.copyfile(str(live) + "-wal", str(copy) + "-wal") | |
| series("control-cp-main-file-then-log", cp_both) | |
| stop.write_text("stop") | |
| writer.wait(timeout=30) | |
| save(out, "02-copy-under-a-writer", bar, "pass" if ok else "fail", {"series": data, "rows_committed_at_the_end": live_rows()}) | |
| # ---- 03 --------------------------------------------------------------------------------------------------- | |
| def exp03(bins: dict[str, str], work: Path, out: Path, rounds: int = 500) -> None: | |
| bar = (f"In {rounds} rounds for each program, a replace of a 100 kB file killed with SIGKILL after a random delay never " | |
| "leaves the target missing, empty or half written: it always holds the old or the new content, whole. " | |
| "Temporary files left behind are counted, not judged. The in-place writer is a control and has no bar.") | |
| pad = "x" * 100_000 | |
| data: dict[str, dict] = {} | |
| ok = True | |
| rng = random.Random(20261003) | |
| def whole(path: Path) -> bool: | |
| try: | |
| return len(json.loads(path.read_text())["pad"]) == len(pad) | |
| except (OSError, ValueError, KeyError): | |
| return False | |
| for lang in LANGS: | |
| target = work / f"kill.{lang}.json" | |
| target.write_text(json.dumps({"v": 0, "pad": pad})) | |
| broken = finished = 0 | |
| for i in range(1, rounds + 1): | |
| p = subprocess.Popen([bins[lang], "replace", str(target), json.dumps({"v": i, "pad": pad})]) | |
| time.sleep(rng.uniform(0, 0.004)) | |
| p.kill() | |
| finished += p.wait() == 0 | |
| broken += not whole(target) | |
| left = len(list(work.glob(f"kill.{lang}.json.tmp*"))) | |
| data[lang] = {"rounds": rounds, "target_broken": broken, "replaces_that_finished_before_the_kill": finished, "temporary_files_left": left} | |
| ok &= broken == 0 | |
| # control: the same content written in place, synced but not atomic | |
| src, target = work / "payload.json", work / "kill.inplace.json" | |
| src.write_text(json.dumps({"v": 1, "pad": pad})) | |
| target.write_text(src.read_text()) | |
| broken = 0 | |
| for _ in range(rounds): | |
| p = subprocess.Popen(["dd", f"if={src}", f"of={target}", "bs=1024", "oflag=dsync", "status=none"]) | |
| time.sleep(rng.uniform(0, 0.02)) | |
| p.kill() | |
| p.wait() | |
| broken += not whole(target) | |
| if not whole(target): | |
| target.write_text(src.read_text()) | |
| data["control-write-in-place-with-sync"] = {"rounds": rounds, "target_broken": broken} | |
| save(out, "03-kill-during-replace", bar, "pass" if ok else "fail", {"series": data, "payload_bytes": len(pad)}) | |
| # ---- 04 --------------------------------------------------------------------------------------------------- | |
| def journal(unit: str, since: float) -> list[str]: | |
| r = sh(["journalctl", "--user", "-u", unit, "--since", f"@{int(since)}", "--no-pager", "-o", "json"]) | |
| lines = [] | |
| for raw in r.stdout.splitlines(): | |
| try: | |
| d = json.loads(raw) | |
| t = time.strftime("%H:%M:%S", time.gmtime(int(d["__REALTIME_TIMESTAMP"]) / 1e6)) | |
| lines.append(f"{t} {d.get('MESSAGE', '')}") | |
| except (ValueError, KeyError): | |
| continue | |
| return lines | |
| def exp04(work: Path, out: Path, yjob: str) -> None: | |
| bar = ("A job whose command fails on its first run is run again without anyone asking, finishes, and its unit is then " | |
| "disabled. A job that is stopped while running stays enabled, so the next boot starts it. A real power-off " | |
| "is not part of this run.") | |
| jobs = Path.home() / "runbook" / "jobs" | |
| started = time.time() | |
| script = work / "fails-once.sh" | |
| script.write_text(f"#!/usr/bin/env bash\nf={work}/count; n=$(( $(cat $f 2>/dev/null || echo 0) + 1 )); echo $n > $f\n" | |
| '[ $n -ge 2 ] || { echo "attempt $n: failing on purpose"; exit 7; }\necho "attempt $n: working"; sleep 3; echo "attempt $n: done"\n') | |
| script.chmod(0o755) | |
| a, b = "exp-fails-once", "exp-stopped" | |
| for n in (a, b): | |
| sh([yjob, "cancel", n]) | |
| sh([yjob, "add", "--quiet", a, "--", str(script)]) | |
| deadline = time.time() + 400 | |
| while (jobs / f"{a}.sh").exists() and time.time() < deadline: | |
| time.sleep(5) | |
| log_a = journal(f"yjob@{a}.service", started) | |
| finished = not (jobs / f"{a}.sh").exists() | |
| took = round(time.time() - started) | |
| enabled_after = sh(["systemctl", "--user", "is-enabled", f"yjob@{a}.service"]).stdout.strip() | |
| attempts = int((work / "count").read_text().strip()) if (work / "count").exists() else 0 | |
| long = work / "long.sh" | |
| long.write_text("#!/usr/bin/env bash\necho started; sleep 600\n") | |
| long.chmod(0o755) | |
| t2 = time.time() | |
| sh([yjob, "add", "--quiet", b, "--", str(long)]) | |
| time.sleep(3) | |
| sh(["systemctl", "--user", "stop", f"yjob@{b}.service"]) | |
| time.sleep(2) | |
| stopped_enabled = sh(["systemctl", "--user", "is-enabled", f"yjob@{b}.service"]).stdout.strip() | |
| stopped_active = sh(["systemctl", "--user", "is-active", f"yjob@{b}.service"]).stdout.strip() | |
| still_queued = (jobs / f"{b}.sh").exists() | |
| log_b = journal(f"yjob@{b}.service", t2) | |
| sh([yjob, "cancel", b]) | |
| ok = finished and attempts == 2 and enabled_after == "disabled" and stopped_enabled == "enabled" and still_queued | |
| save(out, "04-durable-job", bar, "pass" if ok else "fail", { | |
| "fails_once": {"attempts": attempts, "finished": finished, "unit_after_success": enabled_after, "seconds_until_finished": took, | |
| "retry_delay_of_the_unit_seconds": 120}, | |
| "stopped": {"unit_after_stop": stopped_enabled, "state_after_stop": stopped_active, "still_queued": still_queued}, | |
| "not_run": "a job continuing after a real power-off of the machine"}, | |
| {"journal-fails-once.txt": "\n".join(log_a) + "\n", "journal-stopped.txt": "\n".join(log_b) + "\n"}) | |
| # ---- 05 --------------------------------------------------------------------------------------------------- | |
| FAKE = ''' | |
| import http.server, sys, time | |
| T0 = time.time(); BUSY = float(sys.argv[2]) | |
| class H(http.server.BaseHTTPRequestHandler): | |
| def do_GET(self): | |
| n = 1 if time.time() - T0 < BUSY else 0 | |
| body = f"yllm_queue_depth {n}\\nyllm_slots_in_use {n}\\nyllm_embed_slots_in_use 0\\n".encode() | |
| self.send_response(200); self.send_header("Content-Length", str(len(body))); self.end_headers(); self.wfile.write(body) | |
| def log_message(self, *a): pass | |
| http.server.HTTPServer(("127.0.0.1", int(sys.argv[1])), H).serve_forever() | |
| ''' | |
| def exp05(work: Path, out: Path, steps: str) -> None: | |
| bar = ("drain: with a service that is busy for 7 s it returns within 3 s of the service becoming idle, exit 0; with a " | |
| "service still busy when the limit of 5 s passes it stops at the limit, exit 1; with no service answering it " | |
| "does not wait. checkpoint: after a writer exits without closing its database, the write-ahead log is " | |
| "emptied and every committed row is in the main file.") | |
| port = 18999 | |
| cases = {} | |
| def drain(busy: float | None, wait: int) -> dict: | |
| srv = subprocess.Popen([sys.executable, "-c", FAKE, str(port), str(busy)]) if busy is not None else None | |
| time.sleep(1.0) | |
| t = time.time() | |
| r = sh([steps, "drain"], env={**os.environ, "GATEWAY": f"http://127.0.0.1:{port}", "WAIT": str(wait)}) | |
| took = round(time.time() - t, 1) | |
| if srv: | |
| srv.kill() | |
| srv.wait() | |
| time.sleep(0.3) | |
| return {"exit": r.returncode, "seconds": took, "said": r.stdout.strip()} | |
| cases["busy 7 s then idle, limit 30 s"] = drain(7, 30) | |
| cases["busy past the limit of 5 s"] = drain(60, 5) | |
| cases["no service answering"] = drain(None, 5) | |
| db = work / "unclean.db" | |
| sh([sys.executable, "-c", f''' | |
| import sqlite3, os | |
| c = sqlite3.connect("{db}"); c.execute("PRAGMA journal_mode=WAL"); c.execute("PRAGMA wal_autocheckpoint=0") | |
| c.execute("create table t(x)"); c.executemany("insert into t values(?)", [(i,) for i in range(20000)]); c.commit() | |
| os._exit(0) | |
| ''']) | |
| wal_before = os.path.getsize(str(db) + "-wal") if os.path.exists(str(db) + "-wal") else 0 | |
| main_before = os.path.getsize(db) | |
| r = sh([steps, "checkpoint"], env={**os.environ, "GATEWAY": "http://127.0.0.1:1", "DBS": f"{db} {work}/missing.db"}) | |
| wal_after = os.path.getsize(str(db) + "-wal") if os.path.exists(str(db) + "-wal") else 0 | |
| rows = sqlite3.connect(db).execute("select count(*) from t").fetchone()[0] | |
| cp = {"log_bytes_before": wal_before, "log_bytes_after": wal_after, "main_file_bytes_before": main_before, | |
| "main_file_bytes_after": os.path.getsize(db), "rows": rows, "said": re.sub(str(work), "SCRATCH", r.stdout.strip())} | |
| c1, c2, c3 = cases.values() | |
| ok = (c1["exit"] == 0 and 5 <= c1["seconds"] <= 10 and c2["exit"] == 1 and 4 <= c2["seconds"] <= 9 and c3["exit"] == 0 | |
| and c3["seconds"] < 2 and wal_before > 0 and wal_after == 0 and rows == 20000) | |
| save(out, "05-drain-and-checkpoint", bar, "pass" if ok else "fail", {"drain": cases, "checkpoint": cp}) | |
| # ---- 06 --------------------------------------------------------------------------------------------------- | |
| def exp06(work: Path, out: Path, stage: str) -> None: | |
| bar = ("A copy of a database whose writer holds an uncommitted row and whose changes are all still in the log: holds " | |
| "every committed row and not the uncommitted one, and passes quick_check. A file that is not a database is " | |
| "reported, exit 1, and leaves no file behind, not even a temporary one. A missing database is skipped.") | |
| live = work / "staged-live.db" | |
| w = sqlite3.connect(live) | |
| w.execute("PRAGMA journal_mode=WAL") | |
| w.execute("PRAGMA wal_autocheckpoint=0") | |
| w.execute("create table t(x)") | |
| w.executemany("insert into t values(?)", [(i,) for i in range(5000)]) | |
| w.commit() | |
| w.execute("insert into t values(-1)") | |
| broken = work / "broken.db" | |
| broken.write_bytes(b"this is not a database, it only has the name" * 200) | |
| dest = work / "staged" | |
| r = sh([sys.executable, stage, str(dest), str(live), str(work / "missing.db"), str(broken)]) | |
| files = sorted(p.name for p in dest.iterdir()) | |
| copy = next((dest / f for f in files if f.endswith("staged-live.db")), None) | |
| rows = lowest = None | |
| check = "" | |
| if copy: | |
| c = sqlite3.connect(copy) | |
| rows, lowest = c.execute("select count(*), min(x) from t").fetchone() | |
| check = c.execute("PRAGMA quick_check").fetchone()[0] | |
| w.rollback() | |
| ok = r.returncode == 1 and len(files) == 1 and rows == 5000 and lowest == 0 and check == "ok" | |
| save(out, "06-consistent-sqlite-copy", bar, "pass" if ok else "fail", { | |
| "exit": r.returncode, "files_in_destination": len(files), "rows_in_copy": rows, "uncommitted_row_in_copy": lowest == -1, | |
| "quick_check": check, "log_bytes_of_the_live_database": os.path.getsize(str(live) + "-wal"), | |
| "reported": re.sub(str(work), "SCRATCH", r.stderr.strip())}) | |
| def environment(bins: dict[str, str]) -> dict: | |
| cpu = next((line.split(":", 1)[1].strip() for line in Path("/proc/cpuinfo").read_text().splitlines() if line.startswith("model name")), "") | |
| fs = sh("findmnt -no FSTYPE,OPTIONS -T .").stdout.strip() | |
| return {"kernel": platform.release(), "cpu": cpu, "file_system_of_the_scratch_directory": fs, "python_sqlite": sqlite3.sqlite_version, | |
| "systemd": sh("systemctl --version").stdout.splitlines()[0] if shutil.which("systemctl") else "", | |
| "binaries": {k: {"bytes": os.path.getsize(v)} for k, v in bins.items()}} | |
| def main() -> int: | |
| ap = argparse.ArgumentParser(description=(__doc__ or "").splitlines()[0]) | |
| ap.add_argument("--go", required=True) | |
| ap.add_argument("--rust", required=True) | |
| ap.add_argument("--tools", required=True) | |
| ap.add_argument("--out", required=True) | |
| ap.add_argument("--only", default="01,02,03,04,05,06") | |
| ap.add_argument("--yjob", default=str(Path.home() / "runbook/tools/yjob")) | |
| a = ap.parse_args() | |
| bins = {"go": os.path.abspath(a.go), "rust": os.path.abspath(a.rust)} | |
| out, tools = Path(a.out).resolve(), Path(a.tools).resolve() | |
| out.mkdir(parents=True, exist_ok=True) | |
| scratch_root = Path.home() / ".cache" | |
| scratch_root.mkdir(exist_ok=True) | |
| with tempfile.TemporaryDirectory(dir=scratch_root, prefix="durability-exp-") as tmp: | |
| work = Path(tmp) | |
| os.chdir(work) | |
| (out / "environment.json").write_text(json.dumps(environment(bins), indent=1) + "\n") | |
| only = set(a.only.split(",")) | |
| if "01" in only: | |
| exp01(bins, work, out) | |
| if "02" in only: | |
| exp02(bins, work, out) | |
| if "03" in only: | |
| exp03(bins, work, out) | |
| if "04" in only: | |
| exp04(work, out, a.yjob) | |
| if "05" in only: | |
| exp05(work, out, str(tools / "quiesce-steps.sh")) | |
| if "06" in only: | |
| exp06(work, out, str(tools / "sqlite-stage.py")) | |
| return 0 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |