Merge pull request #10123 from gadfort/check-overlaps

pad: check overlap layers on placement checks

Author: maliberty

src/mpl/test/fixed_covers.ok

@@ -1,5 +1,5 @@
 [INFO ODB-0227] LEF file: ./Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
-[INFO ODB-0227] LEF file: ./Nangate45_io/dummy_pads.lef, created 29 library cells
+[INFO ODB-0227] LEF file: ./Nangate45_io/dummy_pads.lef, created 30 library cells
 [INFO ODB-0227] LEF file: ./testcases/orientation_improve1.lef, created 10 library cells
 [INFO ODB-0128] Design: boundary_push1
 [INFO ODB-0131]     Created 152 components and 904 component-terminals.

src/mpl/test/io_pads1.ok

@@ -1,5 +1,5 @@
 [INFO ODB-0227] LEF file: Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
-[INFO ODB-0227] LEF file: Nangate45_io/dummy_pads.lef, created 29 library cells
+[INFO ODB-0227] LEF file: Nangate45_io/dummy_pads.lef, created 30 library cells
 [INFO ODB-0227] LEF file: testcases/macro_only.lef, created 9 library cells
 [INFO ODB-0128] Design: io_pads1
 [INFO ODB-0130]     Created 1 pins.

src/mpl/test/macros_without_pins1.ok

@@ -1,5 +1,5 @@
 [INFO ODB-0227] LEF file: ./Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
-[INFO ODB-0227] LEF file: ./Nangate45_io/dummy_pads.lef, created 29 library cells
+[INFO ODB-0227] LEF file: ./Nangate45_io/dummy_pads.lef, created 30 library cells
 [INFO ODB-0227] LEF file: ./testcases/orientation_improve1.lef, created 10 library cells
 [INFO ODB-0128] Design: boundary_push1
 [INFO ODB-0131]     Created 402 components and 2402 component-terminals.

src/pad/src/ICeWall.cpp

@@ -518,33 +518,6 @@ void ICeWall::placeCorner(odb::dbMaster* master, int ring_index)
 
     const odb::Rect row_bbox = row->getBBox();
 
-    // Check for instances overlapping the corner site
-    bool place_inst = true;
-    for (auto* check_inst : block->getInsts()) {
-      if (check_inst == inst) {
-        continue;
-      }
-      if (!check_inst->isFixed()) {
-        continue;
-      }
-      if (check_inst->getMaster()->isCover()) {
-        continue;
-      }
-      const odb::Rect check_rect = check_inst->getBBox()->getBox();
-      if (row_bbox.overlaps(check_rect)) {
-        place_inst = false;
-        break;
-      }
-    }
-    if (!place_inst) {
-      logger_->warn(
-          utl::PAD,
-          44,
-          "Skipping corner cell placement in {} due to overlapping instances",
-          row->getName());
-      continue;
-    }
-
     const bool create_inst = inst == nullptr;
     if (create_inst) {
       inst = odb::dbInst::create(block, master, corner_name.c_str());
@@ -554,20 +527,20 @@ void ICeWall::placeCorner(odb::dbMaster* master, int ring_index)
     inst->setLocation(row_bbox.xMin(), row_bbox.yMin());
     inst->setPlacementStatus(odb::dbPlacementStatus::FIRM);
 
-    const CheckerOnlyPadPlacer checker(logger_, block, row);
+    const CheckerOnlyPadPlacer checker(logger_, block, row, {inst});
     if (!checker.check(inst)) {
       if (create_inst) {
         logger_->warn(utl::PAD,
                       45,
                       "Skipping corner cell generation for {} due to "
-                      "overlapping bump cell",
+                      "overlapping instances",
                       inst->getName());
         odb::dbInst::destroy(inst);
       } else {
         logger_->warn(utl::PAD,
                       46,
                       "Skipping corner cell placement for {} due to "
-                      "overlapping bump cell",
+                      "overlapping instances",
                       inst->getName());
         inst->setPlacementStatus(odb::dbPlacementStatus::UNPLACED);
       }

src/pad/src/PadPlacer.cpp

@@ -37,6 +37,8 @@ PadPlacer::PadPlacer(utl::Logger* logger,
 {
   populateInstWidths();
   populateObstructions();
+
+  addInstsOverlapCache(insts);
 }
 
 void PadPlacer::populateInstWidths()
@@ -398,8 +400,10 @@ void PadPlacer::populateObstructions()
           covers.insert(check_inst);
           continue;
         }
-        instance_obstructions_.insert(
-            {check_inst->getBBox()->getBox(), check_inst});
+
+        instance_obstructions_.insert({check_inst->getBBox()->getBox(),
+                                       getInstanceOutline(check_inst),
+                                       check_inst});
       }
     }
   }
@@ -411,9 +415,83 @@ void PadPlacer::populateObstructions()
   }
 }
 
+std::optional<odb::Polygon> PadPlacer::getMasterOutline(
+    odb::dbMaster* master) const
+{
+  std::vector<odb::Rect> master_obs;
+  for (auto* obs : master->getObstructions()) {
+    auto* layer = obs->getTechLayer();
+    if (layer != nullptr) {
+      if (layer->getType() != odb::dbTechLayerType::OVERLAP) {
+        continue;
+      }
+      master_obs.push_back(obs->getBox());
+    }
+  }
+
+  if (master_obs.empty()) {
+    return std::nullopt;
+  }
+
+  if (master_obs.size() == 1) {
+    return odb::Polygon(master_obs.front());
+  }
+
+  const auto overlaps = odb::Polygon::merge(master_obs);
+  if (overlaps.size() == 1) {
+    return overlaps.front();
+  }
+
+  return std::nullopt;
+}
+
+std::optional<odb::Polygon> PadPlacer::getInstanceOutline(
+    odb::dbInst* inst) const
+{
+  const auto checker = master_overlap_cache_.find(inst->getMaster());
+  if (checker != master_overlap_cache_.end()) {
+    if (!checker->second) {
+      return std::nullopt;
+    }
+
+    odb::Polygon poly = checker->second.value();
+    const odb::dbTransform xform = inst->getTransform();
+    xform.apply(poly);
+    return poly;
+  }
+
+  const auto master_outline = getMasterOutline(inst->getMaster());
+  if (!master_outline) {
+    return std::nullopt;
+  }
+
+  const odb::dbTransform xform = inst->getTransform();
+  odb::Polygon poly = master_outline.value();
+  xform.apply(poly);
+  return poly;
+}
+
+void PadPlacer::addInstsOverlapCache(const std::vector<odb::dbInst*>& insts)
+{
+  for (auto* inst : insts) {
+    addInstOverlapCache(inst);
+  }
+}
+
+void PadPlacer::addInstOverlapCache(odb::dbInst* inst)
+{
+  if (master_overlap_cache_.find(inst->getMaster())
+      != master_overlap_cache_.end()) {
+    return;
+  }
+  master_overlap_cache_[inst->getMaster()]
+      = getMasterOutline(inst->getMaster());
+}
+
 void PadPlacer::addInstanceObstructions(odb::dbInst* inst)
 {
-  instance_obstructions_.insert({inst->getBBox()->getBox(), inst});
+  instance_obstructions_.insert(
+      {inst->getBBox()->getBox(), getInstanceOutline(inst), inst});
   if (inst->getMaster()->isCover()) {
     for (const auto& [layer, shapes] : getInstanceObstructions(inst)) {
       term_obstructions_[layer].insert(shapes.begin(), shapes.end());
@@ -426,6 +504,8 @@ PadPlacer::checkInstancePlacement(odb::dbInst* inst,
                                   bool return_intersect) const
 {
   const odb::Rect inst_rect = inst->getBBox()->getBox();
+  const std::optional<odb::Polygon> inst_poly = getInstanceOutline(inst);
+
   for (auto itr = blockage_obstructions_.qbegin(
            boost::geometry::index::intersects(inst_rect));
        itr != blockage_obstructions_.qend();
@@ -446,11 +526,29 @@ PadPlacer::checkInstancePlacement(odb::dbInst* inst,
            boost::geometry::index::intersects(inst_rect));
        itr != instance_obstructions_.qend();
        itr++) {
-    const auto& [check_rect, check_inst] = *itr;
+    const auto& [check_rect, check_poly, check_inst] = *itr;
     if (check_rect.overlaps(inst_rect)) {
       if (check_inst == inst) {
         continue;
       }
+      if (check_poly && inst_poly) {
+        // Both have overlap polygons, check them for a more accurate result
+        if (!boost::geometry::intersects(*check_poly, *inst_poly)) {
+          continue;
+        }
+      } else if (check_poly) {
+        // Only the obstruction has an overlap polygon, check it for a more
+        // accurate result
+        if (!boost::geometry::intersects(inst_rect, *check_poly)) {
+          continue;
+        }
+      } else if (inst_poly) {
+        // Only the instance has an overlap polygon, check it for a more
+        // accurate result
+        if (!boost::geometry::intersects(check_rect, *inst_poly)) {
+          continue;
+        }
+      }
       debugPrint(getLogger(),
                  utl::PAD,
                  "Check",
@@ -570,10 +668,12 @@ void UniformPadPlacer::place()
 
 ///////////////////////////////////////////
 
-CheckerOnlyPadPlacer::CheckerOnlyPadPlacer(utl::Logger* logger,
-                                           odb::dbBlock* block,
-                                           odb::dbRow* row)
-    : PadPlacer(logger, block, {}, odb::Direction2D::North, row)
+CheckerOnlyPadPlacer::CheckerOnlyPadPlacer(
+    utl::Logger* logger,
+    odb::dbBlock* block,
+    odb::dbRow* row,
+    const std::vector<odb::dbInst*>& insts)
+    : PadPlacer(logger, block, insts, odb::Direction2D::North, row)
 {
 }
 

src/pad/src/PadPlacer.h

@@ -64,7 +64,8 @@ class PadPlacer
   int getTotalInstWidths() const;
 
  protected:
-  using InstObsValue = std::pair<odb::Rect, odb::dbInst*>;
+  using InstObsValue
+      = std::tuple<odb::Rect, std::optional<odb::Polygon>, odb::dbInst*>;
   using TermObsValue = std::tuple<odb::Rect, odb::dbNet*, odb::dbInst*>;
   using BlockageObsTree
       = boost::geometry::index::rtree<odb::Rect,
@@ -95,10 +96,14 @@ class PadPlacer
   }
   LayerTermObsTree getInstanceObstructions(odb::dbInst* inst,
                                            bool bloat = false) const;
+  std::optional<odb::Polygon> getInstanceOutline(odb::dbInst* inst) const;
   void addInstanceObstructions(odb::dbInst* inst);
 
  private:
   void populateInstWidths();
+  void addInstOverlapCache(odb::dbInst* inst);
+  void addInstsOverlapCache(const std::vector<odb::dbInst*>& inst);
+  std::optional<odb::Polygon> getMasterOutline(odb::dbMaster* master) const;
 
   utl::Logger* logger_;
   odb::dbBlock* block_;
@@ -113,14 +118,18 @@ class PadPlacer
   BlockageObsTree blockage_obstructions_;
   InstObsTree instance_obstructions_;
   LayerTermObsTree term_obstructions_;
+
+  // overlap cache
+  std::map<odb::dbMaster*, std::optional<odb::Polygon>> master_overlap_cache_;
 };
 
 class CheckerOnlyPadPlacer : public PadPlacer
 {
  public:
   CheckerOnlyPadPlacer(utl::Logger* logger,
                        odb::dbBlock* block,
-                       odb::dbRow* row);
+                       odb::dbRow* row,
+                       const std::vector<odb::dbInst*>& insts);
   ~CheckerOnlyPadPlacer() override = default;
 
   void place() override {};

src/pad/test/BUILD

@@ -26,6 +26,7 @@ COMPULSORY_TESTS = [
     "place_bondpad_stagger",
     "place_corners_avoid_bumps",
     "place_corners_avoid_overlap",
+    "place_corners_avoid_overlap_with_overlapobs",
     "place_io_terminals_empty_call",
     "place_pad",
     "place_pad_hv",

src/pad/test/CMakeLists.txt

@@ -19,6 +19,7 @@ or_integration_tests(
     place_bondpad_stagger
     place_corners_avoid_bumps
     place_corners_avoid_overlap
+    place_corners_avoid_overlap_with_overlapobs
     place_io_terminals_empty_call
     place_pad
     place_pad_hv

src/pad/test/assign_bumps.ok

@@ -1,5 +1,5 @@
 [INFO ODB-0227] LEF file: Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
-[INFO ODB-0227] LEF file: Nangate45_io/dummy_pads.lef, created 29 library cells
+[INFO ODB-0227] LEF file: Nangate45_io/dummy_pads.lef, created 30 library cells
 [INFO ODB-0128] Design: soc_bsg_black_parrot
 [INFO ODB-0130]     Created 135 pins.
 [INFO ODB-0131]     Created 267 components and 2277 component-terminals.

src/pad/test/assign_bumps_two_pins.ok

@@ -1,5 +1,5 @@
 [INFO ODB-0227] LEF file: Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
-[INFO ODB-0227] LEF file: Nangate45_io/dummy_pads.lef, created 29 library cells
+[INFO ODB-0227] LEF file: Nangate45_io/dummy_pads.lef, created 30 library cells
 [INFO ODB-0128] Design: soc_bsg_black_parrot
 [INFO ODB-0130]     Created 135 pins.
 [INFO ODB-0131]     Created 267 components and 2277 component-terminals.