gdsdiff 0.1.0__py3-none-any.whl

gdsdiff/native_src/gdsdiff/cuda_assignment.cu

@@ -0,0 +1,304 @@
+#include "cuda_assignment.cuh"
+
+#include <cuda_runtime.h>
+
+#include <algorithm>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+
+namespace gdsdiff {
+namespace {
+
+struct DevicePolygon {
+    std::int64_t x0;
+    std::int64_t y0;
+    std::int64_t x1;
+    std::int64_t y1;
+    std::int32_t layer;
+    std::int32_t datatype;
+    std::uint64_t canonical_id;
+};
+
+struct DeviceTileAssignment {
+    std::int32_t layer;
+    std::int32_t datatype;
+    std::int64_t tx;
+    std::int64_t ty;
+    std::uint64_t canonical_id;
+    std::uint8_t side;
+};
+
+struct DeviceOversized {
+    std::int32_t layer;
+    std::int32_t datatype;
+    std::uint64_t canonical_id;
+    std::uint8_t side;
+    std::int64_t tx0;
+    std::int64_t ty0;
+    std::int64_t tx1;
+    std::int64_t ty1;
+};
+
+__device__ std::int64_t device_floor_div(std::int64_t value, std::int64_t divisor) {
+    std::int64_t quotient = value / divisor;
+    const std::int64_t remainder = value % divisor;
+    if (remainder != 0 && ((remainder < 0) != (divisor < 0))) {
+        --quotient;
+    }
+    return quotient;
+}
+
+__global__ void count_kernel(
+    const DevicePolygon* polygons,
+    std::uint64_t n,
+    std::int64_t tile_size,
+    std::uint64_t max_tiles_per_polygon,
+    std::uint64_t* counts,
+    std::uint8_t* oversized_flags,
+    DeviceOversized* oversized,
+    std::uint8_t side,
+    std::uint32_t* error_flags) {
+    const std::uint64_t index = blockIdx.x * blockDim.x + threadIdx.x;
+    if (index >= n) {
+        return;
+    }
+    const DevicePolygon polygon = polygons[index];
+    const std::int64_t tx0 = device_floor_div(polygon.x0, tile_size);
+    const std::int64_t ty0 = device_floor_div(polygon.y0, tile_size);
+    const std::int64_t tx1 = device_floor_div(polygon.x1, tile_size);
+    const std::int64_t ty1 = device_floor_div(polygon.y1, tile_size);
+    const std::int64_t span_x = tx1 - tx0 + 1;
+    const std::int64_t span_y = ty1 - ty0 + 1;
+    if (span_x <= 0 || span_y <= 0) {
+        error_flags[index] = 1;
+        counts[index] = 0;
+        oversized_flags[index] = 0;
+        return;
+    }
+    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_y_u != 0 && span_x_u > UINT64_MAX / span_y_u) {
+        error_flags[index] = 2;
+        counts[index] = 0;
+        oversized_flags[index] = 0;
+        return;
+    }
+    const std::uint64_t count = span_x_u * span_y_u;
+    if (count > max_tiles_per_polygon) {
+        counts[index] = 0;
+        oversized_flags[index] = 1;
+        oversized[index] = DeviceOversized{
+            polygon.layer,
+            polygon.datatype,
+            polygon.canonical_id,
+            side,
+            tx0,
+            ty0,
+            tx1,
+            ty1,
+        };
+    } else {
+        counts[index] = count;
+        oversized_flags[index] = 0;
+    }
+}
+
+__global__ void emit_kernel(
+    const DevicePolygon* polygons,
+    std::uint64_t n,
+    std::int64_t tile_size,
+    const std::uint64_t* offsets,
+    const std::uint8_t* oversized_flags,
+    DeviceTileAssignment* assignments,
+    std::uint8_t side) {
+    const std::uint64_t index = blockIdx.x * blockDim.x + threadIdx.x;
+    if (index >= n || oversized_flags[index]) {
+        return;
+    }
+    const DevicePolygon polygon = polygons[index];
+    const std::int64_t tx0 = device_floor_div(polygon.x0, tile_size);
+    const std::int64_t ty0 = device_floor_div(polygon.y0, tile_size);
+    const std::int64_t tx1 = device_floor_div(polygon.x1, tile_size);
+    const std::int64_t ty1 = device_floor_div(polygon.y1, tile_size);
+    std::uint64_t out = offsets[index];
+    for (std::int64_t tx = tx0; tx <= tx1; ++tx) {
+        for (std::int64_t ty = ty0; ty <= ty1; ++ty) {
+            assignments[out++] = DeviceTileAssignment{
+                polygon.layer,
+                polygon.datatype,
+                tx,
+                ty,
+                polygon.canonical_id,
+                side,
+            };
+        }
+    }
+}
+
+void check_cuda(cudaError_t status, const char* action) {
+    if (status != cudaSuccess) {
+        throw std::runtime_error(std::string(action) + ": " + cudaGetErrorString(status));
+    }
+}
+
+template <class T>
+class DeviceBuffer {
+public:
+    explicit DeviceBuffer(std::size_t count) : count_(count) {
+        if (count_) {
+            check_cuda(cudaMalloc(&ptr_, sizeof(T) * count_), "cudaMalloc");
+        }
+    }
+
+    ~DeviceBuffer() {
+        if (ptr_) {
+            (void)cudaFree(ptr_);
+        }
+    }
+
+    DeviceBuffer(const DeviceBuffer&) = delete;
+    DeviceBuffer& operator=(const DeviceBuffer&) = delete;
+
+    T* get() { return ptr_; }
+    const T* get() const { return ptr_; }
+
+private:
+    T* ptr_ = nullptr;
+    std::size_t count_ = 0;
+};
+
+std::vector<DevicePolygon> pack_polygons(const std::vector<PolygonRecord>& polygons, const std::vector<std::uint64_t>& ids) {
+    std::vector<DevicePolygon> out;
+    out.reserve(polygons.size());
+    for (std::size_t i = 0; i < polygons.size(); ++i) {
+        out.push_back(DevicePolygon{
+            polygons[i].bbox.x0,
+            polygons[i].bbox.y0,
+            polygons[i].bbox.x1,
+            polygons[i].bbox.y1,
+            polygons[i].layer.layer,
+            polygons[i].layer.datatype,
+            ids[i],
+        });
+    }
+    return out;
+}
+
+}  // namespace
+
+CudaAssignmentResult run_cuda_assignment(
+    const std::vector<PolygonRecord>& polygons,
+    const std::vector<std::uint64_t>& canonical_ids,
+    std::uint8_t side,
+    const TileConfig& config) {
+    if (config.tile_size <= 0 || config.max_tiles_per_polygon == 0) {
+        throw std::invalid_argument("invalid tile config");
+    }
+    if (polygons.size() != canonical_ids.size()) {
+        throw std::invalid_argument("canonical id vector length must match polygon count");
+    }
+    if (polygons.empty()) {
+        return {};
+    }
+
+    const std::uint64_t n = polygons.size();
+    const auto packed = pack_polygons(polygons, canonical_ids);
+    DeviceBuffer<DevicePolygon> d_polygons(n);
+    DeviceBuffer<std::uint64_t> d_counts(n);
+    DeviceBuffer<std::uint8_t> d_oversized_flags(n);
+    DeviceBuffer<DeviceOversized> d_oversized(n);
+    DeviceBuffer<std::uint32_t> d_errors(n);
+    check_cuda(cudaMemcpy(d_polygons.get(), packed.data(), sizeof(DevicePolygon) * packed.size(), cudaMemcpyHostToDevice), "copy polygons");
+    check_cuda(cudaMemset(d_errors.get(), 0, sizeof(std::uint32_t) * n), "clear errors");
+
+    const int threads = 256;
+    const int blocks = static_cast<int>((n + threads - 1) / threads);
+    count_kernel<<<blocks, threads>>>(
+        d_polygons.get(),
+        n,
+        config.tile_size,
+        config.max_tiles_per_polygon,
+        d_counts.get(),
+        d_oversized_flags.get(),
+        d_oversized.get(),
+        side,
+        d_errors.get());
+    check_cuda(cudaGetLastError(), "launch count kernel");
+    check_cuda(cudaDeviceSynchronize(), "run count kernel");
+
+    std::vector<std::uint32_t> errors(n);
+    check_cuda(cudaMemcpy(errors.data(), d_errors.get(), sizeof(std::uint32_t) * n, cudaMemcpyDeviceToHost), "copy errors");
+    for (std::uint32_t error : errors) {
+        if (error) {
+            throw std::overflow_error("CUDA assignment count overflow or invalid span");
+        }
+    }
+
+    std::vector<std::uint64_t> counts(n);
+    std::vector<std::uint8_t> oversized_flags(n);
+    std::vector<DeviceOversized> oversized_raw(n);
+    check_cuda(cudaMemcpy(counts.data(), d_counts.get(), sizeof(std::uint64_t) * n, cudaMemcpyDeviceToHost), "copy counts");
+    check_cuda(cudaMemcpy(oversized_flags.data(), d_oversized_flags.get(), sizeof(std::uint8_t) * n, cudaMemcpyDeviceToHost), "copy oversized flags");
+    check_cuda(cudaMemcpy(oversized_raw.data(), d_oversized.get(), sizeof(DeviceOversized) * n, cudaMemcpyDeviceToHost), "copy oversized");
+
+    std::vector<std::uint64_t> offsets(n);
+    std::uint64_t total = 0;
+    for (std::size_t i = 0; i < counts.size(); ++i) {
+        offsets[i] = total;
+        if (counts[i] > UINT64_MAX - total) {
+            throw std::overflow_error("total assignment count overflow");
+        }
+        total += counts[i];
+    }
+
+    CudaAssignmentResult result;
+    result.total_assignment_count = total;
+    for (std::size_t i = 0; i < oversized_flags.size(); ++i) {
+        if (oversized_flags[i]) {
+            const auto item = oversized_raw[i];
+            result.oversized.push_back(
+                OversizedPolygon{
+                    LayerSpec{item.layer, item.datatype},
+                    item.canonical_id,
+                    item.side,
+                    BBox{item.tx0, item.ty0, item.tx1, item.ty1},
+                });
+        }
+    }
+
+    if (total == 0) {
+        return result;
+    }
+
+    DeviceBuffer<std::uint64_t> d_offsets(n);
+    DeviceBuffer<DeviceTileAssignment> d_assignments(total);
+    check_cuda(cudaMemcpy(d_offsets.get(), offsets.data(), sizeof(std::uint64_t) * n, cudaMemcpyHostToDevice), "copy offsets");
+    emit_kernel<<<blocks, threads>>>(
+        d_polygons.get(),
+        n,
+        config.tile_size,
+        d_offsets.get(),
+        d_oversized_flags.get(),
+        d_assignments.get(),
+        side);
+    check_cuda(cudaGetLastError(), "launch emit kernel");
+    check_cuda(cudaDeviceSynchronize(), "run emit kernel");
+
+    std::vector<DeviceTileAssignment> raw_assignments(total);
+    check_cuda(cudaMemcpy(raw_assignments.data(), d_assignments.get(), sizeof(DeviceTileAssignment) * total, cudaMemcpyDeviceToHost), "copy assignments");
+    result.assignments.reserve(raw_assignments.size());
+    for (const auto item : raw_assignments) {
+        result.assignments.push_back(
+            TileAssignment{
+                LayerSpec{item.layer, item.datatype},
+                item.tx,
+                item.ty,
+                item.canonical_id,
+                item.side,
+            });
+    }
+    return result;
+}
+
+}  // namespace gdsdiff

gdsdiff/native_src/gdsdiff/cuda_assignment.cuh

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "core.hpp"
+
+#include <cstdint>
+#include <vector>
+
+namespace gdsdiff {
+
+struct TileAssignment {
+    LayerSpec layer;
+    std::int64_t tx = 0;
+    std::int64_t ty = 0;
+    std::uint64_t canonical_id = 0;
+    std::uint8_t side = 0;
+
+    friend bool operator==(const TileAssignment&, const TileAssignment&) = default;
+    friend auto operator<=>(const TileAssignment&, const TileAssignment&) = default;
+};
+
+struct CudaAssignmentResult {
+    std::vector<TileAssignment> assignments;
+    std::vector<OversizedPolygon> oversized;
+    std::uint64_t total_assignment_count = 0;
+};
+
+CudaAssignmentResult run_cuda_assignment(
+    const std::vector<PolygonRecord>& polygons,
+    const std::vector<std::uint64_t>& canonical_ids,
+    std::uint8_t side,
+    const TileConfig& config);
+
+}  // namespace gdsdiff

gdsdiff/native_src/gdsdiff/cuda_candidates.cu

@@ -0,0 +1,133 @@
+#include "cuda_candidates.cuh"
+
+#include "cuda_assignment.cuh"
+
+#include <thrust/device_vector.h>
+#include <thrust/equal.h>
+#include <thrust/host_vector.h>
+#include <thrust/reduce.h>
+#include <thrust/sort.h>
+#include <thrust/tuple.h>
+#include <thrust/unique.h>
+
+#include <algorithm>
+#include <map>
+#include <set>
+#include <stdexcept>
+
+namespace gdsdiff {
+namespace {
+
+struct AssignmentKey {
+    std::int32_t layer;
+    std::int32_t datatype;
+    std::int64_t tx;
+    std::int64_t ty;
+    std::uint64_t canonical_id;
+
+    __host__ __device__ bool operator<(const AssignmentKey& other) const {
+        return thrust::make_tuple(layer, datatype, tx, ty, canonical_id)
+            < thrust::make_tuple(other.layer, other.datatype, other.tx, other.ty, other.canonical_id);
+    }
+
+    __host__ __device__ bool operator==(const AssignmentKey& other) const {
+        return layer == other.layer && datatype == other.datatype && tx == other.tx && ty == other.ty
+            && canonical_id == other.canonical_id;
+    }
+};
+
+struct AssignmentKeyEqual {
+    __host__ __device__ bool operator()(const AssignmentKey& left, const AssignmentKey& right) const {
+        return left == right;
+    }
+};
+
+struct SideOr {
+    __host__ __device__ std::uint8_t operator()(std::uint8_t left, std::uint8_t right) const {
+        return static_cast<std::uint8_t>(left | right);
+    }
+};
+
+void merge_oversized(
+    std::map<std::tuple<LayerSpec, std::uint64_t, BBox>, std::uint8_t>& out,
+    const std::vector<OversizedPolygon>& items) {
+    for (const auto& item : items) {
+        auto key = std::make_tuple(item.layer, item.canonical_id, item.tile_bbox);
+        out[key] = static_cast<std::uint8_t>(out[key] | item.side_mask);
+    }
+}
+
+}  // namespace
+
+TilePrefilterResult run_cuda_candidate_compaction(
+    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) {
+    const auto old_assignments = run_cuda_assignment(old_polygons, old_canonical_ids, kOldSide, config);
+    const auto new_assignments = run_cuda_assignment(new_polygons, new_canonical_ids, kNewSide, config);
+
+    std::vector<AssignmentKey> host_keys;
+    std::vector<std::uint8_t> host_sides;
+    host_keys.reserve(old_assignments.assignments.size() + new_assignments.assignments.size());
+    host_sides.reserve(host_keys.capacity());
+    for (const auto& item : old_assignments.assignments) {
+        host_keys.push_back(AssignmentKey{item.layer.layer, item.layer.datatype, item.tx, item.ty, item.canonical_id});
+        host_sides.push_back(item.side);
+    }
+    for (const auto& item : new_assignments.assignments) {
+        host_keys.push_back(AssignmentKey{item.layer.layer, item.layer.datatype, item.tx, item.ty, item.canonical_id});
+        host_sides.push_back(item.side);
+    }
+
+    TilePrefilterResult result;
+    result.assignment_count = host_keys.size();
+
+    if (!host_keys.empty()) {
+        thrust::device_vector<AssignmentKey> keys = host_keys;
+        thrust::device_vector<std::uint8_t> sides = host_sides;
+        thrust::sort_by_key(keys.begin(), keys.end(), sides.begin());
+
+        thrust::device_vector<AssignmentKey> reduced_keys(keys.size());
+        thrust::device_vector<std::uint8_t> reduced_sides(sides.size());
+        auto ends = thrust::reduce_by_key(
+            keys.begin(),
+            keys.end(),
+            sides.begin(),
+            reduced_keys.begin(),
+            reduced_sides.begin(),
+            AssignmentKeyEqual{},
+            SideOr{});
+        const auto reduced_count = static_cast<std::size_t>(ends.first - reduced_keys.begin());
+        result.collapsed_pair_count = reduced_count;
+        reduced_keys.resize(reduced_count);
+        reduced_sides.resize(reduced_count);
+
+        thrust::host_vector<AssignmentKey> final_keys = reduced_keys;
+        thrust::host_vector<std::uint8_t> final_sides = reduced_sides;
+        std::set<TileKey> candidate_tiles;
+        for (std::size_t i = 0; i < reduced_count; ++i) {
+            if (final_sides[i] != kBothSides) {
+                candidate_tiles.insert(TileKey{LayerSpec{final_keys[i].layer, final_keys[i].datatype}, final_keys[i].tx, final_keys[i].ty});
+            }
+        }
+        result.candidate_tiles.assign(candidate_tiles.begin(), candidate_tiles.end());
+    }
+
+    std::map<std::tuple<LayerSpec, std::uint64_t, BBox>, std::uint8_t> oversized_side_masks;
+    merge_oversized(oversized_side_masks, old_assignments.oversized);
+    merge_oversized(oversized_side_masks, new_assignments.oversized);
+    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/cuda_candidates.cuh

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "core.hpp"
+
+#include <cstdint>
+#include <vector>
+
+namespace gdsdiff {
+
+TilePrefilterResult run_cuda_candidate_compaction(
+    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