Merge pull request #8833 from gadfort/pad-rtree-obs

pad: switch to use rtrees for obstructions to make checks faster

Author: maliberty

src/pad/src/ICeWall.cpp

@@ -632,7 +632,7 @@ void ICeWall::placePad(odb::dbMaster* master,
     }
   }
 
-  const SingleInstPadPlacer placer(logger_, getBlock(), getRowEdge(row), row);
+  SingleInstPadPlacer placer(logger_, getBlock(), getRowEdge(row), row);
   placer.place(inst, location, orient.getOrient());
 }
 
@@ -814,7 +814,7 @@ void ICeWall::placeFiller(
     use_height = true;
   }
 
-  const SingleInstPadPlacer placer(logger_, block, getRowEdge(row), row);
+  SingleInstPadPlacer placer(logger_, block, getRowEdge(row), row);
 
   const odb::dbTransform row_xform(row->getOrient());
 

src/pad/src/PadPlacer.cpp

@@ -11,9 +11,11 @@
 #include <map>
 #include <optional>
 #include <set>
+#include <tuple>
 #include <utility>
 #include <vector>
 
+#include "boost/geometry/index/predicates.hpp"
 #include "gui/gui.h"
 #include "odb/db.h"
 #include "odb/dbTransform.h"
@@ -32,6 +34,7 @@ PadPlacer::PadPlacer(utl::Logger* logger,
     : logger_(logger), block_(block), insts_(insts), edge_(edge), row_(row)
 {
   populateInstWidths();
+  populateObstructions();
 }
 
 void PadPlacer::populateInstWidths()
@@ -301,89 +304,180 @@ int PadPlacer::placeInstance(int index,
   return next_pos;
 }
 
-std::optional<std::pair<odb::dbInst*, odb::Rect>>
-PadPlacer::checkInstancePlacement(odb::dbInst* inst) const
+PadPlacer::LayerTermObsTree PadPlacer::getInstanceObstructions(
+    odb::dbInst* inst,
+    bool bloat) const
+{
+  std::map<odb::dbTechLayer*, std::vector<TermObsValue>> shapes;
+
+  // populate map as needed
+  const auto xform = inst->getTransform();
+  for (auto* obs : inst->getMaster()->getObstructions()) {
+    odb::Rect obs_rect = obs->getBox();
+    xform.apply(obs_rect);
+    odb::dbTechLayer* layer = obs->getTechLayer();
+    if (bloat && layer != nullptr) {
+      odb::Rect bloat_rect;
+      obs_rect.bloat(layer->getSpacing(), bloat_rect);
+      obs_rect = bloat_rect;
+    }
+    shapes[obs->getTechLayer()].emplace_back(obs_rect, nullptr, inst);
+  }
+  for (auto* iterm : inst->getITerms()) {
+    for (const auto& [layer, box] : iterm->getGeometries()) {
+      odb::Rect term_rect = box;
+      if (bloat && layer != nullptr) {
+        odb::Rect bloat_rect;
+        box.bloat(layer->getSpacing(), bloat_rect);
+        term_rect = bloat_rect;
+      }
+      shapes[layer].emplace_back(term_rect, iterm->getNet(), inst);
+    }
+  }
+
+  LayerTermObsTree rshapes;
+  for (const auto& [layer, layer_shapes] : shapes) {
+    if (layer == nullptr) {
+      continue;
+    }
+    rshapes[layer] = TermObsTree(layer_shapes.begin(), layer_shapes.end());
+  }
+  return rshapes;
+}
+
+void PadPlacer::populateObstructions()
 {
+  blockage_obstructions_.clear();
+  instance_obstructions_.clear();
+  term_obstructions_.clear();
+
+  const odb::Rect row = row_->getBBox();
+
   std::set<odb::dbInst*> covers;
   auto* block = getBlock();
   if (block) {
-    const odb::Rect inst_rect = inst->getBBox()->getBox();
+    // Get placement blockages
     for (odb::dbBlockage* blockage : block->getBlockages()) {
-      if (blockage->getBBox()->getBox().overlaps(inst_rect)) {
-        return std::make_pair(
-            nullptr, blockage->getBBox()->getBox().intersect(inst_rect));
+      if (blockage->getBBox()->getBox().overlaps(row)) {
+        blockage_obstructions_.insert(blockage->getBBox()->getBox());
       }
     }
-    for (auto* check_inst : block->getInsts()) {
-      if (check_inst == inst) {
-        continue;
+    // Get obstructions that might interfere with RDL routing
+    for (odb::dbObstruction* obs : block->getObstructions()) {
+      if (obs->getBBox()->getBox().overlaps(row)) {
+        term_obstructions_[obs->getBBox()->getTechLayer()].insert(
+            {obs->getBBox()->getBox(), nullptr, nullptr});
       }
+    }
+    for (auto* check_inst : block->getInsts()) {
       if (!check_inst->isFixed()) {
         continue;
       }
-      if (check_inst->getMaster()->isCover()) {
-        covers.insert(check_inst);
-        continue;
-      }
-      if (check_inst->getBBox()->getBox().overlaps(inst_rect)) {
-        return std::make_pair(
-            check_inst, check_inst->getBBox()->getBox().intersect(inst_rect));
+      if (check_inst->getBBox()->getBox().overlaps(row)) {
+        if (check_inst->getMaster()->isCover()) {
+          covers.insert(check_inst);
+          continue;
+        }
+        instance_obstructions_.insert(
+            {check_inst->getBBox()->getBox(), check_inst});
       }
     }
   }
 
-  // Check if inst overlaps with bumps
-  std::map<odb::dbTechLayer*, std::set<std::pair<odb::Rect, odb::dbNet*>>>
-      check_shapes;
-  if (!covers.empty()) {
-    // populate map as needed
-    const auto xform = inst->getTransform();
-    for (auto* obs : inst->getMaster()->getObstructions()) {
-      odb::Rect obs_rect = obs->getBox();
-      xform.apply(obs_rect);
-      odb::dbTechLayer* layer = obs->getTechLayer();
-      if (layer != nullptr) {
-        odb::Rect bloat;
-        obs_rect.bloat(layer->getSpacing(), bloat);
-        obs_rect = bloat;
-      }
-      check_shapes[obs->getTechLayer()].emplace(obs_rect, nullptr);
+  for (odb::dbInst* check_inst : covers) {
+    for (const auto& [layer, shapes] : getInstanceObstructions(check_inst)) {
+      term_obstructions_[layer].insert(shapes.begin(), shapes.end());
     }
-    for (auto* iterm : inst->getITerms()) {
-      for (const auto& [layer, box] : iterm->getGeometries()) {
-        odb::Rect term_rect = box;
-        if (layer != nullptr) {
-          odb::Rect bloat;
-          box.bloat(layer->getSpacing(), bloat);
-          term_rect = bloat;
-        }
-        check_shapes[layer].emplace(term_rect, iterm->getNet());
-      }
+  }
+}
+
+void PadPlacer::addInstanceObstructions(odb::dbInst* inst)
+{
+  instance_obstructions_.insert({inst->getBBox()->getBox(), inst});
+  if (inst->getMaster()->isCover()) {
+    for (const auto& [layer, shapes] : getInstanceObstructions(inst)) {
+      term_obstructions_[layer].insert(shapes.begin(), shapes.end());
     }
   }
+}
 
-  for (odb::dbInst* check_inst : covers) {
-    const auto xform = check_inst->getTransform();
-    for (auto* obs : check_inst->getMaster()->getObstructions()) {
-      odb::Rect obs_rect = obs->getBox();
-      xform.apply(obs_rect);
-      for (const auto& [inst_rect, check_net] :
-           check_shapes[obs->getTechLayer()]) {
-        if (inst_rect.intersects(obs_rect)) {
-          return std::make_pair(check_inst, inst_rect.intersect(obs_rect));
-        }
+std::optional<std::pair<odb::dbInst*, odb::Rect>>
+PadPlacer::checkInstancePlacement(odb::dbInst* inst,
+                                  bool return_intersect) const
+{
+  const odb::Rect inst_rect = inst->getBBox()->getBox();
+  for (auto itr = blockage_obstructions_.qbegin(
+           boost::geometry::index::intersects(inst_rect));
+       itr != blockage_obstructions_.qend();
+       itr++) {
+    if (itr->overlaps(inst_rect)) {
+      debugPrint(getLogger(),
+                 utl::PAD,
+                 "Check",
+                 2,
+                 "{} blocked by blockage: {}",
+                 inst->getName(),
+                 *itr);
+      return std::make_pair(
+          nullptr, return_intersect ? itr->intersect(inst_rect) : *itr);
+    }
+  }
+  for (auto itr = instance_obstructions_.qbegin(
+           boost::geometry::index::intersects(inst_rect));
+       itr != instance_obstructions_.qend();
+       itr++) {
+    const auto& [check_rect, check_inst] = *itr;
+    if (check_rect.overlaps(inst_rect)) {
+      if (check_inst == inst) {
+        continue;
       }
+      debugPrint(getLogger(),
+                 utl::PAD,
+                 "Check",
+                 2,
+                 "{} blocked by fixed instance: {}",
+                 inst->getName(),
+                 check_inst->getName());
+      return std::make_pair(
+          check_inst,
+          return_intersect ? check_rect.intersect(inst_rect) : check_rect);
+    }
+  }
+
+  for (const auto& [layer, term_shapes] : getInstanceObstructions(inst, true)) {
+    if (term_obstructions_.find(layer) == term_obstructions_.end()) {
+      continue;
     }
 
-    for (auto* iterm : check_inst->getITerms()) {
-      for (const auto& [layer, box] : iterm->getGeometries()) {
-        for (const auto& [inst_rect, check_net] : check_shapes[layer]) {
-          const bool nets_match
-              = iterm->getNet() == check_net
-                && (check_net != nullptr || iterm->getNet() != nullptr);
-          if (!nets_match && inst_rect.intersects(box)) {
-            return std::make_pair(check_inst, inst_rect.intersect(box));
-          }
+    const auto& obs_layer = term_obstructions_.at(layer);
+
+    for (const auto& [term_shape, term_net, term_inst] : term_shapes) {
+      for (auto itr
+           = obs_layer.qbegin(boost::geometry::index::intersects(term_shape));
+           itr != obs_layer.qend();
+           itr++) {
+        const auto& [check_rect, check_net, check_inst] = *itr;
+        if (check_inst == inst) {
+          continue;
+        }
+        const bool nets_match
+            = term_net == check_net
+              && (check_net != nullptr || term_net != nullptr);
+        if (!nets_match) {
+          debugPrint(
+              getLogger(),
+              utl::PAD,
+              "Check",
+              2,
+              "{} ({} / {}) blocked by terminal obstruction: {} / {}",
+              inst->getName(),
+              term_shape,
+              term_net == nullptr ? "unconnected" : term_net->getName(),
+              check_rect,
+              check_net == nullptr ? "unconnected" : check_net->getName());
+          return std::make_pair(
+              check_inst,
+              return_intersect ? check_rect.intersect(inst_rect) : check_rect);
         }
       }
     }
@@ -444,6 +538,7 @@ void UniformPadPlacer::place()
                   odb::dbOrientType::R0,
                   /* allow_overlap */ false,
                   /* allow_shift */ true);
+    addInstanceObstructions(inst);
     offset += getInstWidths().at(inst);
     offset += target_spacing;
 
@@ -480,9 +575,10 @@ SingleInstPadPlacer::SingleInstPadPlacer(utl::Logger* logger,
 void SingleInstPadPlacer::place(odb::dbInst* inst,
                                 int location,
                                 const odb::dbOrientType& base_orient,
-                                bool allow_overlap) const
+                                bool allow_overlap)
 {
   placeInstance(snapToRowSite(location), inst, base_orient, allow_overlap);
+  addInstanceObstructions(inst);
 }
 
 ///////////////////////////////////////////
@@ -578,6 +674,7 @@ void BumpAlignedPadPlacer::place()
                 * getRow()->getSpacing();
 
       performPadFlip(ginst);
+      addInstanceObstructions(ginst);
 
       if (gui_debug) {
         gui::Gui::get()->pause();

src/pad/src/PadPlacer.h

@@ -7,12 +7,16 @@
 #include <map>
 #include <optional>
 #include <set>
+#include <tuple>
 #include <utility>
 #include <vector>
 
+#include "boost/geometry/index/parameters.hpp"
+#include "boost/geometry/index/rtree.hpp"
 #include "odb/db.h"
 #include "odb/dbTypes.h"
 #include "odb/geom.h"
+#include "odb/geom_boost.h"
 #include "odb/isotropy.h"
 
 namespace odb {
@@ -53,18 +57,36 @@ class PadPlacer
   int getTotalInstWidths() const;
 
  protected:
+  using InstObsValue = std::pair<odb::Rect, odb::dbInst*>;
+  using TermObsValue = std::tuple<odb::Rect, odb::dbNet*, odb::dbInst*>;
+  using BlockageObsTree
+      = boost::geometry::index::rtree<odb::Rect,
+                                      boost::geometry::index::quadratic<16>>;
+  using InstObsTree
+      = boost::geometry::index::rtree<InstObsValue,
+                                      boost::geometry::index::quadratic<16>>;
+  using TermObsTree
+      = boost::geometry::index::rtree<TermObsValue,
+                                      boost::geometry::index::quadratic<16>>;
+  using LayerTermObsTree = std::map<odb::dbTechLayer*, TermObsTree>;
+
   int placeInstance(int index,
                     odb::dbInst* inst,
                     const odb::dbOrientType& base_orient,
                     bool allow_overlap = false,
                     bool allow_shift = false) const;
+  void populateObstructions();
   std::optional<std::pair<odb::dbInst*, odb::Rect>> checkInstancePlacement(
-      odb::dbInst* inst) const;
+      odb::dbInst* inst,
+      bool return_intersect = true) const;
   int snapToRowSite(int location) const;
   const std::map<odb::dbInst*, int>& getInstWidths() const
   {
     return inst_widths_;
   }
+  LayerTermObsTree getInstanceObstructions(odb::dbInst* inst,
+                                           bool bloat = false) const;
+  void addInstanceObstructions(odb::dbInst* inst);
 
  private:
   void populateInstWidths();
@@ -77,6 +99,11 @@ class PadPlacer
 
   // Computed values
   std::map<odb::dbInst*, int> inst_widths_;
+
+  // Fixed obstructions
+  BlockageObsTree blockage_obstructions_;
+  InstObsTree instance_obstructions_;
+  LayerTermObsTree term_obstructions_;
 };
 
 class CheckerOnlyPadPlacer : public PadPlacer
@@ -110,7 +137,7 @@ class SingleInstPadPlacer : public PadPlacer
   void place(odb::dbInst* inst,
              int location,
              const odb::dbOrientType& base_orient,
-             bool allow_overlap = false) const;
+             bool allow_overlap = false);
 };
 
 class UniformPadPlacer : public PadPlacer