From 4fe55554677742d1fe17168df9e69ea71e2eff34 Mon Sep 17 00:00:00 2001 From: codeasier Date: Mon, 22 Jun 2026 01:22:55 +0800 Subject: [PATCH 1/3] feat: vendor MemSnapDump dump2db backend into pt-snap-cli pt-snap import is now a built-in core capability: the dump2db backend (used to convert raw PyTorch memory snapshot pickles into pt-snap-cli SQLite databases) is vendored under src/pt_snap_cli/vendor/memsnapdump/. Interface layer is frozen: ImportService, ImportOptions, ImportResult, the three error types, and the pt-snap import CLI shape are unchanged from the prototype PR. What changes is where the backend lives. Architecture: - src/pt_snap_cli/vendor/memsnapdump/ holds the minimal closure required to execute run_dump_to_db, with the upstream module structure preserved so future syncs remain diff-friendly. - src/pt_snap_cli/core/snapshot_import_backend.py is the semantic adapter over the vendored backend, isolating the rest of the code from the vendor namespace. - ImportService now calls SnapshotImportBackend instead of importing from the external memsnapdump package. - ImportToolMissingError is repurposed: it now means the vendored backend could not be loaded (a packaging problem), not that the user forgot to install memsnapdump. Dependency and CI: - pyproject.toml: the optional 'memsnapdump' git extra is removed. No runtime external package is required for pt-snap import. - .github/workflows/test.yml: the test job installs only .[dev] and must pass without any extra memsnapdump installation, ensuring vendoring is genuinely self-contained. - black and ruff exclude src/pt_snap_cli/vendor/ so the upstream code is not reformatted on every lint pass. Tests: - The vendored backend is exercised against real .pkl fixtures under tests/fixtures/snapshots/, including a multi-device snapshot, so the closure's coverage of replay/allocator paths is verified. - CLI tests (TestImportCommand) cover the success path, --no-focus, missing file, bad suffix, and missing-tool display. - Service tests cover input validation, focus writing, and the per-error exception paths. Out of scope (unchanged from the prototype PR): split/clipping, API/MCP mirror, subprocess fallback. These belong to separate follow-ups. Refs #65 --- README.md | 8 + docs/en/database.md | 18 + docs/en/quickstart.md | 9 + docs/zh/quickstart.md | 9 + pyproject.toml | 6 + src/pt_snap_cli/cli.py | 38 ++ src/pt_snap_cli/context.py | 8 + src/pt_snap_cli/core/__init__.py | 12 + src/pt_snap_cli/core/errors.py | 33 ++ src/pt_snap_cli/core/import_service.py | 91 +++ src/pt_snap_cli/core/models.py | 36 ++ .../core/snapshot_import_backend.py | 39 ++ src/pt_snap_cli/vendor/__init__.py | 0 .../vendor/memsnapdump/__init__.py | 0 .../vendor/memsnapdump/base/__init__.py | 3 + .../vendor/memsnapdump/base/entities.py | 302 ++++++++++ .../vendor/memsnapdump/simulate/__init__.py | 10 + .../memsnapdump/simulate/allocator_context.py | 11 + .../simulate/allocator_hook_dispatcher.py | 63 +++ .../memsnapdump/simulate/hooker_defs.py | 110 ++++ .../memsnapdump/simulate/replay_executor.py | 37 ++ .../vendor/memsnapdump/simulate/simulate.py | 112 ++++ .../simulate/simulated_caching_allocator.py | 279 ++++++++++ .../memsnapdump/simulate/snapshot_lookup.py | 135 +++++ .../memsnapdump/simulate/snapshot_mutator.py | 407 ++++++++++++++ .../tools/adaptors/database/__init__.py | 4 + .../tools/adaptors/database/defs.py | 20 + .../tools/adaptors/database/entity2record.py | 61 ++ .../tools/adaptors/database/snapshot_db.py | 97 ++++ .../memsnapdump/tools/adaptors/snapshot2db.py | 277 ++++++++++ .../vendor/memsnapdump/util/__init__.py | 9 + .../vendor/memsnapdump/util/file_util.py | 132 +++++ .../vendor/memsnapdump/util/logger.py | 137 +++++ .../vendor/memsnapdump/util/sqlite_meta.py | 520 ++++++++++++++++++ .../vendor/memsnapdump/util/timer.py | 58 ++ tests/core/__init__.py | 0 tests/core/test_import_errors.py | 22 + tests/core/test_import_models.py | 40 ++ tests/core/test_import_service.py | 145 +++++ .../snapshots/snapshot_with_empty_cache.pkl | Bin 0 -> 617060 bytes .../snapshots/snapshot_with_multi_devices.pkl | Bin 0 -> 1355829 bytes tests/test_cli.py | 72 +++ 42 files changed, 3370 insertions(+) create mode 100644 src/pt_snap_cli/core/import_service.py create mode 100644 src/pt_snap_cli/core/snapshot_import_backend.py create mode 100644 src/pt_snap_cli/vendor/__init__.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/__init__.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/base/__init__.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/base/entities.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_context.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/hooker_defs.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/__init__.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/defs.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/util/__init__.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/util/file_util.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/util/logger.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py create mode 100644 src/pt_snap_cli/vendor/memsnapdump/util/timer.py create mode 100644 tests/core/__init__.py create mode 100644 tests/core/test_import_errors.py create mode 100644 tests/core/test_import_models.py create mode 100644 tests/core/test_import_service.py create mode 100644 tests/fixtures/snapshots/snapshot_with_empty_cache.pkl create mode 100644 tests/fixtures/snapshots/snapshot_with_multi_devices.pkl diff --git a/README.md b/README.md index 24b7120..2c9f27d 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,13 @@ pip install -e . ## Quick Start +To start from a raw PyTorch memory snapshot, import the pickle into a SnapshotDB with the built-in backend, then list the available query templates: + +```bash +pt-snap import snapshot.pkl +pt-snap query --list +``` + ```bash # Set the snapshot database and device pt-snap focus examples/snapshot_expandable.pkl.db --device 0 @@ -33,6 +40,7 @@ See the [full quick start guide](docs/en/quickstart.md) for a walkthrough. | Command | Description | |---------|-------------| | `pt-snap focus` | Set and manage analysis focus (database + device) | +| `pt-snap import ` | Import a PyTorch memory snapshot pickle into a SnapshotDB | | `pt-snap query` | Run memory analysis queries | | `pt-snap config` | Manage global configuration | | `pt-snap-mcp` | Start the MCP server for agent integration | diff --git a/docs/en/database.md b/docs/en/database.md index ed4430d..dcc6ee3 100644 --- a/docs/en/database.md +++ b/docs/en/database.md @@ -12,6 +12,24 @@ SnapshotDB is the SQLite database format for persisting PyTorch memory profiling --- +## Producing a snapshot DB + +`pt-snap` analyzes SQLite SnapshotDB files. If you start with a raw PyTorch memory snapshot pickle, import the snapshot with the built-in backend: + +```bash +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: + +```bash +pt-snap query --list +``` + +You can also generate the same SnapshotDB format with another compatible producer, then point `pt-snap focus` at the resulting `.db` file. + +--- + ## Database Structure ### Tables diff --git a/docs/en/quickstart.md b/docs/en/quickstart.md index 1685de9..8ce8443 100644 --- a/docs/en/quickstart.md +++ b/docs/en/quickstart.md @@ -12,6 +12,15 @@ pip install -e . ## Your First Analysis +### Optional: Import a PyTorch Snapshot + +If you have a raw `.pkl` memory snapshot, import it first with the built-in backend: + +```bash +pt-snap import snapshot.pkl +pt-snap query --list +``` + ### Step 1: Set the Snapshot Database and Device Point `pt-snap` to your SQLite snapshot database file: diff --git a/docs/zh/quickstart.md b/docs/zh/quickstart.md index e241dd6..46c78c1 100644 --- a/docs/zh/quickstart.md +++ b/docs/zh/quickstart.md @@ -12,6 +12,15 @@ pip install -e . ## 第一次分析 +### 可选:导入 PyTorch 快照 + +如果你手上是原始 `.pkl` 内存快照,请先使用内建后端导入: + +```bash +pt-snap import snapshot.pkl +pt-snap query --list +``` + ### 第一步:设置快照数据库和设备 将 `pt-snap` 指向你的 SQLite 快照数据库文件: diff --git a/pyproject.toml b/pyproject.toml index 4087312..42a48e6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -67,10 +67,16 @@ pt_snap_cli = [ [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/cli.py b/src/pt_snap_cli/cli.py index 828f9ec..0e33624 100644 --- a/src/pt_snap_cli/cli.py +++ b/src/pt_snap_cli/cli.py @@ -20,12 +20,17 @@ FocusFileInvalidError, FocusNotConfiguredError, FocusService, + ImportExecutionError, + ImportOptions, + ImportService, + ImportToolMissingError, InvalidCategoryError, InvalidDeviceError, PeakMemoryReport, QueryExecutionError, QueryService, ReportService, + SnapshotFileInvalidError, TemplateNotFoundError, TemplateRenderError, ) @@ -153,6 +158,39 @@ def focus_database( _error(str(e)) +@app.command("import") +def import_snapshot( + snapshot_file: Annotated[Path, typer.Argument(help="Path to .pkl snapshot")], + output_dir: Annotated[Path | None, typer.Option("--output-dir", "-o")] = None, + device: Annotated[int | None, typer.Option("--device", "-d")] = None, + no_focus: Annotated[bool, typer.Option("--no-focus", help="Skip focus update")] = False, +) -> None: + """Import a PyTorch memory snapshot into a SQLite database.""" + try: + result = ImportService().import_snapshot( + ImportOptions( + snapshot_file=snapshot_file, + output_dir=output_dir, + device=device, + set_focus=not no_focus, + ) + ) + except ( + ImportToolMissingError, + ImportExecutionError, + SnapshotFileInvalidError, + FocusFileInvalidError, + DatabaseSchemaError, + ) as e: + _error(str(e)) + + typer.echo(f"Imported: {result.db_path}") + if result.focus_state is not None: + focus_file = getattr(result.focus_state, "focus_file", None) + if focus_file is not None: + typer.echo(f"Focus: {focus_file}") + + @app.command("query") def query_database( db_path: Annotated[ diff --git a/src/pt_snap_cli/context.py b/src/pt_snap_cli/context.py index 43ff514..11826e5 100644 --- a/src/pt_snap_cli/context.py +++ b/src/pt_snap_cli/context.py @@ -67,6 +67,14 @@ def device_ids(self) -> list[int]: self._device_ids = self._discover_device_ids() return self._device_ids + def discover_devices(self) -> list[int]: + """Discover device IDs available in the database. + + Method-style alias of the ``device_ids`` property, exposed for + callers (e.g. import service) that prefer an explicit method. + """ + return self.device_ids + def _discover_device_ids(self) -> list[int]: """Discover device IDs from database table names.""" device_ids = set() diff --git a/src/pt_snap_cli/core/__init__.py b/src/pt_snap_cli/core/__init__.py index 1dd1064..d69218a 100644 --- a/src/pt_snap_cli/core/__init__.py +++ b/src/pt_snap_cli/core/__init__.py @@ -3,16 +3,22 @@ DatabaseSchemaError, FocusFileInvalidError, FocusNotConfiguredError, + ImportExecutionError, + ImportToolMissingError, InvalidCategoryError, InvalidDeviceError, PtSnapCoreError, QueryExecutionError, + SnapshotFileInvalidError, TemplateNotFoundError, TemplateRenderError, ) from pt_snap_cli.core.focus_service import FocusService +from pt_snap_cli.core.import_service import ImportService from pt_snap_cli.core.models import ( FocusState, + ImportOptions, + ImportResult, PeakMemoryReport, QueryResult, ResolvedFocus, @@ -34,6 +40,9 @@ "TemplateNotFoundError", "TemplateRenderError", "QueryExecutionError", + "ImportToolMissingError", + "SnapshotFileInvalidError", + "ImportExecutionError", "ResolvedFocus", "FocusState", "TemplateParameter", @@ -41,7 +50,10 @@ "TemplateInfo", "QueryResult", "PeakMemoryReport", + "ImportOptions", + "ImportResult", "FocusService", "QueryService", "ReportService", + "ImportService", ] diff --git a/src/pt_snap_cli/core/errors.py b/src/pt_snap_cli/core/errors.py index e977746..62e20e2 100644 --- a/src/pt_snap_cli/core/errors.py +++ b/src/pt_snap_cli/core/errors.py @@ -36,3 +36,36 @@ class TemplateRenderError(PtSnapCoreError): class QueryExecutionError(PtSnapCoreError): pass + + +class ImportToolMissingError(PtSnapCoreError): + """Raised when the vendored 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. + """ + + pass + + +class SnapshotFileInvalidError(PtSnapCoreError): + """Raised when a candidate snapshot pickle file cannot be used as input. + + Triggers include: path does not exist, path is not a regular file, + suffix is not .pkl or .pickle, file cannot be unpickled, or the + unpickled top-level object is not a dict. + """ + + pass + + +class ImportExecutionError(PtSnapCoreError): + """Raised when the import backend itself fails to produce a database. + + Covers upstream dump2db returning False, raising an exception, + or producing no .db artifact where one was expected. + """ + + pass diff --git a/src/pt_snap_cli/core/import_service.py b/src/pt_snap_cli/core/import_service.py new file mode 100644 index 0000000..d5d238e --- /dev/null +++ b/src/pt_snap_cli/core/import_service.py @@ -0,0 +1,91 @@ +from __future__ import annotations + +import pickle +from collections.abc import Callable +from pathlib import Path +from typing import TYPE_CHECKING + +from pt_snap_cli.core.errors import ImportToolMissingError, SnapshotFileInvalidError +from pt_snap_cli.core.models import ImportOptions, ImportResult +from pt_snap_cli.core.snapshot_import_backend import SnapshotImportBackend + +if TYPE_CHECKING: + from pt_snap_cli.core.focus_service import FocusService + +VALID_SUFFIXES = {".pkl", ".pickle"} + + +class ImportService: + """Import PyTorch snapshot pickle files through the vendored backend.""" + + def __init__( + self, + focus_service: FocusService | None = None, + backend: SnapshotImportBackend | None = None, + ) -> None: + self._focus_service = focus_service + self._backend = backend or SnapshotImportBackend() + self._backend_available = True + self._run_dump_to_db: Callable[[Path, Path, int | None], Path] | None = ( + self._backend.dump_to_db + ) + + def import_snapshot(self, options: ImportOptions) -> ImportResult: + self._validate_snapshot_file(options.snapshot_file) + output_dir = self._resolve_output_dir(options.snapshot_file, options.output_dir) + db_path = self._invoke_backend(options.snapshot_file, output_dir, options.device) + + focus_state = None + if options.set_focus: + if self._focus_service is None: + from pt_snap_cli.core.focus_service import FocusService + + self._focus_service = FocusService() + focus_state = self._focus_service.set_project_focus( + db_path=db_path, + device_id=options.device, + base_dir=output_dir, + ) + + return ImportResult(db_path=db_path, device_id=options.device, focus_state=focus_state) + + def _ensure_backend_available(self) -> None: + if not self._backend_available or self._run_dump_to_db is None: + raise ImportToolMissingError( + "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " + "the package may be incomplete." + ) + + def _invoke_backend( + self, + snapshot_file: Path, + output_dir: Path, + device: int | None, + ) -> Path: + self._ensure_backend_available() + assert self._run_dump_to_db is not None + return self._run_dump_to_db(snapshot_file, output_dir, device) + + @staticmethod + def _validate_snapshot_file(path: Path) -> None: + if not path.exists(): + raise SnapshotFileInvalidError(f"Snapshot file does not exist: {path}") + if not path.is_file(): + raise SnapshotFileInvalidError(f"Snapshot path is not a file: {path}") + if path.suffix.lower() not in VALID_SUFFIXES: + raise SnapshotFileInvalidError( + f"Snapshot suffix must be .pkl or .pickle, got {path.suffix!r}" + ) + try: + with path.open("rb") as file: + obj = pickle.load(file) + except Exception as exc: + raise SnapshotFileInvalidError(f"Cannot unpickle snapshot file: {exc}") from exc + if not isinstance(obj, dict): + raise SnapshotFileInvalidError( + f"Snapshot top-level must be a dict, got {type(obj).__name__}" + ) + + @staticmethod + def _resolve_output_dir(snapshot_file: Path, output_dir: Path | None) -> Path: + return output_dir.resolve() if output_dir is not None else snapshot_file.resolve().parent diff --git a/src/pt_snap_cli/core/models.py b/src/pt_snap_cli/core/models.py index e1768a5..d06ef98 100644 --- a/src/pt_snap_cli/core/models.py +++ b/src/pt_snap_cli/core/models.py @@ -69,3 +69,39 @@ class PeakMemoryReport: peak: dict[str, Any] allocator_gap: dict[str, Any] | None callstack_groups: list[dict[str, Any]] + + +@dataclass(frozen=True) +class ImportOptions: + """Options for `pt-snap import`. + + Attributes: + snapshot_file: Path to the input `.pkl` or `.pickle` snapshot. + output_dir: Directory where the generated `.db` is written. + Defaults to the snapshot file's parent directory. + device: Optional device id to focus on. When None, all available + devices are imported. + set_focus: When True (default), also write project focus so subsequent + `pt-snap query` / `pt-snap report` commands reuse the new DB. + """ + + snapshot_file: Path + output_dir: Path | None = None + device: int | None = None + set_focus: bool = True + + +@dataclass(frozen=True) +class ImportResult: + """Result of `pt-snap import`. + + Attributes: + db_path: Path to the generated SQLite database. + device_id: Device id used during import, or None when not specified. + focus_state: The FocusState written to project focus when + options.set_focus is True, otherwise None. + """ + + db_path: Path + device_id: int | None + focus_state: FocusState | None diff --git a/src/pt_snap_cli/core/snapshot_import_backend.py b/src/pt_snap_cli/core/snapshot_import_backend.py new file mode 100644 index 0000000..66c4ef0 --- /dev/null +++ b/src/pt_snap_cli/core/snapshot_import_backend.py @@ -0,0 +1,39 @@ +from __future__ import annotations + +from pathlib import Path + +from pt_snap_cli.core.errors import ImportExecutionError, ImportToolMissingError +from pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db import run_dump_to_db + + +class SnapshotImportBackend: + """Stable adapter over the vendored snapshot-to-database implementation.""" + + def dump_to_db( + self, + snapshot_file: Path, + output_dir: Path, + device: int | None = None, + ) -> Path: + db_path = output_dir / f"{snapshot_file.name}.db" + + try: + ok = run_dump_to_db( + snapshot_file=str(snapshot_file), + dump_dir=str(output_dir), + device=device, + ) + except ImportError as exc: + raise ImportToolMissingError( + "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " + "the package may be incomplete." + ) from exc + except Exception as exc: + raise ImportExecutionError(f"Vendored snapshot import backend failed: {exc}") from exc + + if not ok: + raise ImportExecutionError("Vendored snapshot import backend reported failure.") + if not db_path.is_file(): + raise ImportExecutionError(f"Expected database not produced: {db_path}") + + return db_path diff --git a/src/pt_snap_cli/vendor/__init__.py b/src/pt_snap_cli/vendor/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/pt_snap_cli/vendor/memsnapdump/__init__.py b/src/pt_snap_cli/vendor/memsnapdump/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/pt_snap_cli/vendor/memsnapdump/base/__init__.py b/src/pt_snap_cli/vendor/memsnapdump/base/__init__.py new file mode 100644 index 0000000..2f6be79 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/base/__init__.py @@ -0,0 +1,3 @@ +from .entities import Frame, TraceEntry, Block, BlockState, Segment, DeviceSnapshot + +__all__ = ["Frame", "TraceEntry", "Block", "BlockState", "Segment", "DeviceSnapshot"] diff --git a/src/pt_snap_cli/vendor/memsnapdump/base/entities.py b/src/pt_snap_cli/vendor/memsnapdump/base/entities.py new file mode 100644 index 0000000..7c7d329 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/base/entities.py @@ -0,0 +1,302 @@ +from typing import List, Literal, Any +from dataclasses import dataclass, field + + +class Frame: + filename: str = "" + line: int = -1 + name: str = "" + + _origin: dict = None # Readonly + + @classmethod + def from_dict(cls, frame_dict: dict): + frame = cls() + frame.filename = frame_dict["filename"] + frame.line = frame_dict["line"] + frame.name = frame_dict["name"] + frame._origin = frame_dict + return frame + + def to_dict(self): + return ( + self._origin + if self._origin + else {"filename": self.filename, "line": self.line, "name": self.name} + ) + + +@dataclass +class TraceEntry: + # When `torch.npu.memory._record_memory_history()` is enabled, + # the snapshot will contain TraceEntry objects that record each + # action the allocator took. + """ + action: Literal[ + 'alloc' # memory allocated + 'free_requested', # the allocated received a call to free memory + 'free_completed', # the memory that was requested to be freed is now + # able to be used in future allocation calls + 'segment_alloc', # the caching allocator ask aclrtMalloc for more memory + # and added it as a segment in its cache + 'segment_free', # the caching allocator called aclrtFree to return memory + # to npu possibly trying free up memory to + # allocate more segments or because empty_caches was called + 'oom', # the allocator threw an OOM exception. 'size' is + # the requested number of bytes that did not succeed + 'snapshot' # the allocator generated a memory snapshot + # useful to coorelate a previously taken + # snapshot with this trace + ] + """ + action: str = "" + addr: int = -1 # not present for OOM + frames: List[Frame] = field(default_factory=list) + size: int = 0 + stream: int = 0 + device_free: int = -1 # only present for OOM, the amount of + # memory npu still reports to be free + + _origin: dict = None # Readonly + idx: int = -1 # 索引,全局唯一 + + @classmethod + def from_dict(cls, trace_dict: dict): + trace_entry = cls( + action=trace_dict["action"], + addr=int(trace_dict["addr"]), + 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", []) + ], + ) + return trace_entry + + 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] + ] + ) + + 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], + ) + ) + + +class BlockState: + ACTIVE_PENDING_FREE = "active_pending_free" + ACTIVE_ALLOCATED = "active_allocated" + INACTIVE = "inactive" + + +@dataclass +class Block: + # A piece of memory returned from the allocator, or + # current cached but inactive. + size: int = 0 + requested_size: int = 0 # size requested during malloc, may be smaller than + # size due to rounding + address: int = -1 + state: Literal[ + "active_allocated", # used by a tensor + "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( + default_factory=list + ) # stack trace from where the allocation occurred + + # 指向持有该block的segment对象 + segment_ptr: Any = None + free_event_idx: int = None + alloc_event_idx: int = None + + @classmethod + def from_dict(cls, block_dict: dict): + block = cls( + size=block_dict["size"], + requested_size=block_dict["requested_size"], + address=block_dict["address"], + state=block_dict["state"], + frames=[Frame.from_dict(frame) for frame in block_dict.get("frames", [])], + ) + return block + + @classmethod + def build_from_event(cls, event: TraceEntry): + block = cls( + size=event.size, + requested_size=event.size, + address=event.addr, + frames=event.frames, + ) + 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], + ) + + +@dataclass +class Segment: + # Segments are memory returned from a aclrtMalloc call. + # The size of reserved memory is the sum of all Segments. + # Segments are cached and reused for future allocations. + # If the reuse is smaller than the segment, the segment + # is split into more then one Block. + # empty_cache() frees Segments that are entirely inactive. + address: int = -1 + total_size: int = 0 # aclrtMalloc'd size of segment + stream: int = 0 + 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) + device: int = 0 + frames: List[Frame] = field(default_factory=list) + is_expandable: bool = False + _origin: dict = None # Readonly + free_or_unmap_event_idx: int = None + alloc_or_map_event_idx: int = None + + @classmethod + def from_dict(cls, segment_dict: dict, ignore_inactive_blocks: bool = False): + segment = cls( + address=segment_dict["address"], + total_size=segment_dict["total_size"], + stream=segment_dict["stream"], + 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", []) + ], + device=segment_dict.get("device", 0), + _origin=segment_dict, + is_expandable=segment_dict.get("is_expandable", False), + ) + for block in segment_dict["blocks"]: + if ignore_inactive_blocks and block["state"] == BlockState.INACTIVE: + continue + _block = Block.from_dict(block) + _block.segment_ptr = segment + segment.blocks.append(_block) + return segment + + @classmethod + def build_from_event(cls, event: TraceEntry, with_inactive_block: bool = False): + segment = cls( + address=event.addr, + total_size=event.size, + stream=event.stream, + frames=event.frames, + device=event.device if hasattr(event, "device") else 0, + allocated_size=0, + active_size=0, + is_expandable=event.action in ["segment_map", "segment_unmap"], + ) + segment.blocks = ( + [] + if not with_inactive_block + else [ + Block( + size=event.size, + requested_size=event.size, + address=event.addr, + state=BlockState.INACTIVE, + segment_ptr=segment, + ) + ] + ) + 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], + ) + + +class DeviceSnapshot: + segments: List[Segment] + trace_entries: List[TraceEntry] + + total_allocated: int # 二次分配总量 + total_reserved: int # 内存池总量 + total_activated: int # 活跃内存总量 + + device: int + + @classmethod + 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 [] + ) + snapshot = cls() + snapshot.segments = [] + snapshot.trace_entries = [] + snapshot.total_allocated = 0 + snapshot.total_reserved = 0 + snapshot.total_activated = 0 + # 读取dump_snapshot时内存状态 + for segment_dict in segments_dict: + # 当segment原始数据中缺少device字段明确指向其所属设备时,默认其归属为device0 + # 此时如果from_dict指定device为0或未指定而缺省为0,则未知归属的device也会纳入分析 + if segment_dict.get("device", 0) != device: + continue + _segment = Segment.from_dict( + segment_dict, ignore_inactive_blocks=ignore_inactive_blocks + ) + snapshot.segments.append(_segment) + snapshot.total_allocated += _segment.allocated_size + snapshot.total_reserved += _segment.total_size + snapshot.total_activated += _segment.active_size + snapshot.segments.sort(key=lambda segment: (segment.address, segment.stream)) + # 读取事件序列 + for idx, trace_entry_dict in enumerate(device_trace_list): + trace_entry = TraceEntry.from_dict(trace_entry_dict) + trace_entry.idx = idx + snapshot.trace_entries.append(trace_entry) + snapshot.device = device + return snapshot + + def to_dict(self): + 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]], + } diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py new file mode 100644 index 0000000..fa76d11 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/__init__.py @@ -0,0 +1,10 @@ +from .simulate import SimulateDeviceSnapshot +from .hooker_defs import SimulateHooker, AllocatorHooker +from .allocator_context import AllocatorContext + +__all__ = [ + "SimulateDeviceSnapshot", + "SimulateHooker", + "AllocatorHooker", + "AllocatorContext", +] diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_context.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_context.py new file mode 100644 index 0000000..0a911d5 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_context.py @@ -0,0 +1,11 @@ +from ..base import DeviceSnapshot, TraceEntry + + +class AllocatorContext: + def __init__(self, snapshot: DeviceSnapshot): + self.device_snapshot = snapshot + self.current_undo_event: TraceEntry = None + self.workspace_flag = False + + def set_current_undo_event(self, undo_event: TraceEntry): + self.current_undo_event = undo_event diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py new file mode 100644 index 0000000..f80b29f --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/allocator_hook_dispatcher.py @@ -0,0 +1,63 @@ +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] = {} + + def register_hooker(self, hooker: AllocatorHooker) -> int: + idx = hash(hooker) + self.hookers[idx] = hooker + return idx + + def unregister_hooker(self, hooker_id: int): + if hooker_id in self.hookers: + del self.hookers[hooker_id] + + def pre_replay_alloc_block(self, block: Block, snapshot: DeviceSnapshot): + for hooker in self.hookers.values(): + hooker.pre_replay_alloc_block(block, snapshot) + + def post_replay_alloc_block(self, block: Block, snapshot: DeviceSnapshot): + for hooker in self.hookers.values(): + hooker.post_replay_alloc_block(block, snapshot) + + def pre_replay_free_block(self, block: Block, snapshot: DeviceSnapshot): + for hooker in self.hookers.values(): + hooker.pre_replay_free_block(block, snapshot) + + def post_replay_free_block( + self, block: Block, snapshot: DeviceSnapshot, use_copy: bool = False + ): + payload = copy.copy(block) if use_copy else 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 + ): + 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 + ): + 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 + ): + 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 + ): + 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/vendor/memsnapdump/simulate/hooker_defs.py new file mode 100644 index 0000000..d68e31e --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/hooker_defs.py @@ -0,0 +1,110 @@ +from abc import ABC, abstractmethod +from ..base import DeviceSnapshot, Segment, Block, TraceEntry + + +class SimulateHooker(ABC): + @abstractmethod + def pre_undo_event( + self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot + ) -> bool: + """ + 【READONLY】在回放事件前回调,此时事件列表**并未POP**出该事件 + :param wait4undo_event: 【只读】待回放的事件(仍在事件列表中) + :param current_snapshot: 【只读】当前的内存块快照 + :return 返回true继续执行,返回false将中断 + """ + ... + + @abstractmethod + def post_undo_event( + self, already_undo_event: TraceEntry, current_snapshot: DeviceSnapshot + ) -> bool: + """ + 【READONLY】在回放事件后回调,此时snapshot已经将该事件从事件列表中丢弃,且segments已回放到事件发生前 + :param already_undo_event: 已回放的事件 + :param current_snapshot: 【只读】当前内存快照 + :return 返回true继续执行,返回false将中断 + """ + ... + + +class AllocatorHooker(ABC): + def pre_replay_alloc_block( + self, wait4alloc_block: Block, current_snapshot: DeviceSnapshot + ): + """ + 在**回放时**分配一个内存块**前**回调,对应一个内存块释放事件回滚前 + :param wait4alloc_block: 待分配的block + :param current_snapshot: 【只读】当前内存快照 + """ + ... + + def post_replay_alloc_block( + self, allocated_block: Block, current_snapshot: DeviceSnapshot + ): + """ + 在**回放时**分配一个内存块**后**回调,对应一个内存块释放事件回滚后 + :param allocated_block: 【只读】新分配的block + :param current_snapshot:【只读】分配block前内存快照 + """ + ... + + def pre_replay_free_block( + self, wait4free_block: Block, current_snapshot: DeviceSnapshot + ): + """ + 在**回放时**释放一个内存块**前**回调,对应一个内存块申请事件回滚前 + :param wait4free_block: 【只读】待释放的block + :param current_snapshot: 【只读】释放block前内存快照 + """ + ... + + def post_replay_free_block( + self, released_block: Block, current_snapshot: DeviceSnapshot + ): + """ + 在回放时,释放一个内存块**后**回调,对应一个内存块申请事件回滚后 + :param released_block: 【副本】已释放的block(副本) + :param current_snapshot: 【只读】释放block后内存快照 + """ + ... + + def pre_replay_map_or_alloc_segment( + self, wait4alloc_map_segment: Segment, current_snapshot: DeviceSnapshot + ): + """ + 在回放时,分配或映射一个内存段**前**回调,对应一个内存段释放或unmap事件回滚前 + :param wait4alloc_map_segment: 【只读】待分配或map的内存段 + :param current_snapshot: 分配或map内存段前的内存快照 + """ + ... + + def post_replay_map_or_alloc_segment( + self, allocated_mapped_segment: Segment, current_snapshot: DeviceSnapshot + ): + """ + 在回放时,分配或映射一个内存段**后**回调,对应一个内存段释放或unmap事件回滚后 + :param allocated_mapped_segment:【副本】已分配或map的内存段 + :param current_snapshot: 分配或map内存段后的内存快照 + """ + ... + + def pre_replay_unmap_or_free_segment( + self, wait4release_segment: Segment, current_snapshot: DeviceSnapshot + ): + """ + 在回放时,释放或unmap一个内存段**前**回调,对应一个内存段申请或map事件前 + :param wait4release_segment:【只读】待释放的内存段 + :param current_snapshot: 释放或unmap内存段前的内存快照 + """ + ... + + def post_replay_unmap_or_free_segment( + self, released_segment: Segment, current_snapshot: DeviceSnapshot + ): + """ + 在回放时,释放或unmap一个内存段**后**回调,对应一个内存段申请或map事件后 + :param released_segment:【副本】已释放的内存段 + :param current_snapshot: 释放或unmap内存段后的内存快照 + """ + ... diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py new file mode 100644 index 0000000..803dc51 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/replay_executor.py @@ -0,0 +1,37 @@ +from logging import Logger + +from ..base import Block, BlockState, Segment, TraceEntry + +from .simulated_caching_allocator import SimulatedCachingAllocator + + +class ReplayExecutor: + def __init__(self, allocator: SimulatedCachingAllocator, replay_logger: Logger): + self.allocator = allocator + self.replay_logger = replay_logger + + def execute(self, event: TraceEntry) -> bool: + if event.action in ["free", "free_completed"]: + block = Block.build_from_event(event) + block.state = ( + BlockState.ACTIVE_ALLOCATED + if event.action == "free" + else BlockState.ACTIVE_PENDING_FREE + ) + return self.allocator.alloc_block(block) + if event.action == "free_requested": + return self.allocator.active_block(event) + if event.action == "alloc": + return self.allocator.free_block(event) + if event.action in ["segment_free", "segment_unmap"]: + segment = Segment.build_from_event(event) + segment.free_or_unmap_event_idx = event.idx + return self.allocator.alloc_or_map_segment( + segment, merge=event.action == "segment_unmap" + ) + if event.action == "segment_alloc": + return self.allocator.free_segment(event) + if event.action == "segment_map": + return self.allocator.unmap_segment(event) + self.replay_logger.warning(f"Skip event{event.to_dict()} during replay.") + return True diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py new file mode 100644 index 0000000..cc1fb3b --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/simulate.py @@ -0,0 +1,112 @@ +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 +from .simulated_caching_allocator import SimulatedCachingAllocator + +loading_logger = get_logger("LOAD") +replay_logger = get_logger("REPLAY") + + +class SimulateDeviceSnapshot: + device_snapshot: DeviceSnapshot + hookers: Dict[int, SimulateHooker] + + device: int + _loading_logger: Logger + _replay_logger: Logger + + def __init__(self, snapshot_dict: dict, device: int): + # 基于device初始化logger + self._loading_logger = loading_logger.getChild(f"{device}") + self._replay_logger = replay_logger.getChild(f"{device}") + if not snapshot_dict: + raise RuntimeError("Cannot init snapshot from empty data.") + self._loading_logger.info("Loading snapshot data...") + self.device_snapshot = DeviceSnapshot.from_dict( + snapshot_dict, device, ignore_inactive_blocks=True + ) + self._loading_logger.info( + f"Finished to load snapshot data: total of {len(self.device_snapshot.trace_entries)} " + 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 + ) + # 识别昇腾torch-npu采集的snapshot中的workspace事件 + if ( + self.device_snapshot.trace_entries + and self.device_snapshot.trace_entries[0].action == "workspace_snapshot" + ): + self.simulated_allocator_context.workspace_flag = True + + def register_hooker(self, hooker: SimulateHooker) -> int: + idx = hash(hooker) + self.hookers[idx] = hooker + return idx + + def unregister_hooker(self, hooker_id: int): + if hooker_id in self.hookers: + del self.hookers[hooker_id] + + def register_allocator_hooker(self, hooker: AllocatorHooker) -> int: + return self.simulated_allocator.register_hooker(hooker) + + def unregister_allocator_hooker(self, hooker_id: int): + self.simulated_allocator.unregister_hooker(hooker_id) + + def replay(self) -> bool: + """ + 开始仿真回放内存事件 + """ + # 倒序遍历 + total_size = len(self.device_snapshot.trace_entries) + self._replay_logger.info(f"Replaying {total_size} entries in snapshot...") + progress_update_point = [0.25, 0.5, 0.75] + while self.device_snapshot.trace_entries: + for hooker in self.hookers.values(): + if hooker and not hooker.pre_undo_event( + self.device_snapshot.trace_entries[-1], self.device_snapshot + ): + self._replay_logger.error( + "An interruption occurred during the replay of the single event pre hook." + ) + return False + event = self.device_snapshot.trace_entries[-1] + self.simulated_allocator_context.set_current_undo_event(event) + if not self.replay_executor.execute(event): + self._replay_logger.error( + "An interruption occurred during the replay of the single event." + ) + 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 + ): + self._replay_logger.info( + f"{(1 - progress_update_point[-1]) * 100}% of entries have been processed, " + f"{current_size} entries remain." + ) + progress_update_point.pop() + for hooker in self.hookers.values(): + if hooker and not hooker.post_undo_event(event, self.device_snapshot): + self._replay_logger.error( + "An interruption occurred during the replay of the single event post hook." + ) + return False + self._replay_logger.info("All events have been successfully replayed.") + return True diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py new file mode 100644 index 0000000..7de5356 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/simulated_caching_allocator.py @@ -0,0 +1,279 @@ +import copy + +from ..base import BlockState, Block, Segment, TraceEntry +from ..util import get_logger + +from .allocator_context import AllocatorContext +from .allocator_hook_dispatcher import AllocatorHookDispatcher +from . import snapshot_lookup, snapshot_mutator + +allocator_logger = get_logger("ALLOCATOR") + + +class SimulatedCachingAllocator: + def __init__(self, ctx: AllocatorContext): + self.ctx = ctx + self.dispatcher = AllocatorHookDispatcher() + + def register_hooker(self, hooker) -> int: + return self.dispatcher.register_hooker(hooker) + + def unregister_hooker(self, hooker_id: int): + self.dispatcher.unregister_hooker(hooker_id) + + def alloc_block(self, new_block: Block) -> bool: + """ + 回放时模拟分配一个新的block + :param new_block: 待分配的block + """ + _error = "Failed to simulate alloc block" + gap_result = snapshot_lookup.find_gap_for_alloc_block( + self.ctx.device_snapshot, + new_block.address, + new_block.size, + self.ctx.current_undo_event.stream if self.ctx.current_undo_event else None, + ) + if gap_result is None: + allocator_logger.error( + f"{_error}: cannot find gap for block (addr={new_block.address}, size={new_block.size})" + ) + return False + 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" + ): + 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 + ) + self.dispatcher.post_replay_alloc_block(new_block, self.ctx.device_snapshot) + return True + + def free_block(self, alloc_event: TraceEntry) -> bool: + """ + 回放时模拟释放一个block,可能涉及到拆分合并 + :param alloc_event: 待回滚的alloc事件 + """ + _error = "Failed to simulate free block" + seg_idx, segment = snapshot_lookup.find_overlapping_segment( + self.ctx.device_snapshot, alloc_event.addr, alloc_event.stream + ) + if seg_idx == -1 or segment is None: + allocator_logger.error( + f"{_error}: cannot find segment for block (addr={alloc_event.addr})" + ) + return False + block_idx, exist_block = snapshot_lookup.find_block(segment, alloc_event.addr) + if block_idx == -1 or exist_block is None: + # workspace场景容忍 + if self.ctx.workspace_flag: + allocator_logger.warning( + 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})" + ) + return False + if exist_block.size < alloc_event.size: + allocator_logger.error( + f"{_error}: block size ({exist_block.size}) < event size ({alloc_event.size})" + ) + return False + exist_block.alloc_event_idx = alloc_event.idx + self.dispatcher.pre_replay_free_block(exist_block, self.ctx.device_snapshot) + 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 + ) + return True + + def active_block(self, free_requested_event: TraceEntry) -> bool: + """ + 回放时模拟active一个block + :param free_requested_event: 待回放的free_requested请求 + """ + _error = "Failed to simulate active block" + seg_idx, segment = snapshot_lookup.find_overlapping_segment( + self.ctx.device_snapshot, + free_requested_event.addr, + free_requested_event.stream, + ) + if seg_idx == -1 or segment is None: + allocator_logger.error( + f"{_error}: cannot find segment for block (addr={free_requested_event.addr})" + ) + return False + block_idx, active_pending_free_block = snapshot_lookup.find_block( + segment, free_requested_event.addr + ) + if block_idx == -1 or active_pending_free_block is None: + allocator_logger.error( + f"{_error}: cannot find block (addr={free_requested_event.addr})" + ) + return False + if active_pending_free_block.state != BlockState.ACTIVE_PENDING_FREE: + # workspace场景容忍异常 + if self.ctx.workspace_flag: + allocator_logger.warning( + f"{_error}: block (addr={free_requested_event.addr}) is not in {BlockState.ACTIVE_PENDING_FREE} state, " + f"but workspace_flag is True, skipping" + ) + return True + allocator_logger.error( + f"{_error}: block (addr={free_requested_event.addr}) is not in {BlockState.ACTIVE_PENDING_FREE} state, " + f"current state: {active_pending_free_block.state}" + ) + return False + 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." + ) + return False + return True + + def alloc_or_map_segment(self, new_segment: Segment, merge: bool = False) -> bool: + """ + 回放时模拟alloc或map一个新的内存段 + :param new_segment: 新内存段 + :param merge: 是否合并,map时对应虚拟内存场景,否则仅为alloc + """ + _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 + ) + 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 + ) + return True + new_seg_start = new_segment.address + new_seg_end = new_seg_start + new_segment.total_size + left_adjacent_idx = -1 + right_adjacent_idx = -1 + for i, seg in enumerate(segments): + if seg.stream != new_segment.stream: + continue + if seg.address + seg.total_size == new_seg_start: + left_adjacent_idx = i + elif new_seg_end == seg.address: + 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 + ) + return True + virtual_map_segment = copy.deepcopy(new_segment) + if not snapshot_mutator.merge_mapped_segment( + self.ctx.device_snapshot, + new_segment, + left_adjacent_idx, + right_adjacent_idx, + ): + 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 + ) + self.dispatcher.post_replay_map_or_alloc_segment( + virtual_map_segment, self.ctx.device_snapshot + ) + return True + + def free_segment(self, alloc_seg_event: TraceEntry) -> bool: + """ + 回放时模拟free一个内存段(非虚拟内存场景) + :param alloc_seg_event: 待回滚的alloc事件 + """ + _error = "Free segment failed" + seg_addr = alloc_seg_event.addr + exist_seg_idx, exist_seg = snapshot_lookup.find_segment( + self.ctx.device_snapshot, seg_addr, alloc_seg_event.stream + ) + if exist_seg_idx == -1 or exist_seg is None: + allocator_logger.error( + f"{_error}: cannot found segment(addr={seg_addr}, stream={alloc_seg_event.stream})" + ) + return False + if exist_seg.total_size != alloc_seg_event.size: + allocator_logger.error( + f"{_error}: cannot free segment(addr={seg_addr}, size={alloc_seg_event.size}) in " + f"exist segment(addr={exist_seg.address}, size={exist_seg.total_size})" + ) + return False + if exist_seg.active_size > 0: + allocator_logger.error( + f"{_error}: cannot free a segment that still has active allocations." + ) + 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 + ) + snapshot_mutator.remove_segment(self.ctx.device_snapshot, exist_seg) + self.dispatcher.post_replay_unmap_or_free_segment( + exist_seg, self.ctx.device_snapshot + ) + return True + + def unmap_segment(self, map_event): + """ + 回放时模拟unmap一个已有的内存段(虚拟内存场景) + :param map_event: 待回滚的map事件 + """ + _error = "Unmap segment failed" + segments = self.ctx.device_snapshot.segments + virtual_free_segment = Segment.build_from_event(map_event) + seg_addr = virtual_free_segment.address + unmap_size = virtual_free_segment.total_size + exist_seg_idx, exist_seg = snapshot_lookup.find_overlapping_segment( + self.ctx.device_snapshot, seg_addr, map_event.stream + ) + if exist_seg_idx < 0 or exist_seg is None or exist_seg_idx >= len(segments): + allocator_logger.error(f"{_error}: cannot found segment(addr={seg_addr})") + return False + virtual_free_segment.free_or_unmap_event_idx = exist_seg.free_or_unmap_event_idx + virtual_free_segment.alloc_or_map_event_idx = map_event.idx + if not ( + seg_addr >= exist_seg.address + and seg_addr + unmap_size <= exist_seg.address + exist_seg.total_size + ): + allocator_logger.error( + f"{_error}: cannot unmap segment(addr={seg_addr}, unmap_size={unmap_size}) in exist segment(" + f"addr={exist_seg.address}, total_size={exist_seg.total_size})" + ) + return False + self.dispatcher.pre_replay_unmap_or_free_segment( + virtual_free_segment, self.ctx.device_snapshot + ) + if exist_seg.stream != map_event.stream: + allocator_logger.error( + f"{_error}: stream mismatch (segment: {exist_seg.stream}, event: {map_event.stream})" + ) + return False + if not snapshot_mutator.split_or_shrink_segment( + self.ctx.device_snapshot, exist_seg_idx, seg_addr, unmap_size + ): + allocator_logger.error(f"{_error}: failed to split or shrink segment") + return False + snapshot_mutator.decrease_reserved(self.ctx.device_snapshot, unmap_size) + self.dispatcher.post_replay_unmap_or_free_segment( + virtual_free_segment, self.ctx.device_snapshot + ) + return True diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py new file mode 100644 index 0000000..58f5611 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_lookup.py @@ -0,0 +1,135 @@ +from typing import Optional, Tuple + +from ..base import Block, DeviceSnapshot, Segment + + +def is_valid_sub_block(block: Block, addr: int, size: int) -> bool: + """Return whether the given range is fully contained in a block.""" + return block.address <= addr and addr + size <= block.address + block.size + + +def find_block(segment: Segment, block_addr: int) -> tuple[int, Block | None]: + """Find the block containing an address inside a segment. + + Returns `(idx, block)` when matched, otherwise `(-1, None)`. + """ + left = 0 + right = len(segment.blocks) - 1 + while left <= right: + mid = (left + right) // 2 + if block_addr < segment.blocks[mid].address: + right = mid - 1 + elif block_addr >= segment.blocks[mid].address + segment.blocks[mid].size: + left = mid + 1 + else: + return mid, segment.blocks[mid] + return -1, None + + +def _scan_overlapping_segments_for_stream( + segments: list[Segment], mid: int, addr: int, stream: int +) -> tuple[int, Segment | None]: + """Scan neighboring overlapping segments to find a stream match.""" + 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 + ): + 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 + ): + return i, segments[i] + return -1, None + + +def find_overlapping_segment( + snapshot: DeviceSnapshot, addr: int, stream: int | None = None +) -> tuple[int, Segment | None]: + """Find the segment whose range overlaps the given address. + + Returns `(idx, segment)` for a containing-range match, otherwise + `(-1, None)`. When `stream` is provided, the matched segment must also + share that stream. + """ + left = 0 + segments = snapshot.segments + right = len(segments) - 1 + while left <= right: + mid = (left + right) // 2 + if addr < segments[mid].address: + right = mid - 1 + elif addr >= segments[mid].address + segments[mid].total_size: + 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 mid, segments[mid] + return -1, 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, + otherwise `(-1, None)`. + """ + seg_idx, seg = find_overlapping_segment(snapshot, addr, stream) + if seg is not None and seg.address == addr and seg.stream == stream: + return seg_idx, seg + return -1, None + + +def find_gap_for_alloc_block( + snapshot: DeviceSnapshot, event_addr: int, event_size: int, stream: int = None +) -> Optional[Tuple[Segment, int]]: + """Find the insertion gap for a block allocation inside a segment. + + Returns `(segment, insert_idx)` when a valid gap exists, otherwise `None`. + The returned index is the position where the new block should be inserted. + """ + seg_idx, segment = find_overlapping_segment(snapshot, event_addr, stream) + if seg_idx == -1 or segment is None: + return None + blocks = segment.blocks + event_end = event_addr + event_size + seg_start = segment.address + seg_end = seg_start + segment.total_size + if len(blocks) == 0: + if seg_start <= event_addr and event_end <= seg_end: + return segment, 0 + return None + + if blocks[0].address >= event_end: + if seg_start <= event_addr: + return segment, 0 + return None + + left, right = 0, len(blocks) - 1 + while left < right: + mid = (left + right + 1) // 2 + if blocks[mid].address <= event_addr: + left = mid + else: + right = mid - 1 + + gap_start = blocks[left].address + blocks[left].size + if left + 1 < len(blocks): + gap_end = blocks[left + 1].address + if gap_start <= event_addr and event_end <= gap_end: + return segment, left + 1 + else: + if gap_start <= event_addr and event_end <= seg_end: + return segment, len(blocks) + + return None diff --git a/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py b/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py new file mode 100644 index 0000000..4bc7126 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/simulate/snapshot_mutator.py @@ -0,0 +1,407 @@ +import bisect + +from ..base import Block, BlockState, DeviceSnapshot, Segment +from ..util import get_logger + +snapshot_mutator_logger = get_logger("ALLOCATOR") + + +# Public API: block mutation helpers + + +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. + The block is inserted into `segment.blocks` at `insert_idx`. + """ + block.segment_ptr = segment + segment.blocks.insert(insert_idx, block) + segment.active_size += block.size + snapshot.total_activated += block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + segment.allocated_size += block.size + snapshot.total_allocated += block.size + + +def detach_block(snapshot: DeviceSnapshot, block: Block) -> bool: + """Detach a block from its owning segment. + + Mutates the block, its segment, and snapshot totals in place. + Returns `True` on success, otherwise `False` when the block has no segment. + """ + segment = block.segment_ptr + if segment is None: + return False + segment.active_size -= block.size + snapshot.total_activated -= block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + segment.allocated_size -= block.size + snapshot.total_allocated -= block.size + segment.blocks.remove(block) + block.segment_ptr = None + return True + + +def promote_pending_free_block(snapshot: DeviceSnapshot, block: Block) -> bool: + """Promote a pending-free block back to allocated state. + + Mutates the block state plus the owning segment and snapshot allocation + totals. Returns `False` when the block has no owning segment. + """ + segment = block.segment_ptr + if segment is None: + return False + block.state = BlockState.ACTIVE_ALLOCATED + segment.allocated_size += block.size + snapshot.total_allocated += block.size + return True + + +# Public API: segment collection mutation + + +def insert_segment(snapshot: DeviceSnapshot, segment: Segment): + """Insert a segment into the snapshot and increase reserved memory. + + Preserves segment ordering and mutates `snapshot.total_reserved` in place. + """ + _insert_segment_sorted(snapshot, segment) + snapshot.total_reserved += segment.total_size + + +def remove_segment(snapshot: DeviceSnapshot, segment: Segment): + """Remove a segment from the snapshot and decrease reserved memory. + + Clears every block's `segment_ptr` and mutates `snapshot.total_reserved` + in place. + """ + snapshot.total_reserved -= segment.total_size + snapshot.segments.remove(segment) + for block in segment.blocks: + block.segment_ptr = None + + +# Public API: segment shape mutation + + +def merge_mapped_segment( + snapshot: DeviceSnapshot, + new_segment: Segment, + left_adjacent_idx: int, + right_adjacent_idx: int, +) -> bool: + """Merge a newly mapped segment with adjacent segments. + + Supports left-only, right-only, or both-side adjacency. Mutates + `snapshot.segments` in place and returns `False` when neither adjacent + index is valid. + """ + _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" + ) + return False + + segments = snapshot.segments + if left_adjacent_idx != -1: + left_seg = segments[left_adjacent_idx] + left_seg.total_size += new_segment.total_size + left_seg.allocated_size += new_segment.allocated_size + left_seg.active_size += new_segment.active_size + for block in new_segment.blocks: + block.segment_ptr = left_seg + left_seg.blocks.append(block) + if right_adjacent_idx != -1: + return _merge_segments(snapshot, left_adjacent_idx, right_adjacent_idx) + return True + + _insert_segment_sorted(snapshot, new_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" + ) + segments.remove(new_segment) + return False + if corrected_right_idx != right_adjacent_idx + 1: + right_segment = segments[corrected_right_idx] + if right_segment.address != new_segment.address + new_segment.total_size: + snapshot_mutator_logger.error( + f"{_error}: inserted segment is not adjacent to the expected right segment" + ) + segments.remove(new_segment) + return False + if not _merge_segments(snapshot, new_idx, corrected_right_idx): + segments.remove(new_segment) + return False + return True + + +def split_or_shrink_segment( + snapshot: DeviceSnapshot, seg_idx: int, seg_addr: int, unmap_size: int +) -> bool: + """Shrink or split a segment to remove an unmapped range. + + Chooses the appropriate internal mutation strategy based on whether the + unmapped range touches the segment edges or lies in the middle. + Returns `True` on success and `False` when the mutation is invalid. + """ + exist_seg = snapshot.segments[seg_idx] + seg_start = exist_seg.address + unmap_end = seg_addr + unmap_size + if seg_addr == seg_start: + return _shrink_segment(snapshot, seg_idx, seg_addr, unmap_size, "left") + if unmap_end == seg_start + exist_seg.total_size: + return _shrink_segment(snapshot, seg_idx, seg_addr, unmap_size, "right") + return _split_segment_at(snapshot, seg_idx, seg_addr, unmap_size) + + +# Public API: snapshot total mutation + + +def increase_reserved(snapshot: DeviceSnapshot, size: int): + """Increase the snapshot reserved-memory total by `size`.""" + snapshot.total_reserved += size + + +def decrease_reserved(snapshot: DeviceSnapshot, size: int): + """Decrease the snapshot reserved-memory total by `size`.""" + snapshot.total_reserved -= size + + +# Private helpers + + +def _insert_segment_sorted(snapshot: DeviceSnapshot, segment: Segment): + """Insert a segment into `snapshot.segments` while preserving sort order.""" + segments = snapshot.segments + keys = [(seg.address, seg.stream) for seg in segments] + idx = bisect.bisect_left(keys, (segment.address, segment.stream)) + segments.insert(idx, segment) + + +def _merge_segments(snapshot: DeviceSnapshot, target_idx: int, source_idx: int) -> bool: + """Merge two adjacent segments with the same stream. + + Mutates `snapshot.segments` in place. Returns `True` on success, otherwise + `False` when indices, adjacency, or stream constraints are not satisfied. + """ + _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}" + ) + return False + if source_idx < 0 or source_idx >= len(segments): + 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" + ) + return False + target = segments[target_idx] + source = segments[source_idx] + if target.stream != source.stream: + snapshot_mutator_logger.error( + f"{_error}: segments have different streams (target: {target.stream}, source: {source.stream})" + ) + return False + are_adjacent = ( + target.address + target.total_size == source.address + or source.address + source.total_size == target.address + ) + if not are_adjacent: + snapshot_mutator_logger.error( + f"{_error}: segments are not adjacent (target: [{target.address}, {target.address + target.total_size}), source: [{source.address}, {source.address + source.total_size}))" + ) + return False + if target.address > source.address: + target, source = source, target + target_idx, source_idx = source_idx, target_idx + target.total_size += source.total_size + target.allocated_size += source.allocated_size + target.active_size += source.active_size + for block in source.blocks: + block.segment_ptr = target + target.blocks.append(block) + del segments[source_idx] + return True + + +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 + `False` when the cut range is invalid. + """ + _error = "Failed to split segment" + segments = snapshot.segments + if seg_idx < 0 or seg_idx >= len(segments): + snapshot_mutator_logger.error(f"{_error}: invalid segment index {seg_idx}") + return False + original_segment = segments[seg_idx] + seg_start = original_segment.address + seg_end = seg_start + original_segment.total_size + cut_end = cut_addr + cut_size + if cut_addr < seg_start or cut_end > seg_end: + snapshot_mutator_logger.error( + f"{_error}: cut range [{cut_addr}, {cut_end}) is outside segment [{seg_start}, {seg_end})" + ) + return False + if cut_addr == seg_start and cut_end == seg_end: + snapshot_mutator_logger.warning( + "Split Seg: cut range covers entire segment, nothing to split, just remove it" + ) + del snapshot.segments[seg_idx] + return True + left_segment = Segment( + address=seg_start, + total_size=cut_addr - seg_start, + stream=original_segment.stream, + segment_type=original_segment.segment_type, + allocated_size=0, + active_size=0, + blocks=[], + device=original_segment.device, + frames=original_segment.frames, + is_expandable=original_segment.is_expandable, + free_or_unmap_event_idx=original_segment.free_or_unmap_event_idx, + alloc_or_map_event_idx=original_segment.alloc_or_map_event_idx, + ) + right_segment = Segment( + address=cut_end, + total_size=seg_end - cut_end, + stream=original_segment.stream, + segment_type=original_segment.segment_type, + allocated_size=0, + active_size=0, + blocks=[], + device=original_segment.device, + frames=original_segment.frames, + is_expandable=original_segment.is_expandable, + free_or_unmap_event_idx=original_segment.free_or_unmap_event_idx, + alloc_or_map_event_idx=original_segment.alloc_or_map_event_idx, + ) + for block in original_segment.blocks: + block_start = block.address + block_end = block_start + block.size + if block_end <= cut_addr: + block.segment_ptr = left_segment + left_segment.blocks.append(block) + left_segment.active_size += block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + left_segment.allocated_size += block.size + elif block_start >= cut_end: + block.segment_ptr = right_segment + right_segment.blocks.append(block) + right_segment.active_size += block.size + if block.state == BlockState.ACTIVE_ALLOCATED: + right_segment.allocated_size += block.size + else: + snapshot_mutator_logger.warning( + f"{_error}: active block [{block_start}, {block_end}) overlaps with cut range [{cut_addr}, {cut_end}), just drop it." + ) + del segments[seg_idx] + if left_segment.total_size > 0: + _insert_segment_sorted(snapshot, left_segment) + if right_segment.total_size > 0: + _insert_segment_sorted(snapshot, right_segment) + return True + + +def _shrink_segment( + snapshot: DeviceSnapshot, + seg_idx: int, + shrink_addr: int, + shrink_size: int, + direction: str, +) -> bool: + """Shrink a segment from the left or right side. + + Mutates the target segment in place and recomputes its size counters. + Returns `True` on success, otherwise `False` when the shrink is invalid. + """ + _error = "Failed to shrink segment" + segments = snapshot.segments + if seg_idx < 0 or seg_idx >= len(segments): + snapshot_mutator_logger.error(f"{_error}: invalid segment index {seg_idx}") + return False + if direction not in ["left", "right"]: + snapshot_mutator_logger.error( + f"{_error}: invalid direction '{direction}', must be 'left' or 'right'" + ) + return False + segment = segments[seg_idx] + seg_start = segment.address + seg_end = seg_start + segment.total_size + shrink_end = shrink_addr + shrink_size + if direction == "left": + if shrink_addr < seg_start or shrink_end > seg_end: + snapshot_mutator_logger.error( + f"{_error}: shrink range [{shrink_addr}, {shrink_end}) is outside segment [{seg_start}, {seg_end})" + ) + return False + 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" + ) + return False + for block in segment.blocks: + block_start = block.address + block_end = block_start + block.size + if block_end <= shrink_end: + snapshot_mutator_logger.error( + f"{_error}: active block [{block_start}, {block_end}) in shrink range [{shrink_addr}, {shrink_end})" + ) + return False + segment.address = new_start + segment.total_size = new_size + 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( + f"{_error}: shrink range [{shrink_addr}, {shrink_end}) is outside segment [{seg_start}, {seg_end})" + ) + return False + new_size = shrink_addr - seg_start + if new_size < 0: + snapshot_mutator_logger.error( + f"{_error}: shrink results in negative segment size" + ) + return False + for block in segment.blocks: + block_start = block.address + block_end = block_start + block.size + if block_start >= shrink_addr: + snapshot_mutator_logger.error( + f"{_error}: active block [{block_start}, {block_end}) in shrink range [{shrink_addr}, {shrink_end})" + ) + return False + segment.blocks = [ + block + for block in segment.blocks + if block.address + block.size <= shrink_addr + ] + segment.total_size = new_size + segment.allocated_size = sum( + b.size for b in segment.blocks if b.state == BlockState.ACTIVE_ALLOCATED + ) + segment.active_size = sum(b.size for b in segment.blocks) + if segment.total_size == 0: + del segments[seg_idx] + return True 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 new file mode 100644 index 0000000..5e8aae8 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/__init__.py @@ -0,0 +1,4 @@ +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/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/defs.py b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/defs.py new file mode 100644 index 0000000..e6ad711 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/defs.py @@ -0,0 +1,20 @@ +class EventFieldDefs: + ID = "id" + ACTION = "action" + ADDR = "address" + SIZE = "size" + STREAM = "stream" + ALLOCATED = "allocated" + ACTIVE = "active" + RESERVED = "reserved" + CALLSTACK = "callstack" + + +class BlockFieldDefs: + ID = "id" + ADDR = "address" + SIZE = "size" + REQUESTED_SIZE = "requestedSize" + STATE = "state" + ALLOC_EVENT_ID = "allocEventId" + FREE_EVENT_ID = "freeEventId" diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py new file mode 100644 index 0000000..52b9d1a --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/entity2record.py @@ -0,0 +1,61 @@ +from .defs import EventFieldDefs, BlockFieldDefs + +from ....base import TraceEntry, Block + + +def make_default_id_counter(start: int = -1): + count = start + + def next_id(): + nonlocal count + current = count + count -= 1 + return current + + return next_id + + +def get_timestamp_by_event_idx(event_idx: int) -> int: + return event_idx * 10 if event_idx is not None else -1 + + +next_default_block_id = make_default_id_counter() +next_default_event_id = make_default_id_counter() + + +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.ACTION: event.action, + EventFieldDefs.ADDR: event.addr, + EventFieldDefs.SIZE: event.size, + EventFieldDefs.STREAM: event.stream, + EventFieldDefs.ALLOCATED: allocated, + EventFieldDefs.ACTIVE: active, + EventFieldDefs.RESERVED: reserved, + EventFieldDefs.CALLSTACK: event.get_callstack(), + } + + +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() + ), + BlockFieldDefs.ADDR: block.address, + BlockFieldDefs.SIZE: block.size, + BlockFieldDefs.REQUESTED_SIZE: block.requested_size, + BlockFieldDefs.STATE: block.state, + BlockFieldDefs.ALLOC_EVENT_ID: ( + block.alloc_event_idx if block.alloc_event_idx is not None else -1 + ), + BlockFieldDefs.FREE_EVENT_ID: ( + block.free_event_idx if block.free_event_idx is not None else -1 + ), + } diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py new file mode 100644 index 0000000..8058fe5 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/database/snapshot_db.py @@ -0,0 +1,97 @@ +from ....util.sqlite_meta import SqliteColumn, SqliteTable, SqliteDB +from .defs import EventFieldDefs, BlockFieldDefs + +TRACE_ENTRY_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, +} + +_TRACE_ENTRY_TABLE_COLUMNS = [ + SqliteColumn(name=EventFieldDefs.ID, data_type=int, primary_key=True), + SqliteColumn( + name=EventFieldDefs.ACTION, + data_type=int, + value_map=TRACE_ENTRY_ACTION_VALUE_MAP.copy(), + ), + SqliteColumn(name=EventFieldDefs.ADDR, data_type=int), + SqliteColumn(name=EventFieldDefs.SIZE, data_type=int), + SqliteColumn(name=EventFieldDefs.STREAM, data_type=int), + SqliteColumn(name=EventFieldDefs.ALLOCATED, data_type=int), + SqliteColumn(name=EventFieldDefs.ACTIVE, data_type=int), + SqliteColumn(name=EventFieldDefs.RESERVED, data_type=int), + SqliteColumn(name=EventFieldDefs.CALLSTACK), +] + +_BLOCK_TABLE_COLUMNS = [ + SqliteColumn(name=BlockFieldDefs.ID, data_type=int, primary_key=True), + SqliteColumn(name=BlockFieldDefs.ADDR, data_type=int), + SqliteColumn(name=BlockFieldDefs.SIZE, data_type=int), + SqliteColumn(name=BlockFieldDefs.REQUESTED_SIZE, data_type=int), + SqliteColumn( + name=BlockFieldDefs.STATE, + default=99, + data_type=int, + value_map=BLOCK_STATE_VALUE_MAP.copy(), + ), + SqliteColumn(name=BlockFieldDefs.ALLOC_EVENT_ID, data_type=int), + SqliteColumn(name=BlockFieldDefs.FREE_EVENT_ID, data_type=int), +] + + +class SnapshotDb(SqliteDB): + TRACE_ENTRY_TABLE_NAME = "trace_entry" + BLOCK_TABLE_NAME = "block" + + def __init__(self, path: str): + super().__init__(path, auto_create=True, with_dictionary_table=True) + # 清理旧版本表格 + self._clear_old_tables() + + 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 + ), + delete_if_exists=True, + ) + + def create_block_table(self, device: int = 0): + self.create_table( + SqliteTable( + self.get_block_table_name_by_device(device), _BLOCK_TABLE_COLUMNS + ), + delete_if_exists=True, + ) + + def get_trace_entry_table(self, device: int = 0): + return self.get_table_by_name(self.get_trace_table_name_by_device(device)) + + def get_block_table(self, device: int = 0): + return self.get_table_by_name(self.get_block_table_name_by_device(device)) + + def _clear_old_tables(self): + """ + 旧版本中创建的db不带device前缀,如果通过旧db打开,需要清理旧表 + """ + self.delete_table(self.TRACE_ENTRY_TABLE_NAME) + self.delete_table(self.BLOCK_TABLE_NAME) + + @staticmethod + def get_block_table_name_by_device(device: int = 0): + return f"{SnapshotDb.BLOCK_TABLE_NAME}_{device}" + + @staticmethod + def get_trace_table_name_by_device(device: int = 0): + return f"{SnapshotDb.TRACE_ENTRY_TABLE_NAME}_{device}" diff --git a/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py new file mode 100644 index 0000000..594c4e7 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/tools/adaptors/snapshot2db.py @@ -0,0 +1,277 @@ +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 ...util.logger import get_logger, set_global_log_file +from ...util.timer import timer + +dump_logger = get_logger("DatabaseDump") + + +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._insert_cache_size = insert_cache_size + for device in devices: + self._device_block_cache[device] = list() + self._device_event_cache[device] = list() + 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].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].append(block_record) + if len(self._device_block_cache[device]) >= self._insert_cache_size: + self._do_insert_blocks(device) + + def flush(self, device: int = 0): + if self._device_event_cache.get(device, None): + self._do_insert_events(device) + if self._device_block_cache.get(device, None): + self._do_insert_blocks(device) + + def _do_insert_events(self, device: int = 0): + if device not in self._device_event_cache: + self._device_event_cache[device] = list() + return + self.db.get_trace_entry_table(device).insert_records( + self.db.conn, self._device_event_cache[device] + ) + self.db.conn.commit() + self._device_event_cache[device].clear() + + def _do_insert_blocks(self, device: int = 0): + if device not in self._device_block_cache: + self._device_block_cache[device] = list() + self.db.get_block_table(device).insert_records( + self.db.conn, self._device_block_cache[device] + ) + self.db.conn.commit() + self._device_block_cache[device].clear() + + def __del__(self): + self.db.conn.commit() + self.db.conn.close() + + +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 + ) + + def post_undo_event( + self, already_undo_event: TraceEntry, current_snapshot: DeviceSnapshot + ) -> bool: + # 回放完毕,dump剩余Segment及block数据, 注意应该先插入blocks + if not current_snapshot.trace_entries: + 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 + ) + # segment不插入block表,而是以模拟事件插入事件表,便于后续重建segment + mock_segment_alloc_event = TraceEntry( + idx=None, + action="segment_map" if seg.is_expandable else "segment_alloc", + addr=seg.address, + frames=seg.frames, + size=seg.total_size, + stream=seg.stream, + ) + self.db_handler.insert_event( + event2record( + event=mock_segment_alloc_event, + allocated=current_snapshot.total_allocated, + active=current_snapshot.total_activated, + reserved=current_snapshot.total_reserved, + ), + current_snapshot.device, + ) + return True + + def pre_undo_event( + self, wait4undo_event: TraceEntry, current_snapshot: DeviceSnapshot + ) -> bool: + # 每个事件回放前dump一次event + self.db_handler.insert_event( + event2record( + event=wait4undo_event, + allocated=current_snapshot.total_allocated, + active=current_snapshot.total_activated, + reserved=current_snapshot.total_reserved, + ), + current_snapshot.device, + ) + 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 flush(self, device: int = 0): + self.db_handler.flush(device) + + +def dump(pickle_file: str, dump_file: str, device=None) -> bool: + try: + data = load_pickle_to_dict(Path(pickle_file)) + except Exception as e: + dump_logger.error("Failed to load pickle file: {}".format(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] + ] + 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( + f"Specified device {device} is not found or has no trace events in the snapshot." + ) + return False + if device is not None: + need_dump_devices = [device] + dump_logger.info(f"Recognized need to dump devices {need_dump_devices}.") + 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}." + ) + 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}." + ) + 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 = "", + device: int | None = None, + log_file: str = "", +) -> bool: + resolved_dump_dir = dump_dir or str(Path(snapshot_file).parent) + if log_file: + set_global_log_file(log_file) + + return dump( + snapshot_file, + 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/vendor/memsnapdump/util/__init__.py new file mode 100644 index 0000000..823b21c --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/util/__init__.py @@ -0,0 +1,9 @@ +""" +工具模块 + +提供常用的工具函数和类,包括日志、文件操作、数据库操作、计时器等。 +""" + +from .logger import get_logger, set_global_log_file + +__all__ = ["get_logger", "set_global_log_file"] diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/file_util.py b/src/pt_snap_cli/vendor/memsnapdump/util/file_util.py new file mode 100644 index 0000000..d2a15dd --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/util/file_util.py @@ -0,0 +1,132 @@ +""" +文件工具模块 + +提供文件和目录操作的实用函数,包括 pickle 文件的读写、文件和目录的校验等功能。 +""" + +import os +import pickle +from pathlib import Path +from typing import Dict, Any + + +def load_pickle_to_dict(pickle_file: Path) -> dict: + """ + 从指定路径加载 pickle 文件,并确保其内容为 dict 类型。 + + Args: + pickle_file (Path): pickle 文件路径 + + Returns: + dict: 加载的字典数据 + + Raises: + FileNotFoundError: 文件不存在 + ValueError: 文件内容不是 dict 类型 + pickle.UnpicklingError: 反序列化失败(如文件损坏或非 pickle 格式) + """ + if not pickle_file.is_file(): + raise FileNotFoundError(f"Cannot found pickle file: {pickle_file}") + + try: + with open(pickle_file, "rb") as f: + data = pickle.load(f) + except Exception: + raise pickle.UnpicklingError(f"Cannot load pickle file: {pickle_file}") + + if not isinstance(data, dict): + raise ValueError( + f"The content of the pickle file is not of type dict, actual type: {type(data).__name__}" + ) + + return data + + +def save_dict_to_pickle(data: Dict[Any, Any], path: Path, protocol: int = 4) -> None: + """ + 将字典保存为 pickle 文件。 + + Args: + data (dict): 要保存的字典 + path (Path): 保存路径(会自动创建父目录) + protocol (int): 保存版本 + + Raises: + TypeError: data 不是 dict 类型 + OSError: 文件写入失败(如权限不足、磁盘满等) + """ + if not isinstance(data, dict): + raise TypeError( + f"Only dict type is supported, but received: {type(data).__name__}" + ) + path.parent.mkdir(parents=True, exist_ok=True) # 自动创建父目录 + + try: + with open(path, "wb") as f: + pickle.dump(data, f, protocol=protocol) + except OSError as e: + raise OSError(f"Unable to write to file {path}: {e}") from e + + +def check_dir_valid( + path: str | Path, need_readable: bool = True, need_writable: bool = True +) -> bool: + """ + 校验目录是否合法,默认要求可读可写。 + + Args: + path: 路径字符串或 pathlib.Path 对象 + need_readable: 是否要求可读,默认为 True + need_writable: 是否要求可写,默认为 True + + Returns: + bool: 目录是否合法且满足权限要求 + + Examples: + >>> check_dir_valid('/tmp', need_readable=True, need_writable=True) + True + >>> check_dir_valid('/nonexistent') + False + """ + _path = path + if not isinstance(path, Path): + _path = Path(_path) + if not _path.is_dir(): + return False + if need_readable and not os.access(_path, os.R_OK): + return False + if need_writable and not os.access(_path, os.W_OK): + return False + return True + + +def check_file_valid( + path: str | Path, need_readable: bool = True, need_writable: bool = False +) -> bool: + """ + 校验文件是否合法,默认要求可读,不要求可写。 + + Args: + path: 路径字符串或 pathlib.Path 对象 + need_readable: 是否要求可读,默认为 True + need_writable: 是否要求可写,默认为 False + + Returns: + bool: 文件是否合法且满足权限要求 + + Examples: + >>> check_file_valid('/etc/passwd', need_readable=True, need_writable=False) + True + >>> check_file_valid('/nonexistent.txt') + False + """ + _path = path + if not isinstance(path, Path): + _path = Path(_path) + if not _path.is_file(): + return False + if need_readable and not os.access(_path, os.R_OK): + return False + if need_writable and not os.access(_path, os.W_OK): + return False + return True diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/logger.py b/src/pt_snap_cli/vendor/memsnapdump/util/logger.py new file mode 100644 index 0000000..c132527 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/util/logger.py @@ -0,0 +1,137 @@ +""" +日志工具模块 + +提供日志记录器的创建和配置功能。 +""" + +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 + + +def set_global_log_file(log_file: str) -> None: + """ + 设置全局日志文件路径,所有 logger 都会输出到该文件。 + + 包括已创建的 logger 和后续创建的 logger。 + + Args: + log_file: 日志文件路径 + + Raises: + OSError: 目录不存在或不可写 + """ + global _global_log_file, _global_file_handler + + log_path = Path(log_file) + parent_dir = log_path.parent + + if not parent_dir.exists(): + 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." + ) + + _global_log_file = str(log_path.absolute()) + + if _global_file_handler is not None: + _global_file_handler.close() + + formatter = logging.Formatter( + fmt="{asctime} [{levelname:^6}][ {name:^12} ]: {message}", + datefmt="%Y-%m-%d %H:%M:%S", + style="{", + ) + + _global_file_handler = logging.FileHandler( + _global_log_file, mode="w", encoding="utf-8" + ) + _global_file_handler.setLevel(logging.DEBUG) + _global_file_handler.setFormatter(formatter) + + _attach_file_handler_to_existing_loggers() + + +_original_levels: dict[str, int] = {} + + +def suppress_logs(): + """Suppress INFO level logs during tests""" + for name in list(logging.Logger.manager.loggerDict.keys()): + logger = logging.getLogger(name) + _original_levels[name] = logger.level + logger.setLevel(logging.WARNING) + + +def restore_logs(): + """Restore original log levels after tests""" + for name, level in _original_levels.items(): + logging.getLogger(name).setLevel(level) + _original_levels.clear() + + +def _attach_file_handler_to_existing_loggers() -> None: + """为所有已存在的 logger 添加文件处理器""" + if _global_file_handler is None: + return + + manager = logging.Logger.manager + logger_dict = manager.loggerDict + + for name in list(logger_dict.keys()): + logger = logging.getLogger(name) + if _global_file_handler not in logger.handlers: + logger.addHandler(_global_file_handler) + + +def get_logger(name: str, level: int = logging.INFO) -> logging.Logger: + """ + 创建并返回一个配置好的 Logger 实例。 + + 该函数会创建一个带有控制台输出的日志记录器,使用统一的格式化样式。 + 如果 logger 已存在 handlers,会先清除再添加新的 handler。 + 如果设置了全局日志文件,同时会输出到文件。 + + Args: + name: logger 名称,通常使用 __name__ 或模块名 + level: 日志级别,默认为 logging.INFO + + Returns: + logging.Logger: 配置好的 Logger 对象 + + Examples: + >>> logger = get_logger(__name__) + >>> logger.info("This is an info message") + 2024-01-01 12:00:00 [ INFO ][ __main__ ]: This is an info message + + >>> logger = get_logger("my_module", level=logging.DEBUG) + >>> logger.debug("Debug message") + """ + logger = logging.getLogger(name) + logger.setLevel(level) + + # 避免重复添加handler + if logger.hasHandlers(): + logger.handlers.clear() + + formatter = logging.Formatter( + fmt="{asctime} [{levelname:^6}][ {name:^12} ]: {message}", + datefmt="%Y-%m-%d %H:%M:%S", + style="{", + ) + + console_handler = logging.StreamHandler() + console_handler.setLevel(level) + console_handler.setFormatter(formatter) + logger.addHandler(console_handler) + + if _global_file_handler is not None: + logger.addHandler(_global_file_handler) + + return logger diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py b/src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py new file mode 100644 index 0000000..84604dd --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/util/sqlite_meta.py @@ -0,0 +1,520 @@ +""" +SQLite 元数据管理模块 + +提供 SQLite 数据库的表结构定义、类型映射、表创建和数据插入等功能。 +支持 Python 类型到 SQLite 类型的自动转换,以及表结构的元数据管理。 +""" + +import ast +import os.path +import sqlite3 +from typing import ( + Any, + Dict, + List, + Optional, + Type, + Union, + Iterable, + get_origin, + get_args, +) + +# 支持的 Python 类型映射 +_PY_TYPE_TO_SQLITE = { + int: "INTEGER", + float: "REAL", + str: "TEXT", + bool: "INTEGER", # SQLite 没有 BOOLEAN,用 0/1 + bytes: "BLOB", +} + + +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: + return _PY_TYPE_TO_SQLITE[origin] + # 处理 Optional[T] => T(Optional 是 Union[T, None]) + if origin is Union: + args = get_args(py_type) + non_none = [t for t in args if t is not type(None)] + if len(non_none) == 1: + return _map_py_type_to_sqlite(non_none[0]) + # 默认 fallback + return "TEXT" + + +def _sqlite_type_to_py_type(sqlite_type: str) -> type: + """将 SQLite 声明类型映射为最可能的 Python 类型""" + if not sqlite_type: + return str # 无类型默认为 TEXT + upper = sqlite_type.upper() + if "INT" in upper: + return int + if "CHAR" in upper or "CLOB" in upper or "TEXT" in upper: + return str + if "BLOB" in upper: + return bytes + if "REAL" in upper or "FLOA" in upper or "DOUB" in upper: + return float + # 兜底:可能是 NUMERIC 或自定义类型,按 TEXT 处理 + return str + + +def _parse_default_value(dflt_str: str) -> Any: + """将 PRAGMA 返回的默认值字符串转为 Python 对象""" + if dflt_str is None: + return None + + # 尝试解析为字面量(支持数字、字符串、布尔、None) + try: + # 处理 SQLite 中的布尔:'1'/'0' 或 'true'/'false'(但 SQLite 实际存整数) + if dflt_str == "1": + return True + elif dflt_str == "0": + return False + elif dflt_str.lower() in ("true", "false"): + return dflt_str.lower() == "true" + # 尝试用 ast.literal_eval 安全解析 + return ast.literal_eval(dflt_str) + except (ValueError, SyntaxError): + # 如果不是合法字面量,当作字符串处理(去掉外层引号) + if dflt_str.startswith("'") and dflt_str.endswith("'"): + return dflt_str[1:-1].replace("''", "'") + elif dflt_str.startswith('"') and dflt_str.endswith('"'): + return dflt_str[1:-1].replace('""', '"') + else: + return dflt_str + + +class SqliteColumn: + """ + SQLite 表的列定义类。 + + 用于定义表中的单个列,包括列名、数据类型、约束条件等属性。 + + Attributes: + name: 列名 + data_type: Python 类型,会自动映射为 SQLite 类型 + primary_key: 是否为主键 + autoincrement: 是否自增(仅适用于 INTEGER 主键) + not_null: 是否不允许 NULL + unique: 是否唯一 + default: 默认值 + value_map: 值映射字典,用于插入时的值转换 + + Examples: + >>> col = SqliteColumn('id', int, primary_key=True, autoincrement=True) + >>> col.to_sql_def() + '`id` INTEGER PRIMARY KEY AUTOINCREMENT' + + >>> col = SqliteColumn('name', str, not_null=True, default='unknown') + >>> col.to_sql_def() + "`name` TEXT NOT NULL DEFAULT 'unknown'" + """ + + def __init__( + self, + name: 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, + ): + if autoincrement and not primary_key: + raise ValueError("autoincrement requires primary_key=True") + if autoincrement and data_type is not int: + raise ValueError("autoincrement only supported for INTEGER type") + self.name = name + self.data_type = data_type + self.primary_key = primary_key + self.autoincrement = autoincrement + self.not_null = not_null + self.unique = unique + self.default = default + self.value_map = value_map + + def _format_default(self) -> str: + """格式化默认值为 SQL 字面量""" + val = self.default + if val is None: + return "NULL" + elif isinstance(val, bool): + return "1" if val else "0" + elif isinstance(val, str): + # 转义单引号(简单处理) + escaped = val.replace("'", "''") + return f"'{escaped}'" + elif isinstance(val, (int, float)): + return str(val) + else: + # 兜底:转为字符串并加引号 + return f"'{str(val)}'" + + def to_sql_def(self) -> str: + """ + 生成列的 SQL 定义语句。 + + Returns: + str: 完整的列定义 SQL,如 "`id` INTEGER PRIMARY KEY AUTOINCREMENT" + + Examples: + >>> col = SqliteColumn('id', int, primary_key=True) + >>> col.to_sql_def() + '`id` INTEGER PRIMARY KEY' + """ + parts = [f"`{self.name}`", _map_py_type_to_sqlite(self.data_type)] + + if self.primary_key: + parts.append("PRIMARY KEY") + if self.autoincrement: + parts.append("AUTOINCREMENT") + if self.not_null: + parts.append("NOT NULL") + if self.unique: + parts.append("UNIQUE") + if self.default is not None: + parts.append(f"DEFAULT {self._format_default()}") + + return " ".join(parts) + + +class SqliteTable: + """ + SQLite 表的定义和管理类。 + + 用于定义表结构、创建表、插入数据等操作。 + + Attributes: + name: 表名 + column_dict: 列定义字典,键为列名,值为 SqliteColumn 对象 + _column_value_map: 列值映射字典,用于插入时的值转换 + + Examples: + >>> columns = [ + ... SqliteColumn('id', int, primary_key=True, autoincrement=True), + ... SqliteColumn('name', str, not_null=True) + ... ] + >>> table = SqliteTable('users', columns) + >>> print(table.to_sql_def()) + CREATE TABLE IF NOT EXISTS users (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` TEXT NOT NULL); + """ + + name: str + 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() + if columns: + for column in columns: + self.column_dict[column.name] = column + if column.value_map: + self._column_value_map[column.name] = column.value_map + + def to_sql_def(self, delete_if_exists: bool = False) -> str: + """ + 生成创建表的 SQL 语句。 + + Args: + delete_if_exists: 是否先 DROP TABLE IF EXISTS,默认为 False + + Returns: + str: 创建表的 SQL 语句 + + Examples: + >>> table.to_sql_def(delete_if_exists=True) + 'DROP TABLE IF EXISTS users;\\nCREATE TABLE users (...)' + """ + column_defs = [col.to_sql_def() for _, col in self.column_dict.items()] + create_sql = f"CREATE TABLE {self.name} ({', '.join(column_defs)});" + + if delete_if_exists: + drop_sql = f"DROP TABLE IF EXISTS {self.name};" + return f"{drop_sql}\n{create_sql}" + else: + # 使用 IF NOT EXISTS 更安全 + 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): + """ + 在数据库中创建表 + :param conn: sqlite3.Connection 对象 + :param delete_if_exists: 是否先删除已存在的表 + """ + sql = self.to_sql_def(delete_if_exists=delete_if_exists) + conn.executescript(sql) # 支持多条 SQL(如 DROP + CREATE) + conn.commit() + + def create_index(self, conn: sqlite3.Connection, column_name: str): + """ + 创建索引 + :param conn: sqlite3.Connection 对象 + :param column_name: 列名 + :return: + """ + conn.execute( + f"CREATE INDEX IF NOT EXISTS idx_{self.name}_{column_name} ON {self.name} ({column_name});" + ) + conn.commit() + + def insert_record(self, conn: sqlite3.Connection, record: Dict[str, Any]): + """ + 插入单条记录。 + + Args: + conn: sqlite3.Connection 对象 + record: 记录字典,键为列名,值为列值 + + Examples: + >>> table.insert_record(conn, {'name': 'Alice', 'age': 30}) + """ + self.insert_records(conn, [record]) + + def insert_records(self, conn: sqlite3.Connection, records: List[Dict[str, Any]]): + """ + 批量插入多条记录。 + + Args: + conn: sqlite3.Connection 对象 + records: 记录字典列表,每个字典的键为列名,值为列值 + + Examples: + >>> records = [ + ... {'name': 'Alice', 'age': 30}, + ... {'name': 'Bob', 'age': 25} + ... ] + >>> table.insert_records(conn, records) + """ + if not records: + return + columns = SqliteTable.get_insert_columns_by_record(records[0]) + placeholders = SqliteTable.get_insert_placeholder_by_record(records[0]) + sql = f"INSERT INTO {self.name} ({', '.join(columns)}) VALUES ({placeholders})" + values = self.get_insert_values_by_records(records) + conn.executemany(sql, values) + conn.commit() + + @staticmethod + def get_insert_columns_by_record(record: Dict[str, Any]): + """ + 从记录字典中获取插入列名列表。 + + Args: + record: 记录字典 + + Returns: + List[str]: 列名列表(带反引号) + """ + return [f"`{key}`" for key in record.keys()] + + @staticmethod + def get_insert_placeholder_by_record(record: Dict[str, Any]): + """ + 生成插入语句的占位符字符串。 + + Args: + record: 记录字典 + + Returns: + str: 占位符字符串,如 "?, ?, ?" + """ + return ", ".join(["?" for _ in record.keys()]) + + def get_insert_values_by_records(self, records: List[Dict[str, Any]]): + """ + 从记录列表中提取插入值,应用值映射。 + + Args: + records: 记录字典列表 + + Returns: + List[Tuple]: 值元组列表,每个元组对应一条记录 + """ + if not records: + return [] + return [ + tuple( + self._column_value_map.get(k, {}).get(r[k], r[k]) + for k in records[0].keys() + ) + for r in records + ] + + +class SqliteDB: + """ + SQLite 数据库管理类。 + + 提供数据库连接、表创建、表结构查询等功能。 + + Attributes: + path: 数据库文件路径 + conn: sqlite3.Connection 对象 + table_cache: 表缓存字典,键为表名,值为 SqliteTable 对象 + with_dictionary_table: 是否创建字典表用于存储值映射 + + Examples: + >>> db = SqliteDB('/path/to/db.sqlite') + >>> table = SqliteTable('users', [ + ... SqliteColumn('id', int, primary_key=True), + ... SqliteColumn('name', str) + ... ]) + >>> db.create_table(table) + """ + + path: str + conn: sqlite3.Connection + table_cache: Dict[str, SqliteTable] + + 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: + raise FileNotFoundError(f"Db file not found: {self.path}.") + dir_path = os.path.dirname(self.path) + if not os.path.exists(dir_path): + os.makedirs(dir_path, exist_ok=True) + + self.conn = sqlite3.connect(self.path) + self.table_cache = {} + self.with_dictionary_table = with_dictionary_table + if self.with_dictionary_table: + self._create_dictionary_table() + + def create_table(self, table: SqliteTable, delete_if_exists: bool = True): + """ + 在数据库中创建表,并缓存表结构。 + + Args: + table: SqliteTable 对象 + delete_if_exists: 是否先删除已存在的表,默认为 True + + Note: + 如果启用了 with_dictionary_table,会自动将值映射存储到字典表中。 + """ + table.create_table(self.conn, delete_if_exists) + self.table_cache[table.name] = table + if not self.with_dictionary_table: + return + dictionary_table = self.get_table_by_name("dictionary") + for column_name, value_map in table._column_value_map.items(): + for key, value in value_map.items(): + dictionary_table.insert_record( + self.conn, + dict(table=table.name, column=column_name, key=value, value=key), + ) + self.conn.commit() + + def delete_table(self, table_name: str): + self.conn.execute(f"DROP TABLE IF EXISTS {table_name};") + self.conn.commit() + + def _create_dictionary_table(self): + _table_columns = [ + SqliteColumn(name="table"), + SqliteColumn(name="column"), + SqliteColumn(name="key"), + SqliteColumn(name="value"), + ] + _dictionary_table = SqliteTable("dictionary", _table_columns) + _dictionary_table.create_table(self.conn, delete_if_exists=True) + self.table_cache[_dictionary_table.name] = _dictionary_table + + def is_table_exists(self, table_name: str) -> bool: + """ + 检查表是否存在。 + + Args: + table_name: 表名 + + Returns: + bool: 表是否存在 + + Note: + 会优先检查缓存,如果缓存中不存在则查询数据库。 + """ + if table_name in self.table_cache: + return True + cursor = self.conn.cursor() + cursor.execute( + """ + SELECT name + FROM sqlite_master + WHERE type = 'table' + AND name = ? + """, + (table_name,), + ) + exist = cursor.fetchone() is not None + if exist: + self.table_cache[table_name] = self.get_table_by_name(table_name) + return exist + + def get_table_by_name(self, table_name: str) -> SqliteTable: + """ + 从数据库中读取表结构,还原为 SqliteTable 对象。 + + Args: + table_name: 表名 + + Returns: + SqliteTable: 表对象 + + Raises: + ValueError: 表不存在 + + Note: + 会优先从缓存中获取,缓存中不存在时才查询数据库。 + """ + if table_name in self.table_cache: + return self.table_cache[table_name] + # 获取列信息 + cur = self.conn.execute(f"PRAGMA table_info({table_name});") + rows = cur.fetchall() + + if not rows: + raise ValueError(f"Table '{table_name}' does not exist.") + table = SqliteTable(table_name) + for row in rows: + cid, name, type_affinity, notnull, dflt_value, pk = row + + py_type = _sqlite_type_to_py_type(type_affinity) + default_val = _parse_default_value(dflt_value) + + # 检测是否为自增(仅当 INTEGER 主键且有 sqlite_sequence 记录) + autoincrement = False + if pk and py_type is int: + # 检查是否存在 sqlite_sequence 表且包含该表 + seq_cur = self.conn.execute( + "SELECT 1 FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';" + ) + if seq_cur.fetchone(): + seq_cur = self.conn.execute( + "SELECT 1 FROM sqlite_sequence WHERE name = ?;", (table_name,) + ) + autoincrement = seq_cur.fetchone() is not None + + column = SqliteColumn( + name=name, + data_type=py_type, + primary_key=bool(pk), + autoincrement=autoincrement, + not_null=bool(notnull), + default=default_val, + # 注意:UNIQUE、COLLATE 无法从 table_info 获取,需解析 CREATE SQL + ) + table.column_dict[column.name] = column + self.table_cache[table_name] = table + return table diff --git a/src/pt_snap_cli/vendor/memsnapdump/util/timer.py b/src/pt_snap_cli/vendor/memsnapdump/util/timer.py new file mode 100644 index 0000000..30f4926 --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/util/timer.py @@ -0,0 +1,58 @@ +""" +计时器工具模块 + +提供函数执行时间测量的装饰器。 +""" + +import time +import logging +from typing import Callable, Optional +from functools import wraps + + +def timer(name: Optional[str] = None, logger: Optional[logging.Logger] = None): + """ + 函数执行时间计时装饰器。 + + 用于测量函数执行时间并输出结果。可以选择输出到 logger 或控制台。 + + Args: + name: 计时器名称,默认使用函数名 + logger: 日志记录器,如果提供则使用 logger.info 输出,否则使用 print + + Returns: + Callable: 装饰器函数 + + Examples: + >>> from ..util import get_logger + >>> logger = get_logger(__name__) + + >>> @timer() + ... def slow_function(): + ... time.sleep(1) + slow_function took 1.0012 seconds + + >>> @timer(name="数据处理", logger=logger) + ... def process_data(): + ... time.sleep(0.5) + 2024-01-01 12:00:00 [ INFO ][ __main__ ]: 数据处理 took 0.5023 seconds + """ + + def decorator(func: Callable): + _name = func.__name__ if not name else name + + @wraps(func) + def wrapper(*args, **kwargs): + start = time.perf_counter() + result = func(*args, **kwargs) + end = time.perf_counter() + info = f"{_name} took {end - start:.4f} seconds" + if logger: + logger.info(info) + else: + print(info) + return result + + return wrapper + + return decorator diff --git a/tests/core/__init__.py b/tests/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/core/test_import_errors.py b/tests/core/test_import_errors.py new file mode 100644 index 0000000..240588e --- /dev/null +++ b/tests/core/test_import_errors.py @@ -0,0 +1,22 @@ +"""Tests for vendoring-era import error types.""" + +from __future__ import annotations + +from pt_snap_cli.core.errors import ( + ImportExecutionError, + ImportToolMissingError, + PtSnapCoreError, + SnapshotFileInvalidError, +) + + +def test_import_tool_missing_error_is_pt_snap_core() -> None: + assert issubclass(ImportToolMissingError, PtSnapCoreError) + + +def test_snapshot_file_invalid_error_is_pt_snap_core() -> None: + assert issubclass(SnapshotFileInvalidError, PtSnapCoreError) + + +def test_import_execution_error_is_pt_snap_core() -> None: + assert issubclass(ImportExecutionError, PtSnapCoreError) diff --git a/tests/core/test_import_models.py b/tests/core/test_import_models.py new file mode 100644 index 0000000..e1b90c6 --- /dev/null +++ b/tests/core/test_import_models.py @@ -0,0 +1,40 @@ +"""Tests for ImportOptions / ImportResult dataclasses.""" + +from __future__ import annotations + +import dataclasses +from pathlib import Path + +from pt_snap_cli.core.models import ImportOptions, ImportResult + + +def test_import_options_defaults() -> None: + options = ImportOptions(snapshot_file=Path("sample.pkl")) + assert options.output_dir is None + assert options.device is None + assert options.set_focus is True + + +def test_import_options_is_frozen() -> None: + options = ImportOptions(snapshot_file=Path("sample.pkl")) + try: + options.set_focus = False # type: ignore[misc] + except dataclasses.FrozenInstanceError: + return + raise AssertionError("ImportOptions should be frozen") + + +def test_import_result_construction() -> None: + result = ImportResult(db_path=Path("sample.pkl.db"), device_id=0, focus_state=None) + assert result.db_path == Path("sample.pkl.db") + assert result.device_id == 0 + assert result.focus_state is None + + +def test_import_result_is_frozen() -> None: + result = ImportResult(db_path=Path("sample.pkl.db"), device_id=0, focus_state=None) + try: + result.db_path = Path("other.db") # type: ignore[misc] + except dataclasses.FrozenInstanceError: + return + raise AssertionError("ImportResult should be frozen") diff --git a/tests/core/test_import_service.py b/tests/core/test_import_service.py new file mode 100644 index 0000000..d5acb3c --- /dev/null +++ b/tests/core/test_import_service.py @@ -0,0 +1,145 @@ +from __future__ import annotations + +import pickle +from pathlib import Path + +import pytest + +from pt_snap_cli.context import Context +from pt_snap_cli.core.errors import ( + ImportExecutionError, + ImportToolMissingError, + SnapshotFileInvalidError, +) +from pt_snap_cli.core.models import ImportOptions + +FIXTURE_DIR = Path(__file__).parents[1] / "fixtures" / "snapshots" +EMPTY_CACHE_SNAPSHOT = FIXTURE_DIR / "snapshot_with_empty_cache.pkl" +MULTI_DEVICE_SNAPSHOT = FIXTURE_DIR / "snapshot_with_multi_devices.pkl" + + +def _import_service_type(): + from pt_snap_cli.core.import_service import ImportService + + return ImportService + + +def test_import_writes_db_and_sets_focus(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + result = service.import_snapshot( + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path) + ) + + assert result.db_path.exists() + assert result.db_path.suffix == ".db" + assert (tmp_path / ".pt-snap" / "focus.json").exists() + + +@pytest.mark.slow +def test_import_with_multi_device_fixture(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + result = service.import_snapshot( + ImportOptions(snapshot_file=MULTI_DEVICE_SNAPSHOT, output_dir=tmp_path) + ) + + assert len(Context(result.db_path).discover_devices()) >= 2 + + +def test_import_returns_focus_state(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + result = service.import_snapshot( + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path) + ) + + assert result.focus_state is not None + assert result.focus_state.source == "project" + + +def test_import_snapshot_file_invalid_missing(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + with pytest.raises(SnapshotFileInvalidError): + service.import_snapshot(ImportOptions(snapshot_file=tmp_path / "missing.pkl")) + + +def test_import_snapshot_file_invalid_suffix(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + snapshot_file = tmp_path / "foo.txt" + snapshot_file.write_bytes(b"not a pickle") + + with pytest.raises(SnapshotFileInvalidError): + service.import_snapshot(ImportOptions(snapshot_file=snapshot_file)) + + +def test_import_snapshot_file_invalid_corrupt_pickle(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + snapshot_file = tmp_path / "corrupt.pkl" + snapshot_file.write_bytes(b"not a pickle") + + with pytest.raises(SnapshotFileInvalidError): + service.import_snapshot(ImportOptions(snapshot_file=snapshot_file)) + + +def test_import_raises_on_missing_tool(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + service._backend_available = False + + with pytest.raises(ImportToolMissingError, match="Vendored snapshot import backend"): + service.import_snapshot( + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path) + ) + + +def test_import_raises_on_upstream_failure(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + def fail_dump_to_db(snapshot_file: Path, dump_dir: Path, device: int | None) -> Path: + raise ImportExecutionError("Vendored snapshot import backend failed: upstream failed") + + monkeypatch.setattr(service, "_run_dump_to_db", fail_dump_to_db) + + with pytest.raises(ImportExecutionError): + service.import_snapshot( + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path) + ) + + +def test_import_skip_focus(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + result = service.import_snapshot( + ImportOptions( + snapshot_file=EMPTY_CACHE_SNAPSHOT, + output_dir=tmp_path, + set_focus=False, + ) + ) + + assert result.db_path.exists() + assert not (tmp_path / ".pt-snap").exists() + assert result.focus_state is None + + +def test_import_output_path_uses_full_filename(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + snapshot_file = tmp_path / "snapshot.pickle" + snapshot_file.write_bytes(pickle.dumps({})) + + result = service.import_snapshot( + ImportOptions(snapshot_file=snapshot_file, output_dir=tmp_path, set_focus=False) + ) + + assert result.db_path.name == "snapshot.pickle.db" diff --git a/tests/fixtures/snapshots/snapshot_with_empty_cache.pkl b/tests/fixtures/snapshots/snapshot_with_empty_cache.pkl new file mode 100644 index 0000000000000000000000000000000000000000..160e449a929ae4f03d4e1d970dc52d78fe480e68 GIT binary patch literal 617060 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%0A^Y&>Zo0Jf!8**k+%)xrX`}5bt)(N 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

-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

vDG=|ks35~mNH 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

rBbttO~ccjoh`&)u0%QoK7mWOtslYiI?y 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 Vu92z|^L_+J467~tGh$4q{{mPEQilKl literal 0 HcmV?d00001 diff --git a/tests/test_cli.py b/tests/test_cli.py index b206f8e..24f503d 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -1,6 +1,7 @@ """Tests for CLI.""" import json +import shutil import sqlite3 from pathlib import Path from unittest.mock import patch @@ -811,6 +812,77 @@ def test_safe_call_reraises_unrelated_keyerror(self) -> None: _safe_call() +class TestImportCommand: + """Test import command.""" + + def test_import_success_writes_focus(self, tmp_path: Path) -> None: + """Test import writes a database and project focus by default.""" + source = Path(__file__).parent / "fixtures" / "snapshots" / "snapshot_with_empty_cache.pkl" + snapshot = tmp_path / "sample.pkl" + shutil.copy(source, snapshot) + + result = runner.invoke(app, ["import", str(snapshot)], catch_exceptions=False) + + assert result.exit_code == 0 + assert "Imported:" in result.stdout + assert (tmp_path / ".pt-snap" / "focus.json").exists() + + def test_import_missing_tool_message( + self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch + ) -> None: + """Test import reports vendored backend packaging guidance when unavailable.""" + from pt_snap_cli.core.import_service import ImportToolMissingError + + snapshot = tmp_path / "sample.pkl" + snapshot.write_bytes(b"not a real snapshot") + + 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." + ) + + monkeypatch.setattr( + "pt_snap_cli.core.import_service.ImportService.import_snapshot", + raise_missing_tool, + ) + + result = runner.invoke(app, ["import", str(snapshot)]) + + assert result.exit_code != 0 + assert "vendored snapshot import backend" in result.output.lower() + assert "reinstall pt-snap-cli" in result.output.lower() + assert "memsnapdump" not in result.output.lower() + + def test_import_invalid_path(self) -> None: + """Test import rejects missing snapshot paths.""" + result = runner.invoke(app, ["import", "/no/such/file.pkl"]) + + assert result.exit_code != 0 + assert "exist" in result.output.lower() + + def test_import_invalid_suffix(self, tmp_path: Path) -> None: + """Test import rejects non-pkl snapshot paths.""" + snapshot = tmp_path / "sample.txt" + snapshot.write_text("not a snapshot") + + result = runner.invoke(app, ["import", str(snapshot)]) + + assert result.exit_code != 0 + assert "suffix" in result.output.lower() or ".pkl" in result.output.lower() + + def test_import_no_focus(self, tmp_path: Path) -> None: + """Test import --no-focus creates a database without writing project focus.""" + source = Path(__file__).parent / "fixtures" / "snapshots" / "snapshot_with_empty_cache.pkl" + snapshot = tmp_path / "sample.pkl" + shutil.copy(source, snapshot) + + result = runner.invoke(app, ["import", str(snapshot), "--no-focus"], catch_exceptions=False) + + assert result.exit_code == 0 + assert not (tmp_path / ".pt-snap").exists() + assert (tmp_path / "sample.pkl.db").exists() + + class TestReportCommand: """Test report subcommands.""" From a2bc255b51ebf5a26001fef496975a323872c8f3 Mon Sep 17 00:00:00 2001 From: codeasier Date: Mon, 22 Jun 2026 07:39:23 +0800 Subject: [PATCH 2/3] fix(import): address review feedback on vendored backend MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backend cleanup: - Remove _backend_available / _ensure_backend_available / _run_dump_to_db indirection in ImportService. Vendor unavailability is reported via ImportToolMissingError from SnapshotImportBackend itself, eliminating the dead private-flag path that was only exercised by tests. - Drop the redundant pickle.load in _validate_snapshot_file. The vendored load_pickle_to_dict already validates dict type and surfaces a clearer error, avoiding a second full unpickle of multi-GB snapshots. - Move the FocusService import to the module top — there is no import cycle, and the lazy import only confused readers. - Tighten snapshot_import_backend: compute db_path once (matching the vendor closure's expression), narrow exception handling to specific failure modes (OSError, sqlite3, pickle, ValueError), pre-delete any existing target .db with a logged warning to prevent the vendored SnapshotDb from silently DROPping tables in pre-existing databases. - Wrap DatabaseSchemaError / FocusFileInvalidError from focus writes as ImportExecutionError so callers only see one import-layer exception type from the service. CLI: - Drop getattr(result.focus_state, 'focus_file', None) fallback in the import command — focus_file is a stable FocusState field. Tests: - Split corrupt-pickle test from suffix test: suffix test now uses a .txt file (only triggers suffix check); corrupt test writes pickle-protocol garbage with .pkl suffix and confirms the vendored backend surfaces ImportExecutionError. - Update the missing-tool / upstream-failure tests to monkeypatch service._backend.dump_to_db instead of private flags. Vendoring: - Add src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md documenting the upstream repository, pinned SHA, license status, and resync strategy. - Add src/pt_snap_cli/vendor/memsnapdump/LICENSE (MIT, same as pt-snap-cli). - The upstream MemSnapDump repo has no top-level LICENSE file; both projects are by the same author and the closure is taken under MIT. CI: - Add a wheel smoke test that builds dist/*.whl, force-reinstalls it, confirms the vendored closure is importable, and runs pt-snap import against a real fixture. This catches any setuptools packaging regression that would otherwise only surface in production installs. Refs review comments on #67. --- .github/workflows/test.yml | 22 ++++++ src/pt_snap_cli/cli.py | 8 +- src/pt_snap_cli/core/import_service.py | 68 ++++++----------- .../core/snapshot_import_backend.py | 36 ++++++++- .../vendor/memsnapdump/ATTRIBUTION.md | 74 +++++++++++++++++++ src/pt_snap_cli/vendor/memsnapdump/LICENSE | 29 ++++++++ tests/core/test_import_service.py | 32 ++++++-- tests/test_cli.py | 4 +- 8 files changed, 214 insertions(+), 59 deletions(-) create mode 100644 src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md create mode 100644 src/pt_snap_cli/vendor/memsnapdump/LICENSE diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 53549a3..01ce41b 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -67,3 +67,25 @@ jobs: name: coverage-report path: coverage.xml retention-days: 30 + + - name: Build wheel + if: matrix.python-version == '3.13' + run: | + python -m pip install --upgrade build + python -m build --wheel + + - name: Wheel smoke test (verify vendored backend 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'" + # End-to-end import against a real fixture — catches any packaging + # regression where setuptools drops src/pt_snap_cli/vendor/. + FIXTURE=tests/fixtures/snapshots/snapshot_with_empty_cache.pkl + rm -rf /tmp/pt-snap-wheel-smoke + mkdir -p /tmp/pt-snap-wheel-smoke + pt-snap import "$FIXTURE" --no-focus --output-dir /tmp/pt-snap-wheel-smoke + test -f /tmp/pt-snap-wheel-smoke/snapshot_with_empty_cache.pkl.db + rm -rf /tmp/pt-snap-wheel-smoke diff --git a/src/pt_snap_cli/cli.py b/src/pt_snap_cli/cli.py index 0e33624..3f8d649 100644 --- a/src/pt_snap_cli/cli.py +++ b/src/pt_snap_cli/cli.py @@ -179,16 +179,12 @@ def import_snapshot( ImportToolMissingError, ImportExecutionError, SnapshotFileInvalidError, - FocusFileInvalidError, - DatabaseSchemaError, ) as e: _error(str(e)) typer.echo(f"Imported: {result.db_path}") - if result.focus_state is not None: - focus_file = getattr(result.focus_state, "focus_file", None) - if focus_file is not None: - typer.echo(f"Focus: {focus_file}") + if result.focus_state is not None and result.focus_state.focus_file is not None: + typer.echo(f"Focus: {result.focus_state.focus_file}") @app.command("query") diff --git a/src/pt_snap_cli/core/import_service.py b/src/pt_snap_cli/core/import_service.py index d5d238e..0417e1b 100644 --- a/src/pt_snap_cli/core/import_service.py +++ b/src/pt_snap_cli/core/import_service.py @@ -1,16 +1,19 @@ from __future__ import annotations -import pickle -from collections.abc import Callable +import logging from pathlib import Path -from typing import TYPE_CHECKING -from pt_snap_cli.core.errors import ImportToolMissingError, SnapshotFileInvalidError +from pt_snap_cli.core.errors import ( + DatabaseSchemaError, + FocusFileInvalidError, + ImportExecutionError, + SnapshotFileInvalidError, +) +from pt_snap_cli.core.focus_service import FocusService from pt_snap_cli.core.models import ImportOptions, ImportResult from pt_snap_cli.core.snapshot_import_backend import SnapshotImportBackend -if TYPE_CHECKING: - from pt_snap_cli.core.focus_service import FocusService +logger = logging.getLogger(__name__) VALID_SUFFIXES = {".pkl", ".pickle"} @@ -25,47 +28,33 @@ def __init__( ) -> None: self._focus_service = focus_service self._backend = backend or SnapshotImportBackend() - self._backend_available = True - self._run_dump_to_db: Callable[[Path, Path, int | None], Path] | None = ( - self._backend.dump_to_db - ) def import_snapshot(self, options: ImportOptions) -> ImportResult: self._validate_snapshot_file(options.snapshot_file) output_dir = self._resolve_output_dir(options.snapshot_file, options.output_dir) - db_path = self._invoke_backend(options.snapshot_file, output_dir, options.device) + db_path = self._backend.dump_to_db(options.snapshot_file, output_dir, options.device) focus_state = None if options.set_focus: if self._focus_service is None: - from pt_snap_cli.core.focus_service import FocusService - self._focus_service = FocusService() - focus_state = self._focus_service.set_project_focus( - db_path=db_path, - device_id=options.device, - base_dir=output_dir, - ) + try: + focus_state = self._focus_service.set_project_focus( + db_path=db_path, + device_id=options.device, + base_dir=output_dir, + ) + except (FocusFileInvalidError, DatabaseSchemaError) as exc: + # Focus write happens after the .db is on disk; if the new + # database fails validation (e.g. vendor produced a non-pt-snap + # schema), report it as an import execution failure rather than + # leaking the underlying domain error through the import API. + raise ImportExecutionError( + f"Imported database cannot be registered as focus: {exc}" + ) from exc return ImportResult(db_path=db_path, device_id=options.device, focus_state=focus_state) - def _ensure_backend_available(self) -> None: - if not self._backend_available or self._run_dump_to_db is None: - raise ImportToolMissingError( - "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " - "the package may be incomplete." - ) - - def _invoke_backend( - self, - snapshot_file: Path, - output_dir: Path, - device: int | None, - ) -> Path: - self._ensure_backend_available() - assert self._run_dump_to_db is not None - return self._run_dump_to_db(snapshot_file, output_dir, device) - @staticmethod def _validate_snapshot_file(path: Path) -> None: if not path.exists(): @@ -76,15 +65,6 @@ def _validate_snapshot_file(path: Path) -> None: raise SnapshotFileInvalidError( f"Snapshot suffix must be .pkl or .pickle, got {path.suffix!r}" ) - try: - with path.open("rb") as file: - obj = pickle.load(file) - except Exception as exc: - raise SnapshotFileInvalidError(f"Cannot unpickle snapshot file: {exc}") from exc - if not isinstance(obj, dict): - raise SnapshotFileInvalidError( - f"Snapshot top-level must be a dict, got {type(obj).__name__}" - ) @staticmethod def _resolve_output_dir(snapshot_file: Path, output_dir: Path | None) -> Path: diff --git a/src/pt_snap_cli/core/snapshot_import_backend.py b/src/pt_snap_cli/core/snapshot_import_backend.py index 66c4ef0..daedd9d 100644 --- a/src/pt_snap_cli/core/snapshot_import_backend.py +++ b/src/pt_snap_cli/core/snapshot_import_backend.py @@ -1,10 +1,16 @@ from __future__ import annotations +import logging +import os +import pickle +import sqlite3 from pathlib import Path from pt_snap_cli.core.errors import ImportExecutionError, ImportToolMissingError from pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db import run_dump_to_db +logger = logging.getLogger(__name__) + class SnapshotImportBackend: """Stable adapter over the vendored snapshot-to-database implementation.""" @@ -15,8 +21,12 @@ def dump_to_db( output_dir: Path, device: int | None = None, ) -> Path: + # Single source of truth for the .db path: must match the expression + # used inside the vendored run_dump_to_db closure (snapshot_file.name + ".db"). db_path = output_dir / f"{snapshot_file.name}.db" + self._ensure_fresh_db(db_path) + try: ok = run_dump_to_db( snapshot_file=str(snapshot_file), @@ -24,11 +34,17 @@ def dump_to_db( device=device, ) except ImportError as exc: + # The vendored closure was not importable at runtime — this is a + # packaging problem, not a user-facing data error. raise ImportToolMissingError( "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " "the package may be incomplete." ) from exc - except Exception as exc: + except (OSError, sqlite3.DatabaseError, pickle.UnpicklingError, ValueError) as exc: + # Narrow, observable failure modes: filesystem, sqlite, pickle parse, + # or vendor validation (e.g. "device not found"). Other exception + # types (MemoryError, KeyboardInterrupt, ...) are intentionally left + # to propagate untouched so the original traceback is preserved. raise ImportExecutionError(f"Vendored snapshot import backend failed: {exc}") from exc if not ok: @@ -37,3 +53,21 @@ def dump_to_db( raise ImportExecutionError(f"Expected database not produced: {db_path}") return db_path + + @staticmethod + def _ensure_fresh_db(db_path: Path) -> None: + """Remove an existing target .db before delegating to the vendor. + + The vendored SnapshotDb opens its database in ``auto_create=True`` mode + and silently ``DROP TABLE``s any pre-existing tables for the old device + schema on ``__init__``. That means re-running ``pt-snap import`` against + a populated .db would destroy user data without warning. We delete the + target file here (with a log message) so the behavior is explicit and + logged, while keeping the vendored closure unchanged. + """ + if db_path.exists() and db_path.is_file(): + logger.warning( + "Overwriting existing database at %s (pt-snap import always regenerates the target).", + db_path, + ) + os.remove(db_path) diff --git a/src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md b/src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md new file mode 100644 index 0000000..542820c --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/ATTRIBUTION.md @@ -0,0 +1,74 @@ +# 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/LICENSE b/src/pt_snap_cli/vendor/memsnapdump/LICENSE new file mode 100644 index 0000000..e37fe9a --- /dev/null +++ b/src/pt_snap_cli/vendor/memsnapdump/LICENSE @@ -0,0 +1,29 @@ +MIT License + +Copyright (c) 2026 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 +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +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/tests/core/test_import_service.py b/tests/core/test_import_service.py index d5acb3c..067eff4 100644 --- a/tests/core/test_import_service.py +++ b/tests/core/test_import_service.py @@ -70,29 +70,46 @@ 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.""" import_service_cls = _import_service_type() service = import_service_cls() snapshot_file = tmp_path / "foo.txt" - snapshot_file.write_bytes(b"not a pickle") + snapshot_file.write_bytes(b"any content is fine here - suffix is the only check") - with pytest.raises(SnapshotFileInvalidError): + with pytest.raises(SnapshotFileInvalidError, match=r"\.pkl|\.pickle|suffix"): service.import_snapshot(ImportOptions(snapshot_file=snapshot_file)) 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 + surfaces as :class:`ImportExecutionError`. + """ import_service_cls = _import_service_type() service = import_service_cls() snapshot_file = tmp_path / "corrupt.pkl" - snapshot_file.write_bytes(b"not a pickle") + # Real pickle protocol header followed by garbage: passes suffix check, + # fails inside the vendor's load_pickle_to_dict. + snapshot_file.write_bytes(b"\x80\x04not a valid pickle stream") - with pytest.raises(SnapshotFileInvalidError): + with pytest.raises(ImportExecutionError, match=r"backend (failed|reported failure)"): service.import_snapshot(ImportOptions(snapshot_file=snapshot_file)) -def test_import_raises_on_missing_tool(tmp_path: Path) -> None: +def test_import_raises_on_missing_tool(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: + """If the vendored backend fails to import, the service surfaces ImportToolMissingError.""" import_service_cls = _import_service_type() service = import_service_cls() - service._backend_available = False + + def raise_missing_tool(*args: object, **kwargs: object) -> Path: + raise ImportToolMissingError( + "Vendored 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"): service.import_snapshot( @@ -101,13 +118,14 @@ def test_import_raises_on_missing_tool(tmp_path: Path) -> None: def test_import_raises_on_upstream_failure(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: + """A backend that raises ImportExecutionError is propagated as-is.""" import_service_cls = _import_service_type() service = import_service_cls() def fail_dump_to_db(snapshot_file: Path, dump_dir: Path, device: int | None) -> Path: raise ImportExecutionError("Vendored snapshot import backend failed: upstream failed") - monkeypatch.setattr(service, "_run_dump_to_db", fail_dump_to_db) + monkeypatch.setattr(service._backend, "dump_to_db", fail_dump_to_db) with pytest.raises(ImportExecutionError): service.import_snapshot( diff --git a/tests/test_cli.py b/tests/test_cli.py index 24f503d..e118fcf 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -831,7 +831,7 @@ def test_import_missing_tool_message( self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: """Test import reports vendored backend packaging guidance when unavailable.""" - from pt_snap_cli.core.import_service import ImportToolMissingError + from pt_snap_cli.core.errors import ImportToolMissingError snapshot = tmp_path / "sample.pkl" snapshot.write_bytes(b"not a real snapshot") @@ -863,6 +863,8 @@ def test_import_invalid_path(self) -> None: def test_import_invalid_suffix(self, tmp_path: Path) -> None: """Test import rejects non-pkl snapshot paths.""" snapshot = tmp_path / "sample.txt" + # Content is irrelevant: the .txt suffix is rejected before the + # backend ever opens the file. snapshot.write_text("not a snapshot") result = runner.invoke(app, ["import", str(snapshot)]) From c22d0fd1203fae4c4c2bf4bec057d2c6985ef1b7 Mon Sep 17 00:00:00 2001 From: codeasier Date: Mon, 22 Jun 2026 16:48:51 +0800 Subject: [PATCH 3/3] fix(import): address follow-up review feedback --- src/pt_snap_cli/core/import_service.py | 1 - .../core/snapshot_import_backend.py | 79 ++++++++----------- tests/core/test_import_service.py | 62 ++++++++++++++- 3 files changed, 92 insertions(+), 50 deletions(-) diff --git a/src/pt_snap_cli/core/import_service.py b/src/pt_snap_cli/core/import_service.py index 0417e1b..6bea179 100644 --- a/src/pt_snap_cli/core/import_service.py +++ b/src/pt_snap_cli/core/import_service.py @@ -42,7 +42,6 @@ def import_snapshot(self, options: ImportOptions) -> ImportResult: focus_state = self._focus_service.set_project_focus( db_path=db_path, device_id=options.device, - base_dir=output_dir, ) except (FocusFileInvalidError, DatabaseSchemaError) as exc: # Focus write happens after the .db is on disk; if the new diff --git a/src/pt_snap_cli/core/snapshot_import_backend.py b/src/pt_snap_cli/core/snapshot_import_backend.py index daedd9d..c57dfbd 100644 --- a/src/pt_snap_cli/core/snapshot_import_backend.py +++ b/src/pt_snap_cli/core/snapshot_import_backend.py @@ -1,15 +1,12 @@ from __future__ import annotations -import logging import os import pickle import sqlite3 +import tempfile from pathlib import Path from pt_snap_cli.core.errors import ImportExecutionError, ImportToolMissingError -from pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db import run_dump_to_db - -logger = logging.getLogger(__name__) class SnapshotImportBackend: @@ -21,53 +18,45 @@ def dump_to_db( output_dir: Path, device: int | None = None, ) -> Path: - # Single source of truth for the .db path: must match the expression - # used inside the vendored run_dump_to_db closure (snapshot_file.name + ".db"). db_path = output_dir / f"{snapshot_file.name}.db" + output_dir.mkdir(parents=True, exist_ok=True) + run_dump_to_db = self._load_run_dump_to_db() + + with tempfile.TemporaryDirectory(dir=output_dir) as tmp_dir_name: + tmp_dir = Path(tmp_dir_name) + tmp_db_path = tmp_dir / db_path.name + try: + ok = run_dump_to_db( + snapshot_file=str(snapshot_file), + dump_dir=str(tmp_dir), + device=device, + ) + except (OSError, sqlite3.DatabaseError, pickle.UnpicklingError, ValueError) as exc: + raise ImportExecutionError( + f"Vendored snapshot import backend failed: {exc}" + ) from exc + + if not ok: + raise ImportExecutionError("Vendored snapshot import backend reported failure.") + if not tmp_db_path.is_file(): + raise ImportExecutionError(f"Expected database not produced: {tmp_db_path}") + + try: + os.replace(tmp_db_path, db_path) + except OSError as exc: + raise ImportExecutionError( + f"Vendored snapshot import backend failed: {exc}" + ) from exc - self._ensure_fresh_db(db_path) + return db_path + @staticmethod + def _load_run_dump_to_db(): try: - ok = run_dump_to_db( - snapshot_file=str(snapshot_file), - dump_dir=str(output_dir), - device=device, - ) + from pt_snap_cli.vendor.memsnapdump.tools.adaptors.snapshot2db import run_dump_to_db except ImportError as exc: - # The vendored closure was not importable at runtime — this is a - # packaging problem, not a user-facing data error. raise ImportToolMissingError( "Vendored snapshot import backend is unavailable. Reinstall pt-snap-cli; " "the package may be incomplete." ) from exc - except (OSError, sqlite3.DatabaseError, pickle.UnpicklingError, ValueError) as exc: - # Narrow, observable failure modes: filesystem, sqlite, pickle parse, - # or vendor validation (e.g. "device not found"). Other exception - # types (MemoryError, KeyboardInterrupt, ...) are intentionally left - # to propagate untouched so the original traceback is preserved. - raise ImportExecutionError(f"Vendored snapshot import backend failed: {exc}") from exc - - if not ok: - raise ImportExecutionError("Vendored snapshot import backend reported failure.") - if not db_path.is_file(): - raise ImportExecutionError(f"Expected database not produced: {db_path}") - - return db_path - - @staticmethod - def _ensure_fresh_db(db_path: Path) -> None: - """Remove an existing target .db before delegating to the vendor. - - The vendored SnapshotDb opens its database in ``auto_create=True`` mode - and silently ``DROP TABLE``s any pre-existing tables for the old device - schema on ``__init__``. That means re-running ``pt-snap import`` against - a populated .db would destroy user data without warning. We delete the - target file here (with a log message) so the behavior is explicit and - logged, while keeping the vendored closure unchanged. - """ - if db_path.exists() and db_path.is_file(): - logger.warning( - "Overwriting existing database at %s (pt-snap import always regenerates the target).", - db_path, - ) - os.remove(db_path) + return run_dump_to_db diff --git a/tests/core/test_import_service.py b/tests/core/test_import_service.py index 067eff4..0c91206 100644 --- a/tests/core/test_import_service.py +++ b/tests/core/test_import_service.py @@ -1,6 +1,8 @@ from __future__ import annotations +import importlib import pickle +import sys from pathlib import Path import pytest @@ -24,17 +26,22 @@ def _import_service_type(): return ImportService -def test_import_writes_db_and_sets_focus(tmp_path: Path) -> None: +def test_import_writes_db_and_sets_focus(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: import_service_cls = _import_service_type() service = import_service_cls() + project_dir = tmp_path / "project" + output_dir = tmp_path / "output" + project_dir.mkdir() + monkeypatch.chdir(project_dir) result = service.import_snapshot( - ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path) + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=output_dir) ) assert result.db_path.exists() assert result.db_path.suffix == ".db" - assert (tmp_path / ".pt-snap" / "focus.json").exists() + assert (project_dir / ".pt-snap" / "focus.json").exists() + assert not (output_dir / ".pt-snap" / "focus.json").exists() @pytest.mark.slow @@ -98,8 +105,55 @@ def test_import_snapshot_file_invalid_corrupt_pickle(tmp_path: Path) -> None: service.import_snapshot(ImportOptions(snapshot_file=snapshot_file)) +def test_failed_reimport_preserves_existing_database(tmp_path: Path) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + result = service.import_snapshot( + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path, set_focus=False) + ) + original_size = result.db_path.stat().st_size + assert Context(result.db_path).discover_devices() + + with pytest.raises(ImportExecutionError, match=r"backend (failed|reported failure)"): + service.import_snapshot( + ImportOptions( + snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path, device=999, set_focus=False + ) + ) + + assert result.db_path.exists() + assert result.db_path.stat().st_size == original_size + assert Context(result.db_path).discover_devices() + + +def test_import_replaces_destination_errors_are_wrapped( + monkeypatch: pytest.MonkeyPatch, tmp_path: Path +) -> None: + import_service_cls = _import_service_type() + service = import_service_cls() + + def fail_replace(*args: object) -> None: + raise OSError("cannot replace") + + monkeypatch.setattr("pt_snap_cli.core.snapshot_import_backend.os.replace", fail_replace) + + with pytest.raises(ImportExecutionError, match="cannot replace"): + service.import_snapshot( + ImportOptions(snapshot_file=EMPTY_CACHE_SNAPSHOT, output_dir=tmp_path, set_focus=False) + ) + + +def test_snapshot_import_backend_lazy_loads_vendor_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) + + importlib.import_module("pt_snap_cli.core.snapshot_import_backend") + + assert vendor_module not in sys.modules + + def test_import_raises_on_missing_tool(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: - """If the vendored backend fails to import, the service surfaces ImportToolMissingError.""" import_service_cls = _import_service_type() service = import_service_cls()