From 7d5cf130a85c4b9ecaf345f9fe6b4667ec7f6275 Mon Sep 17 00:00:00 2001 From: codeasier Date: Fri, 31 Jul 2026 00:10:49 +0800 Subject: [PATCH 01/12] bench: add snapshot import baseline harness --- .gitignore | 3 + benchmarks/baseline_import.py | 314 ++++++++++++++++++++++++++++++++++ 2 files changed, 317 insertions(+) create mode 100644 benchmarks/baseline_import.py diff --git a/.gitignore b/.gitignore index ebcf5b4..5c6962c 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,4 @@ **/superpowers/ + +# Sensitive test data - do not commit +tests/fixtures/snapshots/*.pickle diff --git a/benchmarks/baseline_import.py b/benchmarks/baseline_import.py new file mode 100644 index 0000000..6aac86d --- /dev/null +++ b/benchmarks/baseline_import.py @@ -0,0 +1,314 @@ +"""Baseline import performance benchmark for Issue #74. + +Accepted source: + .claude/worktrees/issue-74-import-performance/benchmarks/baseline_import.py +Accepted source SHA256: + d229e7fdf672d86e5c4f25c0ed8cd41ef94ffe708e7998e4fdcee9cab8d4fb23 + +Run from the worktree root: + PYTHONPATH=src python benchmarks/baseline_import.py +""" + +from __future__ import annotations + +import cProfile +import io +import json +import logging +import os +import pstats +import re +import sqlite3 +import statistics +import subprocess +import sys +import tempfile +from dataclasses import dataclass, field +from pathlib import Path + +FIXTURES = Path("tests/fixtures/snapshots") + +SAMPLES = { + "8k": FIXTURES / "snapshot_with_multi_devices.pkl", + "131k": FIXTURES / "snapshot_16k_94layers.pickle", + "628k": FIXTURES / "memory0.pickle", +} + +DEVICE = 0 + + +@dataclass +class RunResult: + wall_s: float + user_s: float + sys_s: float + max_rss_mb: float + db_size_mb: float + + +@dataclass +class SampleReport: + name: str + path: Path + formal_runs: int = 0 + runs: list[RunResult] = field(default_factory=list) + + @property + def median_wall(self) -> float: + return statistics.median(r.wall_s for r in self.runs) + + def format_table(self) -> str: + lines = [ + f"### {self.name} ({self.path.name})", + "", + f"正式测量 {self.formal_runs} 次,另有 1 次 warmup", + "", + "| Run | Wall (s) | User (s) | Sys (s) | Max RSS (MB) | DB (MB) |", + "|-----|----------|----------|---------|--------------|---------|", + ] + for i, r in enumerate(self.runs, 1): + lines.append( + f"| {i} | {r.wall_s:.3f} | {r.user_s:.3f} | {r.sys_s:.3f} " + f"| {r.max_rss_mb:.1f} | {r.db_size_mb:.1f} |" + ) + if self.runs: + lines.append(f"\n**Median wall time**: {self.median_wall:.3f}s") + return "\n".join(lines) + + +def _parse_time_output(stderr: str) -> dict[str, float]: + wall_match = re.search(r"(\d+\.\d+) real", stderr) + user_match = re.search(r"(\d+\.\d+) user", stderr) + sys_match = re.search(r"(\d+\.\d+) sys", stderr) + rss_match = re.search(r"(\d+)\s+maximum resident set size", stderr) + + return { + "wall_s": float(wall_match.group(1)) if wall_match else 0.0, + "user_s": float(user_match.group(1)) if user_match else 0.0, + "sys_s": float(sys_match.group(1)) if sys_match else 0.0, + "max_rss_bytes": int(rss_match.group(1)) if rss_match else 0, + } + + +def _run_import_once(snapshot: Path, output_dir: Path, device: int) -> RunResult: + env = {**os.environ, "PYTHONPATH": "src"} + result = subprocess.run( + [ + "/usr/bin/time", + "-l", + sys.executable, + "-c", + f""" +import logging; logging.disable(logging.CRITICAL) +from pt_snap_cli.core.import_service import ImportOptions, ImportService +from pathlib import Path +options = ImportOptions( + snapshot_file=Path({str(snapshot)!r}), + output_dir=Path({str(output_dir)!r}), + device={device}, + set_focus=False, + force=True, +) +ImportService().import_snapshot(options) +""", + ], + capture_output=True, + text=True, + env=env, + ) + + if result.returncode != 0: + print(f"STDOUT: {result.stdout}", file=sys.stderr) + print(f"STDERR: {result.stderr}", file=sys.stderr) + raise RuntimeError(f"import failed: {result.returncode}") + + metrics = _parse_time_output(result.stderr) + + db_files = list(output_dir.glob("*.db")) + db_size = sum(f.stat().st_size for f in db_files) if db_files else 0 + + return RunResult( + wall_s=metrics["wall_s"], + user_s=metrics["user_s"], + sys_s=metrics["sys_s"], + max_rss_mb=metrics["max_rss_bytes"] / (1024 * 1024), + db_size_mb=db_size / (1024 * 1024), + ) + + +def _representative_queries(db_path: Path, device: int) -> dict: + """Stable representative summaries (not exact query-template output). + + Event queries use ORDER BY DESC, id ASC so ties resolve + deterministically for before/after comparison. + """ + conn = sqlite3.connect(str(db_path)) + results: dict[str, str] = {} + + peak = conn.execute(f""" + SELECT id, action, allocated, active, reserved + FROM trace_entry_{device} + ORDER BY allocated DESC, id ASC + LIMIT 1 + """).fetchone() + if peak: + results["memory_peak"] = ( + f"id={peak[0]} action={peak[1]} allocated={peak[2]} " + f"active={peak[3]} reserved={peak[4]}" + ) + + gap = conn.execute(f""" + SELECT id, action, allocated, active, reserved, + CAST(reserved AS INTEGER) - CAST(allocated AS INTEGER) AS gap + FROM trace_entry_{device} + ORDER BY gap DESC, id ASC + LIMIT 1 + """).fetchone() + if gap: + results["allocator_gap"] = ( + f"id={gap[0]} action={gap[1]} allocated={gap[2]} " + f"active={gap[3]} reserved={gap[4]} gap={gap[5]}" + ) + + block_count = conn.execute(f""" + SELECT COUNT(*), SUM(size), MAX(size), AVG(size) + FROM block_{device} + """).fetchone() + if block_count: + results["block_summary"] = ( + f"count={block_count[0]} total_size={block_count[1]} " + f"max_size={block_count[2]} avg_size={block_count[3]:.0f}" + ) + + conn.close() + return results + + +def _correctness_summary(output_dir: Path, device: int) -> dict: + db_files = list(output_dir.glob("*.db")) + if not db_files: + return {"error": "no db found"} + db_path = db_files[0] + conn = sqlite3.connect(str(db_path)) + + quick_check = conn.execute("PRAGMA quick_check").fetchone()[0] + + trace_count = conn.execute(f"SELECT COUNT(*) FROM trace_entry_{device}").fetchone()[0] + block_count = conn.execute(f"SELECT COUNT(*) FROM block_{device}").fetchone()[0] + + max_alloc = conn.execute(f"SELECT MAX(allocated) FROM trace_entry_{device}").fetchone()[0] + max_active = conn.execute(f"SELECT MAX(active) FROM trace_entry_{device}").fetchone()[0] + max_reserved = conn.execute(f"SELECT MAX(reserved) FROM trace_entry_{device}").fetchone()[0] + + conn.close() + + summary = { + "quick_check": quick_check, + "trace_rows": trace_count, + "block_rows": block_count, + "max_allocated": max_alloc, + "max_active": max_active, + "max_reserved": max_reserved, + "db_file": db_path.name, + } + + queries = _representative_queries(db_path, device) + summary["representative_queries"] = queries + + return summary + + +def _profile_import(snapshot: Path, output_dir: Path, device: int, top_n: int = 20) -> str: + from pt_snap_cli.core.import_service import ImportOptions, ImportService + + service = ImportService() + options = ImportOptions( + snapshot_file=snapshot, + output_dir=output_dir, + device=device, + set_focus=False, + force=True, + ) + + profiler = cProfile.Profile() + profiler.enable() + service.import_snapshot(options) + profiler.disable() + + stream = io.StringIO() + stats = pstats.Stats(profiler, stream=stream) + stats.sort_stats("cumulative") + stats.print_stats(top_n) + return stream.getvalue() + + +def main() -> None: + import argparse + + logging.getLogger("pt_snap_cli.vendor").setLevel(logging.ERROR) + + parser = argparse.ArgumentParser() + parser.add_argument("--samples", nargs="+", default=["131k", "628k"]) + parser.add_argument("--runs-131k", type=int, default=5) + parser.add_argument("--runs-628k", type=int, default=3) + parser.add_argument("--runs-8k", type=int, default=5) + parser.add_argument("--skip-profile", action="store_true") + parser.add_argument("--skip-correctness", action="store_true") + args = parser.parse_args() + + run_counts = {"8k": args.runs_8k, "131k": args.runs_131k, "628k": args.runs_628k} + reports: list[SampleReport] = [] + + for name in args.samples: + if name not in SAMPLES: + print(f"Unknown sample: {name}", file=sys.stderr) + continue + + snapshot = SAMPLES[name] + if not snapshot.exists(): + print(f"Missing fixture: {snapshot}", file=sys.stderr) + continue + + n_runs = run_counts.get(name, 3) + report = SampleReport(name=name, path=snapshot, formal_runs=n_runs) + + print(f"\n{'='*60}") + print(f"Sample: {name} ({snapshot.name})") + print(f"{'='*60}") + + print(" Warmup run...") + with tempfile.TemporaryDirectory(prefix=f"baseline_{name}_warmup_") as tmp: + _run_import_once(snapshot, Path(tmp), DEVICE) + + for i in range(n_runs): + with tempfile.TemporaryDirectory(prefix=f"baseline_{name}_run{i}_") as tmp: + tmp_path = Path(tmp) + result = _run_import_once(snapshot, tmp_path, DEVICE) + report.runs.append(result) + print( + f" Run {i+1}/{n_runs}: wall={result.wall_s:.3f}s " + f"rss={result.max_rss_mb:.1f}MB db={result.db_size_mb:.1f}MB" + ) + + if i == 0 and not args.skip_correctness: + summary = _correctness_summary(tmp_path, DEVICE) + print(f" Correctness: {json.dumps(summary, indent=2, default=str)}") + + if not args.skip_profile: + print(f"\n cProfile ({name}):") + with tempfile.TemporaryDirectory(prefix=f"baseline_{name}_profile_") as tmp: + profile_output = _profile_import(snapshot, Path(tmp), DEVICE) + print(profile_output) + + reports.append(report) + + print("\n" + "=" * 60) + print("SUMMARY") + print("=" * 60) + for report in reports: + print(report.format_table()) + print() + + +if __name__ == "__main__": + main() From 6e6d26c45ccc2e4d3680c53a31ceb400dc432e78 Mon Sep 17 00:00:00 2001 From: codeasier Date: Fri, 31 Jul 2026 00:11:51 +0800 Subject: [PATCH 02/12] chore: ignore local worktrees --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 5c6962c..98565f2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ **/superpowers/ +.claude/worktrees/ # Sensitive test data - do not commit tests/fixtures/snapshots/*.pickle From d84ad529a1a574716514199d30b1872a00fa958c Mon Sep 17 00:00:00 2001 From: codeasier Date: Fri, 31 Jul 2026 00:47:20 +0800 Subject: [PATCH 03/12] test: establish snapshot runtime migration baseline --- docs/legal/memsnapdump-mit-relicensing.md | 80 ++++ .../snapshot_1768383987920985470.pkl | Bin 0 -> 573970 bytes .../snapshots/snapshot_expandable.pkl | Bin 0 -> 581140 bytes .../snapshot_with_empty_cache_expandable.pkl | Bin 0 -> 614145 bytes tests/snapshot/__init__.py | 1 + tests/snapshot/golden_observations.py | 157 +++++++ tests/snapshot/helpers.py | 42 ++ .../test_allocator_hook_dispatcher.py | 99 +++++ tests/snapshot/test_entities.py | 393 ++++++++++++++++++ tests/snapshot/test_entity2record.py | 99 +++++ tests/snapshot/test_file_util.py | 50 +++ tests/snapshot/test_logger.py | 100 +++++ tests/snapshot/test_replay_executor.py | 127 ++++++ tests/snapshot/test_simulate.py | 261 ++++++++++++ tests/snapshot/test_snapshot2db_runtime.py | 195 +++++++++ tests/snapshot/test_snapshot_lookup.py | 145 +++++++ tests/snapshot/test_snapshot_mutator.py | 289 +++++++++++++ tests/snapshot/test_sqlite_meta.py | 213 ++++++++++ tests/snapshot/test_timer.py | 38 ++ 19 files changed, 2289 insertions(+) create mode 100644 docs/legal/memsnapdump-mit-relicensing.md create mode 100755 tests/fixtures/snapshots/snapshot_1768383987920985470.pkl create mode 100755 tests/fixtures/snapshots/snapshot_expandable.pkl create mode 100644 tests/fixtures/snapshots/snapshot_with_empty_cache_expandable.pkl create mode 100644 tests/snapshot/__init__.py create mode 100644 tests/snapshot/golden_observations.py create mode 100644 tests/snapshot/helpers.py create mode 100644 tests/snapshot/test_allocator_hook_dispatcher.py create mode 100644 tests/snapshot/test_entities.py create mode 100644 tests/snapshot/test_entity2record.py create mode 100644 tests/snapshot/test_file_util.py create mode 100644 tests/snapshot/test_logger.py create mode 100644 tests/snapshot/test_replay_executor.py create mode 100644 tests/snapshot/test_simulate.py create mode 100644 tests/snapshot/test_snapshot2db_runtime.py create mode 100644 tests/snapshot/test_snapshot_lookup.py create mode 100644 tests/snapshot/test_snapshot_mutator.py create mode 100644 tests/snapshot/test_sqlite_meta.py create mode 100644 tests/snapshot/test_timer.py diff --git a/docs/legal/memsnapdump-mit-relicensing.md b/docs/legal/memsnapdump-mit-relicensing.md new file mode 100644 index 0000000..00d280e --- /dev/null +++ b/docs/legal/memsnapdump-mit-relicensing.md @@ -0,0 +1,80 @@ +# MemSnapDump MIT Relicensing Declaration + +## Scope + +This record covers all MemSnapDump code through and including upstream commit +`87ea207372e0985790e1a28dab499dccf3c3b9a4` (`v0.1.0`) in +. + +## Rights-holder confirmation + +On 2026-07-31, Liu Yekang, who publishes MemSnapDump as `codeasier` using +`liuyekang@huawei.com`, explicitly confirmed all of the following in this +execution: + +1. Liu Yekang is the sole author and copyright owner of all MemSnapDump code in + the scope above. +2. The scoped code contains no unaccounted copied code and no code contributed + by a third party. +3. Liu Yekang grants the scoped MemSnapDump code to this pt-snap-cli integration + under the MIT License. + +This declaration was explicitly confirmed by the rights holder in this +execution. The agent recorded that confirmation; the agent did not author the +declaration, does not claim to be the rights holder, and does not supply or +invent a signature. + +The applicable MIT terms are preserved in +`src/pt_snap_cli/vendor/memsnapdump/LICENSE`. This record does not reproduce the +standard license text or represent an additional signature. + +## Corroborating repository evidence + +The pinned audit checkout was inspected on 2026-07-31. Its Git evidence is: + +```text +$ git remote -v +origin https://github.com/codeasier/MemSnapDump.git (fetch) +origin https://github.com/codeasier/MemSnapDump.git (push) + +$ git rev-parse HEAD +87ea207372e0985790e1a28dab499dccf3c3b9a4 + +$ git tag --points-at HEAD +v0.1.0 + +$ git rev-list --count --all +83 + +$ git shortlog -sne --all +83 codeasier + +$ git log --all --format='%aN <%aE>' | LC_ALL=C sort | uniq -c +83 codeasier +``` + +The shortlog and full author audit each report the same single author identity +for all 83 commits. Git history corroborates the declaration but does not +replace the rights holder's explicit confirmation above. + +## Reproduction boundary + +The completed audit used the pinned checkout at: + +```text +/var/folders/44/mmqfw4_j1mq02hggc798tfy80000gn/T/opencode/memsnapdump-audit-20260731 +``` + +Commands in this record are intended to run from that checkout. The checkout +had 84 tracked files. A deterministic tracked-tree manifest hash was produced +with: + +```sh +git ls-files -z | LC_ALL=C sort -z | xargs -0 shasum -a 256 | shasum -a 256 +``` + +Result: + +```text +626e2d5afc6dd0ef908dcccb0ab61c6804938418d65a50fe436f5e6dee797f65 - +``` diff --git a/tests/fixtures/snapshots/snapshot_1768383987920985470.pkl b/tests/fixtures/snapshots/snapshot_1768383987920985470.pkl new file mode 100755 index 0000000000000000000000000000000000000000..5648541e975f3ba7841aa5cbc6bab23b4c32046a GIT binary patch literal 573970 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/snapshots/snapshot_expandable.pkl b/tests/fixtures/snapshots/snapshot_expandable.pkl new file mode 100755 index 0000000000000000000000000000000000000000..cf9c16e44aeafccfb45958b948a7d1696aee9c51 GIT binary patch literal 581140 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

$thaL}ya{G*)=FWp)TCds1$zNY( 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 F{6DoxYRv!u literal 0 HcmV?d00001 diff --git a/tests/fixtures/snapshots/snapshot_with_empty_cache_expandable.pkl b/tests/fixtures/snapshots/snapshot_with_empty_cache_expandable.pkl new file mode 100644 index 0000000000000000000000000000000000000000..c53559f48350596efa7092782de5efa144e7c8e7 GIT binary patch literal 614145 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

+8WkUJz7s-low2oVy0v}HKI?;OTi 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 literal 0 HcmV?d00001 diff --git a/tests/snapshot/__init__.py b/tests/snapshot/__init__.py new file mode 100644 index 0000000..4353971 --- /dev/null +++ b/tests/snapshot/__init__.py @@ -0,0 +1 @@ +"""Snapshot runtime compatibility tests.""" diff --git a/tests/snapshot/golden_observations.py b/tests/snapshot/golden_observations.py new file mode 100644 index 0000000..cf5b8ac --- /dev/null +++ b/tests/snapshot/golden_observations.py @@ -0,0 +1,157 @@ +"""Normalized observations captured from MemSnapDump v0.1.0 before relocation.""" + +FIXTURE_REPLAY_GOLDEN = { + ("snapshot_1768383987920985470.pkl", 0): { + "initial": (52, 0, 9700, 0, 0, 551550976), + "actions": { + "alloc": 3216, + "free_completed": 3216, + "free_requested": 3216, + "segment_alloc": 52, + }, + "final": (0, 0, 0, 0, 0, 0), + }, + ("snapshot_expandable.pkl", 0): { + "initial": (2, 645, 8092, 408698880, 408698880, 643825664), + "actions": { + "alloc": 2899, + "free_completed": 2574, + "free_requested": 2574, + "segment_map": 45, + }, + "final": (2, 320, 0, 94482944, 94482944, 113246208), + }, + ("snapshot_with_empty_cache.pkl", 0): { + "initial": (34, 645, 8180, 416417792, 416417792, 509607936), + "actions": { + "alloc": 2899, + "free_completed": 2574, + "free_requested": 2574, + "segment_alloc": 79, + "segment_free": 54, + }, + "final": (9, 320, 0, 95524864, 95524864, 113246208), + }, + ("snapshot_with_empty_cache_expandable.pkl", 0): { + "initial": (3, 645, 8132, 408698880, 408698880, 490733568), + "actions": { + "alloc": 2899, + "free_completed": 2574, + "free_requested": 2574, + "segment_map": 75, + "segment_unmap": 10, + }, + "final": (2, 320, 0, 94482944, 94482944, 113246208), + }, + ("snapshot_with_multi_devices.pkl", 0): { + "initial": (3, 645, 8132, 408698880, 408698880, 490733568), + "actions": { + "alloc": 2899, + "free_completed": 2574, + "free_requested": 2574, + "segment_map": 75, + "segment_unmap": 10, + }, + "final": (2, 320, 0, 94482944, 94482944, 113246208), + }, + ("snapshot_with_multi_devices.pkl", 1): { + "initial": (52, 0, 9700, 0, 0, 551550976), + "actions": { + "alloc": 3216, + "free_completed": 3216, + "free_requested": 3216, + "segment_alloc": 52, + }, + "final": (0, 0, 0, 0, 0, 0), + }, +} + +DATABASE_GOLDEN = { + ("snapshot_1768383987920985470.pkl", 0): { + "rows": (9700, 3216), + "actions": {2: 52, 4: 3216, 5: 3216, 6: 3216}, + "synthetic": (0, 0), + "first_totals": (0, 0, 2097152), + "last_positive_totals": (0, 0, 551550976), + "nonempty_callstacks": 5979, + }, + ("snapshot_expandable.pkl", 0): { + "rows": (8094, 3219), + "actions": {0: 47, 4: 2899, 5: 2574, 6: 2574}, + "synthetic": (2, 320), + "first_totals": (94482944, 94482944, 113246208), + "last_positive_totals": (408698880, 408698880, 643825664), + "nonempty_callstacks": 4369, + }, + ("snapshot_with_empty_cache.pkl", 0): { + "rows": (8189, 3219), + "actions": {2: 88, 3: 54, 4: 2899, 5: 2574, 6: 2574}, + "synthetic": (9, 320), + "first_totals": (95524864, 95524864, 113246208), + "last_positive_totals": (416417792, 416417792, 509607936), + "nonempty_callstacks": 4450, + }, + ("snapshot_with_empty_cache_expandable.pkl", 0): { + "rows": (8134, 3219), + "actions": {0: 77, 1: 10, 4: 2899, 5: 2574, 6: 2574}, + "synthetic": (2, 320), + "first_totals": (94482944, 94482944, 113246208), + "last_positive_totals": (408698880, 408698880, 490733568), + "nonempty_callstacks": 4405, + }, + ("snapshot_with_multi_devices.pkl", 0): { + "rows": (8134, 3219), + "actions": {0: 77, 1: 10, 4: 2899, 5: 2574, 6: 2574}, + "synthetic": (2, 320), + "first_totals": (94482944, 94482944, 113246208), + "last_positive_totals": (408698880, 408698880, 490733568), + "nonempty_callstacks": 4405, + }, + ("snapshot_with_multi_devices.pkl", 1): { + "rows": (9700, 3216), + "actions": {2: 52, 4: 3216, 5: 3216, 6: 3216}, + "synthetic": (0, 0), + "first_totals": (0, 0, 2097152), + "last_positive_totals": (0, 0, 551550976), + "nonempty_callstacks": 5979, + }, +} + +TRACE_SCHEMA = [ + (0, "id", "INTEGER", 0, None, 1), + (1, "action", "INTEGER", 0, None, 0), + (2, "address", "INTEGER", 0, None, 0), + (3, "size", "INTEGER", 0, None, 0), + (4, "stream", "INTEGER", 0, None, 0), + (5, "allocated", "INTEGER", 0, None, 0), + (6, "active", "INTEGER", 0, None, 0), + (7, "reserved", "INTEGER", 0, None, 0), + (8, "callstack", "TEXT", 0, None, 0), +] + +BLOCK_SCHEMA = [ + (0, "id", "INTEGER", 0, None, 1), + (1, "address", "INTEGER", 0, None, 0), + (2, "size", "INTEGER", 0, None, 0), + (3, "requestedSize", "INTEGER", 0, None, 0), + (4, "state", "INTEGER", 0, "99", 0), + (5, "allocEventId", "INTEGER", 0, None, 0), + (6, "freeEventId", "INTEGER", 0, None, 0), +] + +ACTION_VALUE_MAP = { + "segment_map": 0, + "segment_unmap": 1, + "segment_alloc": 2, + "segment_free": 3, + "alloc": 4, + "free_requested": 5, + "free_completed": 6, + "workspace_snapshot": 7, +} + +BLOCK_STATE_VALUE_MAP = { + "inactive": -1, + "active_allocated": 1, + "active_pending_free": 0, +} diff --git a/tests/snapshot/helpers.py b/tests/snapshot/helpers.py new file mode 100644 index 0000000..f5d017c --- /dev/null +++ b/tests/snapshot/helpers.py @@ -0,0 +1,42 @@ +from __future__ import annotations + +from pathlib import Path + +from pt_snap_cli.vendor.memsnapdump.base import BlockState, DeviceSnapshot, Segment + +FIXTURE_DIR = Path(__file__).parents[1] / "fixtures" / "snapshots" + + +def assert_valid_segment(segment: Segment) -> None: + assert segment.active_size >= segment.allocated_size + assert segment.total_size >= segment.active_size + allocated = 0 + activated = 0 + for block in segment.blocks: + assert block.size > 0 + if block.state != BlockState.INACTIVE: + activated += block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + allocated += block.size + assert block.segment_ptr is segment + assert allocated == segment.allocated_size + assert activated == segment.active_size + + +def assert_valid_segments(segments: list[Segment]) -> None: + previous_start = -1 + previous_end = 0 + for segment in segments: + segment_start = segment.address + segment_end = segment.address + segment.total_size + assert previous_start < previous_end <= segment_start < segment_end + assert_valid_segment(segment) + previous_start = segment_start + previous_end = segment_end + + +def assert_valid_snapshot(snapshot: DeviceSnapshot) -> None: + assert_valid_segments(snapshot.segments) + assert sum(segment.total_size for segment in snapshot.segments) == snapshot.total_reserved + assert sum(segment.allocated_size for segment in snapshot.segments) == snapshot.total_allocated + assert sum(segment.active_size for segment in snapshot.segments) == snapshot.total_activated diff --git a/tests/snapshot/test_allocator_hook_dispatcher.py b/tests/snapshot/test_allocator_hook_dispatcher.py new file mode 100644 index 0000000..d68de5a --- /dev/null +++ b/tests/snapshot/test_allocator_hook_dispatcher.py @@ -0,0 +1,99 @@ +from pt_snap_cli.vendor.memsnapdump.base import Block, DeviceSnapshot, Segment +from pt_snap_cli.vendor.memsnapdump.simulate.allocator_hook_dispatcher import ( + AllocatorHookDispatcher, +) + + +class RecordingHooker: + def __init__(self, name="hook"): + self.name = name + self.calls = [] + + def _record(self, action, payload, snapshot): + self.calls.append((self.name, action, payload, snapshot)) + + def pre_replay_alloc_block(self, block, snapshot): + self._record("pre_alloc", block, snapshot) + + def post_replay_alloc_block(self, block, snapshot): + self._record("post_alloc", block, snapshot) + + def pre_replay_free_block(self, block, snapshot): + self._record("pre_free", block, snapshot) + + def post_replay_free_block(self, block, snapshot): + self._record("post_free", block, snapshot) + + def pre_replay_map_or_alloc_segment(self, segment, snapshot): + self._record("pre_segment_alloc", segment, snapshot) + + def post_replay_map_or_alloc_segment(self, segment, snapshot): + self._record("post_segment_alloc", segment, snapshot) + + def pre_replay_unmap_or_free_segment(self, segment, snapshot): + self._record("pre_segment_free", segment, snapshot) + + def post_replay_unmap_or_free_segment(self, segment, snapshot): + self._record("post_segment_free", segment, snapshot) + + +def test_dispatcher_register_unregister_and_dispatch_copy_behavior(): + dispatcher = AllocatorHookDispatcher() + hooker = RecordingHooker() + snapshot = DeviceSnapshot() + block = Block(size=16, requested_size=16, address=0x1000) + segment = Segment(address=0x1000, total_size=0x100, stream=0) + + hooker_id = dispatcher.register_hooker(hooker) + assert hooker_id in dispatcher.hookers + + dispatcher.pre_replay_alloc_block(block, snapshot) + dispatcher.post_replay_alloc_block(block, snapshot) + dispatcher.pre_replay_free_block(block, snapshot) + dispatcher.post_replay_free_block(block, snapshot, use_copy=True) + dispatcher.pre_replay_map_or_alloc_segment(segment, snapshot) + dispatcher.post_replay_map_or_alloc_segment(segment, snapshot) + dispatcher.pre_replay_unmap_or_free_segment(segment, snapshot) + dispatcher.post_replay_unmap_or_free_segment(segment, snapshot) + + assert [call[1] for call in hooker.calls] == [ + "pre_alloc", + "post_alloc", + "pre_free", + "post_free", + "pre_segment_alloc", + "post_segment_alloc", + "pre_segment_free", + "post_segment_free", + ] + assert hooker.calls[3][2] is not block + assert hooker.calls[3][2].address == block.address + + dispatcher.unregister_hooker(hooker_id) + assert hooker_id not in dispatcher.hookers + + +def test_dispatcher_unregister_missing_id_is_noop(): + dispatcher = AllocatorHookDispatcher() + dispatcher.unregister_hooker(12345) + assert dispatcher.hookers == {} + + +def test_dispatcher_invokes_callbacks_in_registration_order(): + dispatcher = AllocatorHookDispatcher() + snapshot = DeviceSnapshot() + block = Block(size=16, requested_size=16, address=0x1000) + call_order = [] + + class OrderedHooker(RecordingHooker): + def pre_replay_alloc_block(self, block, snapshot): + call_order.append(self.name) + + first = OrderedHooker("first") + second = OrderedHooker("second") + dispatcher.register_hooker(first) + dispatcher.register_hooker(second) + + dispatcher.pre_replay_alloc_block(block, snapshot) + + assert call_order == ["first", "second"] diff --git a/tests/snapshot/test_entities.py b/tests/snapshot/test_entities.py new file mode 100644 index 0000000..54cae0f --- /dev/null +++ b/tests/snapshot/test_entities.py @@ -0,0 +1,393 @@ +import unittest + +from pt_snap_cli.vendor.memsnapdump.base import ( + Block, + BlockState, + DeviceSnapshot, + Frame, + Segment, + TraceEntry, +) +from pt_snap_cli.vendor.memsnapdump.simulate.snapshot_lookup import ( + find_block, + find_overlapping_segment, + find_segment, + is_valid_sub_block, +) + + +class TestFrame(unittest.TestCase): + def test_from_dict(self): + frame_dict = {"filename": "test.py", "line": 42, "name": "test_func"} + frame = Frame.from_dict(frame_dict) + self.assertEqual(frame.filename, "test.py") + self.assertEqual(frame.line, 42) + self.assertEqual(frame.name, "test_func") + self.assertEqual(frame._origin, frame_dict) + + def test_to_dict_with_origin(self): + frame_dict = {"filename": "test.py", "line": 42, "name": "test_func"} + frame = Frame.from_dict(frame_dict) + self.assertEqual(frame.to_dict(), frame_dict) + + def test_to_dict_without_origin(self): + frame = Frame() + frame.filename = "test.py" + frame.line = 42 + frame.name = "test_func" + result = frame.to_dict() + self.assertEqual(result["filename"], "test.py") + self.assertEqual(result["line"], 42) + self.assertEqual(result["name"], "test_func") + + +class TestTraceEntry(unittest.TestCase): + def test_from_dict(self): + trace_dict = { + "action": "alloc", + "addr": 0x1000, + "size": "1024", + "stream": "0", + "frames": [ + {"filename": "test.py", "line": 10, "name": "func_a"}, + {"filename": "test.py", "line": 20, "name": "func_b"}, + ], + } + trace = TraceEntry.from_dict(trace_dict) + self.assertEqual(trace.action, "alloc") + self.assertEqual(trace.addr, 0x1000) + self.assertEqual(trace.size, 1024) + self.assertEqual(trace.stream, 0) + self.assertEqual(len(trace.frames), 2) + self.assertEqual(trace.frames[0].filename, "test.py") + self.assertEqual(trace.frames[1].name, "func_b") + + def test_from_dict_without_frames(self): + trace_dict = { + "action": "free_requested", + "addr": 0x2000, + "size": "2048", + "stream": "1", + } + trace = TraceEntry.from_dict(trace_dict) + self.assertEqual(trace.action, "free_requested") + self.assertEqual(trace.addr, 0x2000) + self.assertEqual(trace.size, 2048) + self.assertEqual(len(trace.frames), 0) + + def test_get_callstack(self): + trace = TraceEntry.from_dict( + { + "action": "alloc", + "addr": 0x1000, + "size": "1024", + "stream": "0", + "frames": [ + {"filename": "test.py", "line": 10, "name": "func_a"}, + {"filename": "main.py", "line": 20, "name": "func_b"}, + ], + } + ) + callstack = trace.get_callstack() + self.assertIn("main.py:20 func_b", callstack) + self.assertIn("test.py:10 func_a", callstack) + + def test_get_callstack_empty_frames(self): + trace = TraceEntry(action="alloc") + self.assertEqual(trace.get_callstack(), "") + + def test_to_dict(self): + trace_dict = { + "action": "alloc", + "addr": 0x1000, + "size": "1024", + "stream": "0", + "frames": [], + } + self.assertEqual(TraceEntry.from_dict(trace_dict).to_dict(), trace_dict) + + +class TestBlock(unittest.TestCase): + def test_from_dict(self): + block = Block.from_dict( + { + "size": 1024, + "requested_size": 512, + "address": 0x1000, + "state": "active_allocated", + "frames": [{"filename": "test.py", "line": 10, "name": "alloc_func"}], + } + ) + self.assertEqual(block.size, 1024) + self.assertEqual(block.requested_size, 512) + self.assertEqual(block.address, 0x1000) + self.assertEqual(block.state, "active_allocated") + self.assertEqual(len(block.frames), 1) + + def test_build_from_event(self): + event = TraceEntry.from_dict( + { + "action": "alloc", + "addr": 0x2000, + "size": "2048", + "stream": "0", + "frames": [{"filename": "test.py", "line": 10, "name": "func"}], + } + ) + block = Block.build_from_event(event) + self.assertEqual(block.size, 2048) + self.assertEqual(block.requested_size, 2048) + self.assertEqual(block.address, 0x2000) + self.assertEqual(len(block.frames), 1) + + def test_valid_sub_block(self): + block = Block(size=1024, address=0x1000) + self.assertTrue(is_valid_sub_block(block, 0x1000, 512)) + self.assertTrue(is_valid_sub_block(block, 0x1200, 512)) + self.assertTrue(is_valid_sub_block(block, 0x1000, 1024)) + self.assertFalse(is_valid_sub_block(block, 0x900, 512)) + self.assertFalse(is_valid_sub_block(block, 0x1400, 512)) + self.assertFalse(is_valid_sub_block(block, 0x1000, 2048)) + + def test_to_dict(self): + block = Block( + size=1024, + requested_size=512, + address=0x1000, + state=BlockState.ACTIVE_ALLOCATED, + frames=[Frame.from_dict({"filename": "test.py", "line": 10, "name": "func"})], + ) + result = block.to_dict() + self.assertEqual(result["size"], 1024) + self.assertEqual(result["requested_size"], 512) + self.assertEqual(result["address"], 0x1000) + self.assertEqual(result["state"], BlockState.ACTIVE_ALLOCATED) + + +class TestSegment(unittest.TestCase): + @staticmethod + def _segment_dict(is_expandable=False, blocks=None): + return { + "address": 0x10000, + "total_size": 4096, + "stream": 0, + "segment_type": "large", + "allocated_size": 2048 if blocks else 0, + "active_size": 3072 if blocks else 0, + "device": 0, + "is_expandable": is_expandable, + "frames": [], + "blocks": blocks or [], + } + + def test_from_dict(self): + segment = Segment.from_dict( + self._segment_dict( + blocks=[ + { + "size": 2048, + "requested_size": 1024, + "address": 0x10000, + "state": "active_allocated", + "frames": [], + }, + { + "size": 2048, + "requested_size": 2048, + "address": 0x10800, + "state": "inactive", + "frames": [], + }, + ] + ) + ) + self.assertEqual(segment.address, 0x10000) + self.assertEqual(segment.total_size, 4096) + self.assertEqual(segment.allocated_size, 2048) + self.assertEqual(segment.active_size, 3072) + self.assertEqual(len(segment.blocks), 2) + self.assertIs(segment.blocks[0].segment_ptr, segment) + self.assertIs(segment.blocks[1].segment_ptr, segment) + + def test_from_dict_with_expandable(self): + self.assertTrue(Segment.from_dict(self._segment_dict(is_expandable=True)).is_expandable) + + def test_build_from_event(self): + event = TraceEntry.from_dict( + { + "action": "segment_alloc", + "addr": 0x20000, + "size": "8192", + "stream": "1", + "frames": [], + } + ) + segment = Segment.build_from_event(event, True) + self.assertEqual(segment.address, 0x20000) + self.assertEqual(segment.total_size, 8192) + self.assertEqual(segment.stream, 1) + self.assertEqual(len(segment.blocks), 1) + self.assertEqual(segment.blocks[0].state, BlockState.INACTIVE) + self.assertIs(segment.blocks[0].segment_ptr, segment) + + def test_build_from_event_expandable(self): + event = TraceEntry.from_dict( + { + "action": "segment_map", + "addr": 0x30000, + "size": "16384", + "stream": "0", + "frames": [], + } + ) + self.assertTrue(Segment.build_from_event(event).is_expandable) + + def test_find_block_returns_idx_and_object(self): + segment = Segment(address=0x10000, total_size=8192) + segment.blocks = [ + Block(size=2048, address=0x10000), + Block(size=2048, address=0x10800), + Block(size=4096, address=0x11000), + ] + for address, expected_idx in ( + (0x10000, 0), + (0x10800, 1), + (0x11000, 2), + (0x10500, 0), + (0x11500, 2), + ): + block_idx, block = find_block(segment, address) + self.assertEqual(block_idx, expected_idx) + self.assertIs(block, segment.blocks[expected_idx]) + for address in (0x9000, 0x13000): + block_idx, block = find_block(segment, address) + self.assertEqual(block_idx, -1) + self.assertIsNone(block) + + def test_to_dict(self): + segment = Segment( + address=0x10000, + total_size=4096, + stream=0, + segment_type="large", + allocated_size=2048, + active_size=2048, + device=0, + is_expandable=False, + ) + result = segment.to_dict() + self.assertEqual(result["address"], 0x10000) + self.assertEqual(result["total_size"], 4096) + self.assertEqual(result["segment_type"], "large") + + +class TestDeviceSnapshot(unittest.TestCase): + def test_from_dict(self): + snapshot = DeviceSnapshot.from_dict( + { + "segments": [ + { + "address": 0x10000, + "total_size": 4096, + "stream": 0, + "segment_type": "large", + "allocated_size": 2048, + "active_size": 2048, + "device": 0, + "is_expandable": False, + "frames": [], + "blocks": [ + { + "size": 2048, + "requested_size": 1024, + "address": 0x10000, + "state": "active_allocated", + "frames": [], + }, + { + "size": 2048, + "requested_size": 2048, + "address": 0x10800, + "state": "inactive", + "frames": [], + }, + ], + } + ], + "device_traces": [ + [ + { + "action": "alloc", + "addr": 0x10000, + "size": "1024", + "stream": "0", + "frames": [], + }, + { + "action": "free_requested", + "addr": 0x10000, + "size": "1024", + "stream": "0", + "frames": [], + }, + ] + ], + }, + 0, + ) + self.assertEqual(len(snapshot.segments), 1) + self.assertEqual(len(snapshot.trace_entries), 2) + self.assertEqual(snapshot.total_reserved, 4096) + self.assertEqual(snapshot.total_allocated, 2048) + self.assertEqual(snapshot.total_activated, 2048) + self.assertEqual(snapshot.trace_entries[0].idx, 0) + self.assertEqual(snapshot.trace_entries[1].idx, 1) + + def test_find_overlapping_segment_returns_idx_and_matches_containing_segment(self): + snapshot = DeviceSnapshot() + snapshot.segments = [ + Segment(address=0x10000, total_size=0x2000), + Segment(address=0x20000, total_size=0x5000), + Segment(address=0x30000, total_size=0x1000), + ] + for address, expected_idx in ((0x10000, 0), (0x20000, 1), (0x30000, 2)): + segment_idx, segment = find_overlapping_segment(snapshot, address) + self.assertEqual(segment_idx, expected_idx) + self.assertIs(segment, snapshot.segments[expected_idx]) + for address in (0x12000, 0x25000, 0x9000, 0x40000): + segment_idx, segment = find_overlapping_segment(snapshot, address) + self.assertEqual(segment_idx, -1) + self.assertIsNone(segment) + + def test_find_overlapping_segment_returns_idx_and_matches_stream_filtered_segment(self): + snapshot = DeviceSnapshot() + snapshot.segments = [ + Segment(address=0x10000, total_size=0x2000, stream=0), + Segment(address=0x10000, total_size=0x3000, stream=1), + Segment(address=0x20000, total_size=0x5000, stream=0), + Segment(address=0x30000, total_size=0x1000, stream=1), + ] + result_idx, result_segment = find_overlapping_segment(snapshot, 0x10000) + self.assertIn(result_idx, [0, 1]) + self.assertIsNotNone(result_segment) + for address, stream, expected_idx in ( + (0x10000, 0, 0), + (0x10000, 1, 1), + (0x20000, 0, 2), + (0x11000, 1, 1), + ): + segment_idx, segment = find_overlapping_segment(snapshot, address, stream=stream) + self.assertEqual(segment_idx, expected_idx) + self.assertIs(segment, snapshot.segments[expected_idx]) + for address, stream in ((0x10000, 2), (0x20000, 1)): + segment_idx, segment = find_overlapping_segment(snapshot, address, stream=stream) + self.assertEqual(segment_idx, -1) + self.assertIsNone(segment) + exact_idx, exact_segment = find_segment(snapshot, 0x30000, stream=1) + self.assertEqual(exact_idx, 3) + self.assertIs(exact_segment, snapshot.segments[3]) + + def test_to_dict(self): + result = DeviceSnapshot.from_dict({"segments": [], "device_traces": [[]]}, 0).to_dict() + self.assertIn("segments", result) + self.assertIn("device_traces", result) diff --git a/tests/snapshot/test_entity2record.py b/tests/snapshot/test_entity2record.py new file mode 100644 index 0000000..083cfe7 --- /dev/null +++ b/tests/snapshot/test_entity2record.py @@ -0,0 +1,99 @@ +from pt_snap_cli.vendor.memsnapdump.base import Block, Frame, TraceEntry +from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.defs import ( + BlockFieldDefs, + EventFieldDefs, +) +from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.entity2record import ( + block2record, + event2record, + get_timestamp_by_event_idx, + make_default_id_counter, +) + + +def test_make_default_id_counter_counts_down_from_start(): + next_id = make_default_id_counter(-3) + + assert next_id() == -3 + assert next_id() == -4 + + +def test_get_timestamp_by_event_idx_handles_none(): + assert get_timestamp_by_event_idx(None) == -1 + assert get_timestamp_by_event_idx(7) == 70 + + +def test_event2record_uses_generated_default_id_when_missing(): + event = TraceEntry(action="alloc", addr=0x1000, size=16, stream=0, idx=None) + + record = event2record(event, allocated=1, active=2, reserved=3) + + assert record[EventFieldDefs.ID] < 0 + assert record[EventFieldDefs.ALLOCATED] == 1 + assert record[EventFieldDefs.ACTIVE] == 2 + assert record[EventFieldDefs.RESERVED] == 3 + + +def test_block2record_uses_generated_default_id_when_missing(): + block = Block(size=16, requested_size=8, address=0x1000, state="active_allocated") + + record = block2record(block) + + assert record[BlockFieldDefs.ID] < 0 + assert record[BlockFieldDefs.ALLOC_EVENT_ID] == -1 + assert record[BlockFieldDefs.FREE_EVENT_ID] == -1 + + +def test_records_preserve_totals_state_ids_and_callstack_serialization(): + event = TraceEntry( + action="alloc", + addr=0x2000, + size=32, + stream=4, + idx=9, + frames=[ + Frame.from_dict({"filename": "inner.py", "line": 10, "name": "inner"}), + Frame.from_dict({"filename": "outer.py", "line": 20, "name": "outer"}), + ], + ) + block = Block( + size=32, + requested_size=24, + address=0x2000, + state="active_pending_free", + alloc_event_idx=9, + free_event_idx=12, + ) + + event_record = event2record(event, allocated=100, active=120, reserved=256) + block_record = block2record(block) + + assert event_record == { + "id": 9, + "action": "alloc", + "address": 0x2000, + "size": 32, + "stream": 4, + "allocated": 100, + "active": 120, + "reserved": 256, + "callstack": "outer.py:20 outer\ninner.py:10 inner", + } + assert block_record == { + "id": 9, + "address": 0x2000, + "size": 32, + "requestedSize": 24, + "state": "active_pending_free", + "allocEventId": 9, + "freeEventId": 12, + } + + +def test_synthetic_ids_remain_negative_and_monotonically_decrease(): + next_id = make_default_id_counter() + + ids = [next_id() for _ in range(4)] + + assert ids == [-1, -2, -3, -4] + assert all(identifier < 0 for identifier in ids) diff --git a/tests/snapshot/test_file_util.py b/tests/snapshot/test_file_util.py new file mode 100644 index 0000000..b4a8ff2 --- /dev/null +++ b/tests/snapshot/test_file_util.py @@ -0,0 +1,50 @@ +import pickle +from pathlib import Path + +import pytest + +from pt_snap_cli.vendor.memsnapdump.util.file_util import ( + check_dir_valid, + check_file_valid, + load_pickle_to_dict, + save_dict_to_pickle, +) + + +def test_save_and_load_pickle_round_trip(tmp_path: Path): + target = tmp_path / "nested" / "snapshot.pkl" + payload = {"device_traces": [1, 2, 3]} + + save_dict_to_pickle(payload, target) + + assert target.exists() + assert load_pickle_to_dict(target) == payload + + +def test_load_pickle_to_dict_rejects_non_dict_payload(tmp_path: Path): + target = tmp_path / "list.pkl" + with target.open("wb") as file_handle: + pickle.dump([1, 2, 3], file_handle) + + with pytest.raises(ValueError): + load_pickle_to_dict(target) + + +def test_load_pickle_to_dict_rejects_missing_file(tmp_path: Path): + with pytest.raises(FileNotFoundError): + load_pickle_to_dict(tmp_path / "missing.pkl") + + +def test_save_dict_to_pickle_rejects_non_dict(tmp_path: Path): + with pytest.raises(TypeError): + save_dict_to_pickle([1, 2, 3], tmp_path / "bad.pkl") + + +def test_check_dir_and_file_valid(tmp_path: Path): + file_path = tmp_path / "sample.txt" + file_path.write_text("ok", encoding="utf-8") + + assert check_dir_valid(tmp_path) + assert check_file_valid(file_path) + assert not check_dir_valid(file_path) + assert not check_file_valid(tmp_path) diff --git a/tests/snapshot/test_logger.py b/tests/snapshot/test_logger.py new file mode 100644 index 0000000..5494af8 --- /dev/null +++ b/tests/snapshot/test_logger.py @@ -0,0 +1,100 @@ +import logging +from pathlib import Path + +import pytest + +from pt_snap_cli.vendor.memsnapdump.util import logger as logger_module + + +@pytest.fixture(autouse=True) +def reset_global_logger_state(): + original_file = logger_module._global_log_file + original_handler = logger_module._global_file_handler + logger_module._global_log_file = None + logger_module._global_file_handler = None + yield + if logger_module._global_file_handler is not None: + logger_module._global_file_handler.close() + logger_module._global_log_file = original_file + logger_module._global_file_handler = original_handler + + +def test_get_logger_basic(): + logger = logger_module.get_logger("snapshot_test_basic") + + assert logger.name == "snapshot_test_basic" + assert logger.level == logging.INFO + assert len(logger.handlers) == 1 + assert isinstance(logger.handlers[0], logging.StreamHandler) + + +def test_get_logger_with_custom_level(): + logger = logger_module.get_logger("snapshot_test_level", level=logging.DEBUG) + + assert logger.level == logging.DEBUG + assert logger.handlers[0].level == logging.DEBUG + + +def test_set_global_log_file(tmp_path: Path): + log_file = tmp_path / "test.log" + logger_module.set_global_log_file(str(log_file)) + + logger = logger_module.get_logger("snapshot_test_global") + + assert len(logger.handlers) == 2 + file_handler = next( + handler for handler in logger.handlers if isinstance(handler, logging.FileHandler) + ) + assert file_handler.baseFilename == str(log_file.absolute()) + + +def test_set_global_log_file_nonexistent_directory(tmp_path: Path): + with pytest.raises(OSError): + logger_module.set_global_log_file(str(tmp_path / "nonexistent" / "test.log")) + + +def test_set_global_log_file_not_directory(tmp_path: Path): + not_directory = tmp_path / "not_dir.txt" + not_directory.write_text("", encoding="utf-8") + + with pytest.raises(OSError): + logger_module.set_global_log_file(str(not_directory / "test.log")) + + +def test_logger_output_to_file(tmp_path: Path): + log_file = tmp_path / "test.log" + logger_module.set_global_log_file(str(log_file)) + logger = logger_module.get_logger("snapshot_test_output") + + logger.info("Test log message") + for handler in logger.handlers: + if isinstance(handler, logging.FileHandler): + handler.flush() + + assert "Test log message" in log_file.read_text(encoding="utf-8") + + +def test_attach_file_handler_to_existing_loggers(tmp_path: Path): + logger = logger_module.get_logger("snapshot_test_existing") + + logger_module.set_global_log_file(str(tmp_path / "test.log")) + + assert len(logger.handlers) == 2 + assert sum(isinstance(handler, logging.FileHandler) for handler in logger.handlers) == 1 + + +def test_multiple_loggers_share_file_handler(tmp_path: Path): + log_file = tmp_path / "test.log" + logger_module.set_global_log_file(str(log_file)) + logger_one = logger_module.get_logger("snapshot_test_one") + logger_two = logger_module.get_logger("snapshot_test_two") + + for logger in (logger_one, logger_two): + assert sum(isinstance(handler, logging.FileHandler) for handler in logger.handlers) == 1 + + logger_one.info("Message from module1") + logger_two.info("Message from module2") + logger_module._global_file_handler.flush() + log_content = log_file.read_text(encoding="utf-8") + assert "Message from module1" in log_content + assert "Message from module2" in log_content diff --git a/tests/snapshot/test_replay_executor.py b/tests/snapshot/test_replay_executor.py new file mode 100644 index 0000000..43e82f6 --- /dev/null +++ b/tests/snapshot/test_replay_executor.py @@ -0,0 +1,127 @@ +import unittest + +import pytest + +from pt_snap_cli.vendor.memsnapdump.base import BlockState, TraceEntry +from pt_snap_cli.vendor.memsnapdump.simulate.replay_executor import ReplayExecutor + + +class FakeAllocator: + def __init__(self): + self.calls = [] + + def alloc_block(self, block): + self.calls.append(("alloc_block", block)) + return True + + def active_block(self, event): + self.calls.append(("active_block", event)) + return True + + def free_block(self, event): + self.calls.append(("free_block", event)) + return True + + def alloc_or_map_segment(self, segment, merge=False): + self.calls.append(("alloc_or_map_segment", segment, merge)) + return True + + def free_segment(self, event): + self.calls.append(("free_segment", event)) + return True + + def unmap_segment(self, event): + self.calls.append(("unmap_segment", event)) + return True + + +class FakeLogger: + def __init__(self): + self.messages = [] + + def warning(self, message, *args, **kwargs): + self.messages.append(message) + + +def make_event(action, addr=0x1000, size=0x100, stream=0, idx=1): + return TraceEntry(action=action, addr=addr, size=size, stream=stream, idx=idx) + + +class TestReplayExecutor(unittest.TestCase): + def setUp(self): + self.allocator = FakeAllocator() + self.logger = FakeLogger() + self.executor = ReplayExecutor(self.allocator, self.logger) + + def test_execute_free_event_maps_to_alloc_block(self): + event = make_event("free") + + result = self.executor.execute(event) + + self.assertTrue(result) + call = self.allocator.calls[0] + self.assertEqual("alloc_block", call[0]) + self.assertEqual(event.addr, call[1].address) + + def test_execute_segment_unmap_maps_to_alloc_or_map_segment_with_merge(self): + event = make_event("segment_unmap", addr=0x2000, size=0x400) + + result = self.executor.execute(event) + + self.assertTrue(result) + call = self.allocator.calls[0] + self.assertEqual("alloc_or_map_segment", call[0]) + self.assertTrue(call[2]) + self.assertEqual(event.idx, call[1].free_or_unmap_event_idx) + + def test_execute_unknown_event_warns_and_skips(self): + event = make_event("unknown_action") + + result = self.executor.execute(event) + + self.assertTrue(result) + self.assertEqual([], self.allocator.calls) + self.assertEqual(1, len(self.logger.messages)) + self.assertIn("Skip event", self.logger.messages[0]) + + +@pytest.mark.parametrize( + ("action", "method", "extra"), + [ + ("free", "alloc_block", BlockState.ACTIVE_ALLOCATED), + ("free_completed", "alloc_block", BlockState.ACTIVE_PENDING_FREE), + ("free_requested", "active_block", None), + ("alloc", "free_block", None), + ("segment_free", "alloc_or_map_segment", False), + ("segment_unmap", "alloc_or_map_segment", True), + ("segment_alloc", "free_segment", None), + ("segment_map", "unmap_segment", None), + ], +) +def test_execute_dispatches_every_allocator_branch(action, method, extra): + allocator = FakeAllocator() + logger = FakeLogger() + event = make_event(action, idx=17) + + assert ReplayExecutor(allocator, logger).execute(event) is True + + call = allocator.calls[0] + assert call[0] == method + if action in {"free", "free_completed"}: + assert call[1].state == extra + elif action in {"segment_free", "segment_unmap"}: + assert call[1].free_or_unmap_event_idx == 17 + assert call[2] is extra + assert logger.messages == [] + + +@pytest.mark.parametrize("action", ["oom", "snapshot", "workspace_snapshot", "unknown_action"]) +def test_execute_preserves_skipped_event_baseline(action): + allocator = FakeAllocator() + logger = FakeLogger() + event = make_event(action) + + assert ReplayExecutor(allocator, logger).execute(event) is True + + assert allocator.calls == [] + assert logger.messages == [f"Skip event{event.to_dict()} during replay."] diff --git a/tests/snapshot/test_simulate.py b/tests/snapshot/test_simulate.py new file mode 100644 index 0000000..ba85557 --- /dev/null +++ b/tests/snapshot/test_simulate.py @@ -0,0 +1,261 @@ +import os +import unittest +from collections import Counter +from pathlib import Path + +import pytest + +from pt_snap_cli.vendor.memsnapdump.base import BlockState +from pt_snap_cli.vendor.memsnapdump.simulate import SimulateDeviceSnapshot, SimulateHooker +from pt_snap_cli.vendor.memsnapdump.simulate.hooker_defs import AllocatorHooker +from pt_snap_cli.vendor.memsnapdump.simulate.snapshot_lookup import find_overlapping_segment +from pt_snap_cli.vendor.memsnapdump.util.file_util import load_pickle_to_dict +from pt_snap_cli.vendor.memsnapdump.util.logger import restore_logs, suppress_logs + +from .golden_observations import FIXTURE_REPLAY_GOLDEN +from .helpers import FIXTURE_DIR, assert_valid_segments, assert_valid_snapshot + + +class ReplayEventHooker(SimulateHooker): + def __init__(self, valid_interval=100): + self.replay_count = 0 + self.valid_interval = valid_interval + + def pre_undo_event(self, wait4undo_event, current_snapshot): + return True + + def post_undo_event(self, already_undo_event, current_snapshot): + if self.replay_count % self.valid_interval == 0: + assert_valid_segments(current_snapshot.segments) + self.replay_count += 1 + return True + + +class ReplayBlockHooker(AllocatorHooker): + def __init__(self, test_util): + self.test_util = test_util + self._segment = None + self.pre_seg_allocated_size = 0 + self.pre_seg_active_size = 0 + self.pre_snapshot_total_allocated_size = 0 + self.pre_snapshot_total_active_size = 0 + + def pre_replay_alloc_block(self, wait4alloc_block, current_snapshot): + super().pre_replay_alloc_block(wait4alloc_block, current_snapshot) + self.test_util.assertNotEqual(wait4alloc_block.state, BlockState.INACTIVE) + segment_idx, self._segment = find_overlapping_segment( + current_snapshot, wait4alloc_block.address + ) + self.test_util.assertTrue(0 <= segment_idx < len(current_snapshot.segments)) + self.pre_seg_allocated_size = self._segment.allocated_size + self.pre_seg_active_size = self._segment.active_size + self.pre_snapshot_total_allocated_size = current_snapshot.total_allocated + self.pre_snapshot_total_active_size = current_snapshot.total_activated + + def post_replay_alloc_block(self, allocated_block, current_snapshot): + super().post_replay_alloc_block(allocated_block, current_snapshot) + self.test_util.assertEqual( + self.pre_seg_active_size + allocated_block.size, self._segment.active_size + ) + self.test_util.assertEqual( + self.pre_snapshot_total_active_size + allocated_block.size, + current_snapshot.total_activated, + ) + if allocated_block.state == BlockState.ACTIVE_ALLOCATED: + self.test_util.assertEqual( + self.pre_seg_allocated_size + allocated_block.size, + self._segment.allocated_size, + ) + self.test_util.assertEqual( + self.pre_snapshot_total_allocated_size + allocated_block.size, + current_snapshot.total_allocated, + ) + + +class TestSimulate(unittest.TestCase): + snapshot_path = FIXTURE_DIR / "snapshot_1768383987920985470.pkl" + expandable_path = FIXTURE_DIR / "snapshot_expandable.pkl" + empty_cache_path = FIXTURE_DIR / "snapshot_with_empty_cache.pkl" + expandable_empty_cache_path = FIXTURE_DIR / "snapshot_with_empty_cache_expandable.pkl" + + @classmethod + def setUpClass(cls): + if os.getenv("UT_VERBOSE_LOG") != "1": + suppress_logs() + + @classmethod + def tearDownClass(cls): + restore_logs() + + @staticmethod + def get_simulate_snapshot(snapshot_path: Path): + return SimulateDeviceSnapshot(load_pickle_to_dict(snapshot_path), 0) + + def _assert_block_hook_replay(self, path): + snapshot = self.get_simulate_snapshot(path) + assert_valid_segments(snapshot.device_snapshot.segments) + snapshot.register_allocator_hooker(ReplayBlockHooker(self)) + self.assertTrue(snapshot.replay()) + + def _assert_event_hook_replay(self, path): + snapshot = self.get_simulate_snapshot(path) + snapshot.register_hooker(ReplayEventHooker()) + self.assertTrue(snapshot.replay()) + + def test_block_hooker_in_snapshot(self): + self._assert_block_hook_replay(self.snapshot_path) + + def test_block_hooker_in_expandable_snapshot(self): + self._assert_block_hook_replay(self.expandable_path) + + def test_block_hooker_in_snapshot_with_empty_cache(self): + self._assert_block_hook_replay(self.empty_cache_path) + + def test_block_hooker_in_expandable_snapshot_with_empty_cache(self): + self._assert_block_hook_replay(self.expandable_empty_cache_path) + + def test_replay_snapshot(self): + self._assert_event_hook_replay(self.snapshot_path) + + def test_replay_expandable_snapshot(self): + self._assert_event_hook_replay(self.expandable_path) + + def test_replay_snapshot_with_empty_cache(self): + self._assert_event_hook_replay(self.empty_cache_path) + + def test_replay_expandable_snapshot_with_empty_cache(self): + self._assert_event_hook_replay(self.expandable_empty_cache_path) + + +class Hooker: + def __init__(self, pre=True, post=True): + self.pre = pre + self.post = post + self.calls = [] + + def pre_undo_event(self, event, snapshot): + self.calls.append(("pre", event.idx)) + return self.pre + + def post_undo_event(self, event, snapshot): + self.calls.append(("post", event.idx)) + return self.post + + +class MinimalAllocatorHooker: + pass + + +def make_snapshot_dict(action="alloc", with_segment=False): + payload = { + "segments": [], + "device_traces": [[{"action": action, "addr": 1, "size": 1, "stream": 0, "frames": []}]], + } + if with_segment: + payload["segments"] = [ + { + "address": 1, + "total_size": 16, + "stream": 0, + "segment_type": "small", + "allocated_size": 0, + "active_size": 0, + "device": 0, + "is_expandable": False, + "frames": [], + "blocks": [], + } + ] + return payload + + +def test_simulate_device_snapshot_raises_on_empty_snapshot(): + with pytest.raises(RuntimeError): + SimulateDeviceSnapshot({}, 0) + + +def test_simulate_device_snapshot_sets_workspace_flag_from_first_event(): + snapshot = SimulateDeviceSnapshot(make_snapshot_dict("workspace_snapshot"), 0) + + assert snapshot.simulated_allocator_context.workspace_flag is True + + +def test_simulate_register_unregister_hookers_and_allocator_hookers(): + snapshot = SimulateDeviceSnapshot(make_snapshot_dict(), 0) + hooker = Hooker() + allocator_hooker = MinimalAllocatorHooker() + + hook_id = snapshot.register_hooker(hooker) + allocator_id = snapshot.register_allocator_hooker(allocator_hooker) + snapshot.unregister_hooker(hook_id) + snapshot.unregister_allocator_hooker(allocator_id) + + assert hook_id not in snapshot.hookers + assert allocator_id not in snapshot.simulated_allocator.dispatcher.hookers + + +def test_simulate_replay_stops_when_pre_hook_returns_false(): + snapshot = SimulateDeviceSnapshot(make_snapshot_dict(), 0) + hooker = Hooker(pre=False) + snapshot.register_hooker(hooker) + + assert snapshot.replay() is False + assert hooker.calls == [("pre", 0)] + + +def test_simulate_replay_stops_when_post_hook_returns_false(): + snapshot = SimulateDeviceSnapshot(make_snapshot_dict("free", with_segment=True), 0) + hooker = Hooker(post=False) + snapshot.register_hooker(hooker) + + assert snapshot.replay() is False + assert hooker.calls == [("pre", 0), ("post", 0)] + + +def snapshot_observation(snapshot): + device_snapshot = snapshot.device_snapshot + return ( + len(device_snapshot.segments), + sum(len(segment.blocks) for segment in device_snapshot.segments), + len(device_snapshot.trace_entries), + device_snapshot.total_allocated, + device_snapshot.total_activated, + device_snapshot.total_reserved, + ) + + +@pytest.mark.parametrize(("fixture_name", "device"), FIXTURE_REPLAY_GOLDEN) +def test_fixture_replay_matches_pre_relocation_golden(fixture_name, device): + golden = FIXTURE_REPLAY_GOLDEN[(fixture_name, device)] + snapshot = SimulateDeviceSnapshot(load_pickle_to_dict(FIXTURE_DIR / fixture_name), device) + + assert snapshot_observation(snapshot) == golden["initial"] + assert ( + Counter(event.action for event in snapshot.device_snapshot.trace_entries) + == golden["actions"] + ) + assert_valid_snapshot(snapshot.device_snapshot) + + assert snapshot.replay() is True + assert snapshot_observation(snapshot) == golden["final"] + assert_valid_snapshot(snapshot.device_snapshot) + + +def test_multi_device_fixture_keeps_device_state_isolated(): + data = load_pickle_to_dict(FIXTURE_DIR / "snapshot_with_multi_devices.pkl") + device_zero = SimulateDeviceSnapshot(data, 0) + device_one = SimulateDeviceSnapshot(data, 1) + device_one_before = snapshot_observation(device_one) + + assert device_zero.replay() is True + + assert snapshot_observation(device_one) == device_one_before + assert snapshot_observation(device_zero) != snapshot_observation(device_one) + + +def test_minimal_workspace_input_only_establishes_tolerance_flag_and_skip_behavior(): + snapshot = SimulateDeviceSnapshot(make_snapshot_dict("workspace_snapshot"), 0) + + assert snapshot.simulated_allocator_context.workspace_flag is True + assert snapshot.replay() is True + assert snapshot.device_snapshot.trace_entries == [] diff --git a/tests/snapshot/test_snapshot2db_runtime.py b/tests/snapshot/test_snapshot2db_runtime.py new file mode 100644 index 0000000..d1524a3 --- /dev/null +++ b/tests/snapshot/test_snapshot2db_runtime.py @@ -0,0 +1,195 @@ +import sqlite3 +from pathlib import Path + +import pytest + +from pt_snap_cli.vendor.memsnapdump.tools.adaptors import snapshot2db +from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database import ( + BLOCK_STATE_VALUE_MAP as RUNTIME_BLOCK_STATE_VALUE_MAP, +) +from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database import ( + TRACE_ENTRY_ACTION_VALUE_MAP as RUNTIME_ACTION_VALUE_MAP, +) +from pt_snap_cli.vendor.memsnapdump.util.logger import restore_logs, suppress_logs + +from .golden_observations import ( + ACTION_VALUE_MAP, + BLOCK_SCHEMA, + BLOCK_STATE_VALUE_MAP, + DATABASE_GOLDEN, + TRACE_SCHEMA, +) +from .helpers import FIXTURE_DIR + + +@pytest.fixture(scope="module") +def dump_database(tmp_path_factory): + output_dir = tmp_path_factory.mktemp("snapshot-runtime-db") + cache = {} + + def dump(fixture_name, device=None): + key = (fixture_name, device) + if key not in cache: + suffix = "all" if device is None else str(device) + output = output_dir / f"{fixture_name}.{suffix}.db" + suppress_logs() + try: + result = snapshot2db.dump(FIXTURE_DIR / fixture_name, output, device) + finally: + restore_logs() + cache[key] = (result, output) + return cache[key] + + return dump + + +def test_snapshot2db(dump_database): + result, database = dump_database("snapshot_with_empty_cache.pkl", 0) + + assert result is True + assert database.exists() + with sqlite3.connect(database) as connection: + assert connection.execute("SELECT COUNT(*) FROM trace_entry_0").fetchone()[0] == 8189 + assert connection.execute("SELECT COUNT(*) FROM block_0").fetchone()[0] == 3219 + + +def test_expandable_snapshot2db(dump_database): + result, database = dump_database("snapshot_with_empty_cache_expandable.pkl", 0) + + assert result is True + assert database.exists() + with sqlite3.connect(database) as connection: + assert connection.execute("SELECT COUNT(*) FROM trace_entry_0").fetchone()[0] == 8134 + assert connection.execute("SELECT COUNT(*) FROM block_0").fetchone()[0] == 3219 + + +def test_empty_device_snapshot(tmp_path: Path): + database = tmp_path / "empty.db" + + assert snapshot2db.dump(FIXTURE_DIR / "snapshot_with_empty_cache.pkl", database, 1) is False + assert not database.exists() + + +def test_dump_all_multiple_device_snapshot(dump_database): + result, database = dump_database("snapshot_with_multi_devices.pkl") + + assert result is True + assert database.exists() + with sqlite3.connect(database) as connection: + tables = { + row[0] + for row in connection.execute( + "SELECT name FROM sqlite_master WHERE type = 'table'" + ).fetchall() + } + assert tables == {"dictionary", "trace_entry_0", "block_0", "trace_entry_1", "block_1"} + + +def negative_id_observation(connection, table): + count, minimum, maximum = connection.execute( + f"SELECT COUNT(*), MIN(id), MAX(id) FROM {table} WHERE id < 0" + ).fetchone() + contiguous = count == 0 or maximum - minimum + 1 == count + return count, contiguous + + +@pytest.mark.parametrize(("fixture_name", "device"), DATABASE_GOLDEN) +def test_database_matches_pre_relocation_golden(dump_database, fixture_name, device): + requested_device = None if fixture_name == "snapshot_with_multi_devices.pkl" else device + result, database = dump_database(fixture_name, requested_device) + golden = DATABASE_GOLDEN[(fixture_name, device)] + trace_table = f"trace_entry_{device}" + block_table = f"block_{device}" + + assert result is True + with sqlite3.connect(database) as connection: + rows = ( + connection.execute(f"SELECT COUNT(*) FROM {trace_table}").fetchone()[0], + connection.execute(f"SELECT COUNT(*) FROM {block_table}").fetchone()[0], + ) + actions = dict( + connection.execute( + f"SELECT action, COUNT(*) FROM {trace_table} GROUP BY action ORDER BY action" + ).fetchall() + ) + first_totals = connection.execute( + f"SELECT allocated, active, reserved FROM {trace_table} ORDER BY id LIMIT 1" + ).fetchone() + last_positive_totals = connection.execute( + f"SELECT allocated, active, reserved FROM {trace_table} " + "WHERE id >= 0 ORDER BY id DESC LIMIT 1" + ).fetchone() + callstacks = connection.execute( + f"SELECT COUNT(*) FROM {trace_table} WHERE callstack != ''" + ).fetchone()[0] + + assert rows == golden["rows"] + assert actions == golden["actions"] + assert negative_id_observation(connection, trace_table) == ( + golden["synthetic"][0], + True, + ) + assert negative_id_observation(connection, block_table) == ( + golden["synthetic"][1], + True, + ) + assert first_totals == golden["first_totals"] + assert last_positive_totals == golden["last_positive_totals"] + assert callstacks == golden["nonempty_callstacks"] + + +def test_database_schema_and_action_state_mapping_are_exact(dump_database): + _, database = dump_database("snapshot_with_multi_devices.pkl") + + assert RUNTIME_ACTION_VALUE_MAP == ACTION_VALUE_MAP + assert RUNTIME_BLOCK_STATE_VALUE_MAP == BLOCK_STATE_VALUE_MAP + with sqlite3.connect(database) as connection: + for device in (0, 1): + assert ( + connection.execute(f"PRAGMA table_info(trace_entry_{device})").fetchall() + == TRACE_SCHEMA + ) + assert ( + connection.execute(f"PRAGMA table_info(block_{device})").fetchall() == BLOCK_SCHEMA + ) + dictionary = connection.execute( + "SELECT `table`, `column`, `key`, `value` FROM dictionary " + "WHERE `table` IN (?, ?) ORDER BY `table`, `column`, CAST(`key` AS INTEGER)", + (f"block_{device}", f"trace_entry_{device}"), + ).fetchall() + assert dictionary == [ + (f"block_{device}", "state", "-1", "inactive"), + (f"block_{device}", "state", "0", "active_pending_free"), + (f"block_{device}", "state", "1", "active_allocated"), + *[ + (f"trace_entry_{device}", "action", str(value), action) + for action, value in ACTION_VALUE_MAP.items() + ], + ] + + +def test_multi_device_database_rows_are_isolated(dump_database): + _, database = dump_database("snapshot_with_multi_devices.pkl") + with sqlite3.connect(database) as connection: + device_zero = connection.execute( + "SELECT COUNT(*), SUM(size), MAX(reserved) FROM trace_entry_0" + ).fetchone() + device_one = connection.execute( + "SELECT COUNT(*), SUM(size), MAX(reserved) FROM trace_entry_1" + ).fetchone() + + assert device_zero != device_one + assert device_zero[0] == DATABASE_GOLDEN[("snapshot_with_multi_devices.pkl", 0)]["rows"][0] + assert device_one[0] == DATABASE_GOLDEN[("snapshot_with_multi_devices.pkl", 1)]["rows"][0] + + +def test_callstack_serialization_preserves_frame_order(dump_database): + _, database = dump_database("snapshot_1768383987920985470.pkl", 0) + with sqlite3.connect(database) as connection: + callstack = connection.execute( + "SELECT callstack FROM trace_entry_0 WHERE callstack LIKE '%\n%' LIMIT 1" + ).fetchone()[0] + + lines = callstack.splitlines() + assert len(lines) >= 2 + assert all(":" in line and " " in line for line in lines) diff --git a/tests/snapshot/test_snapshot_lookup.py b/tests/snapshot/test_snapshot_lookup.py new file mode 100644 index 0000000..cfdcb58 --- /dev/null +++ b/tests/snapshot/test_snapshot_lookup.py @@ -0,0 +1,145 @@ +import unittest + +from pt_snap_cli.vendor.memsnapdump.base import Block, BlockState, DeviceSnapshot, Segment +from pt_snap_cli.vendor.memsnapdump.simulate.snapshot_lookup import ( + find_block, + find_gap_for_alloc_block, + find_overlapping_segment, + find_segment, + is_valid_sub_block, +) + + +class TestSnapshotLookup(unittest.TestCase): + @staticmethod + def make_snapshot(segments: list[Segment]) -> DeviceSnapshot: + snapshot = DeviceSnapshot() + snapshot.segments = sorted(segments, key=lambda segment: (segment.address, segment.stream)) + snapshot.trace_entries = [] + snapshot.total_allocated = sum(segment.allocated_size for segment in snapshot.segments) + snapshot.total_reserved = sum(segment.total_size for segment in snapshot.segments) + snapshot.total_activated = sum(segment.active_size for segment in snapshot.segments) + snapshot.device = 0 + return snapshot + + @staticmethod + def make_segment(address, total_size, stream=0, blocks=None): + segment = Segment( + address=address, + total_size=total_size, + stream=stream, + segment_type="large", + allocated_size=0, + active_size=0, + blocks=[], + ) + for block in blocks or []: + block.segment_ptr = segment + segment.blocks.append(block) + segment.active_size += block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + segment.allocated_size += block.size + return segment + + @staticmethod + def make_block(address, size, state=BlockState.ACTIVE_ALLOCATED): + return Block(size=size, requested_size=size, address=address, state=state) + + def test_find_block_returns_idx_and_block(self): + block_a = self.make_block(0x1000, 0x100) + block_b = self.make_block(0x1400, 0x80) + snapshot = self.make_snapshot( + [self.make_segment(0x1000, 0x1000, blocks=[block_a, block_b])] + ) + + block_idx, found = find_block(snapshot.segments[0], 0x1400) + miss_idx, missing = find_block(snapshot.segments[0], 0x1800) + + self.assertEqual(1, block_idx) + self.assertIs(found, block_b) + self.assertEqual(-1, miss_idx) + self.assertIsNone(missing) + + def test_find_segment_returns_idx_and_exact_segment(self): + snapshot = self.make_snapshot( + [ + self.make_segment(0x1000, 0x300, stream=0), + self.make_segment(0x1000, 0x400, stream=1), + self.make_segment(0x2000, 0x200, stream=0), + ] + ) + + result_idx, result_segment = find_overlapping_segment(snapshot, 0x1000) + overlapping_idx, overlapping = find_overlapping_segment(snapshot, 0x1000, stream=0) + exact_idx, exact = find_segment(snapshot, 0x1000, stream=1) + missing_idx, missing = find_segment(snapshot, 0x1100, stream=1) + + self.assertIn(result_idx, [0, 1]) + self.assertIsNotNone(result_segment) + self.assertEqual(0, overlapping_idx) + self.assertEqual(0x1000, overlapping.address) + self.assertEqual(1, exact_idx) + self.assertEqual(1, exact.stream) + self.assertEqual(-1, missing_idx) + self.assertIsNone(missing) + + def test_find_overlapping_segment_scans_both_sides_when_overlapping_ranges_exist(self): + snapshot = self.make_snapshot( + [ + self.make_segment(0x1000, 0x1000, stream=5), + self.make_segment(0x1800, 0x100, stream=1), + ] + ) + + segment_idx, segment = find_overlapping_segment(snapshot, 0x1850, stream=1) + + self.assertEqual(1, segment_idx) + self.assertIs(segment, snapshot.segments[1]) + + def test_find_overlapping_segment_finds_left_side_overlap_when_mid_stream_mismatches(self): + snapshot = self.make_snapshot( + [ + self.make_segment(0x1000, 0x900, stream=1), + self.make_segment(0x1400, 0x1000, stream=5), + ] + ) + + segment_idx, segment = find_overlapping_segment(snapshot, 0x1850, stream=1) + + self.assertEqual(0, segment_idx) + self.assertIs(segment, snapshot.segments[0]) + + def test_find_overlapping_segment_returns_none_when_overlap_exists_but_stream_missing(self): + snapshot = self.make_snapshot( + [ + self.make_segment(0x1000, 0x1000, stream=5), + self.make_segment(0x1800, 0x100, stream=1), + ] + ) + + segment_idx, segment = find_overlapping_segment(snapshot, 0x1850, stream=9) + + self.assertEqual(-1, segment_idx) + self.assertIsNone(segment) + + def test_is_valid_sub_block_checks_range_inclusion(self): + block = self.make_block(0x1000, 0x200) + + self.assertTrue(is_valid_sub_block(block, 0x1000, 0x100)) + self.assertTrue(is_valid_sub_block(block, 0x1100, 0x100)) + self.assertFalse(is_valid_sub_block(block, 0x0F00, 0x100)) + self.assertFalse(is_valid_sub_block(block, 0x1100, 0x200)) + + def test_find_gap_for_alloc_block_returns_insert_position_between_blocks(self): + block_a = self.make_block(0x1000, 0x100) + block_b = self.make_block(0x1400, 0x100) + snapshot = self.make_snapshot( + [self.make_segment(0x1000, 0x1000, blocks=[block_a, block_b])] + ) + + gap = find_gap_for_alloc_block(snapshot, 0x1200, 0x100, stream=0) + + self.assertIsNotNone(gap) + segment, insert_idx = gap + self.assertEqual(0x1000, segment.address) + self.assertEqual(1, insert_idx) diff --git a/tests/snapshot/test_snapshot_mutator.py b/tests/snapshot/test_snapshot_mutator.py new file mode 100644 index 0000000..50d8398 --- /dev/null +++ b/tests/snapshot/test_snapshot_mutator.py @@ -0,0 +1,289 @@ +import unittest + +from pt_snap_cli.vendor.memsnapdump.base import ( + Block, + BlockState, + DeviceSnapshot, + Segment, + TraceEntry, +) +from pt_snap_cli.vendor.memsnapdump.simulate import snapshot_mutator +from pt_snap_cli.vendor.memsnapdump.simulate.allocator_context import AllocatorContext +from pt_snap_cli.vendor.memsnapdump.simulate.simulated_caching_allocator import ( + SimulatedCachingAllocator, +) + +from .helpers import assert_valid_segment, assert_valid_segments, assert_valid_snapshot + + +def make_snapshot(segments=None, trace_entries=None): + snapshot = DeviceSnapshot() + snapshot.segments = sorted( + segments or [], key=lambda segment: (segment.address, segment.stream) + ) + snapshot.trace_entries = list(trace_entries or []) + snapshot.total_allocated = sum(segment.allocated_size for segment in snapshot.segments) + snapshot.total_activated = sum(segment.active_size for segment in snapshot.segments) + snapshot.total_reserved = sum(segment.total_size for segment in snapshot.segments) + snapshot.device = 0 + return snapshot + + +def make_segment(address=0x1000, total_size=0x1000, stream=0, blocks=None): + segment = Segment( + address=address, + total_size=total_size, + stream=stream, + segment_type="large", + allocated_size=0, + active_size=0, + blocks=[], + ) + for block in blocks or []: + block.segment_ptr = segment + segment.blocks.append(block) + segment.active_size += block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + segment.allocated_size += block.size + return segment + + +def make_block(address=0x1000, size=0x100, state=BlockState.ACTIVE_ALLOCATED): + return Block(size=size, requested_size=size, address=address, state=state) + + +def make_event(action, addr, size, stream=0, idx=0): + return TraceEntry(action=action, addr=addr, size=size, stream=stream, idx=idx) + + +def make_allocator(segments, trace_entries=None): + return SimulatedCachingAllocator(AllocatorContext(make_snapshot(segments, trace_entries))) + + +def test_detach_block_returns_false_when_block_has_no_segment(): + snapshot = make_snapshot() + block = make_block() + + assert snapshot_mutator.detach_block(snapshot, block) is False + assert_valid_segments(snapshot.segments) + + +def test_promote_pending_free_block_returns_false_without_segment(): + snapshot = make_snapshot() + block = make_block(state=BlockState.ACTIVE_PENDING_FREE) + + assert snapshot_mutator.promote_pending_free_block(snapshot, block) is False + assert_valid_segments(snapshot.segments) + + +def test_merge_mapped_segment_merges_left_and_right_adjacent_segments_when_present(): + left = make_segment(0x1000, 0x100) + right = make_segment(0x1300, 0x100) + new_segment = make_segment(0x1100, 0x200) + right_block = make_block(0x1300, 0x80) + right_block.segment_ptr = right + right.blocks.append(right_block) + right.active_size = right_block.size + right.allocated_size = right_block.size + snapshot = make_snapshot([left, right]) + + assert snapshot_mutator.merge_mapped_segment(snapshot, new_segment, 0, 1) is True + assert len(snapshot.segments) == 1 + merged = snapshot.segments[0] + assert merged.total_size == 0x400 + assert right_block.segment_ptr is merged + assert_valid_segments(snapshot.segments) + + +def test_merge_mapped_segment_merges_right_adjacent_segment_without_left_neighbor(): + right = make_segment(0x1300, 0x100) + new_segment = make_segment(0x1100, 0x200) + right_block = make_block(0x1300, 0x80) + right_block.segment_ptr = right + right.blocks.append(right_block) + right.active_size = right_block.size + right.allocated_size = right_block.size + snapshot = make_snapshot([right]) + + assert snapshot_mutator.merge_mapped_segment(snapshot, new_segment, -1, 0) is True + assert len(snapshot.segments) == 1 + merged = snapshot.segments[0] + assert merged.address == 0x1100 + assert merged.total_size == 0x300 + assert right_block.segment_ptr is merged + assert_valid_segments(snapshot.segments) + + +def test_merge_mapped_segment_returns_false_when_no_adjacent_segments_exist(): + snapshot = make_snapshot() + new_segment = make_segment(0x1100, 0x200) + + assert snapshot_mutator.merge_mapped_segment(snapshot, new_segment, -1, -1) is False + assert snapshot.segments == [] + assert_valid_segments(snapshot.segments) + + +def test_split_or_shrink_segment_uses_middle_split_branch(): + segment = make_segment(0x1000, 0x1000) + left_block = make_block(0x1000, 0x100) + right_block = make_block(0x1800, 0x100) + left_block.segment_ptr = segment + right_block.segment_ptr = segment + segment.blocks = [left_block, right_block] + segment.active_size = left_block.size + right_block.size + segment.allocated_size = left_block.size + right_block.size + snapshot = make_snapshot([segment]) + + assert snapshot_mutator.split_or_shrink_segment(snapshot, 0, 0x1400, 0x100) is True + assert len(snapshot.segments) == 2 + assert_valid_segments(snapshot.segments) + + +def test_increase_and_decrease_reserved_update_snapshot_totals(): + snapshot = make_snapshot() + + snapshot_mutator.increase_reserved(snapshot, 64) + snapshot_mutator.decrease_reserved(snapshot, 24) + + assert snapshot.total_reserved == 40 + + +class TestSnapshotMutatorState(unittest.TestCase): + def test_attach_and_detach_block_keep_totals_consistent(self): + snapshot = make_snapshot([]) + segment = make_segment(0x1000, 0x1000) + snapshot_mutator.insert_segment(snapshot, segment) + block = make_block(0x1200, 0x100) + + snapshot_mutator.attach_block(snapshot, segment, block, 0) + + self.assertIs(block.segment_ptr, segment) + self.assertEqual(0x100, segment.active_size) + self.assertEqual(0x100, segment.allocated_size) + self.assertEqual(0x100, snapshot.total_activated) + self.assertEqual(0x100, snapshot.total_allocated) + assert_valid_snapshot(snapshot) + + self.assertTrue(snapshot_mutator.detach_block(snapshot, block)) + self.assertIsNone(block.segment_ptr) + self.assertEqual([], segment.blocks) + self.assertEqual(0, segment.active_size) + self.assertEqual(0, segment.allocated_size) + self.assertEqual(0, snapshot.total_activated) + self.assertEqual(0, snapshot.total_allocated) + assert_valid_snapshot(snapshot) + + def test_insert_and_remove_segment_keep_reserved_consistent(self): + snapshot = make_snapshot([]) + segment = make_segment(0x2000, 0x400) + + snapshot_mutator.insert_segment(snapshot, segment) + + self.assertEqual(1, len(snapshot.segments)) + self.assertEqual(0x400, snapshot.total_reserved) + assert_valid_snapshot(snapshot) + + snapshot_mutator.remove_segment(snapshot, segment) + + self.assertEqual([], snapshot.segments) + self.assertEqual(0, snapshot.total_reserved) + assert_valid_snapshot(snapshot) + + def test_alloc_block_updates_segment_and_snapshot_totals(self): + segment = make_segment(0x1000, 0x1000) + allocator = make_allocator([segment]) + allocator.ctx.set_current_undo_event(make_event("free", 0x1200, 0x100, idx=7)) + new_block = make_block(0x1200, 0x100) + + allocated = allocator.alloc_block(new_block) + + self.assertTrue(allocated) + self.assertEqual(0x100, segment.active_size) + self.assertEqual(0x100, segment.allocated_size) + self.assertEqual(0x100, allocator.ctx.device_snapshot.total_activated) + self.assertEqual(0x100, allocator.ctx.device_snapshot.total_allocated) + self.assertEqual(7, new_block.free_event_idx) + self.assertIs(new_block.segment_ptr, segment) + assert_valid_segment(segment) + assert_valid_snapshot(allocator.ctx.device_snapshot) + + def test_free_block_updates_segment_and_snapshot_totals(self): + block = make_block(0x1200, 0x100) + segment = make_segment(0x1000, 0x1000, blocks=[block]) + allocator = make_allocator([segment]) + event = make_event("alloc", 0x1200, 0x100, idx=8) + + freed = allocator.free_block(event) + + self.assertTrue(freed) + self.assertEqual([], segment.blocks) + self.assertEqual(0, segment.active_size) + self.assertEqual(0, segment.allocated_size) + self.assertEqual(0, allocator.ctx.device_snapshot.total_activated) + self.assertEqual(0, allocator.ctx.device_snapshot.total_allocated) + assert_valid_snapshot(allocator.ctx.device_snapshot) + + def test_active_block_promotes_pending_free_block(self): + block = make_block(0x1200, 0x100, state=BlockState.ACTIVE_PENDING_FREE) + segment = make_segment(0x1000, 0x1000, blocks=[block]) + allocator = make_allocator([segment]) + event = make_event("free_requested", 0x1200, 0x100) + + activated = allocator.active_block(event) + + self.assertTrue(activated) + self.assertEqual(BlockState.ACTIVE_ALLOCATED, block.state) + self.assertEqual(0x100, segment.allocated_size) + self.assertEqual(0x100, allocator.ctx.device_snapshot.total_allocated) + assert_valid_segment(segment) + assert_valid_snapshot(allocator.ctx.device_snapshot) + + def test_workspace_flag_tolerates_missing_block_on_free(self): + segment = make_segment(0x1000, 0x1000) + allocator = make_allocator([segment]) + allocator.ctx.workspace_flag = True + event = make_event("alloc", 0x1200, 0x100) + + tolerated = allocator.free_block(event) + + self.assertTrue(tolerated) + self.assertEqual(0, allocator.ctx.device_snapshot.total_allocated) + self.assertEqual(0, allocator.ctx.device_snapshot.total_activated) + assert_valid_snapshot(allocator.ctx.device_snapshot) + + def test_alloc_or_map_segment_updates_reserved_for_non_merge(self): + allocator = make_allocator([]) + allocator.ctx.set_current_undo_event(make_event("segment_free", 0x2000, 0x400, idx=5)) + segment = make_segment(0x2000, 0x400) + + allocated = allocator.alloc_or_map_segment(segment, merge=False) + + self.assertTrue(allocated) + self.assertEqual(1, len(allocator.ctx.device_snapshot.segments)) + self.assertEqual(0x400, allocator.ctx.device_snapshot.total_reserved) + self.assertEqual(5, segment.free_or_unmap_event_idx) + assert_valid_snapshot(allocator.ctx.device_snapshot) + + def test_alloc_or_map_segment_merge_keeps_snapshot_invariants(self): + left = make_segment(0x1000, 0x100) + allocator = make_allocator([left]) + allocator.ctx.set_current_undo_event(make_event("segment_free", 0x1100, 0x80, idx=9)) + new_segment = make_segment(0x1100, 0x80) + + allocated = allocator.alloc_or_map_segment(new_segment, merge=True) + + self.assertTrue(allocated) + self.assertEqual(1, len(allocator.ctx.device_snapshot.segments)) + self.assertEqual(0x180, allocator.ctx.device_snapshot.total_reserved) + assert_valid_snapshot(allocator.ctx.device_snapshot) + + def test_unmap_segment_keeps_snapshot_invariants(self): + segment = make_segment(0x1000, 0x200) + allocator = make_allocator([segment]) + map_event = make_event("segment_map", 0x1000, 0x80, idx=10) + + unmapped = allocator.unmap_segment(map_event) + + self.assertTrue(unmapped) + self.assertEqual(0x180, allocator.ctx.device_snapshot.total_reserved) + assert_valid_snapshot(allocator.ctx.device_snapshot) diff --git a/tests/snapshot/test_sqlite_meta.py b/tests/snapshot/test_sqlite_meta.py new file mode 100644 index 0000000..9a25f4e --- /dev/null +++ b/tests/snapshot/test_sqlite_meta.py @@ -0,0 +1,213 @@ +import sqlite3 +from pathlib import Path +from typing import Optional + +import pytest + +from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.snapshot_db import SnapshotDb +from pt_snap_cli.vendor.memsnapdump.util.sqlite_meta import ( + SqliteColumn, + SqliteDB, + SqliteTable, + _map_py_type_to_sqlite, + _parse_default_value, + _sqlite_type_to_py_type, +) + + +def test_type_mapping_helpers_cover_supported_and_fallback_types(): + assert _map_py_type_to_sqlite(int) == "INTEGER" + assert _map_py_type_to_sqlite(float) == "REAL" + assert _map_py_type_to_sqlite(str) == "TEXT" + assert _map_py_type_to_sqlite(bytes) == "BLOB" + assert _map_py_type_to_sqlite(Optional[int]) == "INTEGER" # noqa: UP045 + assert _map_py_type_to_sqlite(list) == "TEXT" + + assert _sqlite_type_to_py_type("INTEGER") is int + assert _sqlite_type_to_py_type("TEXT") is str + assert _sqlite_type_to_py_type("BLOB") is bytes + assert _sqlite_type_to_py_type("REAL") is float + assert _sqlite_type_to_py_type("") is str + assert _sqlite_type_to_py_type("NUMERIC") is str + + +@pytest.mark.xfail( + strict=True, + reason="runtime does not recognize the Python 3.10+ PEP 604 optional form", +) +def test_type_mapping_supports_pep604_optional(): + assert _map_py_type_to_sqlite(int | None) == "INTEGER" # noqa: UP045 + + +def test_parse_default_value_handles_literals_bool_and_strings(): + assert _parse_default_value(None) is None + assert _parse_default_value("1") is True + assert _parse_default_value("0") is False + assert _parse_default_value("true") is True + assert _parse_default_value("false") is False + assert _parse_default_value("123") == 123 + assert _parse_default_value("'hello'") == "hello" + assert _parse_default_value('"world"') == "world" + assert _parse_default_value("CURRENT_TIMESTAMP") == "CURRENT_TIMESTAMP" + + +def test_sqlite_column_validation_and_sql_generation(): + with pytest.raises(ValueError): + SqliteColumn("id", int, autoincrement=True) + with pytest.raises(ValueError): + SqliteColumn("id", str, primary_key=True, autoincrement=True) + + column = SqliteColumn("name", str, not_null=True, unique=True, default="O'Reilly") + sql = column.to_sql_def() + assert "`name` TEXT" in sql + assert "NOT NULL" in sql + assert "UNIQUE" in sql + assert "DEFAULT 'O''Reilly'" in sql + assert SqliteColumn("flag", bool, default=True)._format_default() == "1" + assert SqliteColumn("score", float, default=1.5)._format_default() == "1.5" + assert SqliteColumn("misc", dict, default={"a": 1})._format_default() == "'{'a': 1}'" + + +def test_sqlite_table_helpers_create_insert_and_index(tmp_path: Path): + connection = sqlite3.connect(tmp_path / "table.sqlite") + table = SqliteTable( + "users", + [ + SqliteColumn("id", int, primary_key=True), + SqliteColumn("name", str, not_null=True), + SqliteColumn("active", bool, default=False, value_map={True: 1, False: 0}), + ], + ) + + sql = table.to_sql_def(delete_if_exists=True) + assert "DROP TABLE IF EXISTS users;" in sql + assert "CREATE TABLE users" in sql + table.create_table(connection, delete_if_exists=True) + table.create_index(connection, "name") + table.insert_record(connection, {"id": 1, "name": "Alice", "active": True}) + table.insert_records( + connection, + [ + {"id": 2, "name": "Bob", "active": False}, + {"id": 3, "name": "Cara", "active": True}, + ], + ) + + rows = connection.execute("SELECT id, name, active FROM users ORDER BY id").fetchall() + assert rows == [(1, "Alice", 1), (2, "Bob", 0), (3, "Cara", 1)] + assert SqliteTable.get_insert_columns_by_record({"a": 1, "b": 2}) == ["`a`", "`b`"] + assert SqliteTable.get_insert_placeholder_by_record({"a": 1, "b": 2}) == "?, ?" + assert table.get_insert_values_by_records( + [ + {"id": 4, "name": "Dan", "active": True}, + {"id": 5, "name": "Eve", "active": False}, + ] + ) == [(4, "Dan", 1), (5, "Eve", 0)] + assert table.get_insert_values_by_records([]) == [] + connection.close() + + +def test_sqlite_db_create_get_delete_and_dictionary_table(tmp_path: Path): + db = SqliteDB(str(tmp_path / "meta.sqlite"), with_dictionary_table=True) + assert db.is_table_exists("dictionary") is True + assert db.get_table_by_name("dictionary").name == "dictionary" + table = SqliteTable( + "events", + [ + SqliteColumn("id", int, primary_key=True, autoincrement=True), + SqliteColumn("status", str, default="new", value_map={"ALLOC": "alloc"}), + SqliteColumn("enabled", bool, default=True), + ], + ) + db.create_table(table, delete_if_exists=True) + + restored = db.get_table_by_name("events") + assert restored.column_dict["id"].primary_key is True + assert restored.column_dict["id"].autoincrement is True + assert restored.column_dict["status"].default == "new" + assert restored.column_dict["enabled"].default is True + dictionary_rows = db.conn.execute( + "SELECT `table`, `column`, `key`, `value` FROM dictionary ORDER BY rowid" + ).fetchall() + assert ("events", "status", "alloc", "ALLOC") in dictionary_rows + + db.delete_table("events") + assert ( + db.conn.execute( + "SELECT name FROM sqlite_master WHERE type='table' AND name='events'" + ).fetchone() + is None + ) + db.conn.close() + + +def test_sqlite_db_missing_file_without_auto_create_raises(tmp_path: Path): + with pytest.raises(FileNotFoundError): + SqliteDB(str(tmp_path / "missing" / "db.sqlite"), auto_create=False) + + +def test_get_table_by_name_raises_for_missing_table(tmp_path: Path): + db = SqliteDB(str(tmp_path / "empty.sqlite")) + with pytest.raises(ValueError): + db.get_table_by_name("missing_table") + db.conn.close() + + +def pragma(connection: sqlite3.Connection, name: str): + return connection.execute(f"PRAGMA {name}").fetchone()[0] + + +def indexed_columns(connection: sqlite3.Connection, table: str): + indexes = connection.execute(f"PRAGMA index_list('{table}')").fetchall() + return { + column[2] + for index in indexes + for column in connection.execute(f"PRAGMA index_info('{index[1]}')").fetchall() + } + + +def test_snapshot_db_optimizes_import_writes(tmp_path: Path): + db = SnapshotDb(str(tmp_path / "snapshot.db")) + try: + assert pragma(db.conn, "journal_mode") == "memory" + assert pragma(db.conn, "synchronous") == 0 + assert pragma(db.conn, "cache_size") == -65536 + finally: + db.conn.close() + + +def test_generic_sqlite_db_keeps_default_write_settings(tmp_path: Path): + baseline = sqlite3.connect(tmp_path / "baseline.db") + db = SqliteDB(str(tmp_path / "generic.db")) + try: + for name in ("journal_mode", "synchronous", "cache_size"): + assert pragma(db.conn, name) == pragma(baseline, name) + finally: + db.conn.close() + baseline.close() + + +def test_create_trace_entry_table_adds_query_indexes(tmp_path: Path): + db = SnapshotDb(str(tmp_path / "snapshot.db")) + try: + db.create_trace_entry_table(device=2) + assert indexed_columns(db.conn, "trace_entry_2") == { + "allocated", + "active", + "reserved", + } + finally: + db.conn.close() + + +def test_create_block_table_adds_query_indexes(tmp_path: Path): + db = SnapshotDb(str(tmp_path / "snapshot.db")) + try: + db.create_block_table(device=2) + assert indexed_columns(db.conn, "block_2") == { + "allocEventId", + "freeEventId", + "size", + } + finally: + db.conn.close() diff --git a/tests/snapshot/test_timer.py b/tests/snapshot/test_timer.py new file mode 100644 index 0000000..8e39b4f --- /dev/null +++ b/tests/snapshot/test_timer.py @@ -0,0 +1,38 @@ +import time + +from pt_snap_cli.vendor.memsnapdump.util.timer import timer + + +class FakeLogger: + def __init__(self): + self.messages = [] + + def info(self, message): + self.messages.append(message) + + +def test_timer_reports_to_logger(): + logger = FakeLogger() + + @timer(name="unit-work", logger=logger) + def work(): + time.sleep(0.001) + return 123 + + result = work() + + assert result == 123 + assert len(logger.messages) == 1 + assert logger.messages[0].startswith("unit-work took ") + + +def test_timer_without_logger_prints(capsys): + @timer() + def work(): + return "done" + + result = work() + captured = capsys.readouterr() + + assert result == "done" + assert "work took " in captured.out From 5436e236a974c831f51930e5fe5f2a0fa1334836 Mon Sep 17 00:00:00 2001 From: codeasier Date: Fri, 31 Jul 2026 01:01:35 +0800 Subject: [PATCH 04/12] refactor: make snapshot runtime first-party --- .github/workflows/test.yml | 8 +- benchmarks/baseline_import.py | 2 +- benchmarks/sqlite_write_throughput.py | 4 +- docs/en/database.md | 2 +- docs/legal/memsnapdump-mit-relicensing.md | 2 +- pyproject.toml | 7 +- src/pt_snap_cli/core/errors.py | 10 +- src/pt_snap_cli/core/import_service.py | 2 +- .../core/snapshot_import_backend.py | 16 +- .../{vendor/memsnapdump => snapshot}/LICENSE | 10 +- src/pt_snap_cli/snapshot/PROVENANCE.md | 101 +++++++++++ src/pt_snap_cli/snapshot/__init__.py | 3 + .../memsnapdump => snapshot}/base/__init__.py | 2 +- .../memsnapdump => snapshot}/base/entities.py | 88 ++++------ src/pt_snap_cli/snapshot/representation.py | 26 +++ .../simulate/__init__.py | 4 +- .../simulate/allocator_context.py | 0 .../simulate/allocator_hook_dispatcher.py | 20 +-- .../simulate/hooker_defs.py | 26 ++- .../simulate/replay_executor.py | 1 - .../simulate/simulate.py | 21 +-- .../simulate/simulated_caching_allocator.py | 50 ++---- .../simulate/snapshot_lookup.py | 22 +-- .../simulate/snapshot_mutator.py | 44 ++--- .../tools/adaptors/database/__init__.py | 10 ++ .../tools/adaptors/database/defs.py | 0 .../tools/adaptors/database/entity2record.py | 17 +- .../tools/adaptors/database/snapshot_db.py | 8 +- .../tools/adaptors/snapshot2db.py | 163 ++++-------------- .../memsnapdump => snapshot}/util/__init__.py | 0 .../util/file_util.py | 11 +- .../memsnapdump => snapshot}/util/logger.py | 14 +- .../util/sqlite_meta.py | 49 ++---- .../memsnapdump => snapshot}/util/timer.py | 6 +- src/pt_snap_cli/vendor/__init__.py | 0 .../vendor/memsnapdump/ATTRIBUTION.md | 74 -------- .../vendor/memsnapdump/__init__.py | 0 .../tools/adaptors/database/__init__.py | 4 - tests/core/test_import_errors.py | 2 +- tests/core/test_import_service.py | 20 +-- .../snapshot_1768383987920985470.pkl | Bin .../snapshots/snapshot_expandable.pkl | Bin tests/snapshot/helpers.py | 2 +- .../test_allocator_hook_dispatcher.py | 4 +- tests/snapshot/test_entities.py | 4 +- tests/snapshot/test_entity2record.py | 6 +- tests/snapshot/test_file_util.py | 2 +- tests/snapshot/test_logger.py | 2 +- tests/snapshot/test_replay_executor.py | 4 +- tests/snapshot/test_simulate.py | 12 +- tests/snapshot/test_snapshot2db_runtime.py | 29 +++- tests/snapshot/test_snapshot_lookup.py | 4 +- tests/snapshot/test_snapshot_mutator.py | 8 +- tests/snapshot/test_sqlite_meta.py | 4 +- tests/snapshot/test_timer.py | 2 +- tests/test_cli.py | 6 +- tests/test_snapshot_db.py | 4 +- 57 files changed, 388 insertions(+), 554 deletions(-) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/LICENSE (73%) create mode 100644 src/pt_snap_cli/snapshot/PROVENANCE.md create mode 100644 src/pt_snap_cli/snapshot/__init__.py rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/base/__init__.py (50%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/base/entities.py (82%) create mode 100644 src/pt_snap_cli/snapshot/representation.py rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/__init__.py (78%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/allocator_context.py (100%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/allocator_hook_dispatcher.py (77%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/hooker_defs.py (85%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/replay_executor.py (99%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/simulate.py (88%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/simulated_caching_allocator.py (88%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/snapshot_lookup.py (87%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/simulate/snapshot_mutator.py (91%) create mode 100644 src/pt_snap_cli/snapshot/tools/adaptors/database/__init__.py rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/tools/adaptors/database/defs.py (100%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/tools/adaptors/database/entity2record.py (75%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/tools/adaptors/database/snapshot_db.py (93%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/tools/adaptors/snapshot2db.py (53%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/util/__init__.py (100%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/util/file_util.py (92%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/util/logger.py (91%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/util/sqlite_meta.py (93%) rename src/pt_snap_cli/{vendor/memsnapdump => snapshot}/util/timer.py (92%) delete mode 100644 src/pt_snap_cli/vendor/__init__.py delete mode 100644 src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md delete mode 100644 src/pt_snap_cli/vendor/memsnapdump/__init__.py delete mode 100644 src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/__init__.py mode change 100755 => 100644 tests/fixtures/snapshots/snapshot_1768383987920985470.pkl mode change 100755 => 100644 tests/fixtures/snapshots/snapshot_expandable.pkl diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 220a439..1deaefa 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -74,15 +74,15 @@ jobs: python -m pip install --upgrade build python -m build --wheel - - name: Wheel smoke test (verify vendored backend is packaged) + - name: Wheel smoke test (verify snapshot runtime is packaged) if: matrix.python-version == '3.13' run: | set -euo pipefail python -m pip install --force-reinstall dist/*.whl - # Confirm the vendored closure was actually packaged into the wheel. - python -c "import pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db as m; assert hasattr(m, 'run_dump_to_db'), 'vendored run_dump_to_db missing in installed wheel'" + # Confirm the first-party runtime was actually packaged into the wheel. + python -c "import pt_snap_cli.snapshot.tools.adaptors.snapshot2db as m; assert hasattr(m, 'run_dump_to_db'), 'snapshot run_dump_to_db missing in installed wheel'" # End-to-end import against a real fixture — catches any packaging - # regression where setuptools drops src/pt_snap_cli/vendor/. + # regression where setuptools drops src/pt_snap_cli/snapshot/. FIXTURE=tests/fixtures/snapshots/snapshot_with_empty_cache.pkl rm -rf /tmp/pt-snap-wheel-smoke mkdir -p /tmp/pt-snap-wheel-smoke diff --git a/benchmarks/baseline_import.py b/benchmarks/baseline_import.py index 6aac86d..9817109 100644 --- a/benchmarks/baseline_import.py +++ b/benchmarks/baseline_import.py @@ -245,7 +245,7 @@ def _profile_import(snapshot: Path, output_dir: Path, device: int, top_n: int = def main() -> None: import argparse - logging.getLogger("pt_snap_cli.vendor").setLevel(logging.ERROR) + logging.getLogger("pt_snap_cli.snapshot").setLevel(logging.ERROR) parser = argparse.ArgumentParser() parser.add_argument("--samples", nargs="+", default=["131k", "628k"]) diff --git a/benchmarks/sqlite_write_throughput.py b/benchmarks/sqlite_write_throughput.py index 8b82078..da542c9 100644 --- a/benchmarks/sqlite_write_throughput.py +++ b/benchmarks/sqlite_write_throughput.py @@ -11,8 +11,8 @@ from contextlib import ExitStack from pathlib import Path -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.snapshot_db import SnapshotDb -from pt_snap_cli.vendor.memsnapdump.util.sqlite_meta import SqliteDB +from pt_snap_cli.snapshot.tools.adaptors.database.snapshot_db import SnapshotDb +from pt_snap_cli.snapshot.util.sqlite_meta import SqliteDB def measure(db: SqliteDB, rows: int, batch_size: int) -> float: diff --git a/docs/en/database.md b/docs/en/database.md index 6bc1333..e72b1e7 100644 --- a/docs/en/database.md +++ b/docs/en/database.md @@ -20,7 +20,7 @@ SnapshotDB is the SQLite database format for persisting PyTorch memory profiling pt-snap import snapshot.pkl ``` -The import command uses a vendored MemSnapDump backend to produce `snapshot.pkl.db` next to the input file by default, then updates project focus so subsequent commands can use it directly: +The import command uses pt-snap-cli's first-party snapshot runtime to produce `snapshot.pkl.db` next to the input file by default, then updates project focus so subsequent commands can use it directly: ```bash pt-snap query --list diff --git a/docs/legal/memsnapdump-mit-relicensing.md b/docs/legal/memsnapdump-mit-relicensing.md index 00d280e..725886a 100644 --- a/docs/legal/memsnapdump-mit-relicensing.md +++ b/docs/legal/memsnapdump-mit-relicensing.md @@ -25,7 +25,7 @@ declaration, does not claim to be the rights holder, and does not supply or invent a signature. The applicable MIT terms are preserved in -`src/pt_snap_cli/vendor/memsnapdump/LICENSE`. This record does not reproduce the +`src/pt_snap_cli/snapshot/LICENSE`. This record does not reproduce the standard license text or represent an additional signature. ## Corroborating repository evidence diff --git a/pyproject.toml b/pyproject.toml index 10e2ce3..6b3ccc9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -63,6 +63,7 @@ pt_snap_cli = [ "query/templates/*.yaml", "query/templates/*/*.yaml", ] +"pt_snap_cli.snapshot" = ["LICENSE", "PROVENANCE.md"] [tool.setuptools_scm] version_scheme = "no-guess-dev" @@ -71,16 +72,10 @@ local_scheme = "no-local-version" [tool.black] line-length = 100 target-version = ["py310"] -extend-exclude = ''' -( - ^/src/pt_snap_cli/vendor/ -) -''' [tool.ruff] line-length = 100 target-version = "py310" -extend-exclude = ["src/pt_snap_cli/vendor"] [tool.ruff.lint] select = ["E", "F", "W", "I", "N", "UP", "B", "C4"] diff --git a/src/pt_snap_cli/core/errors.py b/src/pt_snap_cli/core/errors.py index a09fd61..336e697 100644 --- a/src/pt_snap_cli/core/errors.py +++ b/src/pt_snap_cli/core/errors.py @@ -39,12 +39,10 @@ class QueryExecutionError(PtSnapCoreError): class ImportToolMissingError(PtSnapCoreError): - """Raised when the vendored snapshot import backend is unavailable. + """Raised when the built-in snapshot import backend is unavailable. - In the vendored model, this no longer means "the user forgot to install - memsnapdump" — the dump2db backend is built in. It means the vendored - backend could not be imported or initialized, which is a packaging - or installation problem. + The backend is part of pt-snap-cli, so this indicates a packaging or + installation problem rather than a missing optional tool. """ pass @@ -64,7 +62,7 @@ class SnapshotFileInvalidError(PtSnapCoreError): class ImportExecutionError(PtSnapCoreError): """Raised when the import backend itself fails to produce a database. - Covers upstream dump2db returning False, raising an exception, + Covers the snapshot adaptor returning False, raising an exception, or producing no .db artifact where one was expected. """ diff --git a/src/pt_snap_cli/core/import_service.py b/src/pt_snap_cli/core/import_service.py index 36af999..d5e2f38 100644 --- a/src/pt_snap_cli/core/import_service.py +++ b/src/pt_snap_cli/core/import_service.py @@ -22,7 +22,7 @@ class ImportService: - """Import PyTorch snapshot pickle files through the vendored backend.""" + """Import PyTorch snapshot pickle files through the built-in backend.""" def __init__( self, diff --git a/src/pt_snap_cli/core/snapshot_import_backend.py b/src/pt_snap_cli/core/snapshot_import_backend.py index e4bb023..0e6d56c 100644 --- a/src/pt_snap_cli/core/snapshot_import_backend.py +++ b/src/pt_snap_cli/core/snapshot_import_backend.py @@ -11,7 +11,7 @@ class SnapshotImportBackend: - """Stable adapter over the vendored snapshot-to-database implementation.""" + """Stable adapter over the first-party snapshot-to-database implementation.""" def dump_to_db( self, @@ -34,12 +34,10 @@ def dump_to_db( device=device, ) except (OSError, sqlite3.DatabaseError, pickle.UnpicklingError, ValueError) as exc: - raise ImportExecutionError( - f"Vendored snapshot import backend failed: {exc}" - ) from exc + raise ImportExecutionError(f"Snapshot import backend failed: {exc}") from exc if not ok: - raise ImportExecutionError("Vendored snapshot import backend reported failure.") + raise ImportExecutionError("Snapshot import backend reported failure.") if not tmp_db_path.is_file(): raise ImportExecutionError(f"Expected database not produced: {tmp_db_path}") @@ -49,9 +47,7 @@ def dump_to_db( try: os.replace(tmp_db_path, db_path) except OSError as exc: - raise ImportExecutionError( - f"Vendored snapshot import backend failed: {exc}" - ) from exc + raise ImportExecutionError(f"Snapshot import backend failed: {exc}") from exc return db_path @@ -62,10 +58,10 @@ def target_db_path(snapshot_file: Path, output_dir: Path) -> Path: @staticmethod def _load_run_dump_to_db(): try: - from pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db import run_dump_to_db + from pt_snap_cli.snapshot.tools.adaptors.snapshot2db import run_dump_to_db except ImportError as exc: raise ImportToolMissingError( - "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " + "Snapshot import backend is unavailable. Reinstall pt-snap-cli; " "the package may be incomplete." ) from exc return run_dump_to_db diff --git a/src/pt_snap_cli/vendor/memsnapdump/LICENSE b/src/pt_snap_cli/snapshot/LICENSE similarity index 73% rename from src/pt_snap_cli/vendor/memsnapdump/LICENSE rename to src/pt_snap_cli/snapshot/LICENSE index e37fe9a..368b755 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/LICENSE +++ b/src/pt_snap_cli/snapshot/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2026 codeasier +Copyright (c) 2026 Liu Yekang / codeasier Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -19,11 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - ---- - -The software in this directory is vendored from -https://github.com/codeasier/MemSnapDump, copyright (c) 2026 codeasier. The -upstream repository does not publish a top-level LICENSE file; the same -author publishes the same code under MIT terms in pt-snap-cli. See -ATTRIBUTION.md for the pinned upstream commit SHA and sync strategy. diff --git a/src/pt_snap_cli/snapshot/PROVENANCE.md b/src/pt_snap_cli/snapshot/PROVENANCE.md new file mode 100644 index 0000000..ea5ab4d --- /dev/null +++ b/src/pt_snap_cli/snapshot/PROVENANCE.md @@ -0,0 +1,101 @@ +# Snapshot Runtime Provenance + +## Source and license + +- Source repository: +- Source tag: `v0.1.0` +- Source commit: `87ea207372e0985790e1a28dab499dccf3c3b9a4` +- First-party migration date: 2026-07-31 +- Original copyright identity: Copyright (c) 2026 Liu Yekang / `codeasier` + +- License: MIT; terms are retained in `src/pt_snap_cli/snapshot/LICENSE`. +- Relicensing evidence: `docs/legal/memsnapdump-mit-relicensing.md` + +Liu Yekang confirmed sole authorship and copyright ownership, the absence of +unaccounted copied or third-party contributed code, and the MIT grant for this +pt-snap-cli integration. The evidence file records the dated confirmation and +corroborating repository audit. + +## Retained source mappings + +Every URL is fixed to the audited commit rather than a moving branch or tag. + +| First-party path | Audited upstream blob | +| --- | --- | +| `snapshot/__init__.py` | | +| `snapshot/base/__init__.py` | | +| `snapshot/base/entities.py` | | +| `snapshot/simulate/__init__.py` | | +| `snapshot/simulate/allocator_context.py` | | +| `snapshot/simulate/allocator_hook_dispatcher.py` | | +| `snapshot/simulate/hooker_defs.py` | | +| `snapshot/simulate/replay_executor.py` | | +| `snapshot/simulate/simulate.py` | | +| `snapshot/simulate/simulated_caching_allocator.py` | | +| `snapshot/simulate/snapshot_lookup.py` | | +| `snapshot/simulate/snapshot_mutator.py` | | +| `snapshot/tools/adaptors/database/__init__.py` | | +| `snapshot/tools/adaptors/database/defs.py` | | +| `snapshot/tools/adaptors/database/entity2record.py` | | +| `snapshot/tools/adaptors/database/snapshot_db.py` | | +| `snapshot/tools/adaptors/snapshot2db.py` | | +| `snapshot/util/__init__.py` | | +| `snapshot/util/file_util.py` | | +| `snapshot/util/logger.py` | | +| `snapshot/util/sqlite_meta.py` | | +| `snapshot/util/timer.py` | | + +`snapshot/representation.py` is a pt-snap-cli-local shared loader/replay +entrypoint and has no direct upstream blob. + +## Deferred slice source mappings + +Task 4 intentionally does not add the split engine or service. These audited +runtime sources remain missing until the later split task: + +| Planned first-party path | Audited upstream blob | +| --- | --- | +| `snapshot/tools/slice_dump/__init__.py` | | +| `snapshot/tools/slice_dump/dump.py` | | +| `snapshot/tools/slice_dump/hooker.py` | | + +The upstream standalone split frontend is deliberately excluded, not deferred: +. + +## Local modifications + +- Commit `7a40d5c` retained the minimum import/replay closure and rewrote package + imports for pt-snap-cli. +- Commit `a14ff77` added `PRAGMA journal_mode = MEMORY`, `PRAGMA synchronous = + OFF`, and `PRAGMA cache_size = -65536` to the replaceable database writer. +- Commit `9740b3c` added indexes for trace `allocated`, `active`, and `reserved` + columns and block `alloc_event_id`, `free_event_id`, and `size` columns. +- On 2026-07-31, Task 4 relocated the closure to `pt_snap_cli.snapshot`, rewrote + internal/service/test/benchmark/CI imports, and removed the empty `vendor` + package. +- Task 4 added `representation.py` so import pickle loading, device snapshot + construction, hook registration, and replay pass through shared first-party + functions designed for later split reuse. +- Task 4 removed standalone argparse parsing, exit codes, `main()`, timer wiring, + and the module-entrypoint block from `snapshot2db.py`; callable `dump()` and + `run_dump_to_db()` behavior remains retained. +- Task 4 mechanically formatted the snapshot tree with Black and applied Ruff's + safe import, typing, f-string, export, and literal cleanups. The targeted + `B024`/`B027` suppression preserves optional no-op allocator callbacks, and + the targeted `B904` suppression preserves established corrupt-pickle exception + context. No behavior-altering modernization was applied. + +## Migration toolchain + +- Ruff: `0.15.8` +- Black: `26.3.1` (CPython 3.13.11) + +These are the actual versions queried and used during the 2026-07-31 migration. + +## Future update policy + +This record is append-only. The snapshot maintainer owns it and must append an +entry for every future update under `src/pt_snap_cli/snapshot/`, recording the +date, affected scope, source or local-change identity, and reason. Existing +source mappings, modification history, and licensing evidence must not be +rewritten or removed; corrections are appended with their rationale. diff --git a/src/pt_snap_cli/snapshot/__init__.py b/src/pt_snap_cli/snapshot/__init__.py new file mode 100644 index 0000000..a4165a4 --- /dev/null +++ b/src/pt_snap_cli/snapshot/__init__.py @@ -0,0 +1,3 @@ +from .representation import load_snapshot_representation, replay_snapshot + +__all__ = ["load_snapshot_representation", "replay_snapshot"] diff --git a/src/pt_snap_cli/vendor/memsnapdump/base/__init__.py b/src/pt_snap_cli/snapshot/base/__init__.py similarity index 50% rename from src/pt_snap_cli/vendor/memsnapdump/base/__init__.py rename to src/pt_snap_cli/snapshot/base/__init__.py index 2f6be79..936f416 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/base/__init__.py +++ b/src/pt_snap_cli/snapshot/base/__init__.py @@ -1,3 +1,3 @@ -from .entities import Frame, TraceEntry, Block, BlockState, Segment, DeviceSnapshot +from .entities import Block, BlockState, DeviceSnapshot, Frame, Segment, TraceEntry __all__ = ["Frame", "TraceEntry", "Block", "BlockState", "Segment", "DeviceSnapshot"] diff --git a/src/pt_snap_cli/vendor/memsnapdump/base/entities.py b/src/pt_snap_cli/snapshot/base/entities.py similarity index 82% rename from src/pt_snap_cli/vendor/memsnapdump/base/entities.py rename to src/pt_snap_cli/snapshot/base/entities.py index 7c7d329..dd9c8fd 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/base/entities.py +++ b/src/pt_snap_cli/snapshot/base/entities.py @@ -1,5 +1,5 @@ -from typing import List, Literal, Any from dataclasses import dataclass, field +from typing import Any, Literal class Frame: @@ -51,7 +51,7 @@ class TraceEntry: """ action: str = "" addr: int = -1 # not present for OOM - frames: List[Frame] = field(default_factory=list) + frames: list[Frame] = field(default_factory=list) size: int = 0 stream: int = 0 device_free: int = -1 # only present for OOM, the amount of @@ -68,10 +68,7 @@ def from_dict(cls, trace_dict: dict): size=int(trace_dict["size"]), stream=int(trace_dict["stream"]), _origin=trace_dict, - frames=[ - Frame.from_dict(_frame_dict) - for _frame_dict in trace_dict.get("frames", []) - ], + frames=[Frame.from_dict(_frame_dict) for _frame_dict in trace_dict.get("frames", [])], ) return trace_entry @@ -79,23 +76,20 @@ def get_callstack(self): if not self.frames: return "" return "\n".join( - [ - f"{frame.filename}:{frame.line} {frame.name}" - for frame in self.frames[::-1] - ] + [f"{frame.filename}:{frame.line} {frame.name}" for frame in self.frames[::-1]] ) def to_dict(self): return ( self._origin if self._origin - else dict( - action=self.action, - addr=self.addr, - size=self.size, - stream=self.stream, - frames=[frame.to_dict() for frame in self.frames], - ) + else { + "action": self.action, + "addr": self.addr, + "size": self.size, + "stream": self.stream, + "frames": [frame.to_dict() for frame in self.frames], + } ) @@ -118,7 +112,7 @@ class Block: "active_pending_free", # waiting for another stream to finish using this, then it will become free "inactive", ] = BlockState.INACTIVE # free for reuse - frames: List[Frame] = field( + frames: list[Frame] = field( default_factory=list ) # stack trace from where the allocation occurred @@ -149,13 +143,13 @@ def build_from_event(cls, event: TraceEntry): return block def to_dict(self): - return dict( - size=self.size, - requested_size=self.requested_size, - address=self.address, - state=self.state, - frames=[frame.to_dict() for frame in self.frames], - ) + return { + "size": self.size, + "requested_size": self.requested_size, + "address": self.address, + "state": self.state, + "frames": [frame.to_dict() for frame in self.frames], + } @dataclass @@ -172,9 +166,9 @@ class Segment: segment_type: Literal["small", "large"] = "" # 'large' (>1MB) allocated_size: int = 0 # size of memory in use active_size: int = 0 # size of memory in use or in active_awaiting_free state - blocks: List[Block] = field(default_factory=list) + blocks: list[Block] = field(default_factory=list) device: int = 0 - frames: List[Frame] = field(default_factory=list) + frames: list[Frame] = field(default_factory=list) is_expandable: bool = False _origin: dict = None # Readonly free_or_unmap_event_idx: int = None @@ -189,9 +183,7 @@ def from_dict(cls, segment_dict: dict, ignore_inactive_blocks: bool = False): segment_type=segment_dict["segment_type"], allocated_size=segment_dict["allocated_size"], active_size=segment_dict["active_size"], - frames=[ - Frame.from_dict(_frame) for _frame in segment_dict.get("frames", []) - ], + frames=[Frame.from_dict(_frame) for _frame in segment_dict.get("frames", [])], device=segment_dict.get("device", 0), _origin=segment_dict, is_expandable=segment_dict.get("is_expandable", False), @@ -232,23 +224,23 @@ def build_from_event(cls, event: TraceEntry, with_inactive_block: bool = False): return segment def to_dict(self): - return dict( - address=self.address, - total_size=self.total_size, - stream=self.stream, - segment_type=self.segment_type, - allocated_size=self.allocated_size, - active_size=self.active_size, - device=self.device, - is_expandable=self.is_expandable, - frames=[frame.to_dict() for frame in self.frames], - blocks=[block.to_dict() for block in self.blocks], - ) + return { + "address": self.address, + "total_size": self.total_size, + "stream": self.stream, + "segment_type": self.segment_type, + "allocated_size": self.allocated_size, + "active_size": self.active_size, + "device": self.device, + "is_expandable": self.is_expandable, + "frames": [frame.to_dict() for frame in self.frames], + "blocks": [block.to_dict() for block in self.blocks], + } class DeviceSnapshot: - segments: List[Segment] - trace_entries: List[TraceEntry] + segments: list[Segment] + trace_entries: list[TraceEntry] total_allocated: int # 二次分配总量 total_reserved: int # 内存池总量 @@ -257,14 +249,10 @@ class DeviceSnapshot: device: int @classmethod - def from_dict( - cls, snapshot_dict: dict, device: int, ignore_inactive_blocks: bool = False - ): + def from_dict(cls, snapshot_dict: dict, device: int, ignore_inactive_blocks: bool = False): segments_dict = snapshot_dict.get("segments", []) device_traces = snapshot_dict.get("device_traces", []) - device_trace_list = ( - device_traces[device] if 0 <= device <= len(device_traces) else [] - ) + device_trace_list = device_traces[device] if 0 <= device <= len(device_traces) else [] snapshot = cls() snapshot.segments = [] snapshot.trace_entries = [] diff --git a/src/pt_snap_cli/snapshot/representation.py b/src/pt_snap_cli/snapshot/representation.py new file mode 100644 index 0000000..2dba159 --- /dev/null +++ b/src/pt_snap_cli/snapshot/representation.py @@ -0,0 +1,26 @@ +from pathlib import Path +from typing import Any + +from .simulate import AllocatorHooker, SimulateDeviceSnapshot, SimulateHooker +from .util.file_util import load_pickle_to_dict + + +def load_snapshot_representation(snapshot_file: str | Path) -> dict[str, Any]: + """Load the first-party snapshot representation from a trusted pickle.""" + return load_pickle_to_dict(Path(snapshot_file)) + + +def replay_snapshot( + representation: dict[str, Any], + device: int, + *, + hooker: SimulateHooker | None = None, + allocator_hooker: AllocatorHooker | None = None, +) -> tuple[SimulateDeviceSnapshot, bool]: + """Construct and replay one device through the shared snapshot runtime.""" + snapshot = SimulateDeviceSnapshot(representation, device) + if hooker is not None: + snapshot.register_hooker(hooker) + if allocator_hooker is not None: + snapshot.register_allocator_hooker(allocator_hooker) + return snapshot, snapshot.replay() diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py b/src/pt_snap_cli/snapshot/simulate/__init__.py similarity index 78% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py rename to src/pt_snap_cli/snapshot/simulate/__init__.py index fa76d11..7ba1cd4 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py +++ b/src/pt_snap_cli/snapshot/simulate/__init__.py @@ -1,6 +1,6 @@ -from .simulate import SimulateDeviceSnapshot -from .hooker_defs import SimulateHooker, AllocatorHooker from .allocator_context import AllocatorContext +from .hooker_defs import AllocatorHooker, SimulateHooker +from .simulate import SimulateDeviceSnapshot __all__ = [ "SimulateDeviceSnapshot", diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_context.py b/src/pt_snap_cli/snapshot/simulate/allocator_context.py similarity index 100% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_context.py rename to src/pt_snap_cli/snapshot/simulate/allocator_context.py diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py b/src/pt_snap_cli/snapshot/simulate/allocator_hook_dispatcher.py similarity index 77% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py rename to src/pt_snap_cli/snapshot/simulate/allocator_hook_dispatcher.py index f80b29f..78da158 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py +++ b/src/pt_snap_cli/snapshot/simulate/allocator_hook_dispatcher.py @@ -1,14 +1,12 @@ import copy -from typing import Dict from ..base import Block, DeviceSnapshot, Segment - from .hooker_defs import AllocatorHooker class AllocatorHookDispatcher: def __init__(self): - self.hookers: Dict[int, AllocatorHooker] = {} + self.hookers: dict[int, AllocatorHooker] = {} def register_hooker(self, hooker: AllocatorHooker) -> int: idx = hash(hooker) @@ -38,26 +36,18 @@ def post_replay_free_block( for hooker in self.hookers.values(): hooker.post_replay_free_block(payload, snapshot) - def pre_replay_map_or_alloc_segment( - self, segment: Segment, snapshot: DeviceSnapshot - ): + def pre_replay_map_or_alloc_segment(self, segment: Segment, snapshot: DeviceSnapshot): for hooker in self.hookers.values(): hooker.pre_replay_map_or_alloc_segment(segment, snapshot) - def post_replay_map_or_alloc_segment( - self, segment: Segment, snapshot: DeviceSnapshot - ): + def post_replay_map_or_alloc_segment(self, segment: Segment, snapshot: DeviceSnapshot): for hooker in self.hookers.values(): hooker.post_replay_map_or_alloc_segment(segment, snapshot) - def pre_replay_unmap_or_free_segment( - self, segment: Segment, snapshot: DeviceSnapshot - ): + def pre_replay_unmap_or_free_segment(self, segment: Segment, snapshot: DeviceSnapshot): for hooker in self.hookers.values(): hooker.pre_replay_unmap_or_free_segment(segment, snapshot) - def post_replay_unmap_or_free_segment( - self, segment: Segment, snapshot: DeviceSnapshot - ): + def post_replay_unmap_or_free_segment(self, segment: Segment, snapshot: DeviceSnapshot): for hooker in self.hookers.values(): hooker.post_replay_unmap_or_free_segment(segment, snapshot) diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/hooker_defs.py b/src/pt_snap_cli/snapshot/simulate/hooker_defs.py similarity index 85% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/hooker_defs.py rename to src/pt_snap_cli/snapshot/simulate/hooker_defs.py index d68e31e..a7587a5 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/hooker_defs.py +++ b/src/pt_snap_cli/snapshot/simulate/hooker_defs.py @@ -1,12 +1,14 @@ +# The allocator callbacks are intentionally optional no-ops for partial hook implementations. +# ruff: noqa: B024, B027 + from abc import ABC, abstractmethod -from ..base import DeviceSnapshot, Segment, Block, TraceEntry + +from ..base import Block, DeviceSnapshot, Segment, TraceEntry class SimulateHooker(ABC): @abstractmethod - def pre_undo_event( - self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot - ) -> bool: + def pre_undo_event(self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot) -> bool: """ 【READONLY】在回放事件前回调,此时事件列表**并未POP**出该事件 :param wait4undo_event: 【只读】待回放的事件(仍在事件列表中) @@ -29,9 +31,7 @@ def post_undo_event( class AllocatorHooker(ABC): - def pre_replay_alloc_block( - self, wait4alloc_block: Block, current_snapshot: DeviceSnapshot - ): + def pre_replay_alloc_block(self, wait4alloc_block: Block, current_snapshot: DeviceSnapshot): """ 在**回放时**分配一个内存块**前**回调,对应一个内存块释放事件回滚前 :param wait4alloc_block: 待分配的block @@ -39,9 +39,7 @@ def pre_replay_alloc_block( """ ... - def post_replay_alloc_block( - self, allocated_block: Block, current_snapshot: DeviceSnapshot - ): + def post_replay_alloc_block(self, allocated_block: Block, current_snapshot: DeviceSnapshot): """ 在**回放时**分配一个内存块**后**回调,对应一个内存块释放事件回滚后 :param allocated_block: 【只读】新分配的block @@ -49,9 +47,7 @@ def post_replay_alloc_block( """ ... - def pre_replay_free_block( - self, wait4free_block: Block, current_snapshot: DeviceSnapshot - ): + def pre_replay_free_block(self, wait4free_block: Block, current_snapshot: DeviceSnapshot): """ 在**回放时**释放一个内存块**前**回调,对应一个内存块申请事件回滚前 :param wait4free_block: 【只读】待释放的block @@ -59,9 +55,7 @@ def pre_replay_free_block( """ ... - def post_replay_free_block( - self, released_block: Block, current_snapshot: DeviceSnapshot - ): + def post_replay_free_block(self, released_block: Block, current_snapshot: DeviceSnapshot): """ 在回放时,释放一个内存块**后**回调,对应一个内存块申请事件回滚后 :param released_block: 【副本】已释放的block(副本) diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py b/src/pt_snap_cli/snapshot/simulate/replay_executor.py similarity index 99% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py rename to src/pt_snap_cli/snapshot/simulate/replay_executor.py index 803dc51..691fdf7 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py +++ b/src/pt_snap_cli/snapshot/simulate/replay_executor.py @@ -1,7 +1,6 @@ from logging import Logger from ..base import Block, BlockState, Segment, TraceEntry - from .simulated_caching_allocator import SimulatedCachingAllocator diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py b/src/pt_snap_cli/snapshot/simulate/simulate.py similarity index 88% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py rename to src/pt_snap_cli/snapshot/simulate/simulate.py index cc1fb3b..dbbee65 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py +++ b/src/pt_snap_cli/snapshot/simulate/simulate.py @@ -1,9 +1,7 @@ from logging import Logger -from typing import Dict from ..base import DeviceSnapshot from ..util import get_logger - from .allocator_context import AllocatorContext from .hooker_defs import AllocatorHooker, SimulateHooker from .replay_executor import ReplayExecutor @@ -15,7 +13,7 @@ class SimulateDeviceSnapshot: device_snapshot: DeviceSnapshot - hookers: Dict[int, SimulateHooker] + hookers: dict[int, SimulateHooker] device: int _loading_logger: Logger @@ -36,15 +34,9 @@ def __init__(self, snapshot_dict: dict, device: int): f"entries and {len(self.device_snapshot.segments)} segments." ) self.hookers = dict[int, SimulateHooker]() - self.simulated_allocator_context = AllocatorContext( - snapshot=self.device_snapshot - ) - self.simulated_allocator = SimulatedCachingAllocator( - self.simulated_allocator_context - ) - self.replay_executor = ReplayExecutor( - self.simulated_allocator, self._replay_logger - ) + self.simulated_allocator_context = AllocatorContext(snapshot=self.device_snapshot) + self.simulated_allocator = SimulatedCachingAllocator(self.simulated_allocator_context) + self.replay_executor = ReplayExecutor(self.simulated_allocator, self._replay_logger) # 识别昇腾torch-npu采集的snapshot中的workspace事件 if ( self.device_snapshot.trace_entries @@ -93,10 +85,7 @@ def replay(self) -> bool: return False self.device_snapshot.trace_entries.pop() current_size = len(self.device_snapshot.trace_entries) - if ( - progress_update_point - and progress_update_point[-1] * total_size >= current_size - ): + if progress_update_point and progress_update_point[-1] * total_size >= current_size: self._replay_logger.info( f"{(1 - progress_update_point[-1]) * 100}% of entries have been processed, " f"{current_size} entries remain." diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py b/src/pt_snap_cli/snapshot/simulate/simulated_caching_allocator.py similarity index 88% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py rename to src/pt_snap_cli/snapshot/simulate/simulated_caching_allocator.py index 7de5356..8afe8c8 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py +++ b/src/pt_snap_cli/snapshot/simulate/simulated_caching_allocator.py @@ -1,11 +1,10 @@ import copy -from ..base import BlockState, Block, Segment, TraceEntry +from ..base import Block, BlockState, Segment, TraceEntry from ..util import get_logger - +from . import snapshot_lookup, snapshot_mutator from .allocator_context import AllocatorContext from .allocator_hook_dispatcher import AllocatorHookDispatcher -from . import snapshot_lookup, snapshot_mutator allocator_logger = get_logger("ALLOCATOR") @@ -41,17 +40,12 @@ def alloc_block(self, new_block: Block) -> bool: segment, insert_idx = gap_result if self.ctx.current_undo_event: new_block.free_event_idx = self.ctx.current_undo_event.idx - if ( - self.ctx.current_undo_event - and self.ctx.current_undo_event.action == "free_completed" - ): + if self.ctx.current_undo_event and self.ctx.current_undo_event.action == "free_completed": new_block.state = BlockState.ACTIVE_PENDING_FREE else: new_block.state = BlockState.ACTIVE_ALLOCATED self.dispatcher.pre_replay_alloc_block(new_block, self.ctx.device_snapshot) - snapshot_mutator.attach_block( - self.ctx.device_snapshot, segment, new_block, insert_idx - ) + snapshot_mutator.attach_block(self.ctx.device_snapshot, segment, new_block, insert_idx) self.dispatcher.post_replay_alloc_block(new_block, self.ctx.device_snapshot) return True @@ -77,9 +71,7 @@ def free_block(self, alloc_event: TraceEntry) -> bool: f"{_error}: cannot find block (addr={alloc_event.addr}), workspace scenario tolerance" ) return True - allocator_logger.error( - f"{_error}: cannot find block (addr={alloc_event.addr})" - ) + allocator_logger.error(f"{_error}: cannot find block (addr={alloc_event.addr})") return False if exist_block.size < alloc_event.size: allocator_logger.error( @@ -91,9 +83,7 @@ def free_block(self, alloc_event: TraceEntry) -> bool: if not snapshot_mutator.detach_block(self.ctx.device_snapshot, exist_block): allocator_logger.error(f"{_error}: block has no segment_ptr") return False - self.dispatcher.post_replay_free_block( - exist_block, self.ctx.device_snapshot, use_copy=True - ) + self.dispatcher.post_replay_free_block(exist_block, self.ctx.device_snapshot, use_copy=True) return True def active_block(self, free_requested_event: TraceEntry) -> bool: @@ -136,9 +126,7 @@ def active_block(self, free_requested_event: TraceEntry) -> bool: if not snapshot_mutator.promote_pending_free_block( self.ctx.device_snapshot, active_pending_free_block ): - allocator_logger.error( - f"{_error}: the found active pending block's segment is none." - ) + allocator_logger.error(f"{_error}: the found active pending block's segment is none.") return False return True @@ -150,16 +138,12 @@ def alloc_or_map_segment(self, new_segment: Segment, merge: bool = False) -> boo """ _error = "Failed to alloc or map segment" segments = self.ctx.device_snapshot.segments - self.dispatcher.pre_replay_map_or_alloc_segment( - new_segment, self.ctx.device_snapshot - ) + self.dispatcher.pre_replay_map_or_alloc_segment(new_segment, self.ctx.device_snapshot) if self.ctx.current_undo_event: new_segment.free_or_unmap_event_idx = self.ctx.current_undo_event.idx if not merge: snapshot_mutator.insert_segment(self.ctx.device_snapshot, new_segment) - self.dispatcher.post_replay_map_or_alloc_segment( - new_segment, self.ctx.device_snapshot - ) + self.dispatcher.post_replay_map_or_alloc_segment(new_segment, self.ctx.device_snapshot) return True new_seg_start = new_segment.address new_seg_end = new_seg_start + new_segment.total_size @@ -174,9 +158,7 @@ def alloc_or_map_segment(self, new_segment: Segment, merge: bool = False) -> boo right_adjacent_idx = i if left_adjacent_idx == -1 and right_adjacent_idx == -1: snapshot_mutator.insert_segment(self.ctx.device_snapshot, new_segment) - self.dispatcher.post_replay_map_or_alloc_segment( - new_segment, self.ctx.device_snapshot - ) + self.dispatcher.post_replay_map_or_alloc_segment(new_segment, self.ctx.device_snapshot) return True virtual_map_segment = copy.deepcopy(new_segment) if not snapshot_mutator.merge_mapped_segment( @@ -187,9 +169,7 @@ def alloc_or_map_segment(self, new_segment: Segment, merge: bool = False) -> boo ): allocator_logger.error(f"{_error}: failed to merge adjacent segments") return False - snapshot_mutator.increase_reserved( - self.ctx.device_snapshot, virtual_map_segment.total_size - ) + snapshot_mutator.increase_reserved(self.ctx.device_snapshot, virtual_map_segment.total_size) self.dispatcher.post_replay_map_or_alloc_segment( virtual_map_segment, self.ctx.device_snapshot ) @@ -223,13 +203,9 @@ def free_segment(self, alloc_seg_event: TraceEntry) -> bool: return False exist_seg.alloc_or_map_event_idx = alloc_seg_event.idx - self.dispatcher.pre_replay_unmap_or_free_segment( - exist_seg, self.ctx.device_snapshot - ) + self.dispatcher.pre_replay_unmap_or_free_segment(exist_seg, self.ctx.device_snapshot) snapshot_mutator.remove_segment(self.ctx.device_snapshot, exist_seg) - self.dispatcher.post_replay_unmap_or_free_segment( - exist_seg, self.ctx.device_snapshot - ) + self.dispatcher.post_replay_unmap_or_free_segment(exist_seg, self.ctx.device_snapshot) return True def unmap_segment(self, map_event): diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py b/src/pt_snap_cli/snapshot/simulate/snapshot_lookup.py similarity index 87% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py rename to src/pt_snap_cli/snapshot/simulate/snapshot_lookup.py index 58f5611..2ff359b 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py +++ b/src/pt_snap_cli/snapshot/simulate/snapshot_lookup.py @@ -1,5 +1,3 @@ -from typing import Optional, Tuple - from ..base import Block, DeviceSnapshot, Segment @@ -33,18 +31,12 @@ def _scan_overlapping_segments_for_stream( for i in range(mid - 1, -1, -1): if addr < segments[i].address: break - if ( - addr < segments[i].address + segments[i].total_size - and segments[i].stream == stream - ): + if addr < segments[i].address + segments[i].total_size and segments[i].stream == stream: return i, segments[i] for i in range(mid + 1, len(segments)): if addr < segments[i].address: break - if ( - addr < segments[i].address + segments[i].total_size - and segments[i].stream == stream - ): + if addr < segments[i].address + segments[i].total_size and segments[i].stream == stream: return i, segments[i] return -1, None @@ -69,16 +61,12 @@ def find_overlapping_segment( left = mid + 1 else: if stream is not None and segments[mid].stream != stream: - return _scan_overlapping_segments_for_stream( - segments, mid, addr, stream - ) + return _scan_overlapping_segments_for_stream(segments, mid, addr, stream) return mid, segments[mid] return -1, None -def find_segment( - snapshot: DeviceSnapshot, addr: int, stream: int -) -> tuple[int, Segment | None]: +def find_segment(snapshot: DeviceSnapshot, addr: int, stream: int) -> tuple[int, Segment | None]: """Find the segment whose start address exactly matches the given address. Returns `(idx, segment)` for an exact start-address and stream match, @@ -92,7 +80,7 @@ def find_segment( def find_gap_for_alloc_block( snapshot: DeviceSnapshot, event_addr: int, event_size: int, stream: int = None -) -> Optional[Tuple[Segment, int]]: +) -> tuple[Segment, int] | None: """Find the insertion gap for a block allocation inside a segment. Returns `(segment, insert_idx)` when a valid gap exists, otherwise `None`. diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py b/src/pt_snap_cli/snapshot/simulate/snapshot_mutator.py similarity index 91% rename from src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py rename to src/pt_snap_cli/snapshot/simulate/snapshot_mutator.py index 4bc7126..e1118bf 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py +++ b/src/pt_snap_cli/snapshot/simulate/snapshot_mutator.py @@ -9,9 +9,7 @@ # Public API: block mutation helpers -def attach_block( - snapshot: DeviceSnapshot, segment: Segment, block: Block, insert_idx: int -): +def attach_block(snapshot: DeviceSnapshot, segment: Segment, block: Block, insert_idx: int): """Attach a block to a segment and update allocation totals. Mutates the block, the owning segment, and snapshot totals in place. @@ -101,9 +99,7 @@ def merge_mapped_segment( """ _error = "Failed to merge mapped segment" if left_adjacent_idx == -1 and right_adjacent_idx == -1: - snapshot_mutator_logger.error( - f"{_error}: both adjacent segment indices are missing" - ) + snapshot_mutator_logger.error(f"{_error}: both adjacent segment indices are missing") return False segments = snapshot.segments @@ -123,9 +119,7 @@ def merge_mapped_segment( new_idx = segments.index(new_segment) corrected_right_idx = new_idx + 1 if corrected_right_idx >= len(segments): - snapshot_mutator_logger.error( - f"{_error}: right adjacent segment missing after insert" - ) + snapshot_mutator_logger.error(f"{_error}: right adjacent segment missing after insert") segments.remove(new_segment) return False if corrected_right_idx != right_adjacent_idx + 1: @@ -194,19 +188,13 @@ def _merge_segments(snapshot: DeviceSnapshot, target_idx: int, source_idx: int) _error = "Failed to merge segments" segments = snapshot.segments if target_idx < 0 or target_idx >= len(segments): - snapshot_mutator_logger.error( - f"{_error}: invalid target segment index {target_idx}" - ) + snapshot_mutator_logger.error(f"{_error}: invalid target segment index {target_idx}") return False if source_idx < 0 or source_idx >= len(segments): - snapshot_mutator_logger.error( - f"{_error}: invalid source segment index {source_idx}" - ) + snapshot_mutator_logger.error(f"{_error}: invalid source segment index {source_idx}") return False if target_idx == source_idx: - snapshot_mutator_logger.error( - f"{_error}: target and source are the same segment" - ) + snapshot_mutator_logger.error(f"{_error}: target and source are the same segment") return False target = segments[target_idx] source = segments[source_idx] @@ -237,9 +225,7 @@ def _merge_segments(snapshot: DeviceSnapshot, target_idx: int, source_idx: int) return True -def _split_segment_at( - snapshot: DeviceSnapshot, seg_idx: int, cut_addr: int, cut_size: int -) -> bool: +def _split_segment_at(snapshot: DeviceSnapshot, seg_idx: int, cut_addr: int, cut_size: int) -> bool: """Split a segment around a cut range and keep non-overlapping blocks. Mutates `snapshot.segments` in place. Returns `True` on success, otherwise @@ -355,9 +341,7 @@ def _shrink_segment( new_start = shrink_end new_size = seg_end - new_start if new_size < 0: - snapshot_mutator_logger.error( - f"{_error}: shrink results in negative segment size" - ) + snapshot_mutator_logger.error(f"{_error}: shrink results in negative segment size") return False for block in segment.blocks: block_start = block.address @@ -369,9 +353,7 @@ def _shrink_segment( return False segment.address = new_start segment.total_size = new_size - segment.blocks = [ - block for block in segment.blocks if block.address >= new_start - ] + segment.blocks = [block for block in segment.blocks if block.address >= new_start] else: if shrink_addr < seg_start or shrink_end > seg_end: snapshot_mutator_logger.error( @@ -380,9 +362,7 @@ def _shrink_segment( return False new_size = shrink_addr - seg_start if new_size < 0: - snapshot_mutator_logger.error( - f"{_error}: shrink results in negative segment size" - ) + snapshot_mutator_logger.error(f"{_error}: shrink results in negative segment size") return False for block in segment.blocks: block_start = block.address @@ -393,9 +373,7 @@ def _shrink_segment( ) return False segment.blocks = [ - block - for block in segment.blocks - if block.address + block.size <= shrink_addr + block for block in segment.blocks if block.address + block.size <= shrink_addr ] segment.total_size = new_size segment.allocated_size = sum( diff --git a/src/pt_snap_cli/snapshot/tools/adaptors/database/__init__.py b/src/pt_snap_cli/snapshot/tools/adaptors/database/__init__.py new file mode 100644 index 0000000..d635e29 --- /dev/null +++ b/src/pt_snap_cli/snapshot/tools/adaptors/database/__init__.py @@ -0,0 +1,10 @@ +from .entity2record import block2record, event2record +from .snapshot_db import BLOCK_STATE_VALUE_MAP, TRACE_ENTRY_ACTION_VALUE_MAP, SnapshotDb + +__all__ = [ + "BLOCK_STATE_VALUE_MAP", + "TRACE_ENTRY_ACTION_VALUE_MAP", + "SnapshotDb", + "block2record", + "event2record", +] diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/defs.py b/src/pt_snap_cli/snapshot/tools/adaptors/database/defs.py similarity index 100% rename from src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/defs.py rename to src/pt_snap_cli/snapshot/tools/adaptors/database/defs.py diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py b/src/pt_snap_cli/snapshot/tools/adaptors/database/entity2record.py similarity index 75% rename from src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py rename to src/pt_snap_cli/snapshot/tools/adaptors/database/entity2record.py index 52b9d1a..8f9affc 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py +++ b/src/pt_snap_cli/snapshot/tools/adaptors/database/entity2record.py @@ -1,6 +1,5 @@ -from .defs import EventFieldDefs, BlockFieldDefs - -from ....base import TraceEntry, Block +from ....base import Block, TraceEntry +from .defs import BlockFieldDefs, EventFieldDefs def make_default_id_counter(start: int = -1): @@ -23,13 +22,9 @@ def get_timestamp_by_event_idx(event_idx: int) -> int: next_default_event_id = make_default_id_counter() -def event2record( - event: TraceEntry, allocated: int = 0, active: int = 0, reserved: int = 0 -) -> dict: +def event2record(event: TraceEntry, allocated: int = 0, active: int = 0, reserved: int = 0) -> dict: return { - EventFieldDefs.ID: ( - event.idx if event.idx is not None else next_default_event_id() - ), + EventFieldDefs.ID: (event.idx if event.idx is not None else next_default_event_id()), EventFieldDefs.ACTION: event.action, EventFieldDefs.ADDR: event.addr, EventFieldDefs.SIZE: event.size, @@ -44,9 +39,7 @@ def event2record( def block2record(block: Block) -> dict: return { BlockFieldDefs.ID: ( - block.alloc_event_idx - if block.alloc_event_idx is not None - else next_default_block_id() + block.alloc_event_idx if block.alloc_event_idx is not None else next_default_block_id() ), BlockFieldDefs.ADDR: block.address, BlockFieldDefs.SIZE: block.size, diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py b/src/pt_snap_cli/snapshot/tools/adaptors/database/snapshot_db.py similarity index 93% rename from src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py rename to src/pt_snap_cli/snapshot/tools/adaptors/database/snapshot_db.py index c8b51d9..ef18173 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py +++ b/src/pt_snap_cli/snapshot/tools/adaptors/database/snapshot_db.py @@ -65,9 +65,7 @@ def __init__(self, path: str): def create_trace_entry_table(self, device: int = 0): self.create_table( - SqliteTable( - self.get_trace_table_name_by_device(device), _TRACE_ENTRY_TABLE_COLUMNS - ), + SqliteTable(self.get_trace_table_name_by_device(device), _TRACE_ENTRY_TABLE_COLUMNS), delete_if_exists=True, ) table = self.get_trace_entry_table(device) @@ -80,9 +78,7 @@ def create_trace_entry_table(self, device: int = 0): def create_block_table(self, device: int = 0): self.create_table( - SqliteTable( - self.get_block_table_name_by_device(device), _BLOCK_TABLE_COLUMNS - ), + SqliteTable(self.get_block_table_name_by_device(device), _BLOCK_TABLE_COLUMNS), delete_if_exists=True, ) table = self.get_block_table(device) diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py b/src/pt_snap_cli/snapshot/tools/adaptors/snapshot2db.py similarity index 53% rename from src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py rename to src/pt_snap_cli/snapshot/tools/adaptors/snapshot2db.py index 594c4e7..c66cfd4 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py +++ b/src/pt_snap_cli/snapshot/tools/adaptors/snapshot2db.py @@ -1,15 +1,10 @@ -import os -import sys -import argparse from pathlib import Path -from ...simulate import SimulateHooker, SimulateDeviceSnapshot, AllocatorHooker -from ...base import DeviceSnapshot, TraceEntry, Block, BlockState -from ...util.file_util import check_dir_valid, load_pickle_to_dict - -from .database import SnapshotDb, block2record, event2record +from ...base import Block, BlockState, DeviceSnapshot, TraceEntry +from ...representation import load_snapshot_representation, replay_snapshot +from ...simulate import AllocatorHooker, SimulateHooker from ...util.logger import get_logger, set_global_log_file -from ...util.timer import timer +from .database import SnapshotDb, block2record, event2record dump_logger = get_logger("DatabaseDump") @@ -18,25 +13,25 @@ class SnapshotDbHandler: def __init__(self, db_path: str, devices: list[int], insert_cache_size: int = 1000): self.db_path = db_path self.db = SnapshotDb(db_path) - self._device_event_cache = dict() - self._device_block_cache = dict() + self._device_event_cache = {} + self._device_block_cache = {} self._insert_cache_size = insert_cache_size for device in devices: - self._device_block_cache[device] = list() - self._device_event_cache[device] = list() + self._device_block_cache[device] = [] + self._device_event_cache[device] = [] self.db.create_trace_entry_table(device) self.db.create_block_table(device) def insert_event(self, event_record: dict, device: int = 0): if device not in self._device_event_cache: - self._device_event_cache[device] = list() + self._device_event_cache[device] = [] self._device_event_cache[device].append(event_record) if len(self._device_event_cache[device]) >= self._insert_cache_size: self._do_insert_events(device) def insert_block(self, block_record: dict, device: int = 0): if device not in self._device_block_cache: - self._device_block_cache[device] = list() + self._device_block_cache[device] = [] self._device_block_cache[device].append(block_record) if len(self._device_block_cache[device]) >= self._insert_cache_size: self._do_insert_blocks(device) @@ -49,7 +44,7 @@ def flush(self, device: int = 0): def _do_insert_events(self, device: int = 0): if device not in self._device_event_cache: - self._device_event_cache[device] = list() + self._device_event_cache[device] = [] return self.db.get_trace_entry_table(device).insert_records( self.db.conn, self._device_event_cache[device] @@ -59,7 +54,7 @@ def _do_insert_events(self, device: int = 0): def _do_insert_blocks(self, device: int = 0): if device not in self._device_block_cache: - self._device_block_cache[device] = list() + self._device_block_cache[device] = [] self.db.get_block_table(device).insert_records( self.db.conn, self._device_block_cache[device] ) @@ -73,9 +68,7 @@ def __del__(self): class DumpEventHooker(SimulateHooker, AllocatorHooker): def __init__(self, db_path: str, devices: list[int], dump_cache_size: int = 1000): - self.db_handler = SnapshotDbHandler( - db_path, devices, insert_cache_size=dump_cache_size - ) + self.db_handler = SnapshotDbHandler(db_path, devices, insert_cache_size=dump_cache_size) def post_undo_event( self, already_undo_event: TraceEntry, current_snapshot: DeviceSnapshot @@ -85,9 +78,7 @@ def post_undo_event( for seg in current_snapshot.segments: for block in seg.blocks: if block.state != BlockState.INACTIVE: - self.db_handler.insert_block( - block2record(block), current_snapshot.device - ) + self.db_handler.insert_block(block2record(block), current_snapshot.device) # segment不插入block表,而是以模拟事件插入事件表,便于后续重建segment mock_segment_alloc_event = TraceEntry( idx=None, @@ -108,9 +99,7 @@ def post_undo_event( ) return True - def pre_undo_event( - self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot - ) -> bool: + def pre_undo_event(self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot) -> bool: # 每个事件回放前dump一次event self.db_handler.insert_event( event2record( @@ -123,12 +112,8 @@ def pre_undo_event( ) return True - def post_replay_free_block( - self, released_block: Block, current_snapshot: DeviceSnapshot - ): - self.db_handler.insert_block( - block2record(released_block), current_snapshot.device - ) + def post_replay_free_block(self, released_block: Block, current_snapshot: DeviceSnapshot): + self.db_handler.insert_block(block2record(released_block), current_snapshot.device) def flush(self, device: int = 0): self.db_handler.flush(device) @@ -136,15 +121,13 @@ def flush(self, device: int = 0): def dump(pickle_file: str, dump_file: str, device=None) -> bool: try: - data = load_pickle_to_dict(Path(pickle_file)) + data = load_snapshot_representation(Path(pickle_file)) except Exception as e: - dump_logger.error("Failed to load pickle file: {}".format(e)) + dump_logger.error(f"Failed to load pickle file: {e}") return False device_traces = data.get("device_traces", []) # 当指定device为空时dump所有记录了跟踪事件的device,否则仅dump指定device - need_dump_devices = [ - device for device in range(len(device_traces)) if device_traces[device] - ] + need_dump_devices = [device for device in range(len(device_traces)) if device_traces[device]] dump_logger.info(f"Recognized have trace events devices {need_dump_devices}.") if device is not None and device not in need_dump_devices: dump_logger.error( @@ -157,82 +140,21 @@ def dump(pickle_file: str, dump_file: str, device=None) -> bool: hooker = DumpEventHooker(dump_file, need_dump_devices) for device in need_dump_devices: dump_logger.info(f"Start to dump the snapshot to database for device {device}.") - snapshot = SimulateDeviceSnapshot(data, device) - snapshot.register_hooker(hooker) - snapshot.register_allocator_hooker(hooker) - if not snapshot.replay(): - dump_logger.error( - f"Failed to dump the snapshot to database for device {device}." - ) + _, replayed = replay_snapshot( + data, + device, + hooker=hooker, + allocator_hooker=hooker, + ) + if not replayed: + dump_logger.error(f"Failed to dump the snapshot to database for device {device}.") return False dump_logger.info(f"Finished dump the snapshot to database for device {device}.") hooker.flush(device) - dump_logger.info( - f"Successfully dump the snapshot to database for devices {need_dump_devices}." - ) + dump_logger.info(f"Successfully dump the snapshot to database for devices {need_dump_devices}.") return True -def get_args(argv=None): - parser = argparse.ArgumentParser( - description="This script is used to parse and convert snapshot data into a database " - "format that is more convenient for visualization." - ) - arg_snapshot = parser.add_argument( - "snapshot_file", type=str, help="Memory snapshot file path." - ) - arg_dump_dir = parser.add_argument( - "--dump_dir", - "-o", - required=False, - type=str, - default="", - help="Specify the directory to store the parsed database file. If not provided, " - "the same directory as the specified snapshot file will be used by default.", - ) - arg_log_file = parser.add_argument( - "--log", - "-l", - required=False, - type=str, - default="", - help="Specify the log file path. If provided, all logs will be written to this file.", - ) - parser.add_argument( - "--device", - "-d", - required=False, - type=lambda x: ( - int(x) if int(x) >= 0 else parser.error("The device id must be at least 0") - ), - help="Specify the device id to dump. If not provided, " - "we will dump the data of all devices.", - ) - args = parser.parse_args(argv) - snapshot_path = Path(args.snapshot_file) - # 校验snapshot path - if not snapshot_path.is_file() or not os.access(args.snapshot_file, os.R_OK): - raise argparse.ArgumentError( - arg_snapshot, - "The specified snapshot file does not exist, or is not a file, or is not readable.", - ) - # 校验dump目标路径 - if not args.dump_dir: - args.dump_dir = snapshot_path.parent - if not Path(args.dump_dir).is_dir() or not check_dir_valid(args.dump_dir): - raise argparse.ArgumentError( - arg_dump_dir, - "The specified directory does not exist, or is not a directory, " - "or is not writable", - ) - if args.log: - try: - set_global_log_file(args.log) - except OSError as e: - raise argparse.ArgumentError(arg_log_file, str(e)) - return args - - def run_dump_to_db( snapshot_file: str, dump_dir: str = "", @@ -248,30 +170,3 @@ def run_dump_to_db( Path(resolved_dump_dir) / f"{Path(snapshot_file).name}.db", device, ) - - -class ExistCode: - SUCCESS = 0 - FAILED = -1 - - -@timer(name="Dump snapshot to database.", logger=dump_logger) -def main(argv=None): - try: - args = get_args(argv) - except argparse.ArgumentError as e: - dump_logger.error("Failed to parse arguments: {}".format(e)) - sys.exit(ExistCode.FAILED) - if not run_dump_to_db( - snapshot_file=args.snapshot_file, - dump_dir=str(args.dump_dir), - device=args.device, - log_file=args.log, - ): - dump_logger.error("Failed to dump the snapshot to database.") - sys.exit(ExistCode.FAILED) - sys.exit(ExistCode.SUCCESS) - - -if __name__ == "__main__": - main() diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/__init__.py b/src/pt_snap_cli/snapshot/util/__init__.py similarity index 100% rename from src/pt_snap_cli/vendor/memsnapdump/util/__init__.py rename to src/pt_snap_cli/snapshot/util/__init__.py diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/file_util.py b/src/pt_snap_cli/snapshot/util/file_util.py similarity index 92% rename from src/pt_snap_cli/vendor/memsnapdump/util/file_util.py rename to src/pt_snap_cli/snapshot/util/file_util.py index d2a15dd..7980a8a 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/util/file_util.py +++ b/src/pt_snap_cli/snapshot/util/file_util.py @@ -7,7 +7,7 @@ import os import pickle from pathlib import Path -from typing import Dict, Any +from typing import Any def load_pickle_to_dict(pickle_file: Path) -> dict: @@ -32,7 +32,8 @@ def load_pickle_to_dict(pickle_file: Path) -> dict: with open(pickle_file, "rb") as f: data = pickle.load(f) except Exception: - raise pickle.UnpicklingError(f"Cannot load pickle file: {pickle_file}") + # Preserve the established exception context and corrupt-pickle behavior. + raise pickle.UnpicklingError(f"Cannot load pickle file: {pickle_file}") # noqa: B904 if not isinstance(data, dict): raise ValueError( @@ -42,7 +43,7 @@ def load_pickle_to_dict(pickle_file: Path) -> dict: return data -def save_dict_to_pickle(data: Dict[Any, Any], path: Path, protocol: int = 4) -> None: +def save_dict_to_pickle(data: dict[Any, Any], path: Path, protocol: int = 4) -> None: """ 将字典保存为 pickle 文件。 @@ -56,9 +57,7 @@ def save_dict_to_pickle(data: Dict[Any, Any], path: Path, protocol: int = 4) -> OSError: 文件写入失败(如权限不足、磁盘满等) """ if not isinstance(data, dict): - raise TypeError( - f"Only dict type is supported, but received: {type(data).__name__}" - ) + raise TypeError(f"Only dict type is supported, but received: {type(data).__name__}") path.parent.mkdir(parents=True, exist_ok=True) # 自动创建父目录 try: diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/logger.py b/src/pt_snap_cli/snapshot/util/logger.py similarity index 91% rename from src/pt_snap_cli/vendor/memsnapdump/util/logger.py rename to src/pt_snap_cli/snapshot/util/logger.py index c132527..6b25845 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/util/logger.py +++ b/src/pt_snap_cli/snapshot/util/logger.py @@ -6,11 +6,11 @@ import logging from pathlib import Path -from typing import Optional + from .file_util import check_dir_valid -_global_log_file: Optional[str] = None -_global_file_handler: Optional[logging.FileHandler] = None +_global_log_file: str | None = None +_global_file_handler: logging.FileHandler | None = None def set_global_log_file(log_file: str) -> None: @@ -34,9 +34,7 @@ def set_global_log_file(log_file: str) -> None: raise OSError(f"Log directory '{parent_dir}' does not exist.") if not parent_dir.is_dir() or not check_dir_valid(parent_dir): - raise OSError( - f"Log directory '{parent_dir}' is not writable or does not exist." - ) + raise OSError(f"Log directory '{parent_dir}' is not writable or does not exist.") _global_log_file = str(log_path.absolute()) @@ -49,9 +47,7 @@ def set_global_log_file(log_file: str) -> None: style="{", ) - _global_file_handler = logging.FileHandler( - _global_log_file, mode="w", encoding="utf-8" - ) + _global_file_handler = logging.FileHandler(_global_log_file, mode="w", encoding="utf-8") _global_file_handler.setLevel(logging.DEBUG) _global_file_handler.setFormatter(formatter) diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py b/src/pt_snap_cli/snapshot/util/sqlite_meta.py similarity index 93% rename from src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py rename to src/pt_snap_cli/snapshot/util/sqlite_meta.py index 84604dd..cef2a82 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py +++ b/src/pt_snap_cli/snapshot/util/sqlite_meta.py @@ -8,16 +8,12 @@ import ast import os.path import sqlite3 +from collections.abc import Iterable from typing import ( Any, - Dict, - List, - Optional, - Type, Union, - Iterable, - get_origin, get_args, + get_origin, ) # 支持的 Python 类型映射 @@ -30,7 +26,7 @@ } -def _map_py_type_to_sqlite(py_type: Type) -> str: +def _map_py_type_to_sqlite(py_type: type) -> str: """将 Python 类型转换为 SQLite 类型""" origin = get_origin(py_type) or py_type if origin in _PY_TYPE_TO_SQLITE: @@ -117,13 +113,13 @@ class SqliteColumn: def __init__( self, name: str, - data_type: Type = str, + data_type: type = str, primary_key: bool = False, # 是否主键 autoincrement: bool = False, # 是否自增 not_null: bool = False, # 是否不可为空 unique: bool = False, # 是否唯一 - default: Optional[Any] = None, # 缺省值, - value_map: Dict[Any, Any] = None, + default: Any | None = None, # 缺省值, + value_map: dict[Any, Any] = None, ): if autoincrement and not primary_key: raise ValueError("autoincrement requires primary_key=True") @@ -205,13 +201,13 @@ class SqliteTable: """ name: str - column_dict: Dict[str, SqliteColumn] - _column_value_map: Dict[str, Dict[Any, Any]] + column_dict: dict[str, SqliteColumn] + _column_value_map: dict[str, dict[Any, Any]] def __init__(self, table_name: str, columns: Iterable[SqliteColumn] = None): self.name = table_name self.column_dict = {} - self._column_value_map = dict() + self._column_value_map = {} if columns: for column in columns: self.column_dict[column.name] = column @@ -240,9 +236,7 @@ def to_sql_def(self, delete_if_exists: bool = False) -> str: return f"{drop_sql}\n{create_sql}" else: # 使用 IF NOT EXISTS 更安全 - create_sql = create_sql.replace( - "CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1 - ) + create_sql = create_sql.replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1) return create_sql def create_table(self, conn: sqlite3.Connection, delete_if_exists: bool = False): @@ -267,7 +261,7 @@ def create_index(self, conn: sqlite3.Connection, column_name: str): ) conn.commit() - def insert_record(self, conn: sqlite3.Connection, record: Dict[str, Any]): + def insert_record(self, conn: sqlite3.Connection, record: dict[str, Any]): """ 插入单条记录。 @@ -280,7 +274,7 @@ def insert_record(self, conn: sqlite3.Connection, record: Dict[str, Any]): """ self.insert_records(conn, [record]) - def insert_records(self, conn: sqlite3.Connection, records: List[Dict[str, Any]]): + def insert_records(self, conn: sqlite3.Connection, records: list[dict[str, Any]]): """ 批量插入多条记录。 @@ -305,7 +299,7 @@ def insert_records(self, conn: sqlite3.Connection, records: List[Dict[str, Any]] conn.commit() @staticmethod - def get_insert_columns_by_record(record: Dict[str, Any]): + def get_insert_columns_by_record(record: dict[str, Any]): """ 从记录字典中获取插入列名列表。 @@ -318,7 +312,7 @@ def get_insert_columns_by_record(record: Dict[str, Any]): return [f"`{key}`" for key in record.keys()] @staticmethod - def get_insert_placeholder_by_record(record: Dict[str, Any]): + def get_insert_placeholder_by_record(record: dict[str, Any]): """ 生成插入语句的占位符字符串。 @@ -330,7 +324,7 @@ def get_insert_placeholder_by_record(record: Dict[str, Any]): """ return ", ".join(["?" for _ in record.keys()]) - def get_insert_values_by_records(self, records: List[Dict[str, Any]]): + def get_insert_values_by_records(self, records: list[dict[str, Any]]): """ 从记录列表中提取插入值,应用值映射。 @@ -343,10 +337,7 @@ def get_insert_values_by_records(self, records: List[Dict[str, Any]]): if not records: return [] return [ - tuple( - self._column_value_map.get(k, {}).get(r[k], r[k]) - for k in records[0].keys() - ) + tuple(self._column_value_map.get(k, {}).get(r[k], r[k]) for k in records[0].keys()) for r in records ] @@ -374,11 +365,9 @@ class SqliteDB: path: str conn: sqlite3.Connection - table_cache: Dict[str, SqliteTable] + table_cache: dict[str, SqliteTable] - def __init__( - self, path: str, auto_create: bool = True, with_dictionary_table: bool = False - ): + def __init__(self, path: str, auto_create: bool = True, with_dictionary_table: bool = False): self.path = os.path.realpath(path) if not os.path.exists(self.path): if not auto_create: @@ -413,7 +402,7 @@ def create_table(self, table: SqliteTable, delete_if_exists: bool = True): for key, value in value_map.items(): dictionary_table.insert_record( self.conn, - dict(table=table.name, column=column_name, key=value, value=key), + {"table": table.name, "column": column_name, "key": value, "value": key}, ) self.conn.commit() diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/timer.py b/src/pt_snap_cli/snapshot/util/timer.py similarity index 92% rename from src/pt_snap_cli/vendor/memsnapdump/util/timer.py rename to src/pt_snap_cli/snapshot/util/timer.py index 30f4926..7d6d57c 100644 --- a/src/pt_snap_cli/vendor/memsnapdump/util/timer.py +++ b/src/pt_snap_cli/snapshot/util/timer.py @@ -4,13 +4,13 @@ 提供函数执行时间测量的装饰器。 """ -import time import logging -from typing import Callable, Optional +import time +from collections.abc import Callable from functools import wraps -def timer(name: Optional[str] = None, logger: Optional[logging.Logger] = None): +def timer(name: str | None = None, logger: logging.Logger | None = None): """ 函数执行时间计时装饰器。 diff --git a/src/pt_snap_cli/vendor/__init__.py b/src/pt_snap_cli/vendor/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md b/src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md deleted file mode 100644 index 542820c..0000000 --- a/src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md +++ /dev/null @@ -1,74 +0,0 @@ -# Vendored MemSnapDump - -This directory contains a vendored copy of the `dump2db` toolchain from -[`codeasier/MemSnapDump`](https://github.com/codeasier/MemSnapDump). The vendored -code is the minimum closure required to invoke -`memsnapdump.tools.adaptors.snapshot2db.run_dump_to_db` from -`pt_snap_cli.core.snapshot_import_backend`. - -## Upstream metadata - -| Field | Value | -| ------------ | ------------------------------------------------------------------ | -| Repository | https://github.com/codeasier/MemSnapDump | -| Pinned SHA | `87ea207372e0985790e1a28dab499dccf3c3b9a4` (branch `master`, HEAD at vendoring time) | -| Vendored on | 2026-06-22 | -| Vendored by | pt-snap-cli maintainers | -| Closure size | 22 Python source files (5 `__init__.py` + 17 modules) | - -## License - -The upstream repository does not publish a top-level `LICENSE` file. Both -`pt-snap-cli` and `MemSnapDump` are developed by the same author and pt-snap-cli -inherits the upstream code under the same MIT license terms; see [`LICENSE`](./LICENSE) -in this directory for the full text. When upstream publishes a formal license -file in a future release, the pinned SHA in this file should be updated and -the upstream license text should replace this one. - -## Syncing strategy - -The closure is intentionally laid out to mirror the upstream module structure -one-to-one: - -``` -memsnapdump/ -├── __init__.py -├── base/ -├── simulate/ -├── tools/adaptors/database/ -└── util/ -``` - -This makes future re-syncs a matter of `diff -ru` between this tree and a fresh -upstream checkout, file by file. To resync: - -1. `git fetch https://github.com/codeasier/MemSnapDump.git master` -2. For each Python file under `src/pt_snap_cli/vendor/memsnapdump/`, copy the - upstream file from the same path, preserving the upstream license header - (if any). -3. Update the pinned SHA in the table above. -4. Re-run `pytest` and the wheel smoke test in CI. - -## Local modifications - -**None.** The vendored code is intended to be byte-identical to the pinned -upstream SHA, so that re-syncing is a clean replace operation. Any local fix -or workaround that the project needs should be applied in -`src/pt_snap_cli/core/snapshot_import_backend.py` (the semantic adapter) or -in `src/pt_snap_cli/core/import_service.py`, **not** in this directory. - -## Lint / format exclusion - -`pyproject.toml` excludes this entire tree from `black` and `ruff` so that -upstream code is not reformatted on every lint pass. When you upgrade the -pinned SHA, run `black` and `ruff` against the new tree first to surface any -drift between the upstream style and our pinned configuration. - -## Tooling - -- `black` and `ruff` are configured with `extend-exclude` covering - `src/pt_snap_cli/vendor/`. -- CI includes a wheel smoke test (`.github/workflows/test.yml`) that builds - the package, installs the wheel, and runs `pt-snap import` against a real - fixture. This guarantees that any packaging regression (e.g. setuptools - dropping the vendored closure) is caught before release. diff --git a/src/pt_snap_cli/vendor/memsnapdump/__init__.py b/src/pt_snap_cli/vendor/memsnapdump/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/__init__.py b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/__init__.py deleted file mode 100644 index 5e8aae8..0000000 --- a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from .snapshot_db import SnapshotDb, TRACE_ENTRY_ACTION_VALUE_MAP, BLOCK_STATE_VALUE_MAP -from .entity2record import event2record, block2record - -__all__ = ["SnapshotDb", "event2record", "block2record"] diff --git a/tests/core/test_import_errors.py b/tests/core/test_import_errors.py index 240588e..5f31034 100644 --- a/tests/core/test_import_errors.py +++ b/tests/core/test_import_errors.py @@ -1,4 +1,4 @@ -"""Tests for vendoring-era import error types.""" +"""Tests for snapshot import error types.""" from __future__ import annotations diff --git a/tests/core/test_import_service.py b/tests/core/test_import_service.py index c0fec0b..ba3439c 100644 --- a/tests/core/test_import_service.py +++ b/tests/core/test_import_service.py @@ -79,7 +79,7 @@ def test_import_snapshot_file_invalid_missing(tmp_path: Path) -> None: def test_import_snapshot_file_invalid_suffix(tmp_path: Path) -> None: - """Wrong suffix is rejected before the vendor backend is invoked.""" + """Wrong suffix is rejected before the snapshot backend is invoked.""" import_service_cls = _import_service_type() service = import_service_cls() snapshot_file = tmp_path / "foo.txt" @@ -93,14 +93,14 @@ def test_import_snapshot_file_invalid_corrupt_pickle(tmp_path: Path) -> None: """A .pkl file that cannot be unpickled surfaces as an import execution error. After removing the redundant upfront pickle.load, the suffix check passes - for ``.pkl`` and the failure is reported by the vendored backend, which + for ``.pkl`` and the failure is reported by the snapshot backend, which surfaces as :class:`ImportExecutionError`. """ import_service_cls = _import_service_type() service = import_service_cls() snapshot_file = tmp_path / "corrupt.pkl" # Real pickle protocol header followed by garbage: passes suffix check, - # fails inside the vendor's load_pickle_to_dict. + # fails inside the shared first-party representation loader. snapshot_file.write_bytes(b"\x80\x04not a valid pickle stream") with pytest.raises(ImportExecutionError, match=r"backend (failed|reported failure)"): @@ -147,14 +147,14 @@ def fail_replace(*args: object) -> None: ) -def test_snapshot_import_backend_lazy_loads_vendor_module() -> None: +def test_snapshot_import_backend_lazy_loads_exact_runtime_module() -> None: sys.modules.pop("pt_snap_cli.core.snapshot_import_backend", None) - vendor_module = "pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db" - sys.modules.pop(vendor_module, None) + runtime_module = "pt_snap_cli.snapshot.tools.adaptors.snapshot2db" + sys.modules.pop(runtime_module, None) importlib.import_module("pt_snap_cli.core.snapshot_import_backend") - assert vendor_module not in sys.modules + assert runtime_module not in sys.modules def test_import_raises_on_missing_tool(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: @@ -163,13 +163,13 @@ def test_import_raises_on_missing_tool(monkeypatch: pytest.MonkeyPatch, tmp_path def raise_missing_tool(*args: object, **kwargs: object) -> Path: raise ImportToolMissingError( - "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " + "Snapshot import backend is unavailable. Reinstall pt-snap-cli; " "the package may be incomplete." ) monkeypatch.setattr(service._backend, "dump_to_db", raise_missing_tool) - with pytest.raises(ImportToolMissingError, match="Vendored snapshot import backend"): + with pytest.raises(ImportToolMissingError, match="Snapshot import backend"): service.import_snapshot( ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path) ) @@ -186,7 +186,7 @@ def fail_dump_to_db( device: int | None, finalize_temp_db=None, ) -> Path: - raise ImportExecutionError("Vendored snapshot import backend failed: upstream failed") + raise ImportExecutionError("Snapshot import backend failed: runtime failed") monkeypatch.setattr(service._backend, "dump_to_db", fail_dump_to_db) diff --git a/tests/fixtures/snapshots/snapshot_1768383987920985470.pkl b/tests/fixtures/snapshots/snapshot_1768383987920985470.pkl old mode 100755 new mode 100644 diff --git a/tests/fixtures/snapshots/snapshot_expandable.pkl b/tests/fixtures/snapshots/snapshot_expandable.pkl old mode 100755 new mode 100644 diff --git a/tests/snapshot/helpers.py b/tests/snapshot/helpers.py index f5d017c..0575f86 100644 --- a/tests/snapshot/helpers.py +++ b/tests/snapshot/helpers.py @@ -2,7 +2,7 @@ from pathlib import Path -from pt_snap_cli.vendor.memsnapdump.base import BlockState, DeviceSnapshot, Segment +from pt_snap_cli.snapshot.base import BlockState, DeviceSnapshot, Segment FIXTURE_DIR = Path(__file__).parents[1] / "fixtures" / "snapshots" diff --git a/tests/snapshot/test_allocator_hook_dispatcher.py b/tests/snapshot/test_allocator_hook_dispatcher.py index d68de5a..f72da16 100644 --- a/tests/snapshot/test_allocator_hook_dispatcher.py +++ b/tests/snapshot/test_allocator_hook_dispatcher.py @@ -1,5 +1,5 @@ -from pt_snap_cli.vendor.memsnapdump.base import Block, DeviceSnapshot, Segment -from pt_snap_cli.vendor.memsnapdump.simulate.allocator_hook_dispatcher import ( +from pt_snap_cli.snapshot.base import Block, DeviceSnapshot, Segment +from pt_snap_cli.snapshot.simulate.allocator_hook_dispatcher import ( AllocatorHookDispatcher, ) diff --git a/tests/snapshot/test_entities.py b/tests/snapshot/test_entities.py index 54cae0f..9e63e76 100644 --- a/tests/snapshot/test_entities.py +++ b/tests/snapshot/test_entities.py @@ -1,6 +1,6 @@ import unittest -from pt_snap_cli.vendor.memsnapdump.base import ( +from pt_snap_cli.snapshot.base import ( Block, BlockState, DeviceSnapshot, @@ -8,7 +8,7 @@ Segment, TraceEntry, ) -from pt_snap_cli.vendor.memsnapdump.simulate.snapshot_lookup import ( +from pt_snap_cli.snapshot.simulate.snapshot_lookup import ( find_block, find_overlapping_segment, find_segment, diff --git a/tests/snapshot/test_entity2record.py b/tests/snapshot/test_entity2record.py index 083cfe7..a2e9e9f 100644 --- a/tests/snapshot/test_entity2record.py +++ b/tests/snapshot/test_entity2record.py @@ -1,9 +1,9 @@ -from pt_snap_cli.vendor.memsnapdump.base import Block, Frame, TraceEntry -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.defs import ( +from pt_snap_cli.snapshot.base import Block, Frame, TraceEntry +from pt_snap_cli.snapshot.tools.adaptors.database.defs import ( BlockFieldDefs, EventFieldDefs, ) -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.entity2record import ( +from pt_snap_cli.snapshot.tools.adaptors.database.entity2record import ( block2record, event2record, get_timestamp_by_event_idx, diff --git a/tests/snapshot/test_file_util.py b/tests/snapshot/test_file_util.py index b4a8ff2..ccbdcdb 100644 --- a/tests/snapshot/test_file_util.py +++ b/tests/snapshot/test_file_util.py @@ -3,7 +3,7 @@ import pytest -from pt_snap_cli.vendor.memsnapdump.util.file_util import ( +from pt_snap_cli.snapshot.util.file_util import ( check_dir_valid, check_file_valid, load_pickle_to_dict, diff --git a/tests/snapshot/test_logger.py b/tests/snapshot/test_logger.py index 5494af8..3b2c431 100644 --- a/tests/snapshot/test_logger.py +++ b/tests/snapshot/test_logger.py @@ -3,7 +3,7 @@ import pytest -from pt_snap_cli.vendor.memsnapdump.util import logger as logger_module +from pt_snap_cli.snapshot.util import logger as logger_module @pytest.fixture(autouse=True) diff --git a/tests/snapshot/test_replay_executor.py b/tests/snapshot/test_replay_executor.py index 43e82f6..fe0cdc2 100644 --- a/tests/snapshot/test_replay_executor.py +++ b/tests/snapshot/test_replay_executor.py @@ -2,8 +2,8 @@ import pytest -from pt_snap_cli.vendor.memsnapdump.base import BlockState, TraceEntry -from pt_snap_cli.vendor.memsnapdump.simulate.replay_executor import ReplayExecutor +from pt_snap_cli.snapshot.base import BlockState, TraceEntry +from pt_snap_cli.snapshot.simulate.replay_executor import ReplayExecutor class FakeAllocator: diff --git a/tests/snapshot/test_simulate.py b/tests/snapshot/test_simulate.py index ba85557..4514729 100644 --- a/tests/snapshot/test_simulate.py +++ b/tests/snapshot/test_simulate.py @@ -5,12 +5,12 @@ import pytest -from pt_snap_cli.vendor.memsnapdump.base import BlockState -from pt_snap_cli.vendor.memsnapdump.simulate import SimulateDeviceSnapshot, SimulateHooker -from pt_snap_cli.vendor.memsnapdump.simulate.hooker_defs import AllocatorHooker -from pt_snap_cli.vendor.memsnapdump.simulate.snapshot_lookup import find_overlapping_segment -from pt_snap_cli.vendor.memsnapdump.util.file_util import load_pickle_to_dict -from pt_snap_cli.vendor.memsnapdump.util.logger import restore_logs, suppress_logs +from pt_snap_cli.snapshot.base import BlockState +from pt_snap_cli.snapshot.simulate import SimulateDeviceSnapshot, SimulateHooker +from pt_snap_cli.snapshot.simulate.hooker_defs import AllocatorHooker +from pt_snap_cli.snapshot.simulate.snapshot_lookup import find_overlapping_segment +from pt_snap_cli.snapshot.util.file_util import load_pickle_to_dict +from pt_snap_cli.snapshot.util.logger import restore_logs, suppress_logs from .golden_observations import FIXTURE_REPLAY_GOLDEN from .helpers import FIXTURE_DIR, assert_valid_segments, assert_valid_snapshot diff --git a/tests/snapshot/test_snapshot2db_runtime.py b/tests/snapshot/test_snapshot2db_runtime.py index d1524a3..c849b63 100644 --- a/tests/snapshot/test_snapshot2db_runtime.py +++ b/tests/snapshot/test_snapshot2db_runtime.py @@ -3,14 +3,14 @@ import pytest -from pt_snap_cli.vendor.memsnapdump.tools.adaptors import snapshot2db -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database import ( +from pt_snap_cli.snapshot.tools.adaptors import snapshot2db +from pt_snap_cli.snapshot.tools.adaptors.database import ( BLOCK_STATE_VALUE_MAP as RUNTIME_BLOCK_STATE_VALUE_MAP, ) -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database import ( +from pt_snap_cli.snapshot.tools.adaptors.database import ( TRACE_ENTRY_ACTION_VALUE_MAP as RUNTIME_ACTION_VALUE_MAP, ) -from pt_snap_cli.vendor.memsnapdump.util.logger import restore_logs, suppress_logs +from pt_snap_cli.snapshot.util.logger import restore_logs, suppress_logs from .golden_observations import ( ACTION_VALUE_MAP, @@ -53,6 +53,27 @@ def test_snapshot2db(dump_database): assert connection.execute("SELECT COUNT(*) FROM block_0").fetchone()[0] == 3219 +def test_snapshot2db_uses_shared_load_and_replay_entrypoints(monkeypatch, tmp_path): + database = tmp_path / "shared-entrypoints.db" + original_load = snapshot2db.load_snapshot_representation + original_replay = snapshot2db.replay_snapshot + calls = {"load": 0, "replay": 0} + + def load(snapshot_file): + calls["load"] += 1 + return original_load(snapshot_file) + + def replay(representation, device, **kwargs): + calls["replay"] += 1 + return original_replay(representation, device, **kwargs) + + monkeypatch.setattr(snapshot2db, "load_snapshot_representation", load) + monkeypatch.setattr(snapshot2db, "replay_snapshot", replay) + + assert snapshot2db.dump(FIXTURE_DIR / "snapshot_with_empty_cache.pkl", database, 0) + assert calls == {"load": 1, "replay": 1} + + def test_expandable_snapshot2db(dump_database): result, database = dump_database("snapshot_with_empty_cache_expandable.pkl", 0) diff --git a/tests/snapshot/test_snapshot_lookup.py b/tests/snapshot/test_snapshot_lookup.py index cfdcb58..cce4436 100644 --- a/tests/snapshot/test_snapshot_lookup.py +++ b/tests/snapshot/test_snapshot_lookup.py @@ -1,7 +1,7 @@ import unittest -from pt_snap_cli.vendor.memsnapdump.base import Block, BlockState, DeviceSnapshot, Segment -from pt_snap_cli.vendor.memsnapdump.simulate.snapshot_lookup import ( +from pt_snap_cli.snapshot.base import Block, BlockState, DeviceSnapshot, Segment +from pt_snap_cli.snapshot.simulate.snapshot_lookup import ( find_block, find_gap_for_alloc_block, find_overlapping_segment, diff --git a/tests/snapshot/test_snapshot_mutator.py b/tests/snapshot/test_snapshot_mutator.py index 50d8398..7cf812d 100644 --- a/tests/snapshot/test_snapshot_mutator.py +++ b/tests/snapshot/test_snapshot_mutator.py @@ -1,15 +1,15 @@ import unittest -from pt_snap_cli.vendor.memsnapdump.base import ( +from pt_snap_cli.snapshot.base import ( Block, BlockState, DeviceSnapshot, Segment, TraceEntry, ) -from pt_snap_cli.vendor.memsnapdump.simulate import snapshot_mutator -from pt_snap_cli.vendor.memsnapdump.simulate.allocator_context import AllocatorContext -from pt_snap_cli.vendor.memsnapdump.simulate.simulated_caching_allocator import ( +from pt_snap_cli.snapshot.simulate import snapshot_mutator +from pt_snap_cli.snapshot.simulate.allocator_context import AllocatorContext +from pt_snap_cli.snapshot.simulate.simulated_caching_allocator import ( SimulatedCachingAllocator, ) diff --git a/tests/snapshot/test_sqlite_meta.py b/tests/snapshot/test_sqlite_meta.py index 9a25f4e..818c9a5 100644 --- a/tests/snapshot/test_sqlite_meta.py +++ b/tests/snapshot/test_sqlite_meta.py @@ -4,8 +4,8 @@ import pytest -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.snapshot_db import SnapshotDb -from pt_snap_cli.vendor.memsnapdump.util.sqlite_meta import ( +from pt_snap_cli.snapshot.tools.adaptors.database.snapshot_db import SnapshotDb +from pt_snap_cli.snapshot.util.sqlite_meta import ( SqliteColumn, SqliteDB, SqliteTable, diff --git a/tests/snapshot/test_timer.py b/tests/snapshot/test_timer.py index 8e39b4f..86f9d02 100644 --- a/tests/snapshot/test_timer.py +++ b/tests/snapshot/test_timer.py @@ -1,6 +1,6 @@ import time -from pt_snap_cli.vendor.memsnapdump.util.timer import timer +from pt_snap_cli.snapshot.util.timer import timer class FakeLogger: diff --git a/tests/test_cli.py b/tests/test_cli.py index 46208de..68b3f5b 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -831,7 +831,7 @@ def test_import_success_writes_focus(self, tmp_path: Path) -> None: def test_import_missing_tool_message( self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: - """Test import reports vendored backend packaging guidance when unavailable.""" + """Test import reports built-in backend packaging guidance when unavailable.""" from pt_snap_cli.core.errors import ImportToolMissingError snapshot = tmp_path / "sample.pkl" @@ -839,7 +839,7 @@ def test_import_missing_tool_message( def raise_missing_tool(*args: object, **kwargs: object) -> object: raise ImportToolMissingError( - "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; the package may be incomplete." + "Snapshot import backend is unavailable. Reinstall pt-snap-cli; the package may be incomplete." ) monkeypatch.setattr( @@ -850,7 +850,7 @@ def raise_missing_tool(*args: object, **kwargs: object) -> object: result = runner.invoke(app, ["import", str(snapshot)]) assert result.exit_code != 0 - assert "vendored snapshot import backend" in result.output.lower() + assert "snapshot import backend" in result.output.lower() assert "reinstall pt-snap-cli" in result.output.lower() assert "memsnapdump" not in result.output.lower() diff --git a/tests/test_snapshot_db.py b/tests/test_snapshot_db.py index d51f266..0d232a3 100644 --- a/tests/test_snapshot_db.py +++ b/tests/test_snapshot_db.py @@ -3,8 +3,8 @@ import sqlite3 from pathlib import Path -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.database.snapshot_db import SnapshotDb -from pt_snap_cli.vendor.memsnapdump.util.sqlite_meta import SqliteDB +from pt_snap_cli.snapshot.tools.adaptors.database.snapshot_db import SnapshotDb +from pt_snap_cli.snapshot.util.sqlite_meta import SqliteDB def _pragma(conn: sqlite3.Connection, name: str) -> object: From 1317ec9eb5078cbf67e75b89cbe2bdee5d5f7453 Mon Sep 17 00:00:00 2001 From: codeasier Date: Fri, 31 Jul 2026 01:34:56 +0800 Subject: [PATCH 05/12] feat: add replay-safe snapshot splitting --- src/pt_snap_cli/cli.py | 45 ++ src/pt_snap_cli/core/__init__.py | 6 + src/pt_snap_cli/core/errors.py | 28 + src/pt_snap_cli/core/models.py | 19 + src/pt_snap_cli/core/split_service.py | 272 +++++++ src/pt_snap_cli/snapshot/PROVENANCE.md | 29 +- src/pt_snap_cli/snapshot/base/entities.py | 19 +- src/pt_snap_cli/snapshot/representation.py | 132 +++- .../snapshot/tools/slice_dump/__init__.py | 3 + .../snapshot/tools/slice_dump/dump.py | 45 ++ .../snapshot/tools/slice_dump/hooker.py | 122 ++++ tests/core/test_split_service.py | 663 ++++++++++++++++++ tests/snapshot/test_slice_dump_runtime.py | 143 ++++ tests/test_cli.py | 88 +++ 14 files changed, 1598 insertions(+), 16 deletions(-) create mode 100644 src/pt_snap_cli/core/split_service.py create mode 100644 src/pt_snap_cli/snapshot/tools/slice_dump/__init__.py create mode 100644 src/pt_snap_cli/snapshot/tools/slice_dump/dump.py create mode 100644 src/pt_snap_cli/snapshot/tools/slice_dump/hooker.py create mode 100644 tests/core/test_split_service.py create mode 100644 tests/snapshot/test_slice_dump_runtime.py diff --git a/src/pt_snap_cli/cli.py b/src/pt_snap_cli/cli.py index 049bdfc..1c9c0eb 100644 --- a/src/pt_snap_cli/cli.py +++ b/src/pt_snap_cli/cli.py @@ -32,6 +32,9 @@ QueryService, ReportService, SnapshotFileInvalidError, + SplitError, + SplitOptions, + SplitService, TemplateNotFoundError, TemplateRenderError, ) @@ -193,6 +196,48 @@ def import_snapshot( typer.echo(f"Focus: {result.focus_state.focus_file}") +@app.command("split") +def split_snapshot( + snapshot_file: Annotated[ + Path, + typer.Argument( + help="Path to .pkl or .pickle snapshot", + metavar="SNAPSHOT_PATH", + ), + ], + output: Annotated[Path, typer.Option("--output", "-o", help="New output directory")], + device: Annotated[int | None, typer.Option("--device", "-d")] = None, + slices: Annotated[int | None, typer.Option("--slices", "-s")] = None, + max_entries: Annotated[int | None, typer.Option("--max-entries", "-m")] = None, + output_format: Annotated[ + str, + typer.Option( + "--format", + help="Output format: pickle or json", + metavar="{pickle,json}", + ), + ] = "pickle", +) -> None: + """Split a snapshot into independently replayable device slices.""" + try: + result = SplitService().split( + SplitOptions( + snapshot_file=snapshot_file, + output=output, + device=device, + slices=slices, + max_entries=max_entries, + format=output_format, + ) + ) + except SplitError as exc: + _error(str(exc)) + + typer.echo(f"Split: {result.output}") + typer.echo(f"Devices: {', '.join(map(str, result.devices))}") + typer.echo(f"Files: {len(result.files)}") + + @app.command("metadata") def show_database_metadata( db_path: Annotated[ diff --git a/src/pt_snap_cli/core/__init__.py b/src/pt_snap_cli/core/__init__.py index 32f25a0..2f5a87d 100644 --- a/src/pt_snap_cli/core/__init__.py +++ b/src/pt_snap_cli/core/__init__.py @@ -12,6 +12,7 @@ QueryExecutionError, SnapshotFileInvalidError, SourceChangedError, + SplitError, TemplateNotFoundError, TemplateRenderError, ) @@ -27,12 +28,14 @@ PeakMemoryReport, QueryResult, ResolvedFocus, + SplitOptions, TemplateInfo, TemplateParameter, TemplateSummary, ) from pt_snap_cli.core.query_service import QueryService from pt_snap_cli.core.report_service import ReportService +from pt_snap_cli.core.split_service import SplitService __all__ = [ "PtSnapCoreError", @@ -50,6 +53,7 @@ "ImportExecutionError", "ImportMetadataError", "SourceChangedError", + "SplitError", "ResolvedFocus", "FocusState", "ImportMetadata", @@ -61,9 +65,11 @@ "PeakMemoryReport", "ImportOptions", "ImportResult", + "SplitOptions", "FocusService", "ImportMetadataService", "QueryService", "ReportService", "ImportService", + "SplitService", ] diff --git a/src/pt_snap_cli/core/errors.py b/src/pt_snap_cli/core/errors.py index 336e697..4b9fd76 100644 --- a/src/pt_snap_cli/core/errors.py +++ b/src/pt_snap_cli/core/errors.py @@ -1,3 +1,8 @@ +from dataclasses import dataclass +from pathlib import Path +from typing import Literal + + class PtSnapCoreError(Exception): pass @@ -79,3 +84,26 @@ class SourceChangedError(ImportExecutionError): """Raised when the source snapshot changes while an import is running.""" pass + + +SplitPhase = Literal[ + "argument", + "path", + "device", + "conflict", + "load/engine", + "generated-validation", + "publication", +] + + +@dataclass(frozen=True) +class SplitError(PtSnapCoreError): + """A phase-identifying split failure suitable for CLI presentation.""" + + phase: SplitPhase + source_path: Path + detail: str + + def __str__(self) -> str: + return f"Split {self.phase} failed for '{self.source_path}': {self.detail}" diff --git a/src/pt_snap_cli/core/models.py b/src/pt_snap_cli/core/models.py index 8f93afe..d9d0c48 100644 --- a/src/pt_snap_cli/core/models.py +++ b/src/pt_snap_cli/core/models.py @@ -17,6 +17,7 @@ "forced", ] MetadataStatus = Literal["available", "unavailable", "invalid"] +SplitFormat = Literal["pickle", "json"] @dataclass(frozen=True) @@ -149,3 +150,21 @@ class ImportResult: reused: bool metadata: ImportMetadata cache_miss_reason: CacheMissReason | None + + +@dataclass(frozen=True) +class SplitOptions: + snapshot_file: Path + output: Path + device: int | None = None + slices: int | None = None + max_entries: int | None = None + format: str = "pickle" + + +@dataclass(frozen=True) +class SplitResult: + output: Path + files: tuple[Path, ...] + devices: tuple[int, ...] + format: SplitFormat diff --git a/src/pt_snap_cli/core/split_service.py b/src/pt_snap_cli/core/split_service.py new file mode 100644 index 0000000..7695065 --- /dev/null +++ b/src/pt_snap_cli/core/split_service.py @@ -0,0 +1,272 @@ +from __future__ import annotations + +import ctypes +import errno +import os +import re +import shutil +import sys +import tempfile +from pathlib import Path +from stat import S_ISDIR, S_ISLNK +from typing import NoReturn, cast + +from pt_snap_cli.core.errors import SplitError, SplitPhase +from pt_snap_cli.core.models import SplitFormat, SplitOptions, SplitResult +from pt_snap_cli.snapshot.representation import ( + load_and_replay_snapshot, + load_snapshot_representation, + replay_snapshot, + save_snapshot_representation, +) +from pt_snap_cli.snapshot.tools.slice_dump.hooker import SliceDumpHooker + +_ENTRY_RANGE = re.compile(r"_entry_(\d+)_(\d+)\.pkl$") +_AT_FDCWD = -100 +_RENAME_NOREPLACE = 1 +_RENAME_EXCL = 0x00000004 +_StageIdentity = tuple[int, int] + + +class SplitService: + """Replay, validate, and atomically publish snapshot slices.""" + + def split(self, options: SplitOptions) -> SplitResult: + source = options.snapshot_file + self._validate_before_load(options) + try: + self._preflight_publication() + except Exception as exc: + self._fail("publication", source, str(exc), exc) + + try: + representation = load_snapshot_representation(source, "pickle") + except Exception as exc: + self._fail("load/engine", source, str(exc), exc) + + traces = representation.get("device_traces") + if not isinstance(traces, list): + self._fail("device", source, "snapshot has no device trace list") + nonempty_devices = [index for index, entries in enumerate(traces) if entries] + if options.device is not None: + if options.device not in nonempty_devices: + self._fail( + "device", + source, + f"device {options.device} does not exist or has no trace entries", + ) + devices = [options.device] + else: + devices = nonempty_devices + if not devices: + self._fail("device", source, "snapshot has no device with trace entries") + + output = options.output + try: + stage = Path( + tempfile.mkdtemp(prefix=f".{output.name}.pt-snap-", dir=str(output.parent)) + ) + stage_identity = self._stage_identity(stage) + except Exception as exc: + self._fail("publication", source, f"cannot create staging directory: {exc}", exc) + published_files: list[Path] = [] + try: + for device in devices: + generated = self._slice_device( + representation, + source, + stage, + device, + options.slices, + options.max_entries, + cast(SplitFormat, options.format), + ) + published_files.extend(generated) + self._verify_stage_identity(stage, stage_identity) + self._publish_directory(stage, output) + except SplitError: + self._cleanup_stage(stage, stage_identity) + raise + except Exception as exc: + self._cleanup_stage(stage, stage_identity) + self._fail("publication", source, str(exc), exc) + + return SplitResult( + output=output, + files=tuple(output / path.name for path in published_files), + devices=tuple(devices), + format=cast(SplitFormat, options.format), + ) + + def _validate_before_load(self, options: SplitOptions) -> None: + source = options.snapshot_file + if (options.slices is None) == (options.max_entries is None): + self._fail("argument", source, "exactly one of --slices and --max-entries is required") + strategy = options.slices if options.slices is not None else options.max_entries + if strategy is None or strategy <= 0: + self._fail("argument", source, "the split strategy value must be positive") + if options.format not in ("pickle", "json"): + self._fail("argument", source, "format must be exactly 'pickle' or 'json'") + if not source.exists(): + self._fail("path", source, "source does not exist") + if not source.is_file(): + self._fail("path", source, "source is not a regular file") + if source.suffix.lower() not in (".pkl", ".pickle"): + self._fail("path", source, "source suffix must be .pkl or .pickle") + if options.device is not None and options.device < 0: + self._fail("device", source, "device must be non-negative") + if not options.output.parent.exists(): + self._fail("path", source, f"output parent does not exist: {options.output.parent}") + if not options.output.parent.is_dir(): + self._fail("path", source, f"output parent is not a directory: {options.output.parent}") + if os.path.lexists(options.output): + self._fail("conflict", source, f"destination already exists: {options.output}") + + def _slice_device( + self, + representation: dict[str, object], + source: Path, + stage: Path, + device: int, + slices: int | None, + max_entries: int | None, + output_format: SplitFormat, + ) -> list[Path]: + try: + raw_dir = stage / f".device-{device}" + raw_dir.mkdir() + event_count = len(cast(list[object], representation["device_traces"])[device]) + hooker = SliceDumpHooker( + dump_dir=str(raw_dir), + num_of_slices=slices if slices is not None else 1, + max_entries=max_entries if max_entries is not None else event_count, + dump_type="pkl", + ) + _, replayed = replay_snapshot(representation, device, hooker=hooker) + except Exception as exc: + self._fail("load/engine", source, f"device {device}: {exc}", exc) + if not replayed: + self._fail("load/engine", source, f"device {device}: replay engine returned false") + + try: + raw_files = sorted(raw_dir.glob("*.pkl"), key=self._slice_start) + except Exception as exc: + self._fail("generated-validation", source, str(exc), exc) + if not raw_files: + self._fail("load/engine", source, f"device {device}: engine generated no slices") + + extension = "pkl" if output_format == "pickle" else "json" + outputs: list[Path] = [] + for index, raw_file in enumerate(raw_files): + try: + slice_representation = load_snapshot_representation(raw_file, "pickle") + output_file = stage / (f"{source.stem}__device-{device}__slice-{index}.{extension}") + save_snapshot_representation(slice_representation, output_file, output_format) + _, _, replayed = load_and_replay_snapshot(output_file, output_format, device) + if not replayed: + raise ValueError("replay returned false") + except Exception as exc: + self._fail( + "generated-validation", + source, + f"generated slice for device {device} failed validation: {exc}", + exc, + ) + outputs.append(output_file) + shutil.rmtree(raw_dir) + return outputs + + @staticmethod + def _slice_start(path: Path) -> int: + match = _ENTRY_RANGE.search(path.name) + if match is None: + raise ValueError(f"Unexpected engine output name: {path.name}") + return int(match.group(1)) + + @staticmethod + def _stage_identity(stage: Path) -> _StageIdentity: + status = stage.lstat() + if S_ISLNK(status.st_mode) or not S_ISDIR(status.st_mode): + raise OSError(errno.EINVAL, "staging path is not an owned directory", stage) + return status.st_dev, status.st_ino + + @classmethod + def _verify_stage_identity(cls, stage: Path, identity: _StageIdentity) -> None: + if cls._stage_identity(stage) != identity: + raise OSError(errno.ESTALE, "staging directory identity changed", stage) + + @classmethod + def _cleanup_stage(cls, stage: Path, identity: _StageIdentity) -> None: + try: + cls._verify_stage_identity(stage, identity) + shutil.rmtree(stage) + except Exception: + return + + @staticmethod + def _preflight_publication() -> None: + if sys.platform == "darwin": + if getattr(ctypes.CDLL(None, use_errno=True), "renamex_np", None) is None: + raise OSError(errno.ENOTSUP, "renamex_np(RENAME_EXCL) is unavailable") + return + if sys.platform.startswith("linux"): + if getattr(ctypes.CDLL(None, use_errno=True), "renameat2", None) is None: + raise OSError(errno.ENOTSUP, "renameat2(RENAME_NOREPLACE) is unavailable") + return + if os.name == "nt": + return + raise OSError(errno.ENOTSUP, "atomic no-replace directory rename is unavailable") + + @staticmethod + def _publish_directory(stage: Path, destination: Path) -> None: + if sys.platform == "darwin": + libc = ctypes.CDLL(None, use_errno=True) + renamex_np = libc.renamex_np + renamex_np.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint] + renamex_np.restype = ctypes.c_int + if renamex_np(os.fsencode(stage), os.fsencode(destination), _RENAME_EXCL) != 0: + error_number = ctypes.get_errno() + raise OSError(error_number, os.strerror(error_number), destination) + return + if sys.platform.startswith("linux"): + libc = ctypes.CDLL(None, use_errno=True) + renameat2 = getattr(libc, "renameat2", None) + if renameat2 is None: + raise OSError(errno.ENOTSUP, "atomic no-replace directory rename is unavailable") + renameat2.argtypes = [ + ctypes.c_int, + ctypes.c_char_p, + ctypes.c_int, + ctypes.c_char_p, + ctypes.c_uint, + ] + renameat2.restype = ctypes.c_int + if ( + renameat2( + _AT_FDCWD, + os.fsencode(stage), + _AT_FDCWD, + os.fsencode(destination), + _RENAME_NOREPLACE, + ) + != 0 + ): + error_number = ctypes.get_errno() + raise OSError(error_number, os.strerror(error_number), destination) + return + if os.name == "nt": + os.rename(stage, destination) + return + raise OSError(errno.ENOTSUP, "atomic no-replace directory rename is unavailable") + + @staticmethod + def _fail( + phase: SplitPhase, + source: Path, + detail: str, + cause: BaseException | None = None, + ) -> NoReturn: + error = SplitError(phase=phase, source_path=source, detail=detail) + if cause is None: + raise error + raise error from cause diff --git a/src/pt_snap_cli/snapshot/PROVENANCE.md b/src/pt_snap_cli/snapshot/PROVENANCE.md index ea5ab4d..9f2c12b 100644 --- a/src/pt_snap_cli/snapshot/PROVENANCE.md +++ b/src/pt_snap_cli/snapshot/PROVENANCE.md @@ -48,12 +48,9 @@ Every URL is fixed to the audited commit rather than a moving branch or tag. `snapshot/representation.py` is a pt-snap-cli-local shared loader/replay entrypoint and has no direct upstream blob. -## Deferred slice source mappings +## Slice source mappings -Task 4 intentionally does not add the split engine or service. These audited -runtime sources remain missing until the later split task: - -| Planned first-party path | Audited upstream blob | +| First-party path | Audited upstream blob | | --- | --- | | `snapshot/tools/slice_dump/__init__.py` | | | `snapshot/tools/slice_dump/dump.py` | | @@ -84,6 +81,28 @@ The upstream standalone split frontend is deliberately excluded, not deferred: `B024`/`B027` suppression preserves optional no-op allocator callbacks, and the targeted `B904` suppression preserves established corrupt-pickle exception context. No behavior-altering modernization was applied. +- On 2026-07-31, Tasks 5 and 6 ported `tools/slice_dump/{__init__.py,dump.py,hooker.py}` + to the first-party namespace. Package imports and formatting changed; the + standalone argparse parser and module-entrypoint block were removed. Callable + engine return values, warnings, replay strategy, and legacy engine filenames + remain unchanged. +- The product `SplitService` deliberately replaces the engine filenames with + `__device-__slice-.`, selects every nonempty + device when no device is requested, requires exactly one positive strategy, + and replay-validates normalized pickle/JSON output before exclusive atomic + directory publication. These are pt-snap product-boundary differences, not + claims of byte-for-byte upstream frontend equivalence. +- `representation.py` now provides explicit pickle/JSON load, save, and + serialization APIs, one load/replay validation path, and strict canonical + bytes/SHA256 helpers for cross-format equivalence tests. +- The first-party slice payload extends the pinned upstream representation with + an explicit `id` on every trace entry. This preserves the original snapshot's + global event IDs across slice boundaries without mutating source `_origin` + dictionaries. `TraceEntry` loading honors explicit IDs while retaining + enumeration fallback for original snapshots, so established import + observations remain unchanged. Upstream comparisons therefore treat IDs and + product filenames as intentional required differences while continuing to + compare selected devices, event ranges, allocator state, and slice counts. ## Migration toolchain diff --git a/src/pt_snap_cli/snapshot/base/entities.py b/src/pt_snap_cli/snapshot/base/entities.py index dd9c8fd..8e0ad0b 100644 --- a/src/pt_snap_cli/snapshot/base/entities.py +++ b/src/pt_snap_cli/snapshot/base/entities.py @@ -69,6 +69,7 @@ def from_dict(cls, trace_dict: dict): stream=int(trace_dict["stream"]), _origin=trace_dict, frames=[Frame.from_dict(_frame_dict) for _frame_dict in trace_dict.get("frames", [])], + idx=int(trace_dict["id"]) if "id" in trace_dict else -1, ) return trace_entry @@ -79,9 +80,11 @@ def get_callstack(self): [f"{frame.filename}:{frame.line} {frame.name}" for frame in self.frames[::-1]] ) - def to_dict(self): - return ( - self._origin + def to_dict(self, include_id: bool = False): + if self._origin and not include_id: + return self._origin + trace_dict = ( + dict(self._origin) if self._origin else { "action": self.action, @@ -91,6 +94,9 @@ def to_dict(self): "frames": [frame.to_dict() for frame in self.frames], } ) + if include_id: + trace_dict["id"] = self.idx + return trace_dict class BlockState: @@ -276,15 +282,16 @@ def from_dict(cls, snapshot_dict: dict, device: int, ignore_inactive_blocks: boo # 读取事件序列 for idx, trace_entry_dict in enumerate(device_trace_list): trace_entry = TraceEntry.from_dict(trace_entry_dict) - trace_entry.idx = idx + if "id" not in trace_entry_dict: + trace_entry.idx = idx snapshot.trace_entries.append(trace_entry) snapshot.device = device return snapshot - def to_dict(self): + def to_dict(self, include_trace_ids: bool = False): return { "segments": [segment.to_dict() for segment in self.segments], # 需要根据deviceId,将事件列表填入,如果deviceId不为0,前序还要padding空事件列表 "device_traces": [[] for _ in range(self.device)] - + [[trace.to_dict() for trace in self.trace_entries]], + + [[trace.to_dict(include_id=include_trace_ids) for trace in self.trace_entries]], } diff --git a/src/pt_snap_cli/snapshot/representation.py b/src/pt_snap_cli/snapshot/representation.py index 2dba159..63dd25a 100644 --- a/src/pt_snap_cli/snapshot/representation.py +++ b/src/pt_snap_cli/snapshot/representation.py @@ -1,13 +1,124 @@ +import hashlib +import json +import math +import pickle from pathlib import Path -from typing import Any +from typing import Any, Literal, cast from .simulate import AllocatorHooker, SimulateDeviceSnapshot, SimulateHooker -from .util.file_util import load_pickle_to_dict +from .util.file_util import load_pickle_to_dict, save_dict_to_pickle +SnapshotFormat = Literal["pickle", "json"] -def load_snapshot_representation(snapshot_file: str | Path) -> dict[str, Any]: - """Load the first-party snapshot representation from a trusted pickle.""" - return load_pickle_to_dict(Path(snapshot_file)) + +def load_pickle_representation(snapshot_file: str | Path) -> dict[str, Any]: + """Load a trusted pickle snapshot representation.""" + return cast(dict[str, Any], load_pickle_to_dict(Path(snapshot_file))) + + +def load_json_representation(snapshot_file: str | Path) -> dict[str, Any]: + """Load a JSON snapshot representation.""" + with Path(snapshot_file).open(encoding="utf-8") as stream: + value: object = json.load(stream) + if not isinstance(value, dict): + raise ValueError( + f"The content of the JSON file is not of type dict, actual type: {type(value).__name__}" + ) + return cast(dict[str, Any], value) + + +def load_snapshot_representation( + snapshot_file: str | Path, snapshot_format: SnapshotFormat = "pickle" +) -> dict[str, Any]: + """Load either supported representation through one dispatch point.""" + if snapshot_format == "pickle": + return load_pickle_representation(snapshot_file) + if snapshot_format == "json": + return load_json_representation(snapshot_file) + raise ValueError(f"Unsupported snapshot format: {snapshot_format}") + + +def serialize_snapshot_representation( + representation: dict[str, Any], snapshot_format: SnapshotFormat = "pickle" +) -> bytes: + """Serialize a snapshot in its supported pickle or normalized JSON form.""" + if snapshot_format == "pickle": + return serialize_pickle_representation(representation) + if snapshot_format == "json": + return serialize_json_representation(representation) + raise ValueError(f"Unsupported snapshot format: {snapshot_format}") + + +def serialize_pickle_representation(representation: dict[str, Any]) -> bytes: + """Serialize the complete runtime-coupled pickle representation.""" + return pickle.dumps(representation, protocol=4) + + +def serialize_json_representation(representation: dict[str, Any]) -> bytes: + """Serialize the normalized inspectable JSON representation.""" + return canonical_snapshot_bytes(representation) + + +def save_pickle_representation(representation: dict[str, Any], snapshot_file: str | Path) -> None: + """Save a trusted pickle snapshot using the retained protocol.""" + save_dict_to_pickle(representation, Path(snapshot_file), protocol=4) + + +def save_json_representation(representation: dict[str, Any], snapshot_file: str | Path) -> None: + """Save normalized compact UTF-8 JSON.""" + Path(snapshot_file).write_bytes(serialize_json_representation(representation)) + + +def save_snapshot_representation( + representation: dict[str, Any], + snapshot_file: str | Path, + snapshot_format: SnapshotFormat = "pickle", +) -> None: + """Save a snapshot representation without caller-specific format behavior.""" + path = Path(snapshot_file) + if snapshot_format == "pickle": + save_pickle_representation(representation, path) + return + if snapshot_format == "json": + save_json_representation(representation, path) + return + raise ValueError(f"Unsupported snapshot format: {snapshot_format}") + + +def canonicalize_snapshot(value: object) -> object: + """Normalize supported snapshot values without changing semantic list order.""" + if value is None or isinstance(value, (str, bool, int)): + return value + if isinstance(value, float): + if not math.isfinite(value): + raise ValueError("Canonical snapshots do not support non-finite floats.") + return value + if isinstance(value, dict): + normalized: dict[str, object] = {} + if not all(isinstance(key, str) for key in value): + raise ValueError("Canonical snapshots require string dictionary keys.") + for key in sorted(cast(dict[str, object], value)): + normalized[key] = canonicalize_snapshot(value[key]) + return normalized + if isinstance(value, (list, tuple)): + return [canonicalize_snapshot(item) for item in value] + raise ValueError(f"Canonical snapshots do not support {type(value).__name__} values.") + + +def canonical_snapshot_bytes(representation: object) -> bytes: + """Return canonical UTF-8 JSON bytes for representation equivalence.""" + return json.dumps( + canonicalize_snapshot(representation), + sort_keys=True, + ensure_ascii=False, + allow_nan=False, + separators=(",", ":"), + ).encode("utf-8") + + +def canonical_snapshot_sha256(representation: object) -> str: + """Return the SHA256 of the canonical snapshot bytes.""" + return hashlib.sha256(canonical_snapshot_bytes(representation)).hexdigest() def replay_snapshot( @@ -24,3 +135,14 @@ def replay_snapshot( if allocator_hooker is not None: snapshot.register_allocator_hooker(allocator_hooker) return snapshot, snapshot.replay() + + +def load_and_replay_snapshot( + snapshot_file: str | Path, + snapshot_format: SnapshotFormat, + device: int, +) -> tuple[dict[str, Any], SimulateDeviceSnapshot, bool]: + """Load and replay either format through the shared validation entrypoint.""" + representation = load_snapshot_representation(snapshot_file, snapshot_format) + snapshot, replayed = replay_snapshot(representation, device) + return representation, snapshot, replayed diff --git a/src/pt_snap_cli/snapshot/tools/slice_dump/__init__.py b/src/pt_snap_cli/snapshot/tools/slice_dump/__init__.py new file mode 100644 index 0000000..532e717 --- /dev/null +++ b/src/pt_snap_cli/snapshot/tools/slice_dump/__init__.py @@ -0,0 +1,3 @@ +from .dump import run_slice_dump + +__all__ = ["run_slice_dump"] diff --git a/src/pt_snap_cli/snapshot/tools/slice_dump/dump.py b/src/pt_snap_cli/snapshot/tools/slice_dump/dump.py new file mode 100644 index 0000000..2ecd2c6 --- /dev/null +++ b/src/pt_snap_cli/snapshot/tools/slice_dump/dump.py @@ -0,0 +1,45 @@ +import os.path +from pathlib import Path + +from ...representation import load_snapshot_representation, replay_snapshot +from ...util import get_logger +from .hooker import SliceDumpHooker + +dump_logger = get_logger("DUMP") + + +def run_slice_dump( + snapshot_file: str, + device: int = 0, + slices: int = 4, + max_entries: int = 15000, + dump_dir: str = "", + dump_type: str = "pkl", +): + resolved_dump_dir = dump_dir or os.path.dirname(snapshot_file) + dump_logger.info(f"Start to dump snapshot slice, reading pickle file '{snapshot_file}'.") + df = load_snapshot_representation(Path(snapshot_file), "pickle") + if "segments" not in df or "device_traces" not in df or not df["device_traces"]: + dump_logger.warning( + "Snapshot files with no event records cannot be replayed or split. You may have disabled " + "history event recoding during collection." + ) + return + if len(df["device_traces"]) <= device or not df["device_traces"][device]: + dump_logger.warning( + f"The snapshot file did not record any event data for the specified device {device}." + ) + return + dump_logger.info( + f"Start loading snapshot with {len(df['segments'])} segments, " + f"{len(df['device_traces'][device])} events" + ) + dump_logger.info("Successfully loaded snapshot, starting to replay and dump.") + slice_dump_hooker = SliceDumpHooker( + dump_dir=resolved_dump_dir, + num_of_slices=slices, + max_entries=max_entries, + dump_type=dump_type, + ) + _, _ = replay_snapshot(df, device, hooker=slice_dump_hooker) + dump_logger.info("Successfully replay and dump snapshot.") diff --git a/src/pt_snap_cli/snapshot/tools/slice_dump/hooker.py b/src/pt_snap_cli/snapshot/tools/slice_dump/hooker.py new file mode 100644 index 0000000..b1ed841 --- /dev/null +++ b/src/pt_snap_cli/snapshot/tools/slice_dump/hooker.py @@ -0,0 +1,122 @@ +import copy +import json +import math +import os +from pathlib import Path +from typing import Literal + +from ...base import DeviceSnapshot, TraceEntry +from ...simulate import SimulateHooker +from ...util import get_logger +from ...util.file_util import save_dict_to_pickle + +dump_logger = get_logger("DUMP") + + +class SliceDumpHooker(SimulateHooker): + """Split snapshots by event count while reconstructing boundary state.""" + + def __init__( + self, + dump_dir: str, + num_of_slices: int = 4, + max_entries: int = 15000, + dump_type: Literal["json", "pkl"] = "pkl", + dump_progress_point=None, + ): + if dump_progress_point is None: + dump_progress_point = [0.75, 0.5, 0.25] + if num_of_slices <= 0: + raise ValueError( + "The number of slices must be a positive integer and cannot be non-positive, at least 1." + ) + if ( + (not os.path.exists(dump_dir)) + or not os.path.isdir(dump_dir) + or not os.access(dump_dir, os.W_OK) + ): + raise ValueError( + f"The dump dir {dump_dir} does not exist, is not a directory, or is not writable." + ) + self.num_of_slices = num_of_slices + self.max_entries = max_entries + self.num_of_events = -1 + self.events_buffer = [] + self.prev_segments = None + self.dump_dir = dump_dir + self.dump_count = 0 + self.dump_type = dump_type + self.dump_progress_point = dump_progress_point + self.dump_progress_point.sort() + + def pre_undo_event(self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot) -> bool: + if self.num_of_events == -1: + self.num_of_events = len(current_snapshot.trace_entries) + self._init_splitting_strategy() + self.prev_segments = copy.deepcopy(current_snapshot.segments) + current_num_of_events = len(current_snapshot.trace_entries) + if ( + self.dump_progress_point + and current_num_of_events <= self.dump_progress_point[-1] * self.num_of_events + ): + done_point = self.dump_progress_point.pop() + dump_logger.info(f"Progressing: {(1 - done_point) * 100}%") + return True + + def _init_splitting_strategy(self): + if self.num_of_slices == -1: + raise RuntimeError("Cannot init splitting strategy before init total entries") + if math.ceil(self.num_of_events / self.num_of_slices) > self.max_entries: + dump_logger.warning( + "The expected number of slices may leads the single snapshot file exceeds the " + "max_entries limit.Splitting will be performed based on max_entries, or you may try " + "increasing the max_entries value." + ) + self.max_entries = min(math.ceil(self.num_of_events / self.num_of_slices), self.max_entries) + self.num_of_slices = max( + self.num_of_slices, math.ceil(self.num_of_events / self.max_entries) + ) + + def post_undo_event(self, already_undo_event: TraceEntry, current_snapshot: DeviceSnapshot): + self.events_buffer.insert(0, already_undo_event) + if self._is_need_dump(current_snapshot): + self.dump(current_snapshot.device) + self.prev_segments = copy.deepcopy(current_snapshot.segments) + self.events_buffer.clear() + return True + + def _is_need_dump(self, current_snapshot: DeviceSnapshot) -> bool: + if len(self.events_buffer) >= self.max_entries: + return True + if self.events_buffer and not current_snapshot.trace_entries: + return True + return False + + def dump(self, device: int): + slice_snapshot_name = self._get_dump_filename() + slice_snapshot = DeviceSnapshot() + slice_snapshot.device = device + slice_snapshot.segments = self.prev_segments + slice_snapshot.trace_entries = self.events_buffer + slice_snapshot_dict = slice_snapshot.to_dict(include_trace_ids=True) + del self.prev_segments + self.events_buffer.clear() + dump_logger.info(f"Start to dump snapshot slice: {slice_snapshot_name}") + if self.dump_type == "pkl": + save_dict_to_pickle(slice_snapshot_dict, slice_snapshot_name, protocol=4) + else: + with open(slice_snapshot_name, "w") as stream: + json.dump(slice_snapshot_dict, stream) + self.dump_count += 1 + dump_logger.info(f"Successfully saved slice to file: {slice_snapshot_name}") + + def _get_dump_filename(self) -> Path: + slice_num = self.num_of_slices - self.dump_count + entry_idx_start = max(self.num_of_events - (self.dump_count + 1) * self.max_entries + 1, 0) + entry_idx_end = self.num_of_events - self.dump_count * self.max_entries + return Path( + os.path.join( + self.dump_dir, + f"slice_{slice_num}_entry_{entry_idx_start}_{entry_idx_end}.{self.dump_type}", + ) + ) diff --git a/tests/core/test_split_service.py b/tests/core/test_split_service.py new file mode 100644 index 0000000..d96582b --- /dev/null +++ b/tests/core/test_split_service.py @@ -0,0 +1,663 @@ +from __future__ import annotations + +import pickle +import shutil +from dataclasses import FrozenInstanceError +from pathlib import Path +from typing import Any + +import pytest + +import pt_snap_cli.core.split_service as split_module +from pt_snap_cli.core.errors import SplitError +from pt_snap_cli.core.models import SplitOptions +from pt_snap_cli.core.split_service import SplitService +from pt_snap_cli.snapshot.representation import ( + canonical_snapshot_bytes, + canonical_snapshot_sha256, + load_json_representation, + load_pickle_representation, + load_snapshot_representation, + replay_snapshot, + save_json_representation, + save_pickle_representation, + serialize_json_representation, + serialize_pickle_representation, +) +from pt_snap_cli.snapshot.simulate import SimulateDeviceSnapshot +from pt_snap_cli.snapshot.tools.adaptors.snapshot2db import DumpEventHooker +from pt_snap_cli.snapshot.tools.slice_dump.hooker import SliceDumpHooker +from tests.snapshot.golden_observations import ACTION_VALUE_MAP +from tests.snapshot.helpers import FIXTURE_DIR, assert_valid_snapshot + +MULTI_DEVICE = FIXTURE_DIR / "snapshot_with_multi_devices.pkl" + + +def _options(tmp_path: Path, **changes: object) -> SplitOptions: + values: dict[str, object] = { + "snapshot_file": MULTI_DEVICE, + "output": tmp_path / "split", + "slices": 2, + } + values.update(changes) + return SplitOptions(**values) # type: ignore[arg-type] + + +def _events(paths: tuple[Path, ...], snapshot_format: str, device: int) -> list[dict]: + events: list[dict] = [] + for path in paths: + representation = load_snapshot_representation(path, snapshot_format) # type: ignore[arg-type] + nonempty = [ + index for index, entries in enumerate(representation["device_traces"]) if entries + ] + assert nonempty == [device] + events.extend(representation["device_traces"][device]) + return events + + +def _without_ids(representation: dict[str, Any], device: int) -> dict[str, Any]: + normalized = pickle.loads(pickle.dumps(representation)) + for event in normalized["device_traces"][device]: + event.pop("id", None) + return normalized + + +def _snapshot_state(snapshot: SimulateDeviceSnapshot) -> tuple[bytes, int, int, int]: + device_snapshot = snapshot.device_snapshot + return ( + canonical_snapshot_bytes([segment.to_dict() for segment in device_snapshot.segments]), + device_snapshot.total_allocated, + device_snapshot.total_activated, + device_snapshot.total_reserved, + ) + + +def _assert_slice_invariants( + paths: tuple[Path, ...], source: Path, snapshot_format: str, device: int +) -> None: + original = load_snapshot_representation(source) + original_events = original["device_traces"][device] + original_snapshot = SimulateDeviceSnapshot(original, device) + original_initial = _snapshot_state(original_snapshot) + assert_valid_snapshot(original_snapshot.device_snapshot) + assert original_snapshot.replay() + original_final = _snapshot_state(original_snapshot) + + combined: list[dict[str, Any]] = [] + states: list[tuple[tuple[bytes, int, int, int], tuple[bytes, int, int, int]]] = [] + for path in paths: + representation = load_snapshot_representation(path, snapshot_format) # type: ignore[arg-type] + entries = representation["device_traces"][device] + assert entries + combined.extend(entries) + snapshot = SimulateDeviceSnapshot(representation, device) + assert [event.idx for event in snapshot.device_snapshot.trace_entries] == [ + entry["id"] for entry in entries + ] + assert_valid_snapshot(snapshot.device_snapshot) + before = _snapshot_state(snapshot) + assert snapshot.replay() + assert_valid_snapshot(snapshot.device_snapshot) + states.append((before, _snapshot_state(snapshot))) + + assert [event["id"] for event in combined] == list(range(len(original_events))) + for event, original_event in zip(combined, original_events, strict=True): + assert {key: value for key, value in event.items() if key != "id"} == original_event + assert event["action"] == original_event["action"] + assert event["frames"] == original_event["frames"] + assert event["stream"] == original_event["stream"] + assert states[0][1] == original_final + assert states[-1][0] == original_initial + for previous, current in zip(states, states[1:], strict=False): + assert current[1] == previous[0] + + +def _database_observation( + snapshot_path: Path, snapshot_format: str, device: int, db_path: Path +) -> tuple[list[tuple[Any, ...]], list[tuple[Any, ...]], tuple[int, int, int]]: + representation = load_snapshot_representation(snapshot_path, snapshot_format) # type: ignore[arg-type] + hooker = DumpEventHooker(str(db_path), [device]) + _, replayed = replay_snapshot( + representation, + device, + hooker=hooker, + allocator_hooker=hooker, + ) + assert replayed + hooker.flush(device) + connection = hooker.db_handler.db.conn + trace_rows = connection.execute( + f"SELECT id, action, address, size, stream, allocated, active, reserved, callstack " + f"FROM trace_entry_{device} ORDER BY id" + ).fetchall() + block_rows = connection.execute( + f"SELECT id, address, size, requestedSize, state, allocEventId, freeEventId " + f"FROM block_{device} ORDER BY id" + ).fetchall() + peaks = connection.execute( + f"SELECT MAX(allocated), MAX(active), MAX(reserved) FROM trace_entry_{device}" + ).fetchone() + + source_entries = representation["device_traces"][device] + expected_actions = {entry["id"]: ACTION_VALUE_MAP[entry["action"]] for entry in source_entries} + positive_trace_rows = [row for row in trace_rows if row[0] >= 0] + assert {row[0]: row[1] for row in positive_trace_rows} == expected_actions + positive_ids = set(expected_actions) + positive_blocks = [row for row in block_rows if row[0] >= 0] + assert all(row[0] in positive_ids and row[5] in positive_ids for row in positive_blocks) + assert all(row[6] == -1 or row[6] in positive_ids for row in positive_blocks) + negative_event_ids = [row[0] for row in trace_rows if row[0] < 0] + negative_block_ids = [row[0] for row in block_rows if row[0] < 0] + assert len(negative_event_ids) == len(set(negative_event_ids)) + assert len(negative_block_ids) == len(set(negative_block_ids)) + + normalized_trace = [((-1,) + row[1:]) if row[0] < 0 else row for row in trace_rows] + normalized_blocks = [((-1,) + row[1:]) if row[0] < 0 else row for row in block_rows] + return normalized_trace, normalized_blocks, peaks + + +def test_split_models_and_errors_are_frozen(tmp_path: Path) -> None: + options = _options(tmp_path) + error = SplitError("argument", MULTI_DEVICE, "invalid") + + with pytest.raises(FrozenInstanceError): + options.slices = 3 # type: ignore[misc] + with pytest.raises(FrozenInstanceError): + error.detail = "changed" # type: ignore[misc] + + +def test_split_all_devices_independently_with_deterministic_names(tmp_path: Path) -> None: + result = SplitService().split(_options(tmp_path)) + + assert result.devices == (0, 1) + assert [path.name for path in result.files] == [ + "snapshot_with_multi_devices__device-0__slice-0.pkl", + "snapshot_with_multi_devices__device-0__slice-1.pkl", + "snapshot_with_multi_devices__device-1__slice-0.pkl", + "snapshot_with_multi_devices__device-1__slice-1.pkl", + ] + original = load_snapshot_representation(MULTI_DEVICE) + for device in result.devices: + paths = tuple(path for path in result.files if f"device-{device}" in path.name) + assert [ + {key: value for key, value in event.items() if key != "id"} + for event in _events(paths, "pickle", device) + ] == original["device_traces"][device] + _assert_slice_invariants(paths, MULTI_DEVICE, "pickle", device) + + +@pytest.mark.parametrize( + ("fixture_name", "snapshot_format"), + [ + ("snapshot_1768383987920985470.pkl", "pickle"), + ("snapshot_expandable.pkl", "json"), + ("snapshot_with_empty_cache.pkl", "pickle"), + ], +) +def test_slice_event_and_boundary_state_invariants( + tmp_path: Path, fixture_name: str, snapshot_format: str +) -> None: + source = FIXTURE_DIR / fixture_name + result = SplitService().split( + _options( + tmp_path, + snapshot_file=source, + output=tmp_path / f"{source.stem}-{snapshot_format}", + device=0, + format=snapshot_format, + ) + ) + + _assert_slice_invariants(result.files, source, snapshot_format, 0) + + +def test_split_selected_device_with_max_entries(tmp_path: Path) -> None: + result = SplitService().split(_options(tmp_path, slices=None, max_entries=3000, device=1)) + + assert result.devices == (1,) + assert len(result.files) == 4 + representations = [load_snapshot_representation(path) for path in result.files] + assert all(len(value["device_traces"][1]) <= 3000 for value in representations) + assert all(not value["device_traces"][0] for value in representations) + + +def test_pickle_and_json_have_equal_canonical_bytes_and_sha(tmp_path: Path) -> None: + pickle_result = SplitService().split(_options(tmp_path, output=tmp_path / "pickle", device=0)) + json_result = SplitService().split( + _options(tmp_path, output=tmp_path / "json", device=0, format="json") + ) + + for pickle_path, json_path in zip(pickle_result.files, json_result.files, strict=True): + pickle_value = load_snapshot_representation(pickle_path, "pickle") + json_value = load_snapshot_representation(json_path, "json") + assert canonical_snapshot_bytes(pickle_value) == canonical_snapshot_bytes(json_value) + assert canonical_snapshot_sha256(pickle_value) == canonical_snapshot_sha256(json_value) + assert json_path.read_bytes() == canonical_snapshot_bytes(json_value) + + pickle_db = _database_observation( + pickle_path, "pickle", 0, tmp_path / f"{pickle_path.name}.db" + ) + json_db = _database_observation(json_path, "json", 0, tmp_path / f"{json_path.name}.db") + assert pickle_db == json_db + trace_rows, block_rows, peaks = pickle_db + assert peaks[0] <= peaks[1] <= peaks[2] + assert any(row[0] < 0 for row in trace_rows) + assert any(row[0] < 0 for row in block_rows) + + +def test_product_matches_upstream_ranges_and_counts_with_intentional_names( + tmp_path: Path, +) -> None: + representation = load_snapshot_representation(MULTI_DEVICE) + upstream_dir = tmp_path / "upstream" + upstream_dir.mkdir() + upstream_snapshot = SimulateDeviceSnapshot(representation, 1) + upstream_snapshot.register_hooker( + SliceDumpHooker(str(upstream_dir), num_of_slices=2, max_entries=9700) + ) + assert upstream_snapshot.replay() + upstream_files = sorted( + upstream_dir.glob("*.pkl"), + key=lambda path: int(path.stem.rsplit("_", 2)[-2]), + ) + + product = SplitService().split(_options(tmp_path, output=tmp_path / "product", device=1)) + + assert product.devices == (1,) + assert len(product.files) == len(upstream_files) == 2 + assert all(path.name.startswith("slice_") and "_entry_" in path.name for path in upstream_files) + assert [path.name for path in product.files] == [ + "snapshot_with_multi_devices__device-1__slice-0.pkl", + "snapshot_with_multi_devices__device-1__slice-1.pkl", + ] + for upstream_path, product_path in zip(upstream_files, product.files, strict=True): + extended_upstream = load_snapshot_representation(upstream_path) + product_representation = load_snapshot_representation(product_path) + assert canonical_snapshot_bytes(_without_ids(extended_upstream, 1)) == ( + canonical_snapshot_bytes(_without_ids(product_representation, 1)) + ) + pinned_upstream_shape = _without_ids(extended_upstream, 1) + assert all("id" not in event for event in pinned_upstream_shape["device_traces"][1]) + assert all("id" in event for event in product_representation["device_traces"][1]) + + +@pytest.mark.parametrize( + ("changes", "phase"), + [ + ({"slices": None}, "argument"), + ({"max_entries": 2}, "argument"), + ({"slices": 0}, "argument"), + ({"slices": -1}, "argument"), + ({"format": "pkl"}, "argument"), + ({"device": -1}, "device"), + ({"device": 7}, "device"), + ], +) +def test_invalid_boundaries_fail_before_engine( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, + changes: dict[str, object], + phase: str, +) -> None: + called = False + + def unexpected_engine(*args: object, **kwargs: object) -> None: + nonlocal called + called = True + + monkeypatch.setattr("pt_snap_cli.core.split_service.replay_snapshot", unexpected_engine) + with pytest.raises(SplitError, match=phase): + SplitService().split(_options(tmp_path, **changes)) + assert not called + + +def test_path_boundaries_and_conflict_fail_before_load( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + source_dir = tmp_path / "source.pkl" + source_dir.mkdir() + wrong_suffix = tmp_path / "source.bin" + wrong_suffix.write_bytes(b"x") + parent_file = tmp_path / "parent" + parent_file.write_bytes(b"x") + existing = tmp_path / "existing" + existing.mkdir() + existing_file = tmp_path / "existing-file" + existing_file.write_bytes(b"owned") + broken_link = tmp_path / "broken-link" + cases = [ + _options(tmp_path, snapshot_file=tmp_path / "missing.pkl"), + _options(tmp_path, snapshot_file=source_dir), + _options(tmp_path, snapshot_file=wrong_suffix), + _options(tmp_path, output=tmp_path / "missing" / "split"), + _options(tmp_path, output=parent_file / "split"), + _options(tmp_path, output=existing), + _options(tmp_path, output=existing_file), + ] + try: + broken_link.symlink_to(tmp_path / "missing-target", target_is_directory=True) + except OSError: + pass + else: + cases.append(_options(tmp_path, output=broken_link)) + called = False + + def unexpected_load(*args: object, **kwargs: object) -> None: + nonlocal called + called = True + + monkeypatch.setattr( + "pt_snap_cli.core.split_service.load_snapshot_representation", unexpected_load + ) + for options in cases: + with pytest.raises(SplitError): + SplitService().split(options) + assert not called + + +def test_malformed_pickle_is_load_engine_phase(tmp_path: Path) -> None: + source = tmp_path / "malformed.pkl" + source.write_bytes(b"not pickle") + + with pytest.raises(SplitError, match="load/engine") as caught: + SplitService().split(_options(tmp_path, snapshot_file=source)) + assert str(source) in str(caught.value) + assert not (tmp_path / "split").exists() + + +def test_no_nonempty_device_is_device_phase(tmp_path: Path) -> None: + source = tmp_path / "empty.pkl" + source.write_bytes(pickle.dumps({"segments": [], "device_traces": [[], []]})) + + with pytest.raises(SplitError, match="device"): + SplitService().split(_options(tmp_path, snapshot_file=source)) + assert not (tmp_path / "split").exists() + + +def test_workspace_marker_splits_and_replays(tmp_path: Path) -> None: + source = tmp_path / "workspace.pkl" + source.write_bytes( + pickle.dumps( + { + "segments": [], + "device_traces": [ + [ + { + "action": "workspace_snapshot", + "addr": 1, + "size": 1, + "stream": 0, + "frames": [], + } + ] + ], + } + ) + ) + + result = SplitService().split(_options(tmp_path, snapshot_file=source, slices=1)) + + assert len(result.files) == 1 + assert load_snapshot_representation(result.files[0])["device_traces"][0][0]["action"] == ( + "workspace_snapshot" + ) + + +def test_generated_validation_failure_cleans_owned_stage( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + def fail_validation(*args: object, **kwargs: object) -> None: + raise ValueError("generated invalid") + + monkeypatch.setattr("pt_snap_cli.core.split_service.load_and_replay_snapshot", fail_validation) + with pytest.raises(SplitError, match="generated-validation"): + SplitService().split(_options(tmp_path, device=0)) + assert not (tmp_path / "split").exists() + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +def test_engine_failure_is_mapped_and_cleans_owned_stage( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + def fail_engine(*args: object, **kwargs: object) -> None: + raise RuntimeError("engine failed") + + monkeypatch.setattr("pt_snap_cli.core.split_service.replay_snapshot", fail_engine) + with pytest.raises(SplitError, match="load/engine"): + SplitService().split(_options(tmp_path, device=0)) + assert not (tmp_path / "split").exists() + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +def test_publication_failure_is_mapped_and_cleans_owned_stage( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + def fail_publish(*args: object, **kwargs: object) -> None: + raise OSError("publish failed") + + monkeypatch.setattr(SplitService, "_publish_directory", staticmethod(fail_publish)) + with pytest.raises(SplitError, match="publication"): + SplitService().split(_options(tmp_path, device=0)) + assert not (tmp_path / "split").exists() + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +@pytest.mark.parametrize( + ("failure", "phase", "detail"), + [ + ("engine", "load/engine", "engine primary"), + ("generated", "generated-validation", "generated primary"), + ("publication", "publication", "publication primary"), + ], +) +def test_cleanup_failure_never_masks_primary_error( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, + failure: str, + phase: str, + detail: str, +) -> None: + if failure == "engine": + monkeypatch.setattr( + "pt_snap_cli.core.split_service.replay_snapshot", + lambda *args, **kwargs: (_ for _ in ()).throw(RuntimeError(detail)), + ) + elif failure == "generated": + monkeypatch.setattr( + "pt_snap_cli.core.split_service.load_and_replay_snapshot", + lambda *args, **kwargs: (_ for _ in ()).throw(ValueError(detail)), + ) + else: + monkeypatch.setattr( + SplitService, + "_publish_directory", + staticmethod(lambda *args: (_ for _ in ()).throw(OSError(detail))), + ) + + real_rmtree = shutil.rmtree + + def fail_stage_cleanup(path: Path, *args: object, **kwargs: object) -> None: + if Path(path).name.startswith(".split.pt-snap-"): + raise OSError("cleanup secondary") + real_rmtree(path, *args, **kwargs) # type: ignore[arg-type] + + monkeypatch.setattr("pt_snap_cli.core.split_service.shutil.rmtree", fail_stage_cleanup) + with pytest.raises(SplitError) as caught: + SplitService().split(_options(tmp_path, device=0)) + assert caught.value.phase == phase + assert detail in caught.value.detail + assert "cleanup secondary" not in str(caught.value) + + +def test_stage_substitution_is_not_cleaned_and_primary_error_survives( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + substituted: Path | None = None + + def replace_stage( + self: SplitService, + representation: dict[str, object], + source: Path, + stage: Path, + device: int, + slices: int | None, + max_entries: int | None, + output_format: str, + ) -> list[Path]: + nonlocal substituted + shutil.rmtree(stage) + stage.mkdir() + (stage / "other-owner.txt").write_text("preserve", encoding="utf-8") + substituted = stage + raise SplitError("load/engine", source, "stage substitution primary") + + monkeypatch.setattr(SplitService, "_slice_device", replace_stage) + with pytest.raises(SplitError, match="stage substitution primary") as caught: + SplitService().split(_options(tmp_path, device=0)) + assert caught.value.phase == "load/engine" + assert substituted is not None + assert (substituted / "other-owner.txt").read_text(encoding="utf-8") == "preserve" + + +@pytest.mark.parametrize("nonempty", [False, True]) +def test_publication_race_does_not_replace_or_merge_destination( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, nonempty: bool +) -> None: + real_publish = SplitService._publish_directory + + def race(stage: Path, destination: Path) -> None: + destination.mkdir() + if nonempty: + (destination / "racer.txt").write_text("racer", encoding="utf-8") + real_publish(stage, destination) + + monkeypatch.setattr(SplitService, "_publish_directory", staticmethod(race)) + with pytest.raises(SplitError, match="publication"): + SplitService().split(_options(tmp_path, device=0)) + assert (tmp_path / "split").is_dir() + assert list((tmp_path / "split").iterdir()) == ( + [tmp_path / "split" / "racer.txt"] if nonempty else [] + ) + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +def test_publication_file_race_is_not_replaced( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + real_publish = SplitService._publish_directory + + def race(stage: Path, destination: Path) -> None: + destination.write_text("racer", encoding="utf-8") + real_publish(stage, destination) + + monkeypatch.setattr(SplitService, "_publish_directory", staticmethod(race)) + with pytest.raises(SplitError, match="publication"): + SplitService().split(_options(tmp_path, device=0)) + assert (tmp_path / "split").read_text(encoding="utf-8") == "racer" + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +@pytest.mark.parametrize("broken", [False, True]) +def test_publication_symlink_race_is_not_replaced( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, broken: bool +) -> None: + probe = tmp_path / "probe" + try: + probe.symlink_to(tmp_path / "probe-target", target_is_directory=True) + except OSError: + pytest.skip("directory symlinks are unavailable") + probe.unlink() + + target = tmp_path / "target" + if not broken: + target.mkdir() + real_publish = SplitService._publish_directory + + def race(stage: Path, destination: Path) -> None: + destination.symlink_to(target, target_is_directory=True) + real_publish(stage, destination) + + monkeypatch.setattr(SplitService, "_publish_directory", staticmethod(race)) + with pytest.raises(SplitError, match="publication"): + SplitService().split(_options(tmp_path, device=0)) + assert (tmp_path / "split").is_symlink() + assert (tmp_path / "split").readlink() == target + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +def test_linux_symbol_absence_fails_before_load_engine_or_stage( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + monkeypatch.setattr(split_module.sys, "platform", "linux") + monkeypatch.setattr(split_module.ctypes, "CDLL", lambda *args, **kwargs: object()) + monkeypatch.setattr( + split_module, + "load_snapshot_representation", + lambda *args, **kwargs: pytest.fail("source must not load"), + ) + monkeypatch.setattr( + split_module.tempfile, + "mkdtemp", + lambda *args, **kwargs: pytest.fail("stage must not be created"), + ) + + with pytest.raises(SplitError, match="publication") as caught: + SplitService().split(_options(tmp_path, device=0)) + assert "renameat2(RENAME_NOREPLACE) is unavailable" in caught.value.detail + assert not list(tmp_path.glob(".split.pt-snap-*")) + + +class _FakeRename: + def __init__(self) -> None: + self.calls: list[tuple[object, ...]] = [] + self.argtypes: object = None + self.restype: object = None + + def __call__(self, *args: object) -> int: + self.calls.append(args) + return 0 + + +@pytest.mark.parametrize( + ("platform", "symbol", "expected"), + [ + ("linux", "renameat2", (-100, b"stage", -100, b"destination", 1)), + ("darwin", "renamex_np", (b"stage", b"destination", 4)), + ], +) +def test_platform_no_replace_constants_and_calls( + monkeypatch: pytest.MonkeyPatch, + platform: str, + symbol: str, + expected: tuple[object, ...], +) -> None: + rename = _FakeRename() + library = type("FakeLibrary", (), {symbol: rename})() + monkeypatch.setattr(split_module.sys, "platform", platform) + monkeypatch.setattr(split_module.ctypes, "CDLL", lambda *args, **kwargs: library) + + SplitService._preflight_publication() + SplitService._publish_directory(Path("stage"), Path("destination")) + + assert rename.calls == [expected] + + +def test_canonicalization_rejects_unsupported_values() -> None: + for value in ({1: "bad"}, {"x": float("nan")}, {"x": object()}): + with pytest.raises(ValueError): + canonical_snapshot_bytes(value) + + +def test_explicit_pickle_json_representation_apis_round_trip(tmp_path: Path) -> None: + value = {"tuple": (1, 2), "unicode": "内存", "ordered": [3, 1, 2]} + pickle_path = tmp_path / "value.pkl" + json_path = tmp_path / "value.json" + + save_pickle_representation(value, pickle_path) + save_json_representation(value, json_path) + + assert pickle_path.read_bytes() == serialize_pickle_representation(value) + assert json_path.read_bytes() == serialize_json_representation(value) + assert canonical_snapshot_bytes( + load_pickle_representation(pickle_path) + ) == canonical_snapshot_bytes(load_json_representation(json_path)) diff --git a/tests/snapshot/test_slice_dump_runtime.py b/tests/snapshot/test_slice_dump_runtime.py new file mode 100644 index 0000000..a6ffa4e --- /dev/null +++ b/tests/snapshot/test_slice_dump_runtime.py @@ -0,0 +1,143 @@ +import json +import pickle +from pathlib import Path + +import pytest + +from pt_snap_cli.snapshot.base import DeviceSnapshot, TraceEntry +from pt_snap_cli.snapshot.representation import load_snapshot_representation, replay_snapshot +from pt_snap_cli.snapshot.simulate import SimulateDeviceSnapshot +from pt_snap_cli.snapshot.tools.slice_dump.dump import run_slice_dump +from pt_snap_cli.snapshot.tools.slice_dump.hooker import SliceDumpHooker +from tests.snapshot.helpers import FIXTURE_DIR + + +@pytest.mark.parametrize( + "fixture_name", + ["snapshot_with_empty_cache.pkl", "snapshot_with_empty_cache_expandable.pkl"], +) +def test_upstream_slice_runtime_replays_all_default_slices( + tmp_path: Path, fixture_name: str +) -> None: + representation = load_snapshot_representation(FIXTURE_DIR / fixture_name) + snapshot = SimulateDeviceSnapshot(representation, 0) + total_entries = len(representation["device_traces"][0]) + expected_slices = max(total_entries // 15000, 4) + hooker = SliceDumpHooker(str(tmp_path)) + snapshot.register_hooker(hooker) + + assert snapshot.replay() + outputs = list(tmp_path.glob("*.pkl")) + assert len(outputs) == expected_slices + for output in outputs: + _, _, replayed = _load_replay(output, "pickle", 0) + assert replayed + + +def _load_replay(path: Path, snapshot_format: str, device: int): + representation = load_snapshot_representation(path, snapshot_format) # type: ignore[arg-type] + snapshot, replayed = replay_snapshot(representation, device) + return representation, snapshot, replayed + + +def _make_snapshot(entries_count: int) -> DeviceSnapshot: + snapshot = DeviceSnapshot() + snapshot.device = 0 + snapshot.segments = [] + snapshot.trace_entries = [ + TraceEntry(action="alloc", addr=index, size=1, stream=0, idx=index) + for index in range(entries_count) + ] + return snapshot + + +def test_slice_dump_hooker_rejects_invalid_directory(tmp_path: Path) -> None: + with pytest.raises(ValueError): + SliceDumpHooker(str(tmp_path / "missing"), num_of_slices=1) + + +def test_slice_dump_hooker_strategy_and_warning_match_upstream( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + hooker = SliceDumpHooker(str(tmp_path), num_of_slices=2, max_entries=3) + hooker.num_of_events = 10 + + hooker._init_splitting_strategy() + + assert hooker.max_entries == 3 + assert hooker.num_of_slices == 4 + assert "single snapshot file exceeds the max_entries limit" in caplog.text + + +def test_slice_dump_hooker_json_dump_matches_upstream(tmp_path: Path) -> None: + hooker = SliceDumpHooker(str(tmp_path), num_of_slices=2, max_entries=2, dump_type="json") + hooker.num_of_events = 4 + hooker.prev_segments = [] + hooker.events_buffer = [TraceEntry(action="alloc", addr=1, size=2, stream=0, idx=1)] + + hooker.dump(device=0) + + outputs = list(tmp_path.glob("*.json")) + assert len(outputs) == 1 + payload = json.loads(outputs[0].read_text(encoding="utf-8")) + assert payload["device_traces"][0][0]["id"] == 1 + + +def test_slice_dump_ids_do_not_mutate_origin_and_loading_honors_them(tmp_path: Path) -> None: + origin = { + "action": "workspace_snapshot", + "addr": 1, + "size": 2, + "stream": 3, + "frames": [], + } + representation = {"segments": [], "device_traces": [[origin]]} + snapshot = SimulateDeviceSnapshot(representation, 0) + hooker = SliceDumpHooker(str(tmp_path), num_of_slices=1, max_entries=1) + snapshot.register_hooker(hooker) + + assert snapshot.replay() + assert "id" not in origin + output = next(tmp_path.glob("*.pkl")) + loaded = load_snapshot_representation(output) + assert loaded["device_traces"][0][0]["id"] == 0 + reloaded = SimulateDeviceSnapshot(loaded, 0) + assert reloaded.device_snapshot.trace_entries[0].idx == 0 + + mixed = DeviceSnapshot.from_dict( + { + "segments": [], + "device_traces": [ + [ + {**origin, "id": 42}, + {"action": "alloc", "addr": 2, "size": 2, "stream": 3, "frames": []}, + ] + ], + }, + 0, + ) + assert [event.idx for event in mixed.trace_entries] == [42, 1] + + +def test_slice_dump_hooker_resets_buffers_after_dump(tmp_path: Path) -> None: + hooker = SliceDumpHooker(str(tmp_path), num_of_slices=1, max_entries=1) + hooker.num_of_events = 1 + hooker.prev_segments = [] + event = TraceEntry(action="alloc", addr=1, size=2, stream=0, idx=1) + + hooker.post_undo_event(event, _make_snapshot(0)) + + assert hooker.events_buffer == [] + assert hooker.dump_count == 1 + + +def test_run_slice_dump_retains_upstream_empty_trace_warning_and_return( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + source = tmp_path / "empty.pkl" + source.write_bytes(pickle.dumps({"segments": [], "device_traces": []})) + + result = run_slice_dump(str(source), dump_dir=str(tmp_path)) + + assert result is None + assert "no event records cannot be replayed or split" in caplog.text diff --git a/tests/test_cli.py b/tests/test_cli.py index 68b3f5b..2208be7 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -200,6 +200,94 @@ def test_subcommand_short_help_flag(self) -> None: assert result.exit_code == 0 assert "Execute queries on the memory snapshot database" in result.stdout + def test_split_help_contract(self) -> None: + result = runner.invoke(app, ["split", "--help"]) + assert result.exit_code == 0 + normalized_help = " ".join(result.stdout.split()) + assert "SNAPSHOT_PATH" in result.stdout + assert "SNAPSHOT_FILE" not in result.stdout + assert "--format {pickle,json}" in normalized_help + assert "[default: pickle]" in result.stdout + for option in ("--device", "--slices", "--max-entries", "--output"): + assert option in result.stdout + + def test_split_output_is_required(self) -> None: + result = runner.invoke(app, ["split", "snapshot.pkl", "--slices", "1"]) + assert result.exit_code != 0 + assert "--output" in result.stderr + + def test_split_error_uses_domain_presentation_without_traceback(self, tmp_path: Path) -> None: + source = tmp_path / "missing.pkl" + result = runner.invoke( + app, + ["split", str(source), "--slices", "2", "--output", str(tmp_path / "out")], + ) + assert result.exit_code == 1 + assert f"Split path failed for '{source}'" in result.stdout + assert "Traceback" not in result.stdout + + def test_split_format_metavar_does_not_bypass_domain_validation(self, tmp_path: Path) -> None: + source = Path(__file__).parent / "fixtures" / "snapshots" / "snapshot_expandable.pkl" + result = runner.invoke( + app, + [ + "split", + str(source), + "--slices", + "1", + "--format", + "yaml", + "--output", + str(tmp_path / "out"), + ], + ) + assert result.exit_code == 1 + assert f"Split argument failed for '{source}'" in result.stdout + assert "format must be exactly 'pickle' or 'json'" in result.stdout + + def test_split_does_not_read_or_write_focus(self, tmp_path: Path) -> None: + source = Path(__file__).parent / "fixtures" / "snapshots" / "snapshot_expandable.pkl" + with patch("pt_snap_cli.cli._focus_service", side_effect=AssertionError("focus read")): + result = runner.invoke( + app, + [ + "split", + str(source), + "--device", + "0", + "--slices", + "1", + "--output", + str(tmp_path / "out"), + ], + ) + assert result.exit_code == 0 + assert "Files: 1" in result.stdout + + def test_split_cli_all_devices_max_entries_json(self, tmp_path: Path) -> None: + source = ( + Path(__file__).parent / "fixtures" / "snapshots" / "snapshot_with_multi_devices.pkl" + ) + output = tmp_path / "json-split" + + result = runner.invoke( + app, + [ + "split", + str(source), + "--max-entries", + "5000", + "--format", + "json", + "--output", + str(output), + ], + ) + + assert result.exit_code == 0 + assert "Devices: 0, 1" in result.stdout + assert len(list(output.glob("*.json"))) == 4 + def test_focus_database_not_found(self, tmp_path: Path) -> None: """Test 'focus' command with non-existent database.""" non_existent = tmp_path / "not_found.db" From 13854fae4b099b277f466200fffc660e963e0761 Mon Sep 17 00:00:00 2001 From: codeasier Date: Fri, 31 Jul 2026 01:54:16 +0800 Subject: [PATCH 06/12] docs: document and govern snapshot runtime --- .agents/quickstart/01-cli.md | 16 +-- .agents/quickstart/02-context.md | 6 +- .agents/quickstart/03-models.md | 53 +++---- .agents/quickstart/04-query.md | 52 ++----- .agents/quickstart/ARCHITECTURE.md | 16 ++- .agents/quickstart/README-for-agents.md | 9 +- .../pull_request_template.md | 9 ++ .github/scripts/check_snapshot_provenance.py | 111 ++++++++++++++ .github/workflows/test.yml | 20 +++ CHANGELOG.md | 2 +- README.md | 17 ++- README_zh.md | 15 ++ docs/README.md | 2 + docs/en/database.md | 18 +++ docs/en/quickstart.md | 23 +++ docs/en/splitting.md | 100 +++++++++++++ docs/zh/database.md | 17 +++ docs/zh/quickstart.md | 20 +++ docs/zh/splitting.md | 87 +++++++++++ tests/snapshot/golden_observations.py | 2 +- tests/test_cli.py | 1 - tests/test_governance.py | 135 ++++++++++++++++++ tests/test_release_workflow.py | 2 +- 23 files changed, 643 insertions(+), 90 deletions(-) create mode 100644 .github/scripts/check_snapshot_provenance.py create mode 100644 docs/en/splitting.md create mode 100644 docs/zh/splitting.md create mode 100644 tests/test_governance.py diff --git a/.agents/quickstart/01-cli.md b/.agents/quickstart/01-cli.md index 9c9fb5c..f375eb9 100644 --- a/.agents/quickstart/01-cli.md +++ b/.agents/quickstart/01-cli.md @@ -9,12 +9,12 @@ ### `app` (Typer) Typer 应用实例,管理所有 CLI 命令。 -### `use_database()` +### `focus_database()` 设置当前分析的数据库文件,验证有效性并显示可用设备。 ### `query_database()` 执行查询命令,支持: -- `--template`: 指定查询模板 +- `--template-use`: 指定查询模板 - `--params`: JSON 格式参数 - `--device`: 指定设备 ID - `--list`: 列出可用模板 @@ -31,7 +31,7 @@ Typer 应用实例,管理所有 CLI 命令。 ## 使用示例 ```python -from pt_snap_analyzer.cli import app +from pt_snap_cli.cli import app # 运行 CLI app() @@ -42,10 +42,10 @@ app() pt-snap --version # 设置数据库 -pt-snap use examples/snapshot.pkl.db +pt-snap focus examples/snapshot.pkl.db # 执行查询 -pt-snap query snapshot.pkl.db --template leak_detection --params '{"min_size": 1024}' +pt-snap query snapshot.pkl.db --template-use leak_detection --params '{"min_size": 1024}' # 列出模板 pt-snap query snapshot.pkl.db --list @@ -53,6 +53,6 @@ pt-snap query snapshot.pkl.db --list ## 相关文件 -- [cli.py](../../pt_snap_analyzer/cli.py) - 完整实现 -- [context.py](../../pt_snap_analyzer/context.py) - 数据库上下文 -- [query/executor.py](../../pt_snap_analyzer/query/executor.py) - 查询执行器 +- [cli.py](../../src/pt_snap_cli/cli.py) - 完整实现 +- [context.py](../../src/pt_snap_cli/context.py) - 数据库上下文 +- [query/executor.py](../../src/pt_snap_cli/query/executor.py) - 查询执行器 diff --git a/.agents/quickstart/02-context.md b/.agents/quickstart/02-context.md index 4aa522c..97671e1 100644 --- a/.agents/quickstart/02-context.md +++ b/.agents/quickstart/02-context.md @@ -41,7 +41,7 @@ ## 使用示例 ```python -from pt_snap_analyzer.context import Context +from pt_snap_cli.context import Context # 初始化并验证 ctx = Context("snapshot.pkl.db") @@ -59,5 +59,5 @@ with ctx.connect() as conn: ## 相关文件 -- [context.py](../../pt_snap_analyzer/context.py) - 完整实现 -- [cli.py](../../pt_snap_analyzer/cli.py) - 使用 Context 的 CLI 命令 +- [context.py](../../src/pt_snap_cli/context.py) - 完整实现 +- [cli.py](../../src/pt_snap_cli/cli.py) - 使用 Context 的 CLI 命令 diff --git a/.agents/quickstart/03-models.md b/.agents/quickstart/03-models.md index 2db6414..9ceff96 100644 --- a/.agents/quickstart/03-models.md +++ b/.agents/quickstart/03-models.md @@ -6,26 +6,25 @@ ## 核心组件 -### `Block` 类 +### `MemoryBlock` 类 内存块模型,表示一次内存分配。 **关键属性:** - `address` - 内存地址 - `size` - 分配大小(字节) -- `device_id` - 设备 ID -- `stream_id` - 流 ID -- `start_ns` - 开始时间(纳秒) -- `call_stack` - 调用栈信息 +- `requested_size` - 用户请求的大小 +- `state` - 内存块状态 +- `alloc_event_id` / `free_event_id` - 生命周期事件 ID -### `Event` 类 +### `MemoryEvent` 类 内存事件模型,表示内存分配/释放事件。 **关键属性:** -- `external_id` - 外部 ID -- `block_info` - 关联的内存块 -- `start_ns` - 事件时间戳 +- `id` - 事件 ID +- `action` - 事件类型 +- `allocated` / `active` / `reserved` - 事件后的内存统计 -### `MemoryEventType` 枚举 +### `EventType` 枚举 事件类型定义: - `UNKNOWN` - 未知类型 - `ALLOC` - 分配事件 @@ -39,30 +38,34 @@ ## 使用示例 ```python -from pt_snap_analyzer.models import Block, Event, MemoryEventType +from pt_snap_cli.models import BlockState, EventType, MemoryBlock, MemoryEvent # 创建内存块 -block = Block( +block = MemoryBlock( + id=1, address=0x7f8b4c000000, size=1024, - device_id=0, - stream_id=0, - start_ns=1234567890, - call_stack="main.py:10" + requested_size=1000, + state=BlockState.ACTIVE_ALLOCATED, + alloc_event_id=1, ) # 创建事件 -event = Event( - external_id=1, - block_info=block, - event_type=MemoryEventType.ALLOC, - start_ns=1234567890 +event = MemoryEvent( + id=1, + action=EventType.ALLOC, + address=block.address, + size=block.size, + stream=0, + allocated=1024, + active=1024, + reserved=2048, ) ``` ## 相关文件 -- [models/__init__.py](../../pt_snap_analyzer/models/__init__.py) - 模块导出 -- [models/block.py](../../pt_snap_analyzer/models/block.py) - Block 实现 -- [models/event.py](../../pt_snap_analyzer/models/event.py) - Event 实现 -- [models/_enums.py](../../pt_snap_analyzer/models/_enums.py) - 枚举定义 +- [models/__init__.py](../../src/pt_snap_cli/models/__init__.py) - 模块导出 +- [models/block.py](../../src/pt_snap_cli/models/block.py) - MemoryBlock 实现 +- [models/event.py](../../src/pt_snap_cli/models/event.py) - MemoryEvent 实现 +- [models/_enums.py](../../src/pt_snap_cli/models/_enums.py) - 枚举定义 diff --git a/.agents/quickstart/04-query.md b/.agents/quickstart/04-query.md index 8024428..97d00ac 100644 --- a/.agents/quickstart/04-query.md +++ b/.agents/quickstart/04-query.md @@ -57,47 +57,25 @@ Fluent API 构建 SQL 查询。 位于 `query/templates/` 目录,按分类组织: -- **Basic**: `active_blocks.yaml`, `blocks_by_size.yaml`, `events_by_action.yaml`, `memory_timeline.yaml` -- **Statistical**: `memory_peak.yaml`, `callstack_analysis.yaml` -- **Business**: `leak_detection.yaml` +- **Basic**: `allocation`, `block`, `event` +- **Statistical**: `active_blocks_at_event`, `allocator_gap`, `callstack_analysis`, `memory_peak` +- **Business**: `active_memory_callstack_at_event`, `leak_detection` ## 使用示例 -```python -from pt_snap_analyzer.query import QueryExecutor -from pt_snap_analyzer.context import Context -from pathlib import Path - -# 初始化 -ctx = Context("snapshot.pkl.db") -executor = QueryExecutor(ctx, template_dir=Path("query/templates")) - -# 执行模板查询 -results = executor.execute_template( - "leak_detection", - params={"min_size": 1024}, - device_id=0 -) - -# 使用 QueryBuilder -from pt_snap_analyzer.query import QueryBuilder, Condition - -builder = QueryBuilder() -sql = (builder - .from_table("trace_entry_0") - .columns("address", "size", "start_ns") - .where(Condition("size").gt(1024)) - .order_by("start_ns") - .limit(100) - .build()) +```bash +pt-snap query snapshot.pkl.db --template-use leak_detection \ + --params '{"min_size": 1024}' --device 0 +pt-snap query --list +pt-snap query --template-info leak_detection ``` ## 相关文件 -- [query/__init__.py](../../pt_snap_analyzer/query/__init__.py) - 模块导出 -- [query/executor.py](../../pt_snap_analyzer/query/executor.py) - 执行器 -- [query/builder.py](../../pt_snap_analyzer/query/builder.py) - 构建器 -- [query/condition.py](../../pt_snap_analyzer/query/condition.py) - 条件 -- [query/mapper.py](../../pt_snap_analyzer/query/mapper.py) - 映射器 -- [query/registry.py](../../pt_snap_analyzer/query/registry.py) - 注册表 -- [query/templates/](../../pt_snap_analyzer/query/templates/) - 查询模板 +- [query/__init__.py](../../src/pt_snap_cli/query/__init__.py) - 模块导出 +- [query/executor.py](../../src/pt_snap_cli/query/executor.py) - 执行器 +- [query/builder.py](../../src/pt_snap_cli/query/builder.py) - 构建器 +- [query/condition.py](../../src/pt_snap_cli/query/condition.py) - 条件 +- [query/mapper.py](../../src/pt_snap_cli/query/mapper.py) - 映射器 +- [query/registry.py](../../src/pt_snap_cli/query/registry.py) - 注册表 +- [query/templates/](../../src/pt_snap_cli/query/templates/) - 查询模板 diff --git a/.agents/quickstart/ARCHITECTURE.md b/.agents/quickstart/ARCHITECTURE.md index 9ffd73f..47c303e 100644 --- a/.agents/quickstart/ARCHITECTURE.md +++ b/.agents/quickstart/ARCHITECTURE.md @@ -1,4 +1,4 @@ -# pt-snap-analyzer 架构概览 +# pt-snap-cli 架构概览 ## 项目定位 @@ -7,11 +7,13 @@ PyTorch Memory Snapshot Analysis Tool - 用于分析 PyTorch 内存快照的命 ## 核心架构 ``` -pt_snap_analyzer/ +src/pt_snap_cli/ ├── cli.py # CLI 入口,提供 pt-snap 命令 -├── context.py # 数据库上下文管理 +├── core/ # 共享服务与产品错误 +├── context.py # 只读数据库上下文 +├── snapshot/ # 内建快照导入与回放运行时 ├── models/ # 数据模型定义 -└── query/ # 查询引擎 +└── query/ # 查询引擎与模板 ``` ## 模块依赖关系 @@ -58,13 +60,13 @@ Models 模块 ```bash # 1. 设置数据库 -pt-snap use snapshot.pkl.db +pt-snap focus snapshot.pkl.db # 2. 执行泄漏检测 -pt-snap query snapshot.pkl.db --template leak_detection +pt-snap query snapshot.pkl.db --template-use leak_detection # 3. 调用栈分析 -pt-snap query snapshot.pkl.db --template callstack_analysis +pt-snap query snapshot.pkl.db --template-use callstack_analysis ``` ## 相关文件 diff --git a/.agents/quickstart/README-for-agents.md b/.agents/quickstart/README-for-agents.md index c3f682c..ae7c006 100644 --- a/.agents/quickstart/README-for-agents.md +++ b/.agents/quickstart/README-for-agents.md @@ -3,7 +3,7 @@ ## 📚 文档结构 ``` -docs/agents/ +.agents/quickstart/ ├── README-for-agents.md # 本文件 - 导航索引 ├── ARCHITECTURE.md # 整体架构概览 ├── 01-cli.md # CLI 模块详情 @@ -66,16 +66,15 @@ ARCHITECTURE.md (5 分钟) ## 🔗 与现有文档的关系 -- `docs/agents/` - **Agent 快速参考**(本文档) -- `docs/superpowers/` - **设计文档**(PRDs、specs、plans) +- `.agents/quickstart/` - **Agent 快速参考**(本文档) - `README.md` - **用户使用指南** ## ✨ 最佳实践 ```markdown # 新会话开场 -你好!我已阅读 [ARCHITECTURE.md](docs/agents/ARCHITECTURE.md), -了解到 pt-snap-analyzer 是一个 PyTorch 内存快照分析工具。 +你好!我已阅读 [ARCHITECTURE.md](ARCHITECTURE.md), +了解到 pt-snap-cli 是一个 PyTorch 内存快照分析工具。 请问需要我帮助你做什么? # 执行任务时 diff --git a/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md b/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md index 8f39cdc..ed5f6fd 100644 --- a/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md +++ b/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md @@ -16,6 +16,15 @@ Fixes # - [ ] No new warnings introduced - [ ] Changes tested locally +### Snapshot Runtime Provenance + + +- [ ] Snapshot provenance evaluation completed when snapshot runtime files change +Snapshot provenance decision: +Snapshot provenance no-update reason: + ## 📸 Screenshots (if applicable) diff --git a/.github/scripts/check_snapshot_provenance.py b/.github/scripts/check_snapshot_provenance.py new file mode 100644 index 0000000..110eae7 --- /dev/null +++ b/.github/scripts/check_snapshot_provenance.py @@ -0,0 +1,111 @@ +from __future__ import annotations + +import argparse +import os +import re +import subprocess +import sys +from collections.abc import Sequence +from pathlib import Path + +SNAPSHOT_PREFIX = "src/pt_snap_cli/snapshot/" +PROVENANCE_PATH = f"{SNAPSHOT_PREFIX}PROVENANCE.md" +DECISION_LABEL = "Snapshot provenance decision" +REASON_LABEL = "Snapshot provenance no-update reason" +_DECLARATION = re.compile( + rf"^[ \t]*(?P