gdsdiff 0.1.0__py3-none-any.whl

gdsdiff/backends/__init__.py

@@ -0,0 +1,26 @@
+"""Backend implementations for GPU compare accelerators."""
+
+from .base import ExactComponentBackend, PrefilterBackend
+from .cpu import CpuTileBackend
+from .cuda import CudaBackendUnavailable, CudaTileBackend
+from .exact import (
+    CudaManhattanRectExactComponentBackend,
+    GdstkExactComponentBackend,
+    ManhattanRectExactComponentBackend,
+    UnsupportedExactComponent,
+)
+from .metal import MetalExactUnavailable, MetalManhattanRectExactComponentBackend
+
+__all__ = [
+    "CpuTileBackend",
+    "CudaBackendUnavailable",
+    "CudaTileBackend",
+    "CudaManhattanRectExactComponentBackend",
+    "ExactComponentBackend",
+    "GdstkExactComponentBackend",
+    "ManhattanRectExactComponentBackend",
+    "MetalExactUnavailable",
+    "MetalManhattanRectExactComponentBackend",
+    "PrefilterBackend",
+    "UnsupportedExactComponent",
+]

gdsdiff/backends/base.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol
+
+from ..geometry import PolygonBuffer
+from ..tiling import CpuTilePrefilterResult, TileConfig
+
+if TYPE_CHECKING:
+    from ..exact_oracle import ExactLayerTask, LayerExactDiff
+
+
+@dataclass(frozen=True)
+class BackendCapabilities:
+    name: str
+    deterministic: bool = True
+    requires_gpu: bool = False
+
+
+class PrefilterBackend(Protocol):
+    def capabilities(self) -> BackendCapabilities:
+        ...
+
+    def compare_tile_contributors(
+        self,
+        old_buffer: PolygonBuffer,
+        old_canonical_ids,
+        new_buffer: PolygonBuffer,
+        new_canonical_ids,
+        config: TileConfig,
+    ) -> CpuTilePrefilterResult:
+        ...
+
+
+@dataclass(frozen=True)
+class FileIdentityResult:
+    old_size: int
+    new_size: int
+    same: bool
+    method: str
+
+
+class FileIdentityBackend(Protocol):
+    def capabilities(self) -> BackendCapabilities:
+        ...
+
+    def compare_files(self, old_path: str | Path, new_path: str | Path) -> FileIdentityResult:
+        ...
+
+
+class NativeGeometryBackend(Protocol):
+    """Backend boundary for the planned non-gdstk fast geometry path.
+
+    Implementations should consume a native GDS-derived intermediate
+    representation rather than Python `gdstk.Polygon` objects. CUDA, Metal, and
+    portable CPU backends should share this contract.
+    """
+
+    def capabilities(self) -> BackendCapabilities:
+        ...
+
+
+class ExactComponentBackend(Protocol):
+    """Backend boundary for polygon-level exact evidence tasks.
+
+    Implementations consume independent exact component tasks and return the
+    same `LayerExactDiff` fragments as the `gdstk` oracle. CUDA and Metal
+    backends should target this contract while the CPU/gdstk backend remains
+    the reference oracle.
+    """
+
+    def capabilities(self) -> BackendCapabilities:
+        ...
+
+    def compare_components(self, tasks: tuple["ExactLayerTask", ...]) -> tuple["LayerExactDiff", ...]:
+        ...

gdsdiff/backends/boundary_loop_ctypes.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import ctypes
+import subprocess
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+
+from ..exact_oracle import DiffFragment
+from ..native_cache import ensure_cached_native_library
+
+
+class BoundaryLoopCtypesUnavailable(RuntimeError):
+    pass
+
+
+class _CBoundaryLoopResult(ctypes.Structure):
+    _fields_ = [
+        ("fragment_count", ctypes.c_uint64),
+        ("vertex_count", ctypes.c_uint64),
+        ("vertices_xy", ctypes.POINTER(ctypes.c_int64)),
+        ("fragment_offsets", ctypes.POINTER(ctypes.c_uint64)),
+        ("bboxes", ctypes.POINTER(ctypes.c_int64)),
+        ("twice_areas", ctypes.POINTER(ctypes.c_int64)),
+        ("dropped_zero_area_loop_count", ctypes.c_uint64),
+    ]
+
+
+class _CBoundaryEdgesResult(ctypes.Structure):
+    _fields_ = [
+        ("edge_count", ctypes.c_uint64),
+        ("edges", ctypes.POINTER(ctypes.c_int64)),
+    ]
+
+
+@dataclass(frozen=True)
+class NativeBoundaryLoopResult:
+    fragments: tuple[DiffFragment, ...]
+    dropped_zero_area_loop_count: int
+
+
+@dataclass(frozen=True)
+class NativeBoundaryEdgesResult:
+    edges: np.ndarray
+
+
+def native_boundary_edges_from_fragments(fragments: tuple[DiffFragment, ...]) -> NativeBoundaryEdgesResult:
+    library = _load_library()
+    vertices, offsets = _pack_fragments(fragments)
+    result = _CBoundaryEdgesResult()
+    status = library.gds_boundary_edges_from_polygons(
+        vertices.ctypes.data_as(ctypes.POINTER(ctypes.c_int64)),
+        offsets.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)),
+        ctypes.c_uint64(len(fragments)),
+        ctypes.byref(result),
+    )
+    if status != 0:
+        message = library.gds_boundary_loops_last_error()
+        raise BoundaryLoopCtypesUnavailable(message.decode("utf-8") if message else "native boundary edge assembly failed")
+    try:
+        edge_count = int(result.edge_count)
+        edges = _copy_array(result.edges, edge_count * 4, np.int64).reshape((edge_count, 4))
+        return NativeBoundaryEdgesResult(edges=edges)
+    finally:
+        library.gds_boundary_edges_free(ctypes.byref(result))
+
+
+def native_boundary_loops_from_edges(edges: np.ndarray) -> NativeBoundaryLoopResult:
+    library = _load_library()
+    edges = np.ascontiguousarray(edges, dtype=np.int64)
+    if edges.ndim != 2 or edges.shape[1] != 4:
+        raise ValueError("edges must have shape (N, 4)")
+    result = _CBoundaryLoopResult()
+    status = library.gds_boundary_loops_from_edges(
+        edges.ctypes.data_as(ctypes.POINTER(ctypes.c_int64)),
+        ctypes.c_uint64(len(edges)),
+        ctypes.byref(result),
+    )
+    if status != 0:
+        message = library.gds_boundary_loops_last_error()
+        raise BoundaryLoopCtypesUnavailable(message.decode("utf-8") if message else "native boundary loop assembly failed")
+    try:
+        count = int(result.fragment_count)
+        vertex_count = int(result.vertex_count)
+        vertices = _copy_array(result.vertices_xy, vertex_count * 2, np.int64).reshape((vertex_count, 2))
+        offsets = _copy_array(result.fragment_offsets, count + 1, np.uint64)
+        bboxes = _copy_array(result.bboxes, count * 4, np.int64).reshape((count, 4))
+        twice_areas = _copy_array(result.twice_areas, count, np.int64)
+        fragments = []
+        for index in range(count):
+            start = int(offsets[index])
+            stop = int(offsets[index + 1])
+            points = tuple((int(x), int(y)) for x, y in vertices[start:stop])
+            bbox = tuple(int(value) for value in bboxes[index])
+            fragments.append(DiffFragment(points=points, bbox=bbox, twice_area=int(twice_areas[index])))
+        return NativeBoundaryLoopResult(
+            fragments=tuple(fragments),
+            dropped_zero_area_loop_count=int(result.dropped_zero_area_loop_count),
+        )
+    finally:
+        library.gds_boundary_loops_free(ctypes.byref(result))
+
+
+def boundary_loop_ctypes_available() -> bool:
+    try:
+        _load_library()
+    except BoundaryLoopCtypesUnavailable:
+        return False
+    return True
+
+
+def _copy_array(pointer, count: int, dtype) -> np.ndarray:
+    if count == 0:
+        return np.empty((0,), dtype=dtype)
+    if not pointer:
+        raise BoundaryLoopCtypesUnavailable("native boundary loop result returned a null array")
+    ctype = np.ctypeslib.as_ctypes_type(dtype)
+    array = ctypes.cast(pointer, ctypes.POINTER(ctype * count)).contents
+    return np.frombuffer(array, dtype=dtype).copy()
+
+
+@lru_cache(maxsize=1)
+def _load_library() -> ctypes.CDLL:
+    path = _library_path()
+    library = ctypes.CDLL(str(path))
+    library.gds_boundary_edges_from_polygons.argtypes = [
+        ctypes.POINTER(ctypes.c_int64),
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.c_uint64,
+        ctypes.POINTER(_CBoundaryEdgesResult),
+    ]
+    library.gds_boundary_edges_from_polygons.restype = ctypes.c_int
+    library.gds_boundary_edges_free.argtypes = [ctypes.POINTER(_CBoundaryEdgesResult)]
+    library.gds_boundary_edges_free.restype = None
+    library.gds_boundary_loops_from_edges.argtypes = [
+        ctypes.POINTER(ctypes.c_int64),
+        ctypes.c_uint64,
+        ctypes.POINTER(_CBoundaryLoopResult),
+    ]
+    library.gds_boundary_loops_from_edges.restype = ctypes.c_int
+    library.gds_boundary_loops_free.argtypes = [ctypes.POINTER(_CBoundaryLoopResult)]
+    library.gds_boundary_loops_free.restype = None
+    library.gds_boundary_loops_last_error.argtypes = []
+    library.gds_boundary_loops_last_error.restype = ctypes.c_char_p
+    return library
+
+
+def _build_library(path: Path) -> None:
+    source = _source_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    command = [
+        "g++",
+        "-std=c++17",
+        "-O3",
+        "-shared",
+        "-fPIC",
+        str(source),
+        "-o",
+        str(path),
+    ]
+    try:
+        completed = subprocess.run(command, check=False, text=True, capture_output=True)
+    except FileNotFoundError as exc:
+        raise BoundaryLoopCtypesUnavailable("g++ is not available") from exc
+    if completed.returncode != 0:
+        raise BoundaryLoopCtypesUnavailable((completed.stderr or completed.stdout).strip() or "g++ failed")
+
+
+def _library_path() -> Path:
+    return ensure_cached_native_library(
+        "_gds_boundary_loops.so",
+        sources=(_source_path(),),
+        build_key=("g++", "-std=c++17", "-O3", "-shared", "-fPIC"),
+        builder=_build_library,
+    )
+
+
+def _source_path() -> Path:
+    return Path(__file__).resolve().parents[1] / "native_src" / "gds_boundary_loops.cpp"
+
+
+def _pack_fragments(fragments: tuple[DiffFragment, ...]) -> tuple[np.ndarray, np.ndarray]:
+    vertex_rows: list[tuple[int, int]] = []
+    offsets = [0]
+    for fragment in fragments:
+        vertex_rows.extend(fragment.points)
+        offsets.append(len(vertex_rows))
+    vertices = np.asarray(vertex_rows, dtype=np.int64).reshape((-1, 2))
+    return vertices, np.asarray(offsets, dtype=np.uint64)

gdsdiff/backends/cpu.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from ..geometry import PolygonBuffer
+from ..tiling import CpuTilePrefilterResult, TileConfig, run_cpu_tile_prefilter
+from .base import BackendCapabilities
+
+
+class CpuTileBackend:
+    def capabilities(self) -> BackendCapabilities:
+        return BackendCapabilities(name="cpu", deterministic=True, requires_gpu=False)
+
+    def compare_tile_contributors(
+        self,
+        old_buffer: PolygonBuffer,
+        old_canonical_ids,
+        new_buffer: PolygonBuffer,
+        new_canonical_ids,
+        config: TileConfig,
+    ) -> CpuTilePrefilterResult:
+        return run_cpu_tile_prefilter(old_buffer, old_canonical_ids, new_buffer, new_canonical_ids, config)

gdsdiff/backends/cpu_ctypes.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import ctypes
+import subprocess
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+
+from ..config import LayerSpec
+from ..geometry import PolygonBuffer
+from ..native_cache import ensure_cached_native_library
+from ..tiling import CpuTilePrefilterResult, OversizedPolygon, TileConfig, TileKey
+
+
+class CpuCtypesUnavailable(RuntimeError):
+    pass
+
+
+class _CResult(ctypes.Structure):
+    _fields_ = [
+        ("candidate_tiles", ctypes.POINTER(ctypes.c_int64)),
+        ("candidate_count", ctypes.c_uint64),
+        ("oversized", ctypes.POINTER(ctypes.c_int64)),
+        ("oversized_count", ctypes.c_uint64),
+        ("assignment_count", ctypes.c_uint64),
+        ("collapsed_pair_count", ctypes.c_uint64),
+        ("oversized_matched_count", ctypes.c_uint64),
+    ]
+
+
+@dataclass(frozen=True)
+class _PackedBuffer:
+    bboxes: np.ndarray
+    layers: np.ndarray
+    datatypes: np.ndarray
+    canonical_ids: np.ndarray
+
+
+def run_cpu_ctypes_tile_prefilter(
+    old_buffer: PolygonBuffer,
+    old_canonical_ids,
+    new_buffer: PolygonBuffer,
+    new_canonical_ids,
+    config: TileConfig,
+) -> CpuTilePrefilterResult:
+    library = _load_library()
+    old_packed = _pack_buffer(old_buffer, old_canonical_ids)
+    new_packed = _pack_buffer(new_buffer, new_canonical_ids)
+    old_packed, new_packed, skipped_matched = _skip_exact_tile_bbox_matches(old_packed, new_packed, config)
+    result = _CResult()
+    status = library.gds_cpu_prefilter(
+        _ptr_i64(old_packed.bboxes),
+        _ptr_i32(old_packed.layers),
+        _ptr_i32(old_packed.datatypes),
+        _ptr_u64(old_packed.canonical_ids),
+        ctypes.c_uint64(len(old_packed.canonical_ids)),
+        _ptr_i64(new_packed.bboxes),
+        _ptr_i32(new_packed.layers),
+        _ptr_i32(new_packed.datatypes),
+        _ptr_u64(new_packed.canonical_ids),
+        ctypes.c_uint64(len(new_packed.canonical_ids)),
+        ctypes.c_int64(config.tile_size),
+        ctypes.c_uint64(config.max_tiles_per_polygon),
+        ctypes.byref(result),
+    )
+    if status != 0:
+        message = library.gds_cpu_last_error()
+        raise CpuCtypesUnavailable(message.decode("utf-8") if message else "native CPU prefilter failed")
+    try:
+        return CpuTilePrefilterResult(
+            candidate_tiles=_candidate_tiles_from_result(result),
+            oversized_candidates=_oversized_from_result(result),
+            assignment_count=int(result.assignment_count),
+            collapsed_pair_count=int(result.collapsed_pair_count),
+            oversized_matched_count=int(result.oversized_matched_count) + skipped_matched,
+        )
+    finally:
+        library.gds_cpu_free_result(ctypes.byref(result))
+
+
+def cpu_ctypes_available() -> bool:
+    try:
+        _load_library()
+    except CpuCtypesUnavailable:
+        return False
+    return True
+
+
+def _candidate_tiles_from_result(result: _CResult) -> tuple[TileKey, ...]:
+    if result.candidate_count == 0:
+        return ()
+    array = np.ctypeslib.as_array(result.candidate_tiles, shape=(int(result.candidate_count) * 4,))
+    return tuple(
+        TileKey(LayerSpec(int(array[index]), int(array[index + 1])), int(array[index + 2]), int(array[index + 3]))
+        for index in range(0, len(array), 4)
+    )
+
+
+def _oversized_from_result(result: _CResult) -> tuple[OversizedPolygon, ...]:
+    if result.oversized_count == 0:
+        return ()
+    array = np.ctypeslib.as_array(result.oversized, shape=(int(result.oversized_count) * 8,))
+    return tuple(
+        OversizedPolygon(
+            layer=LayerSpec(int(array[index]), int(array[index + 1])),
+            canonical_id=int(array[index + 2]),
+            side_mask=int(array[index + 3]),
+            tile_bbox=(int(array[index + 4]), int(array[index + 5]), int(array[index + 6]), int(array[index + 7])),
+        )
+        for index in range(0, len(array), 8)
+    )
+
+
+def _pack_buffer(buffer: PolygonBuffer, canonical_ids) -> _PackedBuffer:
+    ids = np.ascontiguousarray(canonical_ids, dtype=np.uint64)
+    if len(ids) != buffer.polygon_count:
+        raise ValueError("canonical id vector length must match polygon count")
+    layers = np.empty(buffer.polygon_count, dtype=np.int32)
+    datatypes = np.empty(buffer.polygon_count, dtype=np.int32)
+    for index, layer_id in enumerate(buffer.layer_ids):
+        layer = buffer.layer_table.layers[int(layer_id)]
+        layers[index] = layer.layer
+        datatypes[index] = layer.datatype
+    return _PackedBuffer(
+        bboxes=np.ascontiguousarray(buffer.bboxes, dtype=np.int64),
+        layers=np.ascontiguousarray(layers, dtype=np.int32),
+        datatypes=np.ascontiguousarray(datatypes, dtype=np.int32),
+        canonical_ids=ids,
+    )
+
+
+def _skip_exact_tile_bbox_matches(old: _PackedBuffer, new: _PackedBuffer, config: TileConfig) -> tuple[_PackedBuffer, _PackedBuffer, int]:
+    side_masks: dict[tuple[int, int, int, int, int, int, int], int] = {}
+    old_first: dict[tuple[int, int, int, int, int, int, int], int] = {}
+    new_first: dict[tuple[int, int, int, int, int, int, int], int] = {}
+    for index, key in enumerate(_tile_bbox_keys(old, config.tile_size)):
+        side_masks[key] = side_masks.get(key, 0) | 1
+        old_first.setdefault(key, index)
+    for index, key in enumerate(_tile_bbox_keys(new, config.tile_size)):
+        side_masks[key] = side_masks.get(key, 0) | 2
+        new_first.setdefault(key, index)
+    old_keep = [old_first[key] for key, mask in side_masks.items() if mask == 1]
+    new_keep = [new_first[key] for key, mask in side_masks.items() if mask == 2]
+    skipped = sum(1 for mask in side_masks.values() if mask == 3)
+    return _take_packed(old, old_keep), _take_packed(new, new_keep), skipped
+
+
+def _tile_bbox_keys(packed: _PackedBuffer, tile_size: int):
+    tx0 = np.floor_divide(packed.bboxes[:, 0], tile_size)
+    ty0 = np.floor_divide(packed.bboxes[:, 1], tile_size)
+    tx1 = np.floor_divide(packed.bboxes[:, 2], tile_size)
+    ty1 = np.floor_divide(packed.bboxes[:, 3], tile_size)
+    for index in range(len(packed.canonical_ids)):
+        yield (
+            int(packed.layers[index]),
+            int(packed.datatypes[index]),
+            int(packed.canonical_ids[index]),
+            int(tx0[index]),
+            int(ty0[index]),
+            int(tx1[index]),
+            int(ty1[index]),
+        )
+
+
+def _take_packed(packed: _PackedBuffer, indices: list[int]) -> _PackedBuffer:
+    if not indices:
+        return _PackedBuffer(
+            bboxes=np.empty((0, 4), dtype=np.int64),
+            layers=np.empty((0,), dtype=np.int32),
+            datatypes=np.empty((0,), dtype=np.int32),
+            canonical_ids=np.empty((0,), dtype=np.uint64),
+        )
+    index_array = np.asarray(indices, dtype=np.int64)
+    return _PackedBuffer(
+        bboxes=np.ascontiguousarray(packed.bboxes[index_array], dtype=np.int64),
+        layers=np.ascontiguousarray(packed.layers[index_array], dtype=np.int32),
+        datatypes=np.ascontiguousarray(packed.datatypes[index_array], dtype=np.int32),
+        canonical_ids=np.ascontiguousarray(packed.canonical_ids[index_array], dtype=np.uint64),
+    )
+
+
+def _ptr_i64(array: np.ndarray):
+    return array.ctypes.data_as(ctypes.POINTER(ctypes.c_int64))
+
+
+def _ptr_i32(array: np.ndarray):
+    return array.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
+
+
+def _ptr_u64(array: np.ndarray):
+    return array.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64))
+
+
+@lru_cache(maxsize=1)
+def _load_library() -> ctypes.CDLL:
+    path = _library_path()
+    library = ctypes.CDLL(str(path))
+    library.gds_cpu_prefilter.argtypes = [
+        ctypes.POINTER(ctypes.c_int64),
+        ctypes.POINTER(ctypes.c_int32),
+        ctypes.POINTER(ctypes.c_int32),
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_int64),
+        ctypes.POINTER(ctypes.c_int32),
+        ctypes.POINTER(ctypes.c_int32),
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.c_uint64,
+        ctypes.c_int64,
+        ctypes.c_uint64,
+        ctypes.POINTER(_CResult),
+    ]
+    library.gds_cpu_prefilter.restype = ctypes.c_int
+    library.gds_cpu_last_error.argtypes = []
+    library.gds_cpu_last_error.restype = ctypes.c_char_p
+    library.gds_cpu_free_result.argtypes = [ctypes.POINTER(_CResult)]
+    library.gds_cpu_free_result.restype = None
+    return library
+
+
+def _build_library(path: Path) -> None:
+    source = _source_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    command = [
+        "g++",
+        "-std=c++17",
+        "-O3",
+        "-fopenmp",
+        "-shared",
+        "-fPIC",
+        str(source),
+        "-o",
+        str(path),
+    ]
+    try:
+        completed = subprocess.run(command, check=False, text=True, capture_output=True)
+    except FileNotFoundError as exc:
+        raise CpuCtypesUnavailable("g++ is not available") from exc
+    if completed.returncode != 0:
+        raise CpuCtypesUnavailable((completed.stderr or completed.stdout).strip() or "g++ failed")
+
+
+def _library_path() -> Path:
+    return ensure_cached_native_library(
+        "_gds_compare_cpu_ctypes.so",
+        sources=(_source_path(),),
+        build_key=("g++", "-std=c++17", "-O3", "-fopenmp", "-shared", "-fPIC"),
+        builder=_build_library,
+    )
+
+
+def _source_path() -> Path:
+    return Path(__file__).resolve().parents[1] / "native_src" / "cpu_prefilter.cpp"

gdsdiff/backends/cuda.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import importlib
+
+from ..geometry import PolygonBuffer
+from ..tiling import CpuTilePrefilterResult, TileConfig
+from .base import BackendCapabilities
+
+
+class CudaBackendUnavailable(RuntimeError):
+    pass
+
+
+class CudaTileBackend:
+    def __init__(self) -> None:
+        try:
+            self._extension = importlib.import_module("gdsdiff._gds_compare_cuda")
+        except ImportError as exc:
+            raise CudaBackendUnavailable("CUDA backend extension is not available") from exc
+
+    def capabilities(self) -> BackendCapabilities:
+        return BackendCapabilities(name="cuda", deterministic=True, requires_gpu=True)
+
+    def compare_tile_contributors(
+        self,
+        old_buffer: PolygonBuffer,
+        old_canonical_ids,
+        new_buffer: PolygonBuffer,
+        new_canonical_ids,
+        config: TileConfig,
+    ) -> CpuTilePrefilterResult:
+        if not hasattr(self._extension, "compare_tile_contributors"):
+            raise CudaBackendUnavailable("CUDA backend extension lacks compare_tile_contributors")
+        return self._extension.compare_tile_contributors(
+            old_buffer,
+            old_canonical_ids,
+            new_buffer,
+            new_canonical_ids,
+            config,
+        )