Merge branch 'master' into mpl-new-blockages

Author: joaomai

Jenkinsfile

@@ -217,28 +217,33 @@ def bazelTest = {
             checkout scm;
             sh label: 'Setup Docker Image', script: 'docker build -f docker/Dockerfile.bazel -t openroad/bazel-ci .';
         }
-        withDockerContainer(args: '-u root -v /var/run/docker.sock:/var/run/docker.sock', image: 'openroad/bazel-ci:latest') {
-            stage('bazelisk test ...') {
-                withCredentials([string(credentialsId: 'bazel-auth-token-b64', variable: 'BAZEL_AUTH_TOKEN_B64')]) {
-                    timeout(time: 120, unit: 'MINUTES') {
-                        def cmd = 'bazelisk test --config=ci --show_timestamps --test_output=errors --curses=no --force_pic --remote_header="Authorization=Basic $BAZEL_AUTH_TOKEN_B64" --profile=build.profile'
-                        try {
-                            try {
-                                sh label: 'Test, using cached results and building a minimum of dependencies', script: cmd + ' ...';
-                            } finally {
-                                sh label: 'Analyze build times', script: 'bazelisk analyze-profile build.profile';
-                            }
-                        } catch (e) {
-                            currentBuild.result = 'FAILURE';
+        try {
+            withDockerContainer(args: '-u root -v /var/run/docker.sock:/var/run/docker.sock', image: 'openroad/bazel-ci:latest') {
+                stage('bazelisk test ...') {
+                    withCredentials([string(credentialsId: 'bazel-auth-token-b64', variable: 'BAZEL_AUTH_TOKEN_B64')]) {
+                        timeout(time: 120, unit: 'MINUTES') {
+                            def cmd = 'bazelisk test --config=ci --show_timestamps --test_output=errors --curses=no --force_pic --remote_header="Authorization=Basic $BAZEL_AUTH_TOKEN_B64" --profile=build.profile'
                             try {
-                                sh label: 'Test (keep_going)', script: cmd + ' --keep_going ...';
-                            } finally {
-                                sh label: 'Analyze build times', script: 'bazelisk analyze-profile build.profile';
+                                try {
+                                    sh label: 'Test, using cached results and building a minimum of dependencies', script: cmd + ' ...';
+                                } finally {
+                                    sh label: 'Analyze build times', script: 'bazelisk analyze-profile build.profile';
+                                }
+                            } catch (e) {
+                                try {
+                                    sh label: 'Test (keep_going)', script: cmd + ' --keep_going ...';
+                                } catch (e2) {
+                                    currentBuild.result = 'FAILURE';
+                                } finally {
+                                    sh label: 'Analyze build times', script: 'bazelisk analyze-profile build.profile';
+                                }
                             }
                         }
                     }
                 }
             }
+        } catch (IOException e) {
+            echo "Caught: ${e}";
         }
     }
 }

src/cut/src/abc_library_factory.cpp

@@ -14,6 +14,7 @@
 #include "db_sta/dbNetwork.hh"
 #include "db_sta/dbSta.hh"
 #include "sta/TimingModel.hh"
+#include "utl/Logger.h"
 // Poor include definitions in ABC
 // clang-format off
 #include "misc/st/st.h"

src/cut/src/logic_extractor.cpp

@@ -20,6 +20,7 @@
 #include "sta/NetworkClass.hh"
 #include "sta/PortDirection.hh"
 #include "sta/SearchPred.hh"
+#include "utl/Logger.h"
 
 namespace cut {
 

src/dft/src/cells/ScanCellFactory.cpp

@@ -19,6 +19,7 @@
 #include "sta/Liberty.hh"
 #include "sta/NetworkClass.hh"
 #include "sta/Sequential.hh"
+#include "utl/Logger.h"
 
 namespace dft {
 

src/dft/src/utils/Utils.cpp

@@ -17,6 +17,7 @@
 #include "sta/Liberty.hh"
 #include "sta/NetworkClass.hh"
 #include "sta/SdcClass.hh"
+#include "utl/Logger.h"
 
 namespace dft::utils {
 

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});
 }
@@ -271,7 +271,7 @@ void Opendp::setFixedGridCells()
     if (cell->getType() == Node::CELL && cell->isFixed()) {
       grid_->visitCellPixels(*cell, true, [&](Pixel* pixel, bool padded) {
         if (padded) {
-          pixel->padding_reserved_by.insert(cell.get());
+          pixel->padding_reserved_by = cell.get();
         } else {
           setGridCell(*cell, pixel);
         }

src/dpl/src/Place.cpp

@@ -641,6 +641,23 @@ bool Opendp::swapCells(Node* cell1, Node* cell2)
           + distChange(cell2, cell1->getLeft(), cell1->getBottom());
 
     if (dist_change < 0) {
+      Journal journal(grid_.get(), nullptr);
+      MoveCellAction action1(cell1,
+                             cell1->getLeft(),
+                             cell1->getBottom(),
+                             cell2->getLeft(),
+                             cell2->getBottom(),
+                             cell1->isPlaced());
+      journal.addAction(action1);
+
+      MoveCellAction action2(cell2,
+                             cell2->getLeft(),
+                             cell2->getBottom(),
+                             cell1->getLeft(),
+                             cell1->getBottom(),
+                             cell2->isPlaced());
+      journal.addAction(action2);
+
       const GridX grid_x1 = grid_->gridX(cell2);
       const GridY grid_y1 = grid_->gridSnapDownY(cell2);
       const GridX grid_x2 = grid_->gridX(cell1);
@@ -650,7 +667,11 @@ bool Opendp::swapCells(Node* cell1, Node* cell2)
       unplaceCell(cell2);
       placeCell(cell1, grid_x1, grid_y1);
       placeCell(cell2, grid_x2, grid_y2);
-      return true;
+      // Check if placement is valid
+      if (drc_engine_->checkDRC(cell1) && drc_engine_->checkDRC(cell2)) {
+        return true;
+      }
+      journal.undo();
     }
   }
   return false;
@@ -873,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++) {
@@ -1208,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)
@@ -312,10 +315,8 @@ bool PlacementDRC::checkPadding(const Node* cell,
       if (hasPaddingConflict(cell, pixel->cell)) {
         return false;
       }
-      for (auto padding_cell : pixel->padding_reserved_by) {
-        if (hasPaddingConflict(cell, padding_cell)) {
-          return false;
-        }
+      if (hasPaddingConflict(cell, pixel->padding_reserved_by)) {
+        return false;
       }
     }
   }