Merge pull request #9441 from gudeh/dpl-debug-deep-iterative

dpl: debug deep iterative and new paintings

Author: maliberty

src/dpl/README.md

@@ -32,6 +32,7 @@ detailed_placement
 | `-max_displacement` | Max distance that an instance can be moved (in microns) when finding a site where it can be placed. Either set one value for both directions or set `{disp_x disp_y}` for individual directions. The default values are `{0, 0}`, and the allowed values within are integers `[0, MAX_INT]`. |
 | `-disallow_one_site_gaps` | Option is deprecated. |
 | `-report_file_name` | File name for saving the report to (e.g. `report.json`.) |
+| `-incremental` | By default DPL initiates with all instances unplaced. With this flag DPL will check for already legalized instances and set them as placed. |
 
 ### Set Placement Padding
 

src/dpl/include/dpl/Opendp.h

@@ -106,7 +106,8 @@ class Opendp
   // max_displacment is in sites. use zero for defaults.
   void detailedPlacement(int max_displacement_x,
                          int max_displacement_y,
-                         const std::string& report_file_name = std::string(""));
+                         const std::string& report_file_name = std::string(""),
+                         bool incremental = false);
   void reportLegalizationStats() const;
 
   void setPaddingGlobal(int left, int right);
@@ -115,6 +116,7 @@ class Opendp
   void setDebug(std::unique_ptr<dpl::DplObserver>& observer);
   void setJumpMoves(int jump_moves);
   void setIterativePlacement(bool iterative);
+  void setDeepIterativePlacement(bool deep_iterative);
 
   // Global padding.
   int padGlobalLeft() const;
@@ -216,7 +218,7 @@ class Opendp
   bool checkOverlap(const Node* cell, const DbuRect& rect) const;
   static bool isInside(const odb::Rect& cell, const odb::Rect& box);
   bool isInside(const Node* cell, const odb::Rect& rect) const;
-  PixelPt searchNearestSite(const Node* cell, GridX x, GridY y) const;
+  PixelPt diamondSearch(const Node* cell, GridX x, GridY y) const;
   int calcDist(GridPt p0, GridPt p1) const;
   bool canBePlaced(const Node* cell, GridX bin_x, GridY bin_y) const;
   bool checkRegionOverlap(const Node* cell,
@@ -236,6 +238,7 @@ class Opendp
   int distChange(const Node* cell, DbuX x, DbuY y) const;
   bool swapCells(Node* cell1, Node* cell2);
   bool refineMove(Node* cell);
+  void deepIterativePause(const std::string& message, bool only_print = false);
 
   DbuPt legalPt(const Node* cell, const DbuPt& pt) const;
   GridPt legalGridPt(const Node* cell, const DbuPt& pt) const;
@@ -309,6 +312,7 @@ class Opendp
   // Place fillers
   dbMasterSeq filterFillerMasters(const dbMasterSeq& filler_masters) const;
   MasterByImplant splitByImplant(const dbMasterSeq& filler_masters);
+  void setInitialGridCells();
   void setGridCells();
   dbMasterSeq& gapFillers(odb::dbTechLayer* implant,
                           GridX gap,
@@ -383,7 +387,10 @@ class Opendp
   std::unique_ptr<DplObserver> debug_observer_;
   std::unique_ptr<Node> dummy_cell_;
   int jump_moves_ = 0;
+  int move_count_ = 1;
   bool iterative_placement_ = false;
+  bool deep_iterative_placement_ = false;
+  bool incremental_ = false;
 
   // Magic numbers
   static constexpr double group_refine_percent_ = .05;

src/dpl/src/Opendp.cpp

@@ -10,6 +10,7 @@
 #include <iterator>
 #include <memory>
 #include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -93,6 +94,14 @@ void Opendp::setIterativePlacement(const bool iterative)
   iterative_placement_ = iterative;
 }
 
+void Opendp::setDeepIterativePlacement(const bool deep_iterative)
+{
+  deep_iterative_placement_ = deep_iterative;
+  if (deep_iterative) {
+    iterative_placement_ = true;
+  }
+}
+
 void Opendp::setJournal(Journal* journal)
 {
   journal_ = journal;
@@ -105,13 +114,17 @@ Journal* Opendp::getJournal() const
 
 void Opendp::detailedPlacement(const int max_displacement_x,
                                const int max_displacement_y,
-                               const std::string& report_file_name)
+                               const std::string& report_file_name,
+                               bool incremental)
 {
+  incremental_ = incremental;
   importDb();
   adjustNodesOrient();
-  for (const auto& node : network_->getNodes()) {
-    if (node->getType() == Node::CELL && !node->isFixed()) {
-      node->setPlaced(false);
+  if (!incremental_) {
+    for (const auto& node : network_->getNodes()) {
+      if (node->getType() == Node::CELL && !node->isFixed()) {
+        node->setPlaced(false);
+      }
     }
   }
 
@@ -339,6 +352,78 @@ void Opendp::findOverlapInRtree(const bgBox& queryBox,
                        std::back_inserter(overlaps));
 }
 
+void Opendp::setInitialGridCells()
+{
+  std::unordered_set<Node*> conflicted;
+  const DbuX site_width = grid_->getSiteWidth();
+
+  // Check which cells are missaligned with rows
+  for (auto& node : network_->getNodes()) {
+    if (node->getType() == Node::CELL && !node->isFixed() && node->isPlaced()) {
+      const GridX x = grid_->gridX(node.get());
+      const GridY y = grid_->gridSnapDownY(node.get());
+      if (node->getLeft() != gridToDbu(x, site_width)
+          || node->getBottom() != grid_->gridYToDbu(y)
+          || !canBePlaced(node.get(), x, y)) {
+        conflicted.insert(node.get());
+      }
+    }
+  }
+
+  // Check which cells are overlapping with other cells
+  for (auto& node : network_->getNodes()) {
+    if (node->getType() == Node::CELL && !node->isFixed() && node->isPlaced()) {
+      if (conflicted.contains(node.get())) {
+        continue;
+      }
+
+      bool node_conflicted = false;
+      grid_->visitCellPixels(
+          *node, false, [&](Pixel* pixel, [[maybe_unused]] bool padded) {
+            if (pixel->cell != nullptr && pixel->cell != node.get()) {
+              node_conflicted = true;
+              if (!pixel->cell->isFixed()) {
+                conflicted.insert(pixel->cell);
+              }
+            } else {
+              pixel->cell = node.get();
+            }
+          });
+
+      if (node_conflicted) {
+        conflicted.insert(node.get());
+      }
+    }
+  }
+
+  for (GridY y{0}; y < grid_->getRowCount(); y++) {
+    for (GridX x{0}; x < grid_->getRowSiteCount(); x++) {
+      Pixel& pixel = grid_->pixel(y, x);
+      if (pixel.cell != nullptr && !pixel.cell->isFixed()) {
+        pixel.cell = nullptr;
+      }
+    }
+  }
+
+  for (auto& node : network_->getNodes()) {
+    if (node->getType() == Node::CELL && !node->isFixed() && node->isPlaced()) {
+      if (conflicted.find(node.get()) == conflicted.end()) {
+        // This cell is perfectly legal and has no conflicts.
+        grid_->visitCellPixels(
+            *node, false, [&](Pixel* pixel, [[maybe_unused]] bool padded) {
+              pixel->cell = node.get();
+              pixel->util = 1.0;
+            });
+        grid_->paintCellPadding(node.get());
+      } else {
+        // This cell is either illegal or was part of an overlap conflict.
+        // Unplace it.
+        unplaceCell(node.get());
+      }
+    }
+  }
+}
+
 void Opendp::setFixedGridCells()
 {
   for (auto& cell : network_->getNodes()) {

src/dpl/src/Opendp.i

@@ -26,9 +26,10 @@ namespace dpl {
 void
 detailed_placement_cmd(int max_displacment_x,
                        int max_displacment_y,
-                       const char* report_file_name){
+                       const char* report_file_name,
+                       bool incremental){
   dpl::Opendp *opendp = ord::OpenRoad::openRoad()->getOpendp();
-  opendp->detailedPlacement(max_displacment_x, max_displacment_y, std::string(report_file_name));
+  opendp->detailedPlacement(max_displacment_x, max_displacment_y, std::string(report_file_name), incremental);
 }
 
 void
@@ -99,14 +100,17 @@ void
 set_debug_cmd(float min_displacement,
               const odb::dbInst* debug_instance,
               int jump_moves,
-              bool iterative_placement)
+              bool iterative_placement,
+              bool deep_iterative_placement,
+              bool paint_pixels)
 {
   dpl::Opendp* opendp = ord::OpenRoad::openRoad()->getOpendp();
   opendp->setJumpMoves(jump_moves);
   opendp->setIterativePlacement(iterative_placement);
+  opendp->setDeepIterativePlacement(deep_iterative_placement);
   if (dpl::Graphics::guiActive()) {
       std::unique_ptr<DplObserver> graphics = std::make_unique<dpl::Graphics>(
-          opendp, min_displacement, debug_instance);
+          opendp, min_displacement, debug_instance, paint_pixels);
       opendp->setDebug(graphics);
   }
 }

src/dpl/src/Opendp.tcl

@@ -4,11 +4,12 @@
 sta::define_cmd_args "detailed_placement" { \
                            [-max_displacement disp|{disp_x disp_y}] \
                            [-disallow_one_site_gaps] \
+                           [-incremental] \
                            [-report_file_name file_name]}
 
 proc detailed_placement { args } {
   sta::parse_key_args "detailed_placement" args \
-    keys {-max_displacement -report_file_name} flags {-disallow_one_site_gaps}
+    keys {-max_displacement -report_file_name} flags {-disallow_one_site_gaps -incremental}
 
   if { [info exists keys(-max_displacement)] } {
     set max_displacement $keys(-max_displacement)
@@ -47,7 +48,7 @@ proc detailed_placement { args } {
     set max_displacement_y [expr [ord::microns_to_dbu $max_displacement_y] \
       / [$site getHeight]]
     dpl::detailed_placement_cmd $max_displacement_x $max_displacement_y \
-      $file_name
+      $file_name [info exists flags(-incremental)]
     dpl::report_legalization_stats
   } else {
     utl::error "DPL" 27 "no rows defined in design. Use initialize_floorplan to add rows."
@@ -297,7 +298,7 @@ namespace eval dpl {
 # measured as a multiple of row_height.
 proc detailed_placement_debug { args } {
   sta::parse_key_args "detailed_placement_debug" args \
-    keys {-instance -min_displacement -jump_moves} flags {-iterative}
+    keys {-instance -min_displacement -jump_moves} flags {-iterative -deep_iterative -paint_pixels}
 
 
   if { [info exists keys(-min_displacement)] } {
@@ -323,7 +324,9 @@ proc detailed_placement_debug { args } {
     set debug_instance "NULL"
   }
 
-  dpl::set_debug_cmd $min_displacement $debug_instance $jump_moves [info exists flags(-iterative)]
+  dpl::set_debug_cmd $min_displacement $debug_instance $jump_moves \
+    [info exists flags(-iterative)] [info exists flags(-deep_iterative)] \
+    [info exists flags(-paint_pixels)]
 }
 
 proc get_masters_arg { arg_name arg } {