Merge pull request #7958 from The-OpenROAD-Project-staging/dpl-site-intervals

dpl: remove sites from Pixel and store as an interval

Author: maliberty

src/dpl/BUILD

@@ -86,6 +86,7 @@ cc_library(
         "//src/utl",
         "@boost.format",
         "@boost.geometry",
+        "@boost.icl",
         "@boost.polygon",
         "@boost.property_tree",
         "@boost.random",
@@ -126,6 +127,7 @@ cc_library(
         "//src/odb",
         "//src/utl",
         "@boost.geometry",
+        "@boost.icl",
         "@boost.polygon",
         "@boost.stacktrace",
         "@boost.utility",

src/dpl/include/dpl/Opendp.h

@@ -284,7 +284,6 @@ class Opendp
   void placeRowFillers(GridY row,
                        const std::string& prefix,
                        const MasterByImplant& filler_masters);
-  std::pair<odb::dbSite*, odb::dbOrientType> fillSite(Pixel* pixel);
   static bool isFiller(odb::dbInst* db_inst);
   bool isOneSiteCell(odb::dbMaster* db_master) const;
   const char* gridInstName(GridY row, GridX col);

src/dpl/src/CheckPlacement.cpp

@@ -344,8 +344,7 @@ bool Opendp::checkInRows(const Node& cell) const
       if (pixel == nullptr || !pixel->is_valid) {
         return false;
       }
-      if (first_row
-          && pixel->sites.find(cell.getSite()) == pixel->sites.end()) {
+      if (first_row && !grid_->getSiteOrientation(x, y, cell.getSite())) {
         return false;
       }
     }

src/dpl/src/DecapPlacement.cpp

@@ -208,8 +208,8 @@ void Opendp::insertDecapInPos(dbMaster* master,
                                 /* physical_only */ true);
   const GridX grid_x = grid_->gridX(pos_x - core_.xMin());
   const GridY grid_y = grid_->gridSnapDownY(pos_y - core_.yMin());
-  const Pixel* pixel = grid_->gridPixel(grid_x, grid_y);
-  const dbOrientType orient = pixel->sites.at(master->getSite());
+  const dbOrientType orient
+      = grid_->getSiteOrientation(grid_x, grid_y, master->getSite()).value();
   inst->setOrient(orient);
   inst->setLocation(pos_x.v, pos_y.v);
   inst->setPlacementStatus(dbPlacementStatus::PLACED);

src/dpl/src/FillerPlacement.cpp

@@ -112,24 +112,6 @@ void Opendp::setGridCells()
   }
 }
 
-// Select the site and orientation to fill this row with.  Use the shortest
-// site.
-std::pair<dbSite*, dbOrientType> Opendp::fillSite(Pixel* pixel)
-{
-  dbSite* selected_site = nullptr;
-  dbOrientType selected_orient;
-  DbuY min_height{std::numeric_limits<int>::max()};
-  for (const auto& [site, orient] : pixel->sites) {
-    DbuY site_height{site->getHeight()};
-    if (site_height < min_height) {
-      min_height = site_height;
-      selected_site = site;
-      selected_orient = orient;
-    }
-  }
-  return {selected_site, selected_orient};
-}
-
 void Opendp::placeRowFillers(GridY row,
                              const std::string& prefix,
                              const MasterByImplant& filler_masters_by_implant)
@@ -145,7 +127,9 @@ void Opendp::placeRowFillers(GridY row,
       ++j;
       continue;
     }
-    auto [site, orient] = fillSite(pixel);
+    // Select the site and orientation to fill this row with.  Use the shortest
+    // site.
+    auto [site, orient] = grid_->getShortestSite(j, row);
     GridX k = j;
     while (k < row_site_count && grid_->gridPixel(k, row)->cell == nullptr
            && grid_->gridPixel(k, row)->is_valid) {

src/dpl/src/Place.cpp

@@ -872,7 +872,7 @@ bool Opendp::checkPixels(const Node* cell,
       if (pixel == nullptr || pixel->cell || !pixel->is_valid
           || (cell->inGroup() && pixel->group != cell->getGroup())
           || (!cell->inGroup() && pixel->group)
-          || (first_row && pixel->sites.find(site) == pixel->sites.end())) {
+          || (first_row && !grid_->getSiteOrientation(x1, y1, site))) {
         return false;
       }
     }
@@ -908,8 +908,8 @@ bool Opendp::checkPixels(const Node* cell,
       }
     }
   }
-  const auto& orient = grid_->gridPixel(x, y)->sites.at(
-      cell->getDbInst()->getMaster()->getSite());
+  dbSite* site = cell->getDbInst()->getMaster()->getSite();
+  const auto orient = grid_->getSiteOrientation(x, y, site).value();
   return drc_engine_->checkDRC(cell, x, y, orient);
 }
 
@@ -1200,8 +1200,8 @@ void Opendp::placeCell(Node* cell, const GridX x, const GridY y)
   setGridLoc(cell, x, y);
   grid_->paintPixel(cell);
   cell->setPlaced(true);
-  cell->setOrient(grid_->gridPixel(x, y)->sites.at(
-      cell->getDbInst()->getMaster()->getSite()));
+  dbSite* site = cell->getDbInst()->getMaster()->getSite();
+  cell->setOrient(grid_->getSiteOrientation(x, y, site).value());
   if (journal_) {
     MoveCellAction action(cell,
                           original_x,

src/dpl/src/infrastructure/Grid.cpp

@@ -76,6 +76,9 @@ void Grid::allocateGrid()
       pixel.blocked_layers = 0;
     }
   }
+
+  row_sites_.clear();
+  row_sites_.resize(row_count_.v);
 }
 
 void Grid::markHopeless(dbBlock* block,
@@ -101,8 +104,9 @@ void Grid::markHopeless(dbBlock* block,
     for (GridX x{x_start}; x < x_end; x++) {
       Pixel* pixel = gridPixel(x, y_row);
       pixel->is_valid = true;
-      pixel->sites[db_row->getSite()] = db_row->getOrient();
     }
+    row_sites_[y_row.v].add(
+        {{x_start.v, x_end.v}, {{db_row->getSite(), db_row->getOrient()}}});
 
     // The safety margin is to avoid having only a very few sites
     // within the diamond search that may still lead to failures.
@@ -211,6 +215,50 @@ void Grid::initGrid(dbDatabase* db,
   markBlocked(block);
 }
 
+std::pair<dbSite*, dbOrientType> Grid::getShortestSite(GridX grid_x,
+                                                       GridY grid_y)
+{
+  dbSite* selected_site = nullptr;
+  dbOrientType selected_orient;
+  DbuY min_height{std::numeric_limits<int>::max()};
+
+  const RowSitesMap& sites_map = row_sites_[grid_y.v];
+  auto it = sites_map.find(grid_x.v);
+
+  if (it != sites_map.end()) {
+    for (const auto& [site, orient] : it->second) {
+      DbuY site_height{site->getHeight()};
+      if (site_height < min_height) {
+        min_height = site_height;
+        selected_site = site;
+        selected_orient = orient;
+      }
+    }
+  }
+
+  return {selected_site, selected_orient};
+}
+
+std::optional<dbOrientType> Grid::getSiteOrientation(GridX x,
+                                                     GridY y,
+                                                     dbSite* site) const
+{
+  const RowSitesMap& sites_map = row_sites_[y.v];
+  auto interval_it = sites_map.find(x.v);
+
+  if (interval_it == sites_map.end()) {
+    return {};
+  }
+
+  const SiteToOrientation& sites_orient = interval_it->second;
+
+  if (auto it = sites_orient.find(site); it != sites_orient.end()) {
+    return it->second;
+  }
+
+  return {};
+}
+
 Pixel* Grid::gridPixel(GridX grid_x, GridY grid_y) const
 {
   if (grid_x >= 0 && grid_x < row_site_count_ && grid_y >= 0

src/dpl/src/infrastructure/Grid.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <boost/icl/interval_map.hpp>
 #include <functional>
 #include <map>
 #include <memory>
@@ -39,9 +40,8 @@ struct Pixel
   bool is_valid = false;     // false for dummy cells
   bool is_hopeless = false;  // too far from sites for diamond search
   uint8_t blocked_layers = 0;
-  std::map<dbSite*, dbOrientType> sites;
-  std::unordered_set<Node*>
-      padding_reserved_by;  // Cells that reserved this pixel for padding
+  // Cells that reserved this pixel for padding
+  std::unordered_set<Node*> padding_reserved_by;
 };
 
 // Return value for grid searches.
@@ -132,6 +132,11 @@ class Grid
   Pixel& pixel(GridY y, GridX x) { return pixels_[y.v][x.v]; }
   const Pixel& pixel(GridY y, GridX x) const { return pixels_[y.v][x.v]; }
 
+  std::optional<dbOrientType> getSiteOrientation(GridX x,
+                                                 GridY y,
+                                                 dbSite* site) const;
+  std::pair<dbSite*, dbOrientType> getShortestSite(GridX grid_x, GridY grid_y);
+
   void resize(int size) { pixels_.resize(size); }
   void resize(GridY size) { pixels_.resize(size.v); }
   void resize(GridY y, GridX size) { pixels_[y.v].resize(size.v); }
@@ -147,14 +152,40 @@ class Grid
   bool isMultiHeight(dbMaster* master) const;
 
  private:
+  // Maps a site to the right orientation to use in a given row
+  using SiteToOrientation = std::map<dbSite*, dbOrientType>;
+
+  // Used to combine the SiteToOrientation for two intervals when merged
+  template <typename MapType>
+  struct SitesCombiner
+  {
+    using first_argument_type = MapType&;
+    using second_argument_type = const MapType&;
+
+    static MapType identity_element() { return MapType(); }
+
+    void operator()(MapType& target, const MapType& source) const
+    {
+      target.insert(source.begin(), source.end());
+    }
+  };
+
+  // Map intervals in rows to the site/orientation mapping
+  using RowSitesMap = boost::icl::interval_map<int,
+                                               SiteToOrientation,
+                                               boost::icl::total_absorber,
+                                               std::less,
+                                               SitesCombiner>;
+
+  using Pixels = std::vector<std::vector<Pixel>>;
+
   void markHopeless(dbBlock* block,
                     int max_displacement_x,
                     int max_displacement_y);
   void markBlocked(dbBlock* block);
   void visitDbRows(dbBlock* block,
                    const std::function<void(odb::dbRow*)>& func) const;
 
-  using Pixels = std::vector<std::vector<Pixel>>;
   Logger* logger_ = nullptr;
   dbBlock* block_ = nullptr;
   std::shared_ptr<Padding> padding_;
@@ -165,6 +196,9 @@ class Grid
   std::vector<DbuY> row_index_to_y_dbu_;         // index is GridY
   std::vector<DbuY> row_index_to_pixel_height_;  // index is GridY
 
+  // Indexed by row (GridY)
+  std::vector<RowSitesMap> row_sites_;
+
   bool has_hybrid_rows_ = false;
   Rect core_;
 

src/dpl/src/optimization/detailed_manager.cxx

@@ -2985,9 +2985,10 @@ void DetailedMgr::paintInGrid(Node* node)
 {
   const auto grid_x = grid_->gridX(node);
   const auto grid_y = grid_->gridSnapDownY(node);
-  auto pixel = grid_->gridPixel(grid_x, grid_y);
+  dbSite* site = node->getDbInst()->getMaster()->getSite();
+  const auto orientation
+      = grid_->getSiteOrientation(grid_x, grid_y, site).value();
   grid_->paintPixel(node, grid_x, grid_y);
-  node->adjustCurrOrient(
-      pixel->sites.at(node->getDbInst()->getMaster()->getSite()));
+  node->adjustCurrOrient(orientation);
 }
 }  // namespace dpl

src/dpl/src/util/journal.cxx

@@ -18,10 +18,11 @@ void paintInGrid(Grid* grid, Node* node)
 {
   const auto grid_x = grid->gridX(DbuX(node->getLeft()));
   const auto grid_y = grid->gridRoundY(DbuY(node->getBottom()));
-  auto pixel = grid->gridPixel(grid_x, grid_y);
+  dbSite* site = node->getDbInst()->getMaster()->getSite();
+  const auto orientation
+      = grid->getSiteOrientation(grid_x, grid_y, site).value();
   grid->paintPixel(node, grid_x, grid_y);
-  node->adjustCurrOrient(
-      pixel->sites.at(node->getDbInst()->getMaster()->getSite()));
+  node->adjustCurrOrient(orientation);
 }
 
 };  // namespace