gdsdiff 0.1.0__py3-none-any.whl

gdsdiff/native_src/gds_structural_scan.cpp

@@ -0,0 +1,335 @@
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <map>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace {
+
+thread_local std::string g_last_error;
+
+struct Reference {
+    std::string child;
+    std::uint64_t multiplier = 1;
+    std::uint64_t raw_hash = 0;
+};
+
+struct Cell {
+    std::uint64_t local_shape_count = 0;
+    std::uint64_t local_shape_hash = 1469598103934665603ull;
+    std::vector<Reference> references;
+};
+
+struct ParseResult {
+    std::map<std::string, Cell> cells;
+};
+
+std::uint16_t read_u16(const unsigned char* p) {
+    return static_cast<std::uint16_t>((static_cast<std::uint16_t>(p[0]) << 8) | p[1]);
+}
+
+std::int16_t read_i16(const unsigned char* p) {
+    return static_cast<std::int16_t>(read_u16(p));
+}
+
+std::string decode_string(const unsigned char* data, std::size_t size) {
+    while (size && data[size - 1] == 0) {
+        --size;
+    }
+    return std::string(reinterpret_cast<const char*>(data), size);
+}
+
+std::uint64_t fnv1a_update(std::uint64_t hash, const unsigned char* data, std::size_t size) {
+    constexpr std::uint64_t prime = 1099511628211ull;
+    for (std::size_t i = 0; i < size; ++i) {
+        hash ^= static_cast<std::uint64_t>(data[i]);
+        hash *= prime;
+    }
+    return hash;
+}
+
+std::uint64_t fnv1a_u64(std::uint64_t hash, std::uint64_t value) {
+    unsigned char bytes[8];
+    for (int i = 0; i < 8; ++i) {
+        bytes[i] = static_cast<unsigned char>((value >> (56 - i * 8)) & 0xff);
+    }
+    return fnv1a_update(hash, bytes, sizeof(bytes));
+}
+
+std::vector<unsigned char> read_file(const char* path) {
+    std::ifstream in(path, std::ios::binary);
+    if (!in) {
+        throw std::runtime_error("unable to open GDS file");
+    }
+    in.seekg(0, std::ios::end);
+    const auto size = in.tellg();
+    if (size < 0) {
+        throw std::runtime_error("unable to determine GDS file size");
+    }
+    in.seekg(0, std::ios::beg);
+    std::vector<unsigned char> data(static_cast<std::size_t>(size));
+    if (!data.empty()) {
+        in.read(reinterpret_cast<char*>(data.data()), static_cast<std::streamsize>(data.size()));
+        if (!in) {
+            throw std::runtime_error("unable to read GDS file");
+        }
+    }
+    return data;
+}
+
+ParseResult parse_gds(const char* path, bool compute_hash) {
+    const auto data = read_file(path);
+    ParseResult result;
+    std::size_t offset = 0;
+    std::string current_name;
+    std::uint64_t local_shape_count = 0;
+    std::uint64_t local_shape_hash = 1469598103934665603ull;
+    std::vector<Reference> references;
+    int element_kind = -1;
+    std::size_t element_start = 0;
+    std::string pending_sname;
+    std::uint64_t pending_multiplier = 1;
+
+    while (offset + 4 <= data.size()) {
+        const std::uint16_t record_len = read_u16(data.data() + offset);
+        const int record_type = data[offset + 2];
+        if (record_len < 4 || offset + record_len > data.size()) {
+            throw std::runtime_error("invalid GDS record length");
+        }
+        const unsigned char* payload = data.data() + offset + 4;
+        const std::size_t payload_size = record_len - 4;
+        offset += record_len;
+
+        switch (record_type) {
+        case 0x05:  // BGNSTR
+            current_name.clear();
+            local_shape_count = 0;
+            local_shape_hash = 1469598103934665603ull;
+            references.clear();
+            break;
+        case 0x06:  // STRNAME
+            current_name = decode_string(payload, payload_size);
+            break;
+        case 0x08:  // BOUNDARY
+        case 0x09:  // PATH
+            element_kind = record_type;
+            element_start = offset - record_len;
+            break;
+        case 0x0A:  // SREF
+        case 0x0B:  // AREF
+            element_kind = record_type;
+            element_start = offset - record_len;
+            pending_sname.clear();
+            pending_multiplier = 1;
+            break;
+        case 0x12:  // SNAME
+            if (element_kind == 0x0A || element_kind == 0x0B) {
+                pending_sname = decode_string(payload, payload_size);
+            }
+            break;
+        case 0x13:  // COLROW
+            if (element_kind == 0x0B) {
+                if (payload_size < 4) {
+                    throw std::runtime_error("invalid COLROW record");
+                }
+                const auto columns = read_i16(payload);
+                const auto rows = read_i16(payload + 2);
+                if (columns <= 0 || rows <= 0) {
+                    throw std::runtime_error("invalid AREF repetition");
+                }
+                pending_multiplier = static_cast<std::uint64_t>(columns) * static_cast<std::uint64_t>(rows);
+            }
+            break;
+        case 0x11:  // ENDEL
+            if (element_kind == 0x08 || element_kind == 0x09) {
+                ++local_shape_count;
+                if (compute_hash) {
+                    local_shape_hash = fnv1a_u64(local_shape_hash, static_cast<std::uint64_t>(record_type));
+                    local_shape_hash = fnv1a_update(local_shape_hash, data.data() + element_start, offset - element_start);
+                }
+            } else if (element_kind == 0x0A || element_kind == 0x0B) {
+                if (pending_sname.empty()) {
+                    throw std::runtime_error("reference missing SNAME");
+                }
+                const std::uint64_t raw_hash = compute_hash
+                    ? fnv1a_update(1469598103934665603ull, data.data() + element_start, offset - element_start)
+                    : 0;
+                references.push_back(Reference{pending_sname, pending_multiplier, raw_hash});
+            }
+            element_kind = -1;
+            pending_sname.clear();
+            pending_multiplier = 1;
+            break;
+        case 0x07:  // ENDSTR
+            if (current_name.empty()) {
+                throw std::runtime_error("cell missing STRNAME");
+            }
+            result.cells[current_name] = Cell{local_shape_count, local_shape_hash, references};
+            current_name.clear();
+            local_shape_count = 0;
+            local_shape_hash = 1469598103934665603ull;
+            references.clear();
+            break;
+        default:
+            break;
+        }
+    }
+    if (offset != data.size()) {
+        throw std::runtime_error("trailing partial GDS record");
+    }
+    return result;
+}
+
+std::string select_top(const std::map<std::string, Cell>& cells, const char* requested_top) {
+    if (requested_top && requested_top[0]) {
+        if (!cells.count(requested_top)) {
+            throw std::runtime_error("requested top cell not found");
+        }
+        return requested_top;
+    }
+    std::set<std::string> referenced;
+    for (const auto& item : cells) {
+        for (const auto& reference : item.second.references) {
+            referenced.insert(reference.child);
+        }
+    }
+    std::vector<std::string> tops;
+    for (const auto& item : cells) {
+        if (!referenced.count(item.first)) {
+            tops.push_back(item.first);
+        }
+    }
+    if (tops.size() != 1) {
+        throw std::runtime_error("expected exactly one top cell");
+    }
+    return tops.front();
+}
+
+std::uint64_t flatten_count(
+    const std::string& name,
+    const std::map<std::string, Cell>& cells,
+    std::map<std::string, std::uint64_t>& memo,
+    std::set<std::string>& visiting,
+    std::set<std::string>& seen) {
+    if (memo.count(name)) {
+        seen.insert(name);
+        return memo.at(name);
+    }
+    if (visiting.count(name)) {
+        throw std::runtime_error("cell reference cycle detected");
+    }
+    const auto found = cells.find(name);
+    if (found == cells.end()) {
+        throw std::runtime_error("unresolved reference");
+    }
+    visiting.insert(name);
+    seen.insert(name);
+    std::uint64_t total = found->second.local_shape_count;
+    for (const auto& reference : found->second.references) {
+        const std::uint64_t child_count = flatten_count(reference.child, cells, memo, visiting, seen);
+        if (reference.multiplier != 0 && child_count > UINT64_MAX / reference.multiplier) {
+            throw std::overflow_error("flattened shape count overflow");
+        }
+        const std::uint64_t add = child_count * reference.multiplier;
+        if (total > UINT64_MAX - add) {
+            throw std::overflow_error("flattened shape count overflow");
+        }
+        total += add;
+    }
+    visiting.erase(name);
+    memo[name] = total;
+    return total;
+}
+
+std::uint64_t structural_hash(
+    const std::string& name,
+    const std::map<std::string, Cell>& cells,
+    std::map<std::string, std::uint64_t>& memo,
+    std::set<std::string>& visiting) {
+    if (memo.count(name)) {
+        return memo.at(name);
+    }
+    if (visiting.count(name)) {
+        throw std::runtime_error("cell reference cycle detected");
+    }
+    const auto found = cells.find(name);
+    if (found == cells.end()) {
+        throw std::runtime_error("unresolved reference");
+    }
+    visiting.insert(name);
+    std::uint64_t hash = 1469598103934665603ull;
+    hash = fnv1a_u64(hash, found->second.local_shape_count);
+    hash = fnv1a_u64(hash, found->second.local_shape_hash);
+    hash = fnv1a_u64(hash, found->second.references.size());
+    for (const auto& reference : found->second.references) {
+        hash = fnv1a_u64(hash, reference.multiplier);
+        hash = fnv1a_u64(hash, reference.raw_hash);
+        hash = fnv1a_update(hash, reinterpret_cast<const unsigned char*>(reference.child.data()), reference.child.size());
+        hash = fnv1a_u64(hash, structural_hash(reference.child, cells, memo, visiting));
+    }
+    visiting.erase(name);
+    memo[name] = hash;
+    return hash;
+}
+
+}  // namespace
+
+extern "C" {
+
+struct GdsStructuralResult {
+    std::uint64_t flattened_shape_count;
+    std::uint64_t cell_count;
+    std::uint64_t reachable_cell_count;
+    std::uint64_t structural_hash;
+};
+
+const char* gds_structural_last_error() {
+    return g_last_error.c_str();
+}
+
+int gds_structural_summary_impl(const char* path, const char* top_name, GdsStructuralResult* out, bool compute_hash) {
+    try {
+        if (!path || !out) {
+            throw std::runtime_error("invalid arguments");
+        }
+        const auto parsed = parse_gds(path, compute_hash);
+        if (parsed.cells.empty()) {
+            throw std::runtime_error("no cells found");
+        }
+        const std::string top = select_top(parsed.cells, top_name);
+        std::map<std::string, std::uint64_t> memo;
+        std::set<std::string> visiting;
+        std::set<std::string> seen;
+        const std::uint64_t count = flatten_count(top, parsed.cells, memo, visiting, seen);
+        std::uint64_t hash = 0;
+        if (compute_hash) {
+            std::map<std::string, std::uint64_t> hash_memo;
+            std::set<std::string> hash_visiting;
+            hash = structural_hash(top, parsed.cells, hash_memo, hash_visiting);
+        }
+        out->flattened_shape_count = count;
+        out->cell_count = parsed.cells.size();
+        out->reachable_cell_count = seen.size();
+        out->structural_hash = hash;
+        return 0;
+    } catch (const std::exception& exc) {
+        g_last_error = exc.what();
+        return 1;
+    }
+}
+
+int gds_structural_summary(const char* path, const char* top_name, GdsStructuralResult* out) {
+    return gds_structural_summary_impl(path, top_name, out, true);
+}
+
+int gds_structural_summary_counts_only(const char* path, const char* top_name, GdsStructuralResult* out) {
+    return gds_structural_summary_impl(path, top_name, out, false);
+}
+
+}  // extern "C"

gdsdiff/native_src/gdsdiff/CMakeLists.txt

@@ -0,0 +1,74 @@
+cmake_minimum_required(VERSION 3.24)
+project(gdsdiff_native LANGUAGES CXX)
+
+if(DEFINED GDS_GPU_COMPARE_BUILD_TESTS AND NOT DEFINED GDSDIFF_BUILD_TESTS)
+    set(GDSDIFF_BUILD_TESTS ${GDS_GPU_COMPARE_BUILD_TESTS})
+endif()
+if(DEFINED GDS_GPU_COMPARE_BUILD_PYTHON AND NOT DEFINED GDSDIFF_BUILD_PYTHON)
+    set(GDSDIFF_BUILD_PYTHON ${GDS_GPU_COMPARE_BUILD_PYTHON})
+endif()
+if(DEFINED GDS_GPU_COMPARE_ENABLE_CUDA AND NOT DEFINED GDSDIFF_ENABLE_CUDA)
+    set(GDSDIFF_ENABLE_CUDA ${GDS_GPU_COMPARE_ENABLE_CUDA})
+endif()
+if(DEFINED GDS_GPU_COMPARE_CUDA_ARCHITECTURES AND NOT DEFINED GDSDIFF_CUDA_ARCHITECTURES)
+    set(GDSDIFF_CUDA_ARCHITECTURES ${GDS_GPU_COMPARE_CUDA_ARCHITECTURES})
+endif()
+
+option(GDSDIFF_BUILD_TESTS "Build native tests" OFF)
+option(GDSDIFF_BUILD_PYTHON "Build optional Python extensions" OFF)
+option(GDSDIFF_ENABLE_CUDA "Build CUDA components" OFF)
+
+add_library(gds_compare_core STATIC core.cpp)
+target_compile_features(gds_compare_core PUBLIC cxx_std_20)
+target_include_directories(gds_compare_core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+if(GDSDIFF_BUILD_TESTS)
+    add_executable(gds_compare_core_test test_core.cpp)
+    target_link_libraries(gds_compare_core_test PRIVATE gds_compare_core)
+endif()
+
+if(GDSDIFF_BUILD_PYTHON)
+    find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+    find_package(pybind11 CONFIG REQUIRED)
+    pybind11_add_module(_gds_compare_core python_bindings.cpp)
+    target_link_libraries(_gds_compare_core PRIVATE gds_compare_core)
+    set_target_properties(_gds_compare_core PROPERTIES
+        CXX_VISIBILITY_PRESET hidden
+        VISIBILITY_INLINES_HIDDEN ON
+    )
+endif()
+
+if(GDSDIFF_ENABLE_CUDA)
+    enable_language(CUDA)
+    find_package(CUDAToolkit REQUIRED)
+    if(GDSDIFF_CUDA_ARCHITECTURES)
+        set(CMAKE_CUDA_ARCHITECTURES ${GDSDIFF_CUDA_ARCHITECTURES})
+    else()
+        set(CMAKE_CUDA_ARCHITECTURES native)
+    endif()
+    add_library(gds_compare_cuda_assignment STATIC cuda_assignment.cu)
+    target_link_libraries(gds_compare_cuda_assignment PRIVATE CUDA::cudart gds_compare_core)
+    target_include_directories(gds_compare_cuda_assignment PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    add_library(gds_compare_cuda_candidates STATIC cuda_candidates.cu)
+    target_link_libraries(gds_compare_cuda_candidates PRIVATE gds_compare_cuda_assignment CUDA::cudart gds_compare_core)
+    target_include_directories(gds_compare_cuda_candidates PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    add_library(gds_compare_cuda_memory STATIC cuda_memory.cu)
+    target_link_libraries(gds_compare_cuda_memory PRIVATE gds_compare_cuda_candidates CUDA::cudart gds_compare_core)
+    target_include_directories(gds_compare_cuda_memory PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    if(GDSDIFF_BUILD_TESTS)
+        add_executable(gds_compare_cuda_assignment_test test_cuda_assignment.cu)
+        target_link_libraries(gds_compare_cuda_assignment_test PRIVATE gds_compare_cuda_assignment CUDA::cudart)
+        add_executable(gds_compare_cuda_candidates_test test_cuda_candidates.cu)
+        target_link_libraries(gds_compare_cuda_candidates_test PRIVATE gds_compare_cuda_candidates CUDA::cudart)
+        add_executable(gds_compare_cuda_memory_test test_cuda_memory.cu)
+        target_link_libraries(gds_compare_cuda_memory_test PRIVATE gds_compare_cuda_memory CUDA::cudart)
+    endif()
+    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/cuda_bindings.cu)
+        find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+        find_package(pybind11 CONFIG REQUIRED)
+        pybind11_add_module(_gds_compare_cuda cuda_bindings.cu)
+        target_link_libraries(_gds_compare_cuda PRIVATE CUDA::cudart gds_compare_core gds_compare_cuda_assignment gds_compare_cuda_candidates gds_compare_cuda_memory)
+    else()
+        message(STATUS "CUDA assignment kernels enabled; Python CUDA binding source is not present yet")
+    endif()
+endif()

gdsdiff/native_src/gdsdiff/core.cpp

@@ -0,0 +1,191 @@
+#include "core.hpp"
+
+#include <algorithm>
+#include <array>
+#include <limits>
+#include <utility>
+
+namespace gdsdiff {
+namespace {
+
+void append_u32_be(std::string& out, std::uint32_t value) {
+    for (int shift = 24; shift >= 0; shift -= 8) {
+        out.push_back(static_cast<char>((value >> shift) & 0xff));
+    }
+}
+
+void append_i64_be(std::string& out, std::int64_t value) {
+    const auto encoded = static_cast<std::uint64_t>(value);
+    for (int shift = 56; shift >= 0; shift -= 8) {
+        out.push_back(static_cast<char>((encoded >> shift) & 0xff));
+    }
+}
+
+std::vector<Point> min_cyclic_rotation(const std::vector<Point>& points) {
+    if (points.empty()) {
+        return points;
+    }
+    std::vector<Point> best;
+    bool initialized = false;
+    for (std::size_t i = 0; i < points.size(); ++i) {
+        std::vector<Point> rotated;
+        rotated.reserve(points.size());
+        rotated.insert(rotated.end(), points.begin() + static_cast<std::ptrdiff_t>(i), points.end());
+        rotated.insert(rotated.end(), points.begin(), points.begin() + static_cast<std::ptrdiff_t>(i));
+        if (!initialized || rotated < best) {
+            best = std::move(rotated);
+            initialized = true;
+        }
+    }
+    return best;
+}
+
+std::vector<Point> canonical_valid_points(const std::vector<Point>& points) {
+    auto forward = min_cyclic_rotation(points);
+    auto reversed = points;
+    std::reverse(reversed.begin(), reversed.end());
+    auto reverse = min_cyclic_rotation(reversed);
+    return std::min(forward, reverse);
+}
+
+using PairKey = std::pair<TileKey, std::uint64_t>;
+
+void add_side(
+    std::map<PairKey, std::uint8_t>& pair_side_masks,
+    std::map<std::tuple<LayerSpec, std::uint64_t, BBox>, std::uint8_t>& oversized_side_masks,
+    const PolygonRecord& polygon,
+    std::uint64_t canonical_id,
+    std::uint8_t side,
+    const TileConfig& config,
+    std::uint64_t& assignment_count) {
+    const BBox tile_bbox = bbox_tile_range(polygon.bbox, config.tile_size);
+    const std::int64_t span_x = tile_bbox.x1 - tile_bbox.x0 + 1;
+    const std::int64_t span_y = tile_bbox.y1 - tile_bbox.y0 + 1;
+    if (span_x <= 0 || span_y <= 0) {
+        throw std::overflow_error("invalid tile span");
+    }
+    const auto span_x_u = static_cast<std::uint64_t>(span_x);
+    const auto span_y_u = static_cast<std::uint64_t>(span_y);
+    if (span_x_u > std::numeric_limits<std::uint64_t>::max() / span_y_u) {
+        throw std::overflow_error("tile span overflow");
+    }
+    const std::uint64_t count = span_x_u * span_y_u;
+    if (count > config.max_tiles_per_polygon) {
+        auto key = std::make_tuple(polygon.layer, canonical_id, tile_bbox);
+        oversized_side_masks[key] = static_cast<std::uint8_t>(oversized_side_masks[key] | side);
+        return;
+    }
+    for (std::int64_t tx = tile_bbox.x0; tx <= tile_bbox.x1; ++tx) {
+        for (std::int64_t ty = tile_bbox.y0; ty <= tile_bbox.y1; ++ty) {
+            PairKey key{TileKey{polygon.layer, tx, ty}, canonical_id};
+            pair_side_masks[key] = static_cast<std::uint8_t>(pair_side_masks[key] | side);
+            ++assignment_count;
+        }
+    }
+}
+
+}  // namespace
+
+std::int64_t floor_div(std::int64_t value, std::int64_t divisor) {
+    if (divisor <= 0) {
+        throw std::invalid_argument("divisor must be positive");
+    }
+    std::int64_t quotient = value / divisor;
+    const std::int64_t remainder = value % divisor;
+    if (remainder != 0 && ((remainder < 0) != (divisor < 0))) {
+        --quotient;
+    }
+    return quotient;
+}
+
+BBox bbox_tile_range(const BBox& bbox, std::int64_t tile_size) {
+    if (tile_size <= 0) {
+        throw std::invalid_argument("tile_size must be positive");
+    }
+    return BBox{
+        floor_div(bbox.x0, tile_size),
+        floor_div(bbox.y0, tile_size),
+        floor_div(bbox.x1, tile_size),
+        floor_div(bbox.y1, tile_size),
+    };
+}
+
+std::string canonical_blob(const std::vector<Point>& points, bool valid) {
+    const std::vector<Point> encoded_points = valid ? canonical_valid_points(points) : points;
+    const std::uint32_t validity = valid ? kValidityValid : kValidityConservativeRaw;
+    if (encoded_points.size() > std::numeric_limits<std::uint32_t>::max()) {
+        throw std::overflow_error("polygon point count exceeds encoding limit");
+    }
+    std::string out;
+    out.reserve(12 + encoded_points.size() * 16);
+    append_u32_be(out, kEncodingVersion);
+    append_u32_be(out, validity);
+    append_u32_be(out, static_cast<std::uint32_t>(encoded_points.size()));
+    for (const Point& point : encoded_points) {
+        append_i64_be(out, point.x);
+        append_i64_be(out, point.y);
+    }
+    return out;
+}
+
+std::vector<std::uint64_t> intern_canonical_blobs(const std::vector<std::string>& blobs) {
+    std::set<std::string> unique_set(blobs.begin(), blobs.end());
+    std::vector<std::string> unique(unique_set.begin(), unique_set.end());
+    std::map<std::string, std::uint64_t> id_by_blob;
+    for (std::size_t i = 0; i < unique.size(); ++i) {
+        id_by_blob.emplace(unique[i], static_cast<std::uint64_t>(i));
+    }
+    std::vector<std::uint64_t> ids;
+    ids.reserve(blobs.size());
+    for (const std::string& blob : blobs) {
+        ids.push_back(id_by_blob.at(blob));
+    }
+    return ids;
+}
+
+TilePrefilterResult run_tile_prefilter(
+    const std::vector<PolygonRecord>& old_polygons,
+    const std::vector<std::uint64_t>& old_canonical_ids,
+    const std::vector<PolygonRecord>& new_polygons,
+    const std::vector<std::uint64_t>& new_canonical_ids,
+    const TileConfig& config) {
+    if (config.tile_size <= 0 || config.max_tiles_per_polygon == 0) {
+        throw std::invalid_argument("invalid tile config");
+    }
+    if (old_polygons.size() != old_canonical_ids.size() || new_polygons.size() != new_canonical_ids.size()) {
+        throw std::invalid_argument("canonical id vector length must match polygon count");
+    }
+
+    std::map<PairKey, std::uint8_t> pair_side_masks;
+    std::map<std::tuple<LayerSpec, std::uint64_t, BBox>, std::uint8_t> oversized_side_masks;
+    TilePrefilterResult result;
+
+    for (std::size_t i = 0; i < old_polygons.size(); ++i) {
+        add_side(pair_side_masks, oversized_side_masks, old_polygons[i], old_canonical_ids[i], kOldSide, config, result.assignment_count);
+    }
+    for (std::size_t i = 0; i < new_polygons.size(); ++i) {
+        add_side(pair_side_masks, oversized_side_masks, new_polygons[i], new_canonical_ids[i], kNewSide, config, result.assignment_count);
+    }
+
+    for (const auto& [key, side_mask] : pair_side_masks) {
+        if (side_mask != kBothSides) {
+            result.candidate_tiles.push_back(key.first);
+        }
+    }
+    std::sort(result.candidate_tiles.begin(), result.candidate_tiles.end());
+    result.candidate_tiles.erase(std::unique(result.candidate_tiles.begin(), result.candidate_tiles.end()), result.candidate_tiles.end());
+    result.collapsed_pair_count = pair_side_masks.size();
+
+    for (const auto& [key, side_mask] : oversized_side_masks) {
+        if (side_mask == kBothSides) {
+            ++result.oversized_matched_count;
+        } else {
+            result.oversized_candidates.push_back(
+                OversizedPolygon{std::get<0>(key), std::get<1>(key), side_mask, std::get<2>(key)});
+        }
+    }
+    std::sort(result.oversized_candidates.begin(), result.oversized_candidates.end());
+    return result;
+}
+
+}  // namespace gdsdiff

gdsdiff/native_src/gdsdiff/core.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace gdsdiff {
+
+constexpr std::uint32_t kEncodingVersion = 1;
+constexpr std::uint32_t kValidityValid = 0;
+constexpr std::uint32_t kValidityConservativeRaw = 1;
+constexpr std::uint8_t kOldSide = 1;
+constexpr std::uint8_t kNewSide = 2;
+constexpr std::uint8_t kBothSides = kOldSide | kNewSide;
+
+struct Point {
+    std::int64_t x = 0;
+    std::int64_t y = 0;
+
+    friend bool operator==(const Point&, const Point&) = default;
+    friend auto operator<=>(const Point&, const Point&) = default;
+};
+
+struct LayerSpec {
+    std::int32_t layer = 0;
+    std::int32_t datatype = 0;
+
+    friend bool operator==(const LayerSpec&, const LayerSpec&) = default;
+    friend auto operator<=>(const LayerSpec&, const LayerSpec&) = default;
+};
+
+struct BBox {
+    std::int64_t x0 = 0;
+    std::int64_t y0 = 0;
+    std::int64_t x1 = 0;
+    std::int64_t y1 = 0;
+
+    friend bool operator==(const BBox&, const BBox&) = default;
+    friend auto operator<=>(const BBox&, const BBox&) = default;
+};
+
+struct PolygonRecord {
+    LayerSpec layer;
+    BBox bbox;
+    std::vector<Point> points;
+    bool valid = true;
+};
+
+struct TileConfig {
+    std::int64_t tile_size = 1024;
+    std::uint64_t max_tiles_per_polygon = 4096;
+};
+
+struct TileKey {
+    LayerSpec layer;
+    std::int64_t tx = 0;
+    std::int64_t ty = 0;
+
+    friend bool operator==(const TileKey&, const TileKey&) = default;
+    friend auto operator<=>(const TileKey&, const TileKey&) = default;
+};
+
+struct OversizedPolygon {
+    LayerSpec layer;
+    std::uint64_t canonical_id = 0;
+    std::uint8_t side_mask = 0;
+    BBox tile_bbox;
+
+    friend bool operator==(const OversizedPolygon&, const OversizedPolygon&) = default;
+    friend auto operator<=>(const OversizedPolygon&, const OversizedPolygon&) = default;
+};
+
+struct TilePrefilterResult {
+    std::vector<TileKey> candidate_tiles;
+    std::vector<OversizedPolygon> oversized_candidates;
+    std::uint64_t assignment_count = 0;
+    std::uint64_t collapsed_pair_count = 0;
+    std::uint64_t oversized_matched_count = 0;
+};
+
+std::int64_t floor_div(std::int64_t value, std::int64_t divisor);
+BBox bbox_tile_range(const BBox& bbox, std::int64_t tile_size);
+std::string canonical_blob(const std::vector<Point>& points, bool valid);
+std::vector<std::uint64_t> intern_canonical_blobs(const std::vector<std::string>& blobs);
+TilePrefilterResult run_tile_prefilter(
+    const std::vector<PolygonRecord>& old_polygons,
+    const std::vector<std::uint64_t>& old_canonical_ids,
+    const std::vector<PolygonRecord>& new_polygons,
+    const std::vector<std::uint64_t>& new_canonical_ids,
+    const TileConfig& config);
+
+}  // namespace gdsdiff