Merge pull request #8805 from gadfort/pad-imp

pad: add user control of `place_pads` mode and fix rounding error in uniform placement

Author: gadfort

src/pad/README.md

@@ -219,6 +219,7 @@ place_pads -row IO_SOUTH u_reset.u_in u_reset.u_out
 ```tcl
 place_pads
     -row row_name
+    [-mode mode]
     pads
 ```
 
@@ -227,8 +228,18 @@ place_pads
 | Switch Name | Description |
 | ----- | ----- |
 | `-row` | Name of the row to place the pad into, examples include: `IO_NORTH`, `IO_SOUTH`, `IO_WEST`, `IO_EAST`, `IO_NORTH_0`, `IO_NORTH_1`. |
+| `-mode` | Select the mode to use during pad placement, choices are `bump_aligned` and `uniform`. Default will select `bump_aligned` if possible, otherwise fallback to `uniform`. |
 | `pads` | Name of the instances in the order they should be placed (left to right for `IO_SOUTH` and `IO_NORTH` and bottom to top for `IO_WEST` and `IO_EAST`). |
 
+#### Modes
+
+In `uniform` mode, the pads will be evenly spread out across the row they are assigned to, as shown in the figure below.
+
+<img src="./doc/image/mode_uniform.png" width=450px>
+
+In `bump_aligned` mode, the pads will be clustered near their assigned bumps to minimize RDL routing distances, as shown below.
+
+<img src="./doc/image/mode_bump_aligned.png" width=450px>
 
 ### Placing Pads Manually
 

src/pad/doc/image/mode_bump_aligned.png

@@ -26,6 +26,13 @@ namespace pad {
 class RDLRouter;
 class RDLGui;
 
+enum class PlacementStrategy
+{
+  DEFAULT,
+  BUMP_ALIGNED,
+  UNIFORM
+};
+
 class ICeWall
 {
  public:
@@ -67,7 +74,9 @@ class ICeWall
                 odb::dbRow* row,
                 int location,
                 bool mirror);
-  void placePads(const std::vector<odb::dbInst*>& insts, odb::dbRow* row);
+  void placePads(const std::vector<odb::dbInst*>& insts,
+                 odb::dbRow* row,
+                 const PlacementStrategy& mode);
   void placeCorner(odb::dbMaster* master, int ring_index);
   void placeFiller(const std::vector<odb::dbMaster*>& masters,
                    odb::dbRow* row,

src/pad/doc/image/mode_uniform.png

@@ -20,6 +20,7 @@
 #include "RDLRouter.h"
 #include "Utilities.h"
 #include "boost/icl/interval_set.hpp"
+#include "gui/gui.h"
 #include "odb/db.h"
 #include "odb/dbTransform.h"
 #include "odb/dbTypes.h"
@@ -678,7 +679,9 @@ int64_t ICeWall::computePadBumpDistance(odb::dbInst* inst,
   return std::numeric_limits<int64_t>::max();
 }
 
-void ICeWall::placePads(const std::vector<odb::dbInst*>& insts, odb::dbRow* row)
+void ICeWall::placePads(const std::vector<odb::dbInst*>& insts,
+                        odb::dbRow* row,
+                        const PlacementStrategy& mode)
 {
   auto* block = getBlock();
   if (block == nullptr) {
@@ -727,8 +730,18 @@ void ICeWall::placePads(const std::vector<odb::dbInst*>& insts, odb::dbRow* row)
       break;
   }
 
+  const double dbus = block->getDbUnitsPerMicron();
+  debugPrint(logger_,
+             utl::PAD,
+             "Place",
+             1,
+             "{}: Row width ({:.4f} um), total instance ({}) width {:.4f} um)",
+             row->getName(),
+             row_width / dbus,
+             inst_widths.size(),
+             total_width / dbus);
+
   if (total_width > row_width) {
-    const double dbus = block->getDbUnitsPerMicron();
     logger_->error(
         utl::PAD,
         40,
@@ -760,17 +773,34 @@ void ICeWall::placePads(const std::vector<odb::dbInst*>& insts, odb::dbRow* row)
     }
   }
 
-  if (!iterm_connections.empty()) {
-    placePadsBumpAligned(insts,
-                         row,
-                         inst_widths,
-                         total_width,
-                         row_width,
-                         row_start,
-                         iterm_connections);
-  } else {
-    placePadsUniform(
-        insts, row, inst_widths, total_width, row_width, row_start);
+  PlacementStrategy use_mode = mode;
+  if (use_mode == PlacementStrategy::DEFAULT) {
+    if (!iterm_connections.empty()) {
+      use_mode = PlacementStrategy::BUMP_ALIGNED;
+    }
+  }
+  if (use_mode == PlacementStrategy::BUMP_ALIGNED
+      && iterm_connections.empty()) {
+    logger_->warn(
+        utl::PAD, 9, "Unable to use bump_aligned mode, switching to uniform");
+    use_mode = PlacementStrategy::UNIFORM;
+  }
+
+  switch (use_mode) {
+    case PlacementStrategy::BUMP_ALIGNED:
+      placePadsBumpAligned(insts,
+                           row,
+                           inst_widths,
+                           total_width,
+                           row_width,
+                           row_start,
+                           iterm_connections);
+      break;
+    case PlacementStrategy::UNIFORM:
+    case PlacementStrategy::DEFAULT:
+      placePadsUniform(
+          insts, row, inst_widths, total_width, row_width, row_start);
+      break;
   }
 
   logger_->info(
@@ -916,6 +946,9 @@ void ICeWall::placePadsBumpAligned(
 
   int offset = row_start;
 
+  const bool gui_debug
+      = logger_->debugCheck(utl::PAD, "Place", 1) && gui::Gui::enabled();
+
   int max_travel = row_width - pads_width;
   // iterate over pads in order
   for (auto itr = insts.begin(); itr != insts.end();) {
@@ -988,6 +1021,10 @@ void ICeWall::placePadsBumpAligned(
                 * row->getSpacing();
 
       performPadFlip(row, ginst, iterm_connections);
+
+      if (gui_debug) {
+        gui::Gui::get()->pause();
+      }
     }
 
     // more iterator to next unplaced pad
@@ -1002,9 +1039,25 @@ void ICeWall::placePadsUniform(const std::vector<odb::dbInst*>& insts,
                                int row_width,
                                int row_start) const
 {
-  const double dbus = getBlock()->getDbUnitsPerMicron();
-  const int target_spacing = (row_width - pads_width) / (insts.size() + 1);
+  const bool gui_debug
+      = logger_->debugCheck(utl::PAD, "Place", 1) && gui::Gui::enabled();
+
+  const float initial_target_spacing
+      = static_cast<float>(row_width - pads_width) / (insts.size() + 1);
+  const int site_width
+      = std::min(row->getSite()->getWidth(), row->getSite()->getHeight());
+  const int target_spacing
+      = std::floor(initial_target_spacing / site_width) * site_width;
   int offset = row_start + target_spacing;
+
+  const double dbus = getBlock()->getDbUnitsPerMicron();
+  debugPrint(logger_,
+             utl::PAD,
+             "Place",
+             1,
+             "Placing pads with uniform: spacing {:.4f} um",
+             target_spacing / dbus);
+
   for (auto* inst : insts) {
     debugPrint(logger_,
                utl::PAD,
@@ -1022,6 +1075,10 @@ void ICeWall::placePadsUniform(const std::vector<odb::dbInst*>& insts,
                   /* allow_shift */ true);
     offset += inst_widths.at(inst);
     offset += target_spacing;
+
+    if (gui_debug) {
+      gui::Gui::get()->pause();
+    }
   }
 }
 

src/pad/include/pad/ICeWall.h

@@ -26,6 +26,18 @@ utl::Logger* getLogger();
 %include "exception.i"
 %include "../../Exception.i"
 
+%typemap(in) pad::PlacementStrategy {
+  char *str = Tcl_GetStringFromObj($input, 0);
+  if (strcasecmp(str, "bump_aligned") == 0) {
+    $1 = pad::PlacementStrategy::BUMP_ALIGNED;
+  } else if (strcasecmp(str, "uniform") == 0) {
+    $1 = pad::PlacementStrategy::UNIFORM;
+  } else if (strcasecmp(str, "default") == 0) {
+    $1 = pad::PlacementStrategy::DEFAULT;
+  } else {
+    $1 = pad::PlacementStrategy::DEFAULT;
+  }
+}
 
 %inline %{
 
@@ -77,9 +89,9 @@ void place_pad(odb::dbMaster* master, const char* name, odb::dbRow* row, int loc
   ord::getICeWall()->placePad(master, name, row, location, mirror);
 }
 
-void place_pads(const std::vector<odb::dbInst*>& insts, odb::dbRow* row)
+void place_pads(const std::vector<odb::dbInst*>& insts, odb::dbRow* row, pad::PlacementStrategy mode)
 {
-  ord::getICeWall()->placePads(insts, row);
+  ord::getICeWall()->placePads(insts, row, mode);
 }
 
 void place_corner(odb::dbMaster* master, int ring_index)

src/pad/src/ICeWall.cpp

@@ -234,11 +234,12 @@ proc place_pad { args } {
 }
 
 sta::define_cmd_args "place_pads" {-row row_name \
+                                   [-mode mode] \
                                    pads}
 
 proc place_pads { args } {
   sta::parse_key_args "place_pads" args \
-    keys {-row} \
+    keys {-row -mode} \
     flags {}
 
   if { $args == {} } {
@@ -249,6 +250,11 @@ proc place_pads { args } {
     set args [lindex $args 0]
   }
 
+  set mode "default"
+  if { [info exists keys(-mode)] } {
+    set mode $keys(-mode)
+  }
+
   set insts []
   foreach inst $args {
     lappend insts [pad::find_instance $inst]
@@ -257,7 +263,8 @@ proc place_pads { args } {
   pad::assert_required place_pads -row
   pad::place_pads \
     $insts \
-    [pad::get_row $keys(-row)]
+    [pad::get_row $keys(-row)] \
+    $mode
 }
 
 sta::define_cmd_args "place_io_fill" {-row row_name \

src/pad/src/pad.i

@@ -34,6 +34,7 @@ COMPULSORY_TESTS = [
     "place_pad_wrong_master",
     "place_pads_bumps",
     "place_pads_bumps_bump_overlap",
+    "place_pads_bumps_strategy",
     "place_pads_too_many",
     "place_pads_uniform",
     "place_pads_uniform_slip",

src/pad/src/pad.tcl

@@ -27,6 +27,7 @@ or_integration_tests(
     place_pad_overblockage
     place_pad_with_bumps
     place_pads_bumps_bump_overlap
+    place_pads_bumps_strategy
     place_pad_wrong_master
     place_pads_bumps
     place_pads_too_many