gdsdiff 0.1.0__py3-none-any.whl

gdsdiff/native_src/gdsdiff/python_bindings.cpp

@@ -0,0 +1,21 @@
+#include "core.hpp"
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_gds_compare_core, m) {
+    m.doc() = "Optional native core helpers for gdsdiff";
+    m.def("floor_div", &gdsdiff::floor_div, py::arg("value"), py::arg("divisor"));
+    m.def(
+        "bbox_tile_range",
+        [](std::int64_t x0, std::int64_t y0, std::int64_t x1, std::int64_t y1, std::int64_t tile_size) {
+            const auto bbox = gdsdiff::bbox_tile_range(gdsdiff::BBox{x0, y0, x1, y1}, tile_size);
+            return py::make_tuple(bbox.x0, bbox.y0, bbox.x1, bbox.y1);
+        },
+        py::arg("x0"),
+        py::arg("y0"),
+        py::arg("x1"),
+        py::arg("y1"),
+        py::arg("tile_size"));
+}

gdsdiff/native_src/gdsdiff/test_core.cpp

@@ -0,0 +1,93 @@
+#include "core.hpp"
+
+#include <cassert>
+#include <iostream>
+
+using namespace gdsdiff;
+
+namespace {
+
+PolygonRecord rect(std::int64_t x0, std::int64_t y0, std::int64_t x1, std::int64_t y1, LayerSpec layer = {1, 0}) {
+    return PolygonRecord{
+        layer,
+        BBox{x0, y0, x1, y1},
+        std::vector<Point>{{x0, y0}, {x1, y0}, {x1, y1}, {x0, y1}},
+        true,
+    };
+}
+
+}  // namespace
+
+int main() {
+    assert(floor_div(-1, 10) == -1);
+    assert(floor_div(-10, 10) == -1);
+    assert(floor_div(-11, 10) == -2);
+    assert((bbox_tile_range(BBox{-11, -1, 10, 20}, 10) == BBox{-2, -1, 1, 2}));
+
+    const auto a = rect(0, 0, 10, 10);
+    const PolygonRecord a_rotated{
+        a.layer,
+        a.bbox,
+        std::vector<Point>{{10, 10}, {0, 10}, {0, 0}, {10, 0}},
+        true,
+    };
+    assert(canonical_blob(a.points, true) == canonical_blob(a_rotated.points, true));
+    assert(canonical_blob(a.points, false) != canonical_blob(a_rotated.points, false));
+
+    const std::vector<std::string> blobs{
+        canonical_blob(a.points, true),
+        canonical_blob(a_rotated.points, true),
+        canonical_blob(rect(20, 0, 30, 10).points, true),
+    };
+    const auto ids = intern_canonical_blobs(blobs);
+    assert(ids.size() == 3);
+    assert(ids[0] == ids[1]);
+    assert(ids[0] != ids[2]);
+
+    const auto identical = run_tile_prefilter(
+        std::vector<PolygonRecord>{rect(0, 0, 9, 9)},
+        std::vector<std::uint64_t>{7},
+        std::vector<PolygonRecord>{rect(0, 0, 9, 9)},
+        std::vector<std::uint64_t>{7},
+        TileConfig{10, 4096});
+    assert(identical.candidate_tiles.empty());
+    assert(identical.assignment_count == 2);
+    assert(identical.collapsed_pair_count == 1);
+
+    const auto changed = run_tile_prefilter(
+        std::vector<PolygonRecord>{rect(0, 0, 9, 9)},
+        std::vector<std::uint64_t>{1},
+        std::vector<PolygonRecord>{rect(20, 0, 29, 9)},
+        std::vector<std::uint64_t>{2},
+        TileConfig{10, 4096});
+    assert(changed.candidate_tiles.size() == 2);
+    assert((changed.candidate_tiles[0] == TileKey{{1, 0}, 0, 0}));
+    assert((changed.candidate_tiles[1] == TileKey{{1, 0}, 2, 0}));
+
+    const auto oversized = run_tile_prefilter(
+        std::vector<PolygonRecord>{rect(0, 0, 100, 100)},
+        std::vector<std::uint64_t>{9},
+        std::vector<PolygonRecord>{},
+        std::vector<std::uint64_t>{},
+        TileConfig{10, 4});
+    assert(oversized.candidate_tiles.empty());
+    assert(oversized.oversized_candidates.size() == 1);
+    assert(oversized.oversized_candidates[0].side_mask == kOldSide);
+    assert((oversized.oversized_candidates[0].tile_bbox == BBox{0, 0, 10, 10}));
+
+    bool length_error = false;
+    try {
+        (void)run_tile_prefilter(
+            std::vector<PolygonRecord>{rect(0, 0, 1, 1)},
+            std::vector<std::uint64_t>{},
+            std::vector<PolygonRecord>{},
+            std::vector<std::uint64_t>{},
+            TileConfig{10, 4096});
+    } catch (const std::invalid_argument&) {
+        length_error = true;
+    }
+    assert(length_error);
+
+    std::cout << "cpp core tests passed\n";
+    return 0;
+}

gdsdiff/native_src/gdsdiff/test_cuda_assignment.cu

@@ -0,0 +1,109 @@
+#include "cuda_assignment.cuh"
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <stdexcept>
+
+using namespace gdsdiff;
+
+namespace {
+
+PolygonRecord rect(std::int64_t x0, std::int64_t y0, std::int64_t x1, std::int64_t y1, LayerSpec layer = {1, 0}) {
+    return PolygonRecord{
+        layer,
+        BBox{x0, y0, x1, y1},
+        std::vector<Point>{{x0, y0}, {x1, y0}, {x1, y1}, {x0, y1}},
+        true,
+    };
+}
+
+std::vector<TileAssignment> cpu_assignments(
+    const std::vector<PolygonRecord>& polygons,
+    const std::vector<std::uint64_t>& ids,
+    std::uint8_t side,
+    const TileConfig& config,
+    std::vector<OversizedPolygon>* oversized) {
+    std::vector<TileAssignment> assignments;
+    for (std::size_t i = 0; i < polygons.size(); ++i) {
+        const auto range = bbox_tile_range(polygons[i].bbox, config.tile_size);
+        const std::uint64_t span_x = static_cast<std::uint64_t>(range.x1 - range.x0 + 1);
+        const std::uint64_t span_y = static_cast<std::uint64_t>(range.y1 - range.y0 + 1);
+        const std::uint64_t count = span_x * span_y;
+        if (count > config.max_tiles_per_polygon) {
+            oversized->push_back(OversizedPolygon{polygons[i].layer, ids[i], side, range});
+            continue;
+        }
+        for (std::int64_t tx = range.x0; tx <= range.x1; ++tx) {
+            for (std::int64_t ty = range.y0; ty <= range.y1; ++ty) {
+                assignments.push_back(TileAssignment{polygons[i].layer, tx, ty, ids[i], side});
+            }
+        }
+    }
+    return assignments;
+}
+
+void assert_matches_cpu(
+    const std::vector<PolygonRecord>& polygons,
+    const std::vector<std::uint64_t>& ids,
+    std::uint8_t side,
+    const TileConfig& config) {
+    std::vector<OversizedPolygon> expected_oversized;
+    auto expected = cpu_assignments(polygons, ids, side, config, &expected_oversized);
+    auto actual = run_cuda_assignment(polygons, ids, side, config);
+    std::sort(expected.begin(), expected.end());
+    std::sort(actual.assignments.begin(), actual.assignments.end());
+    std::sort(expected_oversized.begin(), expected_oversized.end());
+    std::sort(actual.oversized.begin(), actual.oversized.end());
+    assert(actual.assignments == expected);
+    assert(actual.oversized == expected_oversized);
+    assert(actual.total_assignment_count == expected.size());
+}
+
+}  // namespace
+
+int main() {
+    assert_matches_cpu({}, {}, kOldSide, TileConfig{10, 4096});
+    assert_matches_cpu(
+        std::vector<PolygonRecord>{rect(-11, -11, -1, -1)},
+        std::vector<std::uint64_t>{1},
+        kOldSide,
+        TileConfig{10, 4096});
+    assert_matches_cpu(
+        std::vector<PolygonRecord>{rect(0, 0, 10, 10)},
+        std::vector<std::uint64_t>{2},
+        kNewSide,
+        TileConfig{10, 4096});
+    assert_matches_cpu(
+        std::vector<PolygonRecord>{rect(0, 0, 100, 100)},
+        std::vector<std::uint64_t>{3},
+        kOldSide,
+        TileConfig{10, 4});
+
+    std::vector<PolygonRecord> many;
+    std::vector<std::uint64_t> ids;
+    for (int i = 0; i < 777; ++i) {
+        many.push_back(rect(i * 3, -i, i * 3 + 11, -i + 7, LayerSpec{i % 4, i % 2}));
+        ids.push_back(static_cast<std::uint64_t>(i % 9));
+    }
+    assert_matches_cpu(many, ids, kNewSide, TileConfig{10, 4096});
+
+    bool length_error = false;
+    try {
+        (void)run_cuda_assignment(std::vector<PolygonRecord>{rect(0, 0, 1, 1)}, {}, kOldSide, TileConfig{10, 4096});
+    } catch (const std::invalid_argument&) {
+        length_error = true;
+    }
+    assert(length_error);
+
+    bool config_error = false;
+    try {
+        (void)run_cuda_assignment(std::vector<PolygonRecord>{rect(0, 0, 1, 1)}, {1}, kOldSide, TileConfig{0, 4096});
+    } catch (const std::invalid_argument&) {
+        config_error = true;
+    }
+    assert(config_error);
+
+    std::cout << "cuda assignment tests passed\n";
+    return 0;
+}

gdsdiff/native_src/gdsdiff/test_cuda_candidates.cu

@@ -0,0 +1,94 @@
+#include "cuda_candidates.cuh"
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+
+using namespace gdsdiff;
+
+namespace {
+
+PolygonRecord rect(std::int64_t x0, std::int64_t y0, std::int64_t x1, std::int64_t y1, LayerSpec layer = {1, 0}) {
+    return PolygonRecord{
+        layer,
+        BBox{x0, y0, x1, y1},
+        std::vector<Point>{{x0, y0}, {x1, y0}, {x1, y1}, {x0, y1}},
+        true,
+    };
+}
+
+void assert_same_result(
+    const std::vector<PolygonRecord>& old_polygons,
+    const std::vector<std::uint64_t>& old_ids,
+    const std::vector<PolygonRecord>& new_polygons,
+    const std::vector<std::uint64_t>& new_ids,
+    const TileConfig& config) {
+    auto cpu = run_tile_prefilter(old_polygons, old_ids, new_polygons, new_ids, config);
+    auto cuda = run_cuda_candidate_compaction(old_polygons, old_ids, new_polygons, new_ids, config);
+    std::sort(cpu.candidate_tiles.begin(), cpu.candidate_tiles.end());
+    std::sort(cuda.candidate_tiles.begin(), cuda.candidate_tiles.end());
+    std::sort(cpu.oversized_candidates.begin(), cpu.oversized_candidates.end());
+    std::sort(cuda.oversized_candidates.begin(), cuda.oversized_candidates.end());
+    assert(cuda.candidate_tiles == cpu.candidate_tiles);
+    assert(cuda.oversized_candidates == cpu.oversized_candidates);
+    assert(cuda.assignment_count == cpu.assignment_count);
+    assert(cuda.collapsed_pair_count == cpu.collapsed_pair_count);
+    assert(cuda.oversized_matched_count == cpu.oversized_matched_count);
+}
+
+}  // namespace
+
+int main() {
+    assert_same_result({}, {}, {}, {}, TileConfig{10, 4096});
+    assert_same_result(
+        {rect(0, 0, 9, 9)},
+        {1},
+        {rect(0, 0, 9, 9)},
+        {1},
+        TileConfig{10, 4096});
+    assert_same_result(
+        {rect(0, 0, 9, 9)},
+        {1},
+        {rect(20, 0, 29, 9)},
+        {2},
+        TileConfig{10, 4096});
+    assert_same_result(
+        {rect(0, 0, 9, 9), rect(0, 0, 9, 9)},
+        {5, 5},
+        {rect(0, 0, 9, 9)},
+        {5},
+        TileConfig{10, 4096});
+    assert_same_result(
+        {rect(-11, -11, -1, -1)},
+        {1},
+        {},
+        {},
+        TileConfig{10, 4096});
+    assert_same_result(
+        {rect(0, 0, 100, 100)},
+        {9},
+        {},
+        {},
+        TileConfig{10, 4});
+    assert_same_result(
+        {rect(0, 0, 100, 100)},
+        {9},
+        {rect(0, 0, 100, 100)},
+        {9},
+        TileConfig{10, 4});
+
+    std::vector<PolygonRecord> old_polygons;
+    std::vector<PolygonRecord> new_polygons;
+    std::vector<std::uint64_t> old_ids;
+    std::vector<std::uint64_t> new_ids;
+    for (int i = 0; i < 513; ++i) {
+        old_polygons.push_back(rect(i * 7 - 90, i % 17 - 40, i * 7 - 82, i % 17 - 31, LayerSpec{i % 5, i % 3}));
+        old_ids.push_back(static_cast<std::uint64_t>(i % 23));
+        new_polygons.push_back(rect(i * 7 - 88, i % 17 - 40, i * 7 - 80, i % 17 - 31, LayerSpec{i % 5, i % 3}));
+        new_ids.push_back(static_cast<std::uint64_t>((i + 1) % 23));
+    }
+    assert_same_result(old_polygons, old_ids, new_polygons, new_ids, TileConfig{16, 4096});
+
+    std::cout << "cuda candidate tests passed\n";
+    return 0;
+}

gdsdiff/native_src/gdsdiff/test_cuda_memory.cu

@@ -0,0 +1,97 @@
+#include "cuda_memory.cuh"
+#include "cuda_candidates.cuh"
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+
+using namespace gdsdiff;
+
+namespace {
+
+PolygonRecord rect(std::int64_t x0, std::int64_t y0, std::int64_t x1, std::int64_t y1, LayerSpec layer = {1, 0}) {
+    return PolygonRecord{
+        layer,
+        BBox{x0, y0, x1, y1},
+        std::vector<Point>{{x0, y0}, {x1, y0}, {x1, y1}, {x0, y1}},
+        true,
+    };
+}
+
+void sort_result(TilePrefilterResult& result) {
+    std::sort(result.candidate_tiles.begin(), result.candidate_tiles.end());
+    std::sort(result.oversized_candidates.begin(), result.oversized_candidates.end());
+}
+
+void assert_chunked_matches(
+    const std::vector<PolygonRecord>& old_polygons,
+    const std::vector<std::uint64_t>& old_ids,
+    const std::vector<PolygonRecord>& new_polygons,
+    const std::vector<std::uint64_t>& new_ids,
+    const TileConfig& config,
+    const CudaMemoryBudget& budget,
+    bool expect_chunking) {
+    auto cpu = run_tile_prefilter(old_polygons, old_ids, new_polygons, new_ids, config);
+    auto whole_cuda = run_cuda_candidate_compaction(old_polygons, old_ids, new_polygons, new_ids, config);
+    auto chunked = run_cuda_candidate_compaction_chunked(old_polygons, old_ids, new_polygons, new_ids, config, budget);
+    sort_result(cpu);
+    sort_result(whole_cuda);
+    sort_result(chunked.prefilter);
+    assert(chunked.prefilter.candidate_tiles == cpu.candidate_tiles);
+    assert(chunked.prefilter.candidate_tiles == whole_cuda.candidate_tiles);
+    assert(chunked.prefilter.oversized_candidates == cpu.oversized_candidates);
+    assert(chunked.prefilter.oversized_candidates == whole_cuda.oversized_candidates);
+    assert(chunked.stats.chunk_count >= 1);
+    assert(chunked.stats.used_chunking == expect_chunking);
+}
+
+}  // namespace
+
+int main() {
+    assert_chunked_matches({}, {}, {}, {}, TileConfig{10, 4096}, CudaMemoryBudget{64, 64}, false);
+    assert_chunked_matches(
+        {rect(0, 0, 9, 45), rect(20, 0, 29, 9, LayerSpec{2, 0})},
+        {1, 2},
+        {rect(0, 10, 9, 55), rect(25, 0, 34, 9, LayerSpec{2, 0})},
+        {3, 4},
+        TileConfig{10, 4096},
+        CudaMemoryBudget{128, 64},
+        true);
+    assert_chunked_matches(
+        {rect(0, 0, 100, 100)},
+        {9},
+        {},
+        {},
+        TileConfig{10, 4},
+        CudaMemoryBudget{64, 64},
+        false);
+
+    std::vector<PolygonRecord> old_polygons;
+    std::vector<PolygonRecord> new_polygons;
+    std::vector<std::uint64_t> old_ids;
+    std::vector<std::uint64_t> new_ids;
+    for (int i = 0; i < 160; ++i) {
+        old_polygons.push_back(rect(i - 80, i * 5 - 300, i - 71, i * 5 - 276, LayerSpec{i % 3, i % 2}));
+        old_ids.push_back(static_cast<std::uint64_t>(i % 11));
+        new_polygons.push_back(rect(i - 78, i * 5 - 298, i - 69, i * 5 - 274, LayerSpec{i % 3, i % 2}));
+        new_ids.push_back(static_cast<std::uint64_t>((i + 3) % 11));
+    }
+    assert_chunked_matches(old_polygons, old_ids, new_polygons, new_ids, TileConfig{8, 4096}, CudaMemoryBudget{512, 64}, true);
+
+    bool config_error = false;
+    try {
+        (void)run_cuda_candidate_compaction_chunked(
+            {rect(0, 0, 1, 1)},
+            {1},
+            {},
+            {},
+            TileConfig{10, 4096},
+            CudaMemoryBudget{0, 64});
+    } catch (const std::invalid_argument&) {
+        config_error = true;
+    }
+    assert(config_error);
+
+    std::cout << "cuda memory tests passed\n";
+    return 0;
+}