Merge pull request #8651 from hzeller/feature-20251014-using-techlayer

Fix various namespace pollutions by `using odb::...` in header files

Author: maliberty

src/dpl/include/dpl/Opendp.h

@@ -29,11 +29,6 @@ namespace dpl {
 
 using utl::Logger;
 
-using odb::dbDatabase;
-using odb::dbMaster;
-using odb::dbMasterType;
-using odb::dbTechLayer;
-
 class Node;
 class Group;
 class Master;
@@ -73,7 +68,7 @@ struct GridPt;
 struct DbuPt;
 struct DbuRect;
 
-using dbMasterSeq = std::vector<dbMaster*>;
+using dbMasterSeq = std::vector<odb::dbMaster*>;
 
 using IRDropByPoint = std::map<odb::Point, double>;
 struct GapInfo;
@@ -84,7 +79,7 @@ struct IRDrop;
 class Opendp
 {
  public:
-  Opendp(dbDatabase* db, Logger* logger);
+  Opendp(odb::dbDatabase* db, Logger* logger);
   ~Opendp();
 
   Opendp(const Opendp&) = delete;
@@ -101,7 +96,7 @@ class Opendp
   void reportLegalizationStats() const;
 
   void setPaddingGlobal(int left, int right);
-  void setPadding(dbMaster* master, int left, int right);
+  void setPadding(odb::dbMaster* master, int left, int right);
   void setPadding(odb::dbInst* inst, int left, int right);
   void setDebug(std::unique_ptr<dpl::DplObserver>& observer);
 
@@ -120,7 +115,7 @@ class Opendp
   void optimizeMirroring();
 
   // Place decap cells
-  void addDecapMaster(dbMaster* decap_master, double decap_cap);
+  void addDecapMaster(odb::dbMaster* decap_master, double decap_cap);
   void insertDecapCells(double target, IRDropByPoint& psm_ir_drops);
 
   // Get the instance adjacent to the left or right of a given instance
@@ -150,7 +145,7 @@ class Opendp
   // gap -> sequence of masters to fill the gap
   using GapFillers = std::vector<dbMasterSeq>;
 
-  using MasterByImplant = std::map<dbTechLayer*, dbMasterSeq>;
+  using MasterByImplant = std::map<odb::dbTechLayer*, dbMasterSeq>;
 
   using YCoordToGap = std::map<DbuY, std::vector<GapInfo*>>;
 
@@ -278,7 +273,7 @@ class Opendp
   dbMasterSeq filterFillerMasters(const dbMasterSeq& filler_masters) const;
   MasterByImplant splitByImplant(const dbMasterSeq& filler_masters);
   void setGridCells();
-  dbMasterSeq& gapFillers(dbTechLayer* implant,
+  dbMasterSeq& gapFillers(odb::dbTechLayer* implant,
                           GridX gap,
                           const MasterByImplant& filler_masters_by_implant);
   void placeRowFillers(GridY row,
@@ -292,7 +287,9 @@ class Opendp
   std::vector<int> findDecapCellIndices(const DbuX& gap_width,
                                         const double& current,
                                         const double& target);
-  void insertDecapInPos(dbMaster* master, const DbuX& pos_x, const DbuY& pos_y);
+  void insertDecapInPos(odb::dbMaster* master,
+                        const DbuX& pos_x,
+                        const DbuY& pos_y);
   void insertDecapInRow(const std::vector<GapInfo*>& gaps,
                         DbuY gap_y,
                         DbuX irdrop_x,
@@ -309,7 +306,7 @@ class Opendp
   void setGridLoc(Node* cell, GridX x, GridY y);
 
   Logger* logger_ = nullptr;
-  dbDatabase* db_ = nullptr;
+  odb::dbDatabase* db_ = nullptr;
   odb::dbBlock* block_ = nullptr;
   odb::Rect core_;
 
@@ -331,8 +328,8 @@ class Opendp
 
   // Filler placement.
   // gap (in sites) -> seq of masters by implant
-  std::map<dbTechLayer*, GapFillers> gap_fillers_;
-  std::map<dbMaster*, int> filler_count_;
+  std::map<odb::dbTechLayer*, GapFillers> gap_fillers_;
+  std::map<odb::dbMaster*, int> filler_count_;
   bool have_fillers_ = false;
 
   // Decap placement.

src/dpl/src/FillerPlacement.cpp

@@ -9,6 +9,7 @@
 #include "infrastructure/Grid.h"
 #include "infrastructure/Objects.h"
 #include "infrastructure/network.h"
+#include "odb/db.h"
 #include "odb/dbTypes.h"
 #include "utl/Logger.h"
 
@@ -23,7 +24,7 @@ using odb::dbPlacementStatus;
 
 using utl::format_as;
 
-static dbTechLayer* getImplant(dbMaster* master)
+static odb::dbTechLayer* getImplant(dbMaster* master)
 {
   if (!master) {
     return nullptr;
@@ -180,7 +181,7 @@ void Opendp::placeRowFillers(GridY row,
       k++;
     }
 
-    dbTechLayer* implant = nullptr;
+    odb::dbTechLayer* implant = nullptr;
     if (j > 0) {
       auto pixel = grid_->gridPixel(j - 1, row);
       if (pixel->cell && pixel->cell->getDbInst()) {
@@ -252,7 +253,7 @@ const char* Opendp::gridInstName(GridY row, GridX col)
 
 // Return list of masters to fill gap (in site width units).
 dbMasterSeq& Opendp::gapFillers(
-    dbTechLayer* implant,
+    odb::dbTechLayer* implant,
     GridX gap,
     const MasterByImplant& filler_masters_by_implant)
 {

src/dpl/src/Opendp.cpp

@@ -45,7 +45,7 @@ bool Opendp::isMultiRow(const Node* cell) const
 
 ////////////////////////////////////////////////////////////////
 
-Opendp::Opendp(dbDatabase* db, Logger* logger) : logger_(logger), db_(db)
+Opendp::Opendp(odb::dbDatabase* db, Logger* logger) : logger_(logger), db_(db)
 {
   dummy_cell_ = std::make_unique<Node>();
   dummy_cell_->setPlaced(true);
@@ -68,7 +68,7 @@ void Opendp::setPadding(odb::dbInst* inst, const int left, const int right)
   padding_->setPadding(inst, GridX{left}, GridX{right});
 }
 
-void Opendp::setPadding(dbMaster* master, const int left, const int right)
+void Opendp::setPadding(odb::dbMaster* master, const int left, const int right)
 {
   padding_->setPadding(master, GridX{left}, GridX{right});
 }

src/dpl/src/Place.cpp

@@ -894,7 +894,7 @@ bool Opendp::checkPixels(const Node* cell,
     return false;
   }
 
-  dbSite* site = cell->getSite();
+  odb::dbSite* site = cell->getSite();
   for (GridY y1 = y; y1 < y_end; y1++) {
     const bool first_row = (y1 == y);
     for (GridX x1 = x; x1 < x_end; x1++) {
@@ -1229,7 +1229,7 @@ void Opendp::placeCell(Node* cell, const GridX x, const GridY y)
   setGridLoc(cell, x, y);
   grid_->paintPixel(cell);
   cell->setPlaced(true);
-  dbSite* site = cell->getDbInst()->getMaster()->getSite();
+  odb::dbSite* site = cell->getDbInst()->getMaster()->getSite();
   cell->setOrient(grid_->getSiteOrientation(x, y, site).value());
   if (journal_) {
     MoveCellAction action(cell,

src/dpl/src/PlacementDRC.cpp

@@ -11,6 +11,7 @@
 #include "infrastructure/Padding.h"
 #include "odb/db.h"
 #include "odb/dbTransform.h"
+#include "odb/dbTypes.h"
 #include "odb/geom.h"
 
 namespace dpl {
@@ -194,6 +195,8 @@ bool PlacementDRC::checkDRC(const Node* cell,
 namespace {
 bool isCrWtBlClass(const Node* cell)
 {
+  using odb::dbMasterType;
+
   dbMasterType type = cell->getDbInst()->getMaster()->getType();
   // Use switch so if new types are added we get a compiler warning.
   switch (type.getValue()) {
@@ -245,8 +248,8 @@ bool isCrWtBlClass(const Node* cell)
 
 bool isWellTap(const Node* cell)
 {
-  dbMasterType type = cell->getDbInst()->getMaster()->getType();
-  return type == dbMasterType::CORE_WELLTAP;
+  odb::dbMasterType type = cell->getDbInst()->getMaster()->getType();
+  return type == odb::dbMasterType::CORE_WELLTAP;
 }
 
 bool allowOverlap(const Node* cell1, const Node* cell2)

src/dpl/src/dbToOpendp.cpp

@@ -182,7 +182,7 @@ void Opendp::createArchitecture()
       // error.
       continue;
     }
-    dbSite* site = row->getSite();
+    odb::dbSite* site = row->getSite();
     if (site->getHeight() > min_row_height) {
       skip_list[site->getHeight()].insert(site->getName());
       continue;

src/dpl/src/infrastructure/DecapObjects.h

@@ -5,6 +5,7 @@
 
 #include "Coordinates.h"
 #include "dpl/Opendp.h"
+#include "odb/db.h"
 
 namespace dpl {
 
@@ -22,9 +23,9 @@ struct GapInfo
 
 struct DecapCell
 {
-  dbMaster* master;
+  odb::dbMaster* master;
   double capacitance;
-  DecapCell(dbMaster* master, double& capacitance)
+  DecapCell(odb::dbMaster* master, double& capacitance)
       : master(master), capacitance(capacitance)
   {
   }

src/dpl/src/infrastructure/Grid.cpp

@@ -213,7 +213,7 @@ void Grid::markBlocked(odb::dbBlock* block)
   }
 }
 
-void Grid::initGrid(dbDatabase* db,
+void Grid::initGrid(odb::dbDatabase* db,
                     odb::dbBlock* block,
                     std::shared_ptr<Padding> padding,
                     int max_displacement_x,
@@ -228,10 +228,10 @@ void Grid::initGrid(dbDatabase* db,
   markBlocked(block);
 }
 
-std::pair<dbSite*, odb::dbOrientType> Grid::getShortestSite(GridX grid_x,
-                                                            GridY grid_y)
+std::pair<odb::dbSite*, odb::dbOrientType> Grid::getShortestSite(GridX grid_x,
+                                                                 GridY grid_y)
 {
-  dbSite* selected_site = nullptr;
+  odb::dbSite* selected_site = nullptr;
   odb::dbOrientType selected_orient;
   DbuY min_height{std::numeric_limits<int>::max()};
 
@@ -252,9 +252,8 @@ std::pair<dbSite*, odb::dbOrientType> Grid::getShortestSite(GridX grid_x,
   return {selected_site, selected_orient};
 }
 
-std::optional<odb::dbOrientType> Grid::getSiteOrientation(GridX x,
-                                                          GridY y,
-                                                          dbSite* site) const
+std::optional<odb::dbOrientType>
+Grid::getSiteOrientation(GridX x, GridY y, odb::dbSite* site) const
 {
   const RowSitesMap& sites_map = row_sites_[y.v];
   auto interval_it = sites_map.find(x.v);
@@ -365,7 +364,7 @@ void Grid::visitCellBoundaryPixels(
     }
   };
 
-  dbMaster* master = inst->getMaster();
+  odb::dbMaster* master = inst->getMaster();
   auto obstructions = master->getObstructions();
   bool have_obstructions = false;
   const odb::Rect core = getCore();
@@ -689,10 +688,10 @@ void Grid::examineRows(odb::dbBlock* block)
   block_ = block;
   has_hybrid_rows_ = false;
   bool has_non_hybrid_rows = false;
-  dbSite* first_site = nullptr;
+  odb::dbSite* first_site = nullptr;
 
   visitDbRows(block, [&](odb::dbRow* row) {
-    dbSite* site = row->getSite();
+    odb::dbSite* site = row->getSite();
     if (site->isHybrid()) {
       has_hybrid_rows_ = true;
     } else {
@@ -768,7 +767,7 @@ std::unordered_set<int> Grid::getRowCoordinates() const
   return coords;
 }
 
-bool Grid::isMultiHeight(dbMaster* master) const
+bool Grid::isMultiHeight(odb::dbMaster* master) const
 {
   if (uniform_row_height_) {
     return master->getHeight() > uniform_row_height_.value();

src/dpl/src/infrastructure/Grid.h

@@ -23,8 +23,6 @@
 
 namespace dpl {
 
-using odb::dbSite;
-
 struct GridIntervalX
 {
   GridX lo;
@@ -69,7 +67,7 @@ class Grid
  public:
   void init(Logger* logger) { logger_ = logger; }
   void setCore(const odb::Rect& core) { core_ = core; }
-  void initGrid(dbDatabase* db,
+  void initGrid(odb::dbDatabase* db,
                 odb::dbBlock* block,
                 std::shared_ptr<Padding> padding,
                 int max_displacement_x,
@@ -139,9 +137,9 @@ class Grid
 
   std::optional<odb::dbOrientType> getSiteOrientation(GridX x,
                                                       GridY y,
-                                                      dbSite* site) const;
-  std::pair<dbSite*, odb::dbOrientType> getShortestSite(GridX grid_x,
-                                                        GridY grid_y);
+                                                      odb::dbSite* site) const;
+  std::pair<odb::dbSite*, odb::dbOrientType> getShortestSite(GridX grid_x,
+                                                             GridY grid_y);
 
   void resize(int size) { pixels_.resize(size); }
   void resize(GridY size) { pixels_.resize(size.v); }
@@ -155,11 +153,11 @@ class Grid
   odb::Rect getCore() const { return core_; }
   bool cellFitsInCore(Node* cell) const;
 
-  bool isMultiHeight(dbMaster* master) const;
+  bool isMultiHeight(odb::dbMaster* master) const;
 
  private:
   // Maps a site to the right orientation to use in a given row
-  using SiteToOrientation = std::map<dbSite*, odb::dbOrientType>;
+  using SiteToOrientation = std::map<odb::dbSite*, odb::dbOrientType>;
 
   // Used to combine the SiteToOrientation for two intervals when merged
   template <typename MapType>

src/dpl/src/infrastructure/Objects.cpp

@@ -76,11 +76,11 @@ void Master::setTopPowerType(const int top_pwr)
 {
   top_pwr_ = top_pwr;
 }
-void Master::setDbMaster(dbMaster* db_master)
+void Master::setDbMaster(odb::dbMaster* db_master)
 {
   db_master_ = db_master;
 }
-dbMaster* Master::getDbMaster() const
+odb::dbMaster* Master::getDbMaster() const
 {
   return db_master_;
 }
@@ -163,7 +163,7 @@ bool Node::isHold() const
 {
   return hold_;
 }
-dbSite* Node::getSite() const
+odb::dbSite* Node::getSite() const
 {
   if (!getDbInst() || !getDbInst()->getMaster()) {
     return nullptr;
@@ -182,17 +182,17 @@ DbuX Node::siteWidth() const
 }
 bool Node::isHybrid() const
 {
-  dbSite* site = getSite();
+  odb::dbSite* site = getSite();
   return site ? site->isHybrid() : false;
 }
 bool Node::isHybridParent() const
 {
-  dbSite* site = getSite();
+  odb::dbSite* site = getSite();
   return site ? site->hasRowPattern() : false;
 }
 int64_t Node::area() const
 {
-  dbMaster* master = getDbInst()->getMaster();
+  odb::dbMaster* master = getDbInst()->getMaster();
   return int64_t(master->getWidth()) * master->getHeight();
 }
 std::string Node::name() const
@@ -238,7 +238,7 @@ bool Node::isStdCell() const
 bool Node::isBlock() const
 {
   return getDbInst()
-         && getDbInst()->getMaster()->getType() == dbMasterType::BLOCK;
+         && getDbInst()->getMaster()->getType() == odb::dbMasterType::BLOCK;
 }
 Group* Node::getGroup() const
 {