Merge pull request The-OpenROAD-Project#6765 from QuantamHD/make_rows

ifp: Adds make_rows command

Author: maliberty

src/ifp/README.md

@@ -95,6 +95,33 @@ make_tracks
 | `[-x_offset]`, `[-y_offset]` | If set, overrides the LEF technology x-/y- offset. Use the same unit as in the LEFT file. |
 | `[-x_pitch]`, `[-y_pitch]` | If set, overrides the LEF technology x-/y- pitch. Use the same unit as in the LEF file. |
 
+### Make Rows
+
+The `make_rows` command removes existing rows. 
+Use the `make_rows` command to add rows to an existing floorplan. Useful,
+if your floorplan is stored as a floorplan def without rows.
+
+```tcl
+make_rows
+  (-core_area {llx lly urx ury}) | (-core_space (space | {bottom top left right}))
+  -site site_name
+  [-additional_sites site_names]
+  [-flip_sites site_names]
+  [-row_parity NONE|EVEN|ODD]
+```
+
+#### Options
+
+
+| Switch Name | Description |
+| ----- | ----- |
+| `-core_area` | Core area coordinates in microns (lower left x/y and upper right x/y coordinates). |
+| `-core_space` | Space around the core in microns. Allowed values are either one value for all margins or a set of four values, one for each margin. The order of the four values are: `{bottom top left right}`. |
+| `-site` | Site name. |
+| `[-additional_sites]` | Tcl list of sites to make rows for (e.g. `{SITEXX, SITEYY}`) |
+| `[-flip_sites]` | Flip the orientations of rows matching these sites. Sites listed under this option will create `FS`-oriented rows at even indices and `N`-oriented rows at odd ones, and vice versa for sites not listed under this option. (e.g. `{SITEXX, SITEYY}`) |
+| `[-row_parity]` | Snap to either an odd (`ODD`) or even (`EVEN`) number of rows. Defaults to `NONE` (no constraint on parity). |
+
 ### Insert tieoff cells
 
 This comamnd inserts tiecells.

src/ifp/include/ifp/InitFloorplan.hh

@@ -94,6 +94,41 @@ class InitFloorplan
   void insertTiecells(odb::dbMTerm* tie_term,
                       const std::string& prefix = "TIEOFF_");
 
+  // Rect in DBU to set the die area of the top level block.
+  void makeDie(const odb::Rect& die);
+
+  // utilization is in [0, 100]%. This routine will calculate the required
+  // core area for all the standard cells and macros based on the desired
+  // utilization. It will then add core space to each side, and will set
+  // the die area of the top level block to that calculated value.
+  void makeDieUtilization(double utilization,
+                          double aspect_ratio,
+                          int core_space_bottom,
+                          int core_space_top,
+                          int core_space_left,
+                          int core_space_right);
+
+  // The base_site determines the single-height rows.  For hybrid rows it is
+  // a site containing a row pattern. core space is the padding on each side
+  // to inset the rows.
+  void makeRowsWithSpacing(int core_space_bottom,
+                           int core_space_top,
+                           int core_space_left,
+                           int core_space_right,
+                           odb::dbSite* base_site,
+                           const std::vector<odb::dbSite*>& additional_sites
+                           = {},
+                           RowParity row_parity = RowParity::NONE,
+                           const std::set<odb::dbSite*>& flipped_sites = {});
+
+  // The base_site determines the single-height rows.  For hybrid rows it is
+  // a site containing a row pattern.
+  void makeRows(const odb::Rect& core,
+                odb::dbSite* base_site,
+                const std::vector<odb::dbSite*>& additional_sites = {},
+                RowParity row_parity = RowParity::NONE,
+                const std::set<odb::dbSite*>& flipped_sites = {});
+
   void makeTracks();
   void makeTracks(odb::dbTechLayer* layer,
                   int x_offset,

src/ifp/src/InitFloorplan.cc

@@ -88,6 +88,26 @@ using odb::uint;
 
 using upf::eval_upf;
 
+namespace {
+void validateCoreSpacing(odb::dbBlock* block,
+                         utl::Logger* logger,
+                         int core_space_bottom,
+                         int core_space_top,
+                         int core_space_left,
+                         int core_space_right)
+{
+  utl::Validator v(logger, IFP);
+  v.check_non_negative(
+      "core_space_bottom (um) ", block->dbuToMicrons(core_space_bottom), 32);
+  v.check_non_negative(
+      "core_space_top (um) ", block->dbuToMicrons(core_space_top), 33);
+  v.check_non_negative(
+      "core_space_left (um) ", block->dbuToMicrons(core_space_left), 34);
+  v.check_non_negative(
+      "core_space_right (um) ", block->dbuToMicrons(core_space_right), 35);
+}
+}  // namespace
+
 InitFloorplan::InitFloorplan(dbBlock* block,
                              Logger* logger,
                              sta::dbNetwork* network)
@@ -106,19 +126,53 @@ void InitFloorplan::initFloorplan(
     const std::vector<odb::dbSite*>& additional_sites,
     RowParity row_parity,
     const std::set<odb::dbSite*>& flipped_sites)
+{
+  makeDieUtilization(utilization,
+                     aspect_ratio,
+                     core_space_bottom,
+                     core_space_top,
+                     core_space_left,
+                     core_space_right);
+  makeRowsWithSpacing(core_space_bottom,
+                      core_space_top,
+                      core_space_left,
+                      core_space_right,
+                      base_site,
+                      additional_sites,
+                      row_parity,
+                      flipped_sites);
+}
+
+// The base_site determines the single-height rows.  For hybrid rows it is
+// a site containing a row pattern.
+void InitFloorplan::initFloorplan(
+    const odb::Rect& die,
+    const odb::Rect& core,
+    odb::dbSite* base_site,
+    const std::vector<odb::dbSite*>& additional_sites,
+    RowParity row_parity,
+    const std::set<odb::dbSite*>& flipped_sites)
+{
+  makeDie(die);
+  makeRows(core, base_site, additional_sites, row_parity, flipped_sites);
+}
+
+void InitFloorplan::makeDieUtilization(double utilization,
+                                       double aspect_ratio,
+                                       int core_space_bottom,
+                                       int core_space_top,
+                                       int core_space_left,
+                                       int core_space_right)
 {
   utl::Validator v(logger_, IFP);
   v.check_non_negative("utilization", utilization, 12);
-  v.check_non_negative(
-      "core_space_bottom (um) ", block_->dbuToMicrons(core_space_bottom), 32);
-  v.check_non_negative(
-      "core_space_top (um) ", block_->dbuToMicrons(core_space_top), 33);
-  v.check_non_negative(
-      "core_space_left (um) ", block_->dbuToMicrons(core_space_left), 34);
-  v.check_non_negative(
-      "core_space_right (um) ", block_->dbuToMicrons(core_space_right), 35);
   v.check_positive("aspect_ratio", aspect_ratio, 36);
-
+  validateCoreSpacing(block_,
+                      logger_,
+                      core_space_bottom,
+                      core_space_top,
+                      core_space_left,
+                      core_space_right);
   utilization /= 100;
   const double design_area = designArea();
   const double core_area = design_area / utilization;
@@ -133,12 +187,17 @@ void InitFloorplan::initFloorplan(
   const int die_ly = 0;
   const int die_ux = core_ux + core_space_right;
   const int die_uy = core_uy + core_space_top;
-  initFloorplan({die_lx, die_ly, die_ux, die_uy},
-                {core_lx, core_ly, core_ux, core_uy},
-                base_site,
-                additional_sites,
-                row_parity,
-                flipped_sites);
+
+  makeDie({die_lx, die_ly, die_ux, die_uy});
+}
+
+void InitFloorplan::makeDie(const odb::Rect& die)
+{
+  Rect die_area(snapToMfgGrid(die.xMin()),
+                snapToMfgGrid(die.yMin()),
+                snapToMfgGrid(die.xMax()),
+                snapToMfgGrid(die.yMax()));
+  block_->setDieArea(die_area);
 }
 
 double InitFloorplan::designArea()
@@ -191,30 +250,62 @@ static int divCeil(int dividend, int divisor)
   return ceil(static_cast<double>(dividend) / divisor);
 }
 
-void InitFloorplan::initFloorplan(
-    const odb::Rect& die,
-    const odb::Rect& core,
+void InitFloorplan::makeRowsWithSpacing(
+    int core_space_bottom,
+    int core_space_top,
+    int core_space_left,
+    int core_space_right,
     odb::dbSite* base_site,
     const std::vector<odb::dbSite*>& additional_sites,
     RowParity row_parity,
     const std::set<odb::dbSite*>& flipped_sites)
 {
-  if (!die.contains(core)) {
+  odb::Rect block_die_area = block_->getDieArea();
+  if (block_die_area.area() == 0) {
+    logger_->error(IFP, 64, "Floorplan die area is 0. Cannot build rows.");
+  }
+
+  validateCoreSpacing(block_,
+                      logger_,
+                      core_space_bottom,
+                      core_space_top,
+                      core_space_left,
+                      core_space_right);
+
+  int lower_left_x = block_die_area.ll().x();
+  int lower_left_y = block_die_area.ll().y();
+  int upper_right_x = block_die_area.ur().x();
+  int upper_right_y = block_die_area.ur().y();
+
+  int core_lx = lower_left_x + core_space_left;
+  int core_ly = lower_left_y + core_space_bottom;
+  int core_ux = upper_right_x - core_space_right;
+  int core_uy = upper_right_y - core_space_top;
+
+  makeRows({core_lx, core_ly, core_ux, core_uy},
+           base_site,
+           additional_sites,
+           row_parity,
+           flipped_sites);
+}
+
+void InitFloorplan::makeRows(const odb::Rect& core,
+                             odb::dbSite* base_site,
+                             const std::vector<odb::dbSite*>& additional_sites,
+                             RowParity row_parity,
+                             const std::set<odb::dbSite*>& flipped_sites)
+{
+  odb::Rect block_die_area = block_->getDieArea();
+  if (block_die_area.area() == 0) {
+    logger_->error(IFP, 63, "Floorplan die area is 0. Cannot build rows.");
+  }
+
+  if (!block_die_area.contains(core)) {
     logger_->error(IFP, 55, "Die area must contain the core area.");
   }
 
   checkInstanceDimensions(core);
 
-  Rect die_area(snapToMfgGrid(die.xMin()),
-                snapToMfgGrid(die.yMin()),
-                snapToMfgGrid(die.xMax()),
-                snapToMfgGrid(die.yMax()));
-  block_->setDieArea(die_area);
-
-  if (!base_site) {
-    return;  // skip row building
-  }
-
   // The same site can appear in more than one LEF file and therefore
   // in more than one dbLib.  We merge them by name to avoid duplicate
   // rows.

src/ifp/src/InitFloorplan.i

@@ -40,6 +40,7 @@
 #include "ord/OpenRoad.hh"
 #include "ord/Design.h"
 #include "utl/Logger.h"
+#include "odb/geom.h"
 
 // Defined by OpenRoad.i
 namespace ord {
@@ -89,48 +90,29 @@ static utl::Logger* getLogger() {
 
 namespace ifp {
 
-void
-init_floorplan_core(ord::Design* design,
+void make_die(ord::Design* design,
                     int die_lx,
                     int die_ly,
                     int die_ux,
-                    int die_uy,
-                    int core_lx,
-                    int core_ly,
-                    int core_ux,
-                    int core_uy,
-                    odb::dbSite* site,
-                    const std::vector<odb::dbSite*>& additional_sites,
-                    ifp::RowParity row_parity,
-                    const std::vector<odb::dbSite*>& flipped_sites)
+                    int die_uy)
 {
-  std::set<odb::dbSite*> flipped_sites_set(flipped_sites.begin(),
-                                           flipped_sites.end());
-  design->getFloorplan().initFloorplan({die_lx, die_ly, die_ux, die_uy},
-                                {core_lx, core_ly, core_ux, core_uy},
-                                site, additional_sites, row_parity, flipped_sites_set); 
+  design->getFloorplan().makeDie({die_lx, die_ly, die_ux, die_uy});
 }
 
-void
-init_floorplan_util(ord::Design* design,
-                    double util,
-                    double aspect_ratio,
-                    int core_space_bottom,
-                    int core_space_top,
-                    int core_space_left,
-                    int core_space_right,
-                    odb::dbSite* site,
-                    const std::vector<odb::dbSite*>& additional_sites,
-                    ifp::RowParity row_parity,
-                    const std::vector<odb::dbSite*>& flipped_sites)
+void make_die_util(ord::Design* design,
+                  double util,
+                  double aspect_ratio,
+                  int core_space_bottom,
+                  int core_space_top,
+                  int core_space_left,
+                  int core_space_right)
 {
-  std::set<odb::dbSite*> flipped_sites_set(flipped_sites.begin(),
-                                           flipped_sites.end());
-  design->getFloorplan().initFloorplan(util, aspect_ratio,
-                                core_space_bottom, core_space_top,
-                                core_space_left, core_space_right,
-                                site, additional_sites, row_parity,
-                                flipped_sites_set);
+  design->getFloorplan().makeDieUtilization(util, 
+                                            aspect_ratio, 
+                                            core_space_bottom,
+                                            core_space_top,
+                                            core_space_left,
+                                            core_space_right);
 }
 
 void
@@ -146,6 +128,48 @@ make_layer_tracks(ord::Design* design)
   design->getFloorplan().makeTracks();
 }
 
+void
+make_rows_with_spacing(ord::Design* design, 
+          int spacing_lx,
+          int spacing_ly,
+          int spacing_ux,
+          int spacing_uy,
+          odb::dbSite* site,
+          const std::vector<odb::dbSite*>& additional_sites,
+          ifp::RowParity row_parity,
+          const std::vector<odb::dbSite*>& flipped_sites)
+{
+  std::set<odb::dbSite*> flipped_sites_set(flipped_sites.begin(),
+                                           flipped_sites.end());
+  design->getFloorplan().makeRowsWithSpacing(spacing_lx, spacing_ly, 
+                                             spacing_ux, spacing_uy,
+                                             site,
+                                             additional_sites,
+                                             row_parity,
+                                             flipped_sites_set);
+}
+
+void
+make_rows(ord::Design* design, 
+          int core_lx,
+          int core_ly,
+          int core_ux,
+          int core_uy,
+          odb::dbSite* site,
+          const std::vector<odb::dbSite*>& additional_sites,
+          ifp::RowParity row_parity,
+          const std::vector<odb::dbSite*>& flipped_sites)
+{
+  
+  std::set<odb::dbSite*> flipped_sites_set(flipped_sites.begin(),
+                                           flipped_sites.end());
+  design->getFloorplan().makeRows({core_lx, core_ly, core_ux, core_uy},
+                                  site,
+                                  additional_sites,
+                                  row_parity,
+                                  flipped_sites_set);
+}
+
 void
 make_layer_tracks(ord::Design* design,
                   odb::dbTechLayer* layer,