Merge remote-tracking branch 'origin/master' into dpl-bzl-fixes

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

.clang-tidy

@@ -8,7 +8,7 @@ Checks: >
   -clang-analyzer-cplusplus.NewDeleteLeaks,
   -clang-analyzer-optin.performance.Padding,
   readability-*,
-  -readability-identifier-naming
+  -readability-identifier-naming,
   -readability-braces-around-statements,
   -readability-convert-member-functions-to-static,
   -readability-function-cognitive-complexity,

src/dpl/include/dpl/Opendp.h

@@ -29,13 +29,10 @@ namespace dpl {
 
 using utl::Logger;
 
-using odb::dbBlock;
 using odb::dbDatabase;
-using odb::dbInst;
 using odb::dbMaster;
 using odb::dbMasterType;
 using odb::dbTechLayer;
-using odb::Point;
 
 class Node;
 class Group;
@@ -93,8 +90,8 @@ class Opendp
   Opendp(const Opendp&) = delete;
   Opendp& operator=(const Opendp&) = delete;
 
-  void legalCellPos(dbInst* db_inst);  // call from rsz
-  void initMacrosAndGrid();            // call from rsz
+  void legalCellPos(odb::dbInst* db_inst);  // call from rsz
+  void initMacrosAndGrid();                 // call from rsz
 
   // legalize/report
   // max_displacment is in sites. use zero for defaults.
@@ -105,15 +102,15 @@ class Opendp
 
   void setPaddingGlobal(int left, int right);
   void setPadding(dbMaster* master, int left, int right);
-  void setPadding(dbInst* inst, int left, int right);
+  void setPadding(odb::dbInst* inst, int left, int right);
   void setDebug(std::unique_ptr<dpl::DplObserver>& observer);
 
   // Global padding.
   int padGlobalLeft() const;
   int padGlobalRight() const;
   // Find instance/master/global padding value for an instance.
-  int padLeft(dbInst* inst) const;
-  int padRight(dbInst* inst) const;
+  int padLeft(odb::dbInst* inst) const;
+  int padRight(odb::dbInst* inst) const;
 
   void checkPlacement(bool verbose, const std::string& report_file_name = "");
   void fillerPlacement(const dbMasterSeq& filler_masters,
@@ -127,10 +124,11 @@ class Opendp
   void insertDecapCells(double target, IRDropByPoint& psm_ir_drops);
 
   // Get the instance adjacent to the left or right of a given instance
-  dbInst* getAdjacentInstance(dbInst* inst, bool left) const;
+  odb::dbInst* getAdjacentInstance(odb::dbInst* inst, bool left) const;
 
   // Find a cluster of instances that are touching each other
-  std::vector<dbInst*> getAdjacentInstancesCluster(dbInst* inst) const;
+  std::vector<odb::dbInst*> getAdjacentInstancesCluster(
+      odb::dbInst* inst) const;
   Padding* getPadding() { return padding_.get(); }
   void improvePlacement(int seed,
                         int max_displacement_x,
@@ -160,14 +158,14 @@ class Opendp
   friend class Graphics;
   void findDisplacementStats();
   DbuPt pointOffMacro(const Node& cell);
-  void convertDbToCell(dbInst* db_inst, Node& cell);
+  void convertDbToCell(odb::dbInst* db_inst, Node& cell);
   // Return error count.
   void saveViolations(const std::vector<Node*>& failures,
                       odb::dbMarkerCategory* category,
                       const std::string& violation_type = "") const;
   void importDb();
   void importClear();
-  odb::Rect getBbox(dbInst* inst);
+  odb::Rect getBbox(odb::dbInst* inst);
   void createNetwork();
   void createArchitecture();
   void setUpPlacementGroups();
@@ -312,7 +310,7 @@ class Opendp
 
   Logger* logger_ = nullptr;
   dbDatabase* db_ = nullptr;
-  dbBlock* block_ = nullptr;
+  odb::dbBlock* block_ = nullptr;
   odb::Rect core_;
 
   std::unique_ptr<Architecture> arch_;  // Information about rows, etc.

src/dpl/include/dpl/OptMirror.h

@@ -16,7 +16,6 @@ class Logger;
 
 namespace dpl {
 
-using odb::dbInst;
 using odb::dbNet;
 
 using utl::Logger;
@@ -53,15 +52,15 @@ class OptimizeMirroring
   void run();
 
  private:
-  int mirrorCandidates(std::vector<dbInst*>& mirror_candidates);
+  int mirrorCandidates(std::vector<odb::dbInst*>& mirror_candidates);
   void findNetBoxes();
-  std::vector<dbInst*> findMirrorCandidates(NetBoxes& net_boxes);
+  std::vector<odb::dbInst*> findMirrorCandidates(NetBoxes& net_boxes);
 
-  void updateNetBoxes(dbInst* inst);
-  void saveNetBoxes(dbInst* inst);
-  void restoreNetBoxes(dbInst* inst);
+  void updateNetBoxes(odb::dbInst* inst);
+  void saveNetBoxes(odb::dbInst* inst);
+  void restoreNetBoxes(odb::dbInst* inst);
 
-  int64_t hpwl(dbInst* inst);  // Sum of ITerm hpwl's.
+  int64_t hpwl(odb::dbInst* inst);  // Sum of ITerm hpwl's.
 
   Logger* logger_ = nullptr;
   odb::dbDatabase* db_ = nullptr;

src/dpl/src/DecapPlacement.cpp

@@ -205,13 +205,13 @@ void Opendp::insertDecapInPos(dbMaster* master,
 {
   // insert decap inst
   std::string inst_name = "DECAP_" + to_string(decap_count_);
-  dbInst* inst = dbInst::create(block_,
-                                master,
-                                inst_name.c_str(),
-                                /* physical_only */ true);
+  odb::dbInst* inst = odb::dbInst::create(block_,
+                                          master,
+                                          inst_name.c_str(),
+                                          /* physical_only */ true);
   const GridX grid_x = grid_->gridX(pos_x - core_.xMin());
   const GridY grid_y = grid_->gridSnapDownY(pos_y - core_.yMin());
-  const dbOrientType orient
+  const odb::dbOrientType orient
       = grid_->getSiteOrientation(grid_x, grid_y, master->getSite()).value();
   inst->setOrient(orient);
   inst->setLocation(pos_x.v, pos_y.v);

src/dpl/src/FillerPlacement.cpp

@@ -216,10 +216,10 @@ void Opendp::placeRowFillers(GridY row,
       for (dbMaster* master : fillers) {
         std::string inst_name
             = prefix + to_string(row.v) + "_" + to_string(k.v);
-        dbInst* inst = dbInst::create(block_,
-                                      master,
-                                      inst_name.c_str(),
-                                      /* physical_only */ true);
+        odb::dbInst* inst = odb::dbInst::create(block_,
+                                                master,
+                                                inst_name.c_str(),
+                                                /* physical_only */ true);
         DbuX x{core_.xMin() + gridToDbu(k, site_width)};
         DbuY y{core_.yMin() + grid_->gridYToDbu(row)};
         inst->setOrient(orient);
@@ -292,15 +292,15 @@ dbMasterSeq& Opendp::gapFillers(
 void Opendp::removeFillers()
 {
   block_ = db_->getChip()->getBlock();
-  for (dbInst* db_inst : block_->getInsts()) {
+  for (odb::dbInst* db_inst : block_->getInsts()) {
     if (isFiller(db_inst)) {
       odb::dbInst::destroy(db_inst);
     }
   }
 }
 
 /* static */
-bool Opendp::isFiller(dbInst* db_inst)
+bool Opendp::isFiller(odb::dbInst* db_inst)
 {
   dbMaster* db_master = db_inst->getMaster();
   return db_master->getType() == odb::dbMasterType::CORE_SPACER

src/dpl/src/Opendp.cpp

@@ -17,6 +17,7 @@
 #include "boost/geometry/geometry.hpp"
 #include "dpl/OptMirror.h"
 #include "graphics/DplObserver.h"
+#include "infrastructure/Coordinates.h"
 #include "infrastructure/Grid.h"
 #include "infrastructure/Objects.h"
 #include "infrastructure/Padding.h"
@@ -32,6 +33,7 @@ using std::string;
 
 using utl::DPL;
 
+using odb::dbInst;
 using odb::Rect;
 
 ////////////////////////////////////////////////////////////////
@@ -61,7 +63,7 @@ void Opendp::setPaddingGlobal(const int left, const int right)
   padding_->setPaddingGlobal(GridX{left}, GridX{right});
 }
 
-void Opendp::setPadding(dbInst* inst, const int left, const int right)
+void Opendp::setPadding(odb::dbInst* inst, const int left, const int right)
 {
   padding_->setPadding(inst, GridX{left}, GridX{right});
 }
@@ -138,7 +140,7 @@ void Opendp::updateDbInstLocations()
 {
   for (auto& cell : network_->getNodes()) {
     if (!cell->isFixed() && cell->isStdCell()) {
-      dbInst* db_inst_ = cell->getDbInst();
+      odb::dbInst* db_inst_ = cell->getDbInst();
       // Only move the instance if necessary to avoid triggering callbacks.
       if (db_inst_->getOrient() != cell->getOrient()) {
         db_inst_->setOrient(cell->getOrient());
@@ -234,12 +236,12 @@ int Opendp::padGlobalRight() const
   return padding_->padGlobalRight().v;
 }
 
-int Opendp::padLeft(dbInst* inst) const
+int Opendp::padLeft(odb::dbInst* inst) const
 {
   return padding_->padLeft(inst).v;
 }
 
-int Opendp::padRight(dbInst* inst) const
+int Opendp::padRight(odb::dbInst* inst) const
 {
   return padding_->padRight(inst).v;
 }
@@ -353,7 +355,7 @@ void Opendp::groupInitPixels2()
   }
 }
 
-dbInst* Opendp::getAdjacentInstance(dbInst* inst, bool left) const
+odb::dbInst* Opendp::getAdjacentInstance(odb::dbInst* inst, bool left) const
 {
   const Rect inst_rect = inst->getBBox()->getBox();
   DbuX x_dbu = left ? DbuX{inst_rect.xMin() - 1} : DbuX{inst_rect.xMax() + 1};
@@ -364,7 +366,7 @@ dbInst* Opendp::getAdjacentInstance(dbInst* inst, bool left) const
 
   Pixel* pixel = grid_->gridPixel(x, y);
 
-  dbInst* adjacent_inst = nullptr;
+  odb::dbInst* adjacent_inst = nullptr;
 
   // do not return macros, endcaps and tapcells
   if (pixel != nullptr && pixel->cell && pixel->cell->getDbInst()->isCore()) {
@@ -378,9 +380,9 @@ std::vector<dbInst*> Opendp::getAdjacentInstancesCluster(dbInst* inst) const
 {
   const bool left = true;
   const bool right = false;
-  std::vector<dbInst*> adj_inst_cluster;
+  std::vector<odb::dbInst*> adj_inst_cluster;
 
-  dbInst* left_inst = getAdjacentInstance(inst, left);
+  odb::dbInst* left_inst = getAdjacentInstance(inst, left);
   while (left_inst != nullptr) {
     adj_inst_cluster.push_back(left_inst);
     // the right instance can be ignored, since it was added in the line above
@@ -390,7 +392,7 @@ std::vector<dbInst*> Opendp::getAdjacentInstancesCluster(dbInst* inst) const
   std::reverse(adj_inst_cluster.begin(), adj_inst_cluster.end());
   adj_inst_cluster.push_back(inst);
 
-  dbInst* right_inst = getAdjacentInstance(inst, right);
+  odb::dbInst* right_inst = getAdjacentInstance(inst, right);
   while (right_inst != nullptr) {
     adj_inst_cluster.push_back(right_inst);
     // the left instance can be ignored, since it was added in the line above

src/dpl/src/OptMirror.cpp

@@ -69,7 +69,8 @@ void OptimizeMirroring::run()
          return net_box1->hpwl() > net_box2->hpwl();
        });
 
-  std::vector<dbInst*> mirror_candidates = findMirrorCandidates(sorted_boxes);
+  std::vector<odb::dbInst*> mirror_candidates
+      = findMirrorCandidates(sorted_boxes);
   odb::WireLengthEvaluator eval(block_);
   int64_t hpwl_before = eval.hpwl();
   int mirror_count = mirrorCandidates(mirror_candidates);
@@ -113,23 +114,23 @@ void OptimizeMirroring::findNetBoxes()
   }
 }
 
-std::vector<dbInst*> OptimizeMirroring::findMirrorCandidates(
+std::vector<odb::dbInst*> OptimizeMirroring::findMirrorCandidates(
     NetBoxes& net_boxes)
 {
-  std::vector<dbInst*> mirror_candidates;
-  unordered_set<dbInst*> existing;
+  std::vector<odb::dbInst*> mirror_candidates;
+  unordered_set<odb::dbInst*> existing;
   // Find inst terms on the boundary of the net boxes.
   for (NetBox* net_box : net_boxes) {
     if (!net_box->isIgnore()) {
       dbNet* net = net_box->getNet();
       const odb::Rect& box = net_box->getBox();
       for (dbITerm* iterm : net->getITerms()) {
-        dbInst* inst = iterm->getInst();
+        odb::dbInst* inst = iterm->getInst();
         int x, y;
         if (inst->isCore() && !inst->isFixed() && iterm->getAvgXY(&x, &y)
             && (x == box.xMin() || x == box.xMax() || y == box.yMin()
                 || y == box.yMax())) {
-          dbInst* inst = iterm->getInst();
+          odb::dbInst* inst = iterm->getInst();
           if (existing.find(inst) == existing.end()) {
             mirror_candidates.push_back(inst);
             existing.insert(inst);
@@ -147,10 +148,11 @@ std::vector<dbInst*> OptimizeMirroring::findMirrorCandidates(
   return mirror_candidates;
 }
 
-int OptimizeMirroring::mirrorCandidates(std::vector<dbInst*>& mirror_candidates)
+int OptimizeMirroring::mirrorCandidates(
+    std::vector<odb::dbInst*>& mirror_candidates)
 {
   int mirror_count = 0;
-  for (dbInst* inst : mirror_candidates) {
+  for (odb::dbInst* inst : mirror_candidates) {
     // Use hpwl of all nets connected to the instance terms
     // before/after to determine incremental change to total hpwl.
     int64_t hpwl_before = hpwl(inst);
@@ -199,7 +201,7 @@ static dbOrientType orientMirrorY(const dbOrientType& orient)
   return dbOrientType::R0;
 }
 
-int64_t OptimizeMirroring::hpwl(dbInst* inst)
+int64_t OptimizeMirroring::hpwl(odb::dbInst* inst)
 {
   int64_t inst_hpwl = 0;
   for (dbITerm* iterm : inst->getITerms()) {
@@ -214,7 +216,7 @@ int64_t OptimizeMirroring::hpwl(dbInst* inst)
   return inst_hpwl;
 }
 
-void OptimizeMirroring::updateNetBoxes(dbInst* inst)
+void OptimizeMirroring::updateNetBoxes(odb::dbInst* inst)
 {
   for (dbITerm* iterm : inst->getITerms()) {
     dbNet* net = iterm->getNet();
@@ -227,7 +229,7 @@ void OptimizeMirroring::updateNetBoxes(dbInst* inst)
   }
 }
 
-void OptimizeMirroring::saveNetBoxes(dbInst* inst)
+void OptimizeMirroring::saveNetBoxes(odb::dbInst* inst)
 {
   for (dbITerm* iterm : inst->getITerms()) {
     dbNet* net = iterm->getNet();
@@ -237,7 +239,7 @@ void OptimizeMirroring::saveNetBoxes(dbInst* inst)
   }
 }
 
-void OptimizeMirroring::restoreNetBoxes(dbInst* inst)
+void OptimizeMirroring::restoreNetBoxes(odb::dbInst* inst)
 {
   for (dbITerm* iterm : inst->getITerms()) {
     dbNet* net = iterm->getNet();

src/dpl/src/Place.cpp

@@ -22,6 +22,7 @@
 #include "boost/random/uniform_int_distribution.hpp"
 #include "dpl/Opendp.h"
 #include "graphics/DplObserver.h"
+#include "infrastructure/Coordinates.h"
 #include "infrastructure/Grid.h"
 #include "infrastructure/Objects.h"
 #include "infrastructure/Padding.h"
@@ -1055,7 +1056,7 @@ void Opendp::initMacrosAndGrid()
   setFixedGridCells();
 }
 
-void Opendp::convertDbToCell(dbInst* db_inst, Node& cell)
+void Opendp::convertDbToCell(odb::dbInst* db_inst, Node& cell)
 {
   cell.setType(Node::CELL);
   cell.setDbInst(db_inst);
@@ -1105,7 +1106,7 @@ DbuPt Opendp::pointOffMacro(const Node& cell)
   return init;
 }
 
-void Opendp::legalCellPos(dbInst* db_inst)
+void Opendp::legalCellPos(odb::dbInst* db_inst)
 {
   Node cell;
   convertDbToCell(db_inst, cell);