dpl: negotiation dynamic window

src/dpl/README.md

@@ -73,6 +73,9 @@ detailed_placement
     [-report_file_name filename]
     [-use_negotiation]
     [-abacus]
+    [-site_search_window sites]
+    [-row_search_window rows]
+    [-drc_penalty penalty]
 ```
 
 #### Options
@@ -86,6 +89,9 @@ detailed_placement
 | `-report_file_name` | File name for saving the report to (e.g. `report.json`.) |
 | `-use_negotiation` | Use the NegotiationLegalizer instead of the default diamond search engine. |
 | `-abacus` | Enable the Abacus pre-pass within the NegotiationLegalizer. Only effective when `-use_negotiation` is set. |
+| `-site_search_window` | NegotiationLegalizer: maximum number of sites a cell may be moved left or right of its initial position. Default `20`. |
+| `-row_search_window` | NegotiationLegalizer: maximum number of rows a cell may be moved up or down from its initial position. Default `5`. |
+| `-drc_penalty` | NegotiationLegalizer: priority to DRC violations, ramped up each iteration to push DRC cleanup later in the run. Lower values tolerate DRC violations early on while overlaps are resolved. Default `5`. |
 
 ### Set Placement Padding
 

src/dpl/include/dpl/Opendp.h

@@ -110,7 +110,10 @@ class Opendp
                          const std::string& report_file_name = std::string(""),
                          bool incremental = false,
                          bool use_negotiation = false,
-                         bool run_abacus = false);
+                         bool run_abacus = false,
+                         int site_search_window = 0,
+                         int row_search_window = 0,
+                         double drc_penalty = 0.0);
   void reportLegalizationStats() const;
 
   void setPaddingGlobal(int left, int right);
@@ -120,6 +123,8 @@ class Opendp
   void setJumpMoves(int jump_moves);
   void setIterativePlacement(bool iterative);
   void setDeepIterativePlacement(bool deep_iterative);
+  void setNegotiationDebugInterval(int iterative_jump);
+  void setNegotiationDebugStart(int iterative_start);
 
   // Global padding.
   int padGlobalLeft() const;
@@ -366,8 +371,10 @@ class Opendp
   std::unique_ptr<PlacementDRC> drc_engine_;
   Journal* journal_ = nullptr;
 
+  // DPL-wide displacement budget set via detailedPlacement() and honored
+  // by every DPL pass (diamond search, and negotiation).
   int max_displacement_x_ = 0;  // sites
-  int max_displacement_y_ = 0;  // sites
+  int max_displacement_y_ = 0;  // rows
   bool disallow_one_site_gaps_ = false;
   std::vector<Node*> placement_failures_;
 
@@ -398,6 +405,8 @@ class Opendp
   int move_count_ = 1;
   bool iterative_debug_ = false;
   bool deep_iterative_debug_ = false;
+  int negotiation_debug_interval_ = 1;
+  int negotiation_debug_start_ = 0;
   bool incremental_ = false;
   bool use_negotiation_ = false;
 

src/dpl/src/NegotiationLegalizer.cpp

@@ -95,6 +95,16 @@ void NegotiationLegalizer::legalize()
              1,
              "NegotiationLegalizer: starting legalization.");
 
+  logger_->info(utl::DPL,
+                1103,
+                "NegotiationLegalizer search window: +/-{} sites horizontally, "
+                "+/-{} rows vertically.",
+                site_search_window_,
+                row_search_window_);
+
+  logger_->info(
+      utl::DPL, 1104, "NegotiationLegalizer DRC penalty: {}.", drc_penalty_);
+
   double init_from_db_s{0}, build_grid_s{0}, fence_regions_s{0}, abacus_s{0};
   double negotiation_s{0}, post_neg_sync_s{0}, metrics_s{0}, flush_s{0},
       orient_s{0};
@@ -114,7 +124,6 @@ void NegotiationLegalizer::legalize()
 
   if (debug_observer_) {
     debug_observer_->startPlacement(db_->getChip()->getBlock());
-    debugPause("Pause after initFromDb.");
   }
 
   {
@@ -137,6 +146,8 @@ void NegotiationLegalizer::legalize()
     initFenceRegions();
   }
 
+  debugPause("Pause after initialization.");
+
   debugPrint(logger_,
              utl::DPL,
              "negotiation",
@@ -225,12 +236,17 @@ void NegotiationLegalizer::legalize()
   }
 
   if (debug_observer_) {
-    setDplPositions();
+    commitNegotiationPosToDpl();
     // this flush may imply functional changes. It hides initial movements for
     // clean debugging negotiation phase.
-    flushToDb();
+    logger_->report(
+        "Committing post-init positions to odb; debug move line drawings will "
+        "exclude gpl-to-init displacement.");
+    commitNegotiationPosToOdb();
     pushNegotiationPixels();
-    logger_->report("Pause after Abacus pass.");
+    logger_->report(run_abacus_
+                        ? "Pause after initialization: Abacus executed."
+                        : "Pause after initialization: Abacus skipped.");
     debug_observer_->redrawAndPause();
   }
 
@@ -302,12 +318,6 @@ void NegotiationLegalizer::legalize()
       maxDisp,
       nViol);
 
-  {
-    utl::DebugScopedTimer t(
-        flush_s, logger_, utl::DPL, "negotiation_runtime", 1, "flushToDb: {}");
-    flushToDb();
-  }
-
   {
     utl::DebugScopedTimer t(orient_s,
                             logger_,
@@ -332,6 +342,16 @@ void NegotiationLegalizer::legalize()
     }
   }
 
+  {
+    utl::DebugScopedTimer t(flush_s,
+                            logger_,
+                            utl::DPL,
+                            "negotiation_runtime",
+                            1,
+                            "commitNegotiationPosToOdb: {}");
+    commitNegotiationPosToOdb();
+  }
+
   const double total_s = total_timer.elapsed();
   auto pct
       = [total_s](double t) { return total_s > 0 ? 100.0 * t / total_s : 0.0; };
@@ -348,7 +368,7 @@ void NegotiationLegalizer::legalize()
              "negotiation {:.1f}ms ({:.0f}%), "
              "postNegSync {:.1f}ms ({:.0f}%), "
              "metrics {:.1f}ms ({:.0f}%), "
-             "flushToDb {:.1f}ms ({:.0f}%), "
+             "commitNegotiationPosToOdb {:.1f}ms ({:.0f}%), "
              "orientUpdate {:.1f}ms ({:.0f}%)",
              to_ms(total_s),
              to_ms(init_from_db_s),
@@ -369,13 +389,16 @@ void NegotiationLegalizer::legalize()
              pct(flush_s),
              to_ms(orient_s),
              pct(orient_s));
+
+  debugPause("Pause after legalization complete.");
 }
 
 // ===========================================================================
-// flushToDb – write current cell positions to ODB so the GUI reflects them
+// commitNegotiationPosToOdb – write current cell positions to ODB so the GUI
+// reflects them
 // ===========================================================================
 
-void NegotiationLegalizer::flushToDb()
+void NegotiationLegalizer::commitNegotiationPosToOdb()
 {
   const Grid* dplGrid = opendp_->grid_.get();
   for (const auto& cell : cells_) {
@@ -454,17 +477,18 @@ void NegotiationLegalizer::debugPause(const std::string& msg)
   if (!debug_observer_) {
     return;
   }
-  setDplPositions();
+  commitNegotiationPosToDpl();
   pushNegotiationPixels();
   logger_->report("{}", msg);
   debug_observer_->redrawAndPause();
 }
 
 // ===========================================================================
-// setDplPositions – pass the positions to the DPL original structure (Node)
+// commitNegotiationPosToDpl – pass the positions to the DPL original structure
+// (Node)
 // ===========================================================================
 
-void NegotiationLegalizer::setDplPositions()
+void NegotiationLegalizer::commitNegotiationPosToDpl()
 {
   if (!network_) {
     return;
@@ -1012,7 +1036,6 @@ bool NegotiationLegalizer::isValidRow(int rowIdx,
   if (rowIdx < 0 || rowIdx + cell.height > grid_h_) {
     return false;
   }
-  // Every row the cell spans must have real sites.
   for (int dy = 0; dy < cell.height; ++dy) {
     if (!row_has_sites_[rowIdx + dy]) {
       return false;
@@ -1039,19 +1062,94 @@ bool NegotiationLegalizer::isValidRow(int rowIdx,
     Node* node = network_->getNode(cell.db_inst);
     if (node != nullptr && node->getMaster()->isMultiRow()
         && !opendp_->checkRowPowerCompatible(node, GridY{rowIdx})) {
-      debugPrint(logger_,
-                 utl::DPL,
-                 "negotiation",
-                 2,
-                 "rowIdx: {}, cell: {}, power incompatible",
-                 rowIdx,
-                 cell.db_inst->getName());
       return false;
     }
   }
   return true;
 }
 
+std::vector<int> NegotiationLegalizer::verticalWindowRows(const NegCell& cell,
+                                                          int seed_y,
+                                                          int probe_x,
+                                                          int count_per_side,
+                                                          int max_scan) const
+{
+  // A "wall" in the Y direction is off-core: the die edge, or a band of rows
+  // with no placement sites at all (e.g. a full-width macro/blockage row).
+  //
+  // Note we deliberately do NOT treat a macro that merely overlaps the probe
+  // column (capacity == 0 at probe_x) as a vertical wall.  probe_x is the
+  // cell's global-placement x, which may sit on top of a macro horizontally;
+  // that horizontal obstruction is resolved by the X-axis window extension, so
+  // it must not collapse the vertical row search.
+  auto hardWall = [&](int r) {
+    if (r < 0 || r + cell.height > grid_h_) {
+      return true;
+    }
+    for (int dy = 0; dy < cell.height; ++dy) {
+      if (!row_has_sites_[r + dy]) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  // Collect up to `target_valid` valid rows on one side, walking outward until
+  // it has enough, hits a macro/off-core wall, or exceeds `step_cap` steps.
+  // `step_cap` may exceed `max_scan` so the open side can reach further when
+  // the opposite side is walled.
+  auto scan = [&](int dir, int target_valid, int step_cap, bool& hit_wall) {
+    std::vector<int> found;
+    hit_wall = false;
+    for (int step = 1;
+         step <= step_cap && std::cmp_less(found.size(), target_valid);
+         ++step) {
+      const int r = seed_y + dir * step;
+      if (hardWall(r)) {
+        hit_wall = true;
+        break;
+      }
+      if (isValidRow(r, cell, probe_x)) {
+        found.push_back(r);
+      }
+    }
+    return found;
+  };
+
+  // First pass: the nominal symmetric window — up to count_per_side valid rows
+  // on each side, within the max_scan step budget.
+  bool below_wall = false;
+  bool above_wall = false;
+  std::vector<int> below = scan(+1, count_per_side, max_scan, below_wall);
+  std::vector<int> above = scan(-1, count_per_side, max_scan, above_wall);
+
+  // When a macro/off-core wall cuts one side short of its quota, extend the
+  // opposite (open) side by the shortfall so the same number of candidate rows
+  // is still explored. The open side is allowed to walk past max_scan (capped
+  // at 2 * max_scan) to find the extra rows.
+  const int below_deficit
+      = below_wall ? count_per_side - static_cast<int>(below.size()) : 0;
+  const int above_deficit
+      = above_wall ? count_per_side - static_cast<int>(above.size()) : 0;
+  if (above_deficit > 0 && !below_wall) {
+    bool dummy = false;
+    below = scan(+1, count_per_side + above_deficit, 2 * max_scan, dummy);
+  }
+  if (below_deficit > 0 && !above_wall) {
+    bool dummy = false;
+    above = scan(-1, count_per_side + below_deficit, 2 * max_scan, dummy);
+  }
+
+  std::vector<int> rows;
+  rows.reserve(below.size() + above.size() + 1);
+  if (isValidRow(seed_y, cell, probe_x)) {
+    rows.push_back(seed_y);
+  }
+  rows.insert(rows.end(), below.begin(), below.end());
+  rows.insert(rows.end(), above.begin(), above.end());
+  return rows;
+}
+
 bool NegotiationLegalizer::respectsFence(int cell_idx, int x, int y) const
 {
   const NegCell& cell = cells_[cell_idx];