Merge pull request #7906 from gadfort/pdn-stagger

pdn: add support for staggering split cuts

Author: maliberty

src/pdn/README.md

@@ -358,6 +358,7 @@ add_pdn_connect
     [-max_rows rows]
     [-ongrid ongrid_layers]
     [-split_cuts split_cuts_mapping]
+    [-split_cuts_staggered]
 ```
 
 #### Options
@@ -373,6 +374,7 @@ add_pdn_connect
 | `[-max_rows]` | Maximum number of rows when adding arrays of vias. |
 | `[-ongrid]` | List of intermediate layers in a via stack to snap onto a routing grid. |
 | `[-split_cuts]` | Specifies layers to use split cuts on with an associated pitch, for example `{metal3 0.380 metal5 0.500}`. |
+| `[-split_cuts_staggered]` | Specified if the split cuts should be staggered, ie. the ground vias will appear with an offset of pitch / 2. |
 
 ### Repairing power grid vias after detailed routing
 

src/pdn/include/pdn/PdnGen.hh

@@ -145,18 +145,19 @@ class PdnGen
                  StartsWith starts_with,
                  ExtensionMode extend,
                  const std::vector<odb::dbNet*>& nets);
-  void makeConnect(Grid* grid,
-                   odb::dbTechLayer* layer0,
-                   odb::dbTechLayer* layer1,
-                   int cut_pitch_x,
-                   int cut_pitch_y,
-                   const std::vector<odb::dbTechViaGenerateRule*>& vias,
-                   const std::vector<odb::dbTechVia*>& techvias,
-                   int max_rows,
-                   int max_columns,
-                   const std::vector<odb::dbTechLayer*>& ongrid,
-                   const std::map<odb::dbTechLayer*, int>& split_cuts,
-                   const std::string& dont_use_vias);
+  void makeConnect(
+      Grid* grid,
+      odb::dbTechLayer* layer0,
+      odb::dbTechLayer* layer1,
+      int cut_pitch_x,
+      int cut_pitch_y,
+      const std::vector<odb::dbTechViaGenerateRule*>& vias,
+      const std::vector<odb::dbTechVia*>& techvias,
+      int max_rows,
+      int max_columns,
+      const std::vector<odb::dbTechLayer*>& ongrid,
+      const std::map<odb::dbTechLayer*, std::pair<int, bool>>& split_cuts,
+      const std::string& dont_use_vias);
 
   void writeToDb(bool add_pins, const std::string& report_file = "") const;
   void ripUp(odb::dbNet* net);

src/pdn/src/PdnGen-py.i

@@ -16,11 +16,10 @@ using namespace pdn;
 %include <std_vector.i>
 %include <std_array.i>
 %include <std_map.i>
+%include <std_pair.i>
 %include <std_set.i>
 %include <std_string.i>
 
-%include typemaps.i
-
 %import "odb.i"
 %clear int & x, int & y; // defined in dbtypes.i, must be cleared here.
 
@@ -29,9 +28,10 @@ using namespace pdn;
 // that you must %include (not %import) <std_vector.i> and <std_array.i> 
 // before these definitions
 namespace std {
+  %template() std::pair<int, bool>;
   %template(split_cuts_stuff) std::vector<int>;
   %template(stuff)        std::array<int, 4>;
-  %template(split_map)    std::map<odb::dbTechLayer *, int>;  
+  %template(split_map)    std::map<odb::dbTechLayer *, std::pair<int, bool>>;
   %template(grid_list)    std::vector<pdn::Grid *>;
   %template(domain_list)  std::vector<pdn::VoltageDomain *>;
   %template(net_list)     std::vector<odb::dbNet *>;

src/pdn/src/PdnGen.cc

@@ -599,18 +599,19 @@ void PdnGen::makeStrap(Grid* grid,
   grid->addStrap(std::move(strap));
 }
 
-void PdnGen::makeConnect(Grid* grid,
-                         odb::dbTechLayer* layer0,
-                         odb::dbTechLayer* layer1,
-                         int cut_pitch_x,
-                         int cut_pitch_y,
-                         const std::vector<odb::dbTechViaGenerateRule*>& vias,
-                         const std::vector<odb::dbTechVia*>& techvias,
-                         int max_rows,
-                         int max_columns,
-                         const std::vector<odb::dbTechLayer*>& ongrid,
-                         const std::map<odb::dbTechLayer*, int>& split_cuts,
-                         const std::string& dont_use_vias)
+void PdnGen::makeConnect(
+    Grid* grid,
+    odb::dbTechLayer* layer0,
+    odb::dbTechLayer* layer1,
+    int cut_pitch_x,
+    int cut_pitch_y,
+    const std::vector<odb::dbTechViaGenerateRule*>& vias,
+    const std::vector<odb::dbTechVia*>& techvias,
+    int max_rows,
+    int max_columns,
+    const std::vector<odb::dbTechLayer*>& ongrid,
+    const std::map<odb::dbTechLayer*, std::pair<int, bool>>& split_cuts,
+    const std::string& dont_use_vias)
 {
   auto con = std::make_unique<Connect>(grid, layer0, layer1);
   con->setCutPitch(cut_pitch_x, cut_pitch_y);
@@ -626,7 +627,13 @@ void PdnGen::makeConnect(Grid* grid,
   con->setMaxRows(max_rows);
   con->setMaxColumns(max_columns);
   con->setOnGrid(ongrid);
-  con->setSplitCuts(split_cuts);
+
+  std::map<odb::dbTechLayer*, Connect::SplitCut> split_cuts_map;
+  for (const auto& [layer, cut_def] : split_cuts) {
+    split_cuts_map[layer]
+        = Connect::SplitCut{std::get<0>(cut_def), std::get<1>(cut_def)};
+  }
+  con->setSplitCuts(split_cuts_map);
 
   if (!dont_use_vias.empty()) {
     con->filterVias(dont_use_vias);

src/pdn/src/PdnGen.i

@@ -267,12 +267,13 @@ void make_connect(const char* grid_name,
                   const std::vector<odb::dbTechLayer*>& ongrid,
                   const std::vector<odb::dbTechLayer*>& split_cuts_layers,
                   const std::vector<int>& split_cut_pitches,
+                  const bool split_cut_stagger,
                   const char* dont_use_vias)
 {
   PdnGen* pdngen = ord::getPdnGen();
-  std::map<odb::dbTechLayer*, int> split_cuts;
+  std::map<odb::dbTechLayer*, std::pair<int, bool>> split_cuts;
   for (size_t i = 0; i < split_cuts_layers.size(); i++) {
-    split_cuts[split_cuts_layers[i]] = split_cut_pitches[i];
+    split_cuts[split_cuts_layers[i]] = {split_cut_pitches[i], split_cut_stagger};
   }
   for (auto* grid : pdngen->findGrid(grid_name)) {
     pdngen->makeConnect(grid, layer0, layer1, cut_pitch_x, cut_pitch_y, vias, techvias, max_rows, max_columns, ongrid, split_cuts, dont_use_vias);

src/pdn/src/connect.cpp

@@ -92,7 +92,7 @@ void Connect::setOnGrid(const std::vector<odb::dbTechLayer*>& layers)
   ongrid_.insert(layers.begin(), layers.end());
 }
 
-void Connect::setSplitCuts(const std::map<odb::dbTechLayer*, int>& splits)
+void Connect::setSplitCuts(const std::map<odb::dbTechLayer*, SplitCut>& splits)
 {
   split_cuts_ = splits;
   // remove top and bottom layers of the stack
@@ -107,7 +107,17 @@ int Connect::getSplitCutPitch(odb::dbTechLayer* layer) const
     return 0;
   }
 
-  return layer_itr->second;
+  return layer_itr->second.pitch;
+}
+
+bool Connect::getSplitCutStagger(odb::dbTechLayer* layer) const
+{
+  auto layer_itr = split_cuts_.find(layer);
+  if (layer_itr == split_cuts_.end()) {
+    return false;
+  }
+
+  return layer_itr->second.stagger;
 }
 
 bool Connect::appliesToVia(const ViaPtr& via) const
@@ -417,10 +427,11 @@ void Connect::report() const
   }
   if (!split_cuts_.empty()) {
     logger->report("    Split cuts:");
-    for (const auto& [layer, pitch] : split_cuts_) {
-      logger->report("      Layer: {} with pitch {:.4f}",
+    for (const auto& [layer, cut_def] : split_cuts_) {
+      logger->report("      Layer: {} with pitch {:.4f}{}",
                      layer->getName(),
-                     pitch / dbu_per_micron);
+                     cut_def.pitch / dbu_per_micron,
+                     cut_def.stagger ? " staggered" : "");
     }
   }
 }
@@ -448,10 +459,27 @@ void Connect::makeVia(odb::dbSWire* wire,
     return;
   }
 
+  odb::dbNet* index_net = nullptr;
+  if (!split_cuts_.empty()) {
+    index_net = wire->getNet();
+  }
+
   const ViaIndex via_index
-      = std::make_pair(intersection.dx(), intersection.dy());
+      = std::make_tuple(index_net, intersection.dx(), intersection.dy());
   auto& via = vias_[via_index];
 
+  debugPrint(grid_->getLogger(),
+             utl::PDN,
+             "Via",
+             2,
+             "Cache {} at {} / {} / {}",
+             via == nullptr ? "miss" : "hit",
+             std::get<0>(via_index) != nullptr
+                 ? std::get<0>(via_index)->getName()
+                 : "null",
+             std::get<1>(via_index),
+             std::get<2>(via_index));
+
   bool skip_caching = false;
   // make the via stack if one is not available for the given size
   if (via == nullptr) {
@@ -509,7 +537,8 @@ void Connect::makeVia(odb::dbSWire* wire,
         }
       }
 
-      auto* new_via = makeSingleLayerVia(wire->getBlock(),
+      auto* new_via = makeSingleLayerVia(wire->getNet(),
+                                         wire->getBlock(),
                                          l0,
                                          via_lower_rects,
                                          lower_constraint,
@@ -550,6 +579,7 @@ void Connect::makeVia(odb::dbSWire* wire,
 }
 
 DbVia* Connect::generateDbVia(
+    odb::dbNet* net,
     const std::vector<std::shared_ptr<ViaGenerator>>& generators,
     odb::dbBlock* block) const
 {
@@ -571,13 +601,19 @@ DbVia* Connect::generateDbVia(
                via->getCutLayer()->getName(),
                via->hasCutClass() ? via->getCutClass()->getName() : "none");
 
-    const int lower_split = getSplitCut(via->getBottomLayer());
-    const int upper_split = getSplitCut(via->getTopLayer());
-    if (lower_split != 0 || upper_split != 0) {
-      const int pitch = std::max(lower_split, upper_split);
-      via->setSplitCutArray(lower_split != 0, upper_split != 0);
+    const auto lower_split = getSplitCut(via->getBottomLayer());
+    const auto upper_split = getSplitCut(via->getTopLayer());
+    if (lower_split.pitch != 0 || upper_split.pitch != 0) {
+      const int pitch = std::max(lower_split.pitch, upper_split.pitch);
+      via->setSplitCutArray(lower_split.pitch != 0, upper_split.pitch != 0);
       via->setCutPitchX(pitch);
       via->setCutPitchY(pitch);
+      if (lower_split.stagger || upper_split.stagger) {
+        if (net->getSigType() == odb::dbSigType::GROUND) {
+          via->setCutOffsetX(pitch / 2);
+          via->setCutOffsetY(pitch / 2);
+        }
+      }
     }
 
     const bool lower_is_internal = via->getBottomLayer() != layer0_;
@@ -628,6 +664,7 @@ DbVia* Connect::generateDbVia(
 }
 
 DbVia* Connect::makeSingleLayerVia(
+    odb::dbNet* net,
     odb::dbBlock* block,
     odb::dbTechLayer* lower,
     const std::set<odb::Rect>& lower_rects,
@@ -678,7 +715,7 @@ DbVia* Connect::makeSingleLayerVia(
              generate_vias.size(),
              generate_via_rules_.size());
 
-  DbVia* generate_via = generateDbVia(generate_vias, block);
+  DbVia* generate_via = generateDbVia(net, generate_vias, block);
 
   if (generate_via != nullptr) {
     return generate_via;
@@ -720,7 +757,7 @@ DbVia* Connect::makeSingleLayerVia(
              tech_vias.size(),
              tech_vias_.size());
 
-  return generateDbVia(tech_vias, block);
+  return generateDbVia(net, tech_vias, block);
 }
 
 void Connect::populateGenerateRules()
@@ -831,13 +868,13 @@ bool Connect::techViaContains(odb::dbTechVia* via,
   return via->getBottomLayer() == lower && via->getTopLayer() == upper;
 }
 
-int Connect::getSplitCut(odb::dbTechLayer* layer) const
+Connect::SplitCut Connect::getSplitCut(odb::dbTechLayer* layer) const
 {
   auto split_itr = split_cuts_.find(layer);
   if (split_itr != split_cuts_.end()) {
     return split_itr->second;
   }
-  return 0;
+  return SplitCut{};
 }
 
 void Connect::clearShapes()

src/pdn/src/connect.h

@@ -7,6 +7,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -19,6 +20,12 @@ namespace pdn {
 class Connect
 {
  public:
+  struct SplitCut
+  {
+    int pitch{0};
+    bool stagger{false};
+  };
+
   Connect(Grid* grid, odb::dbTechLayer* layer0, odb::dbTechLayer* layer1);
 
   void addFixedVia(odb::dbTechViaGenerateRule* via);
@@ -36,8 +43,9 @@ class Connect
 
   void setOnGrid(const std::vector<odb::dbTechLayer*>& layers);
 
-  void setSplitCuts(const std::map<odb::dbTechLayer*, int>& splits);
+  void setSplitCuts(const std::map<odb::dbTechLayer*, SplitCut>& splits);
   int getSplitCutPitch(odb::dbTechLayer* layer) const;
+  bool getSplitCutStagger(odb::dbTechLayer* layer) const;
 
   void report() const;
 
@@ -98,11 +106,11 @@ class Connect
   int max_columns_ = 0;
 
   std::set<odb::dbTechLayer*> ongrid_;
-  std::map<odb::dbTechLayer*, int> split_cuts_;
+  std::map<odb::dbTechLayer*, SplitCut> split_cuts_;
 
   // map of built vias, where the key is the width and height of the via
   // intersection, and the value points of the associated via stack.
-  using ViaIndex = std::pair<int, int>;
+  using ViaIndex = std::tuple<odb::dbNet*, int, int>;
   std::map<ViaIndex, std::unique_ptr<DbGenerateStackedVia>> vias_;
   std::vector<odb::dbTechViaGenerateRule*> generate_via_rules_;
   std::vector<odb::dbTechVia*> tech_vias_;
@@ -114,6 +122,7 @@ class Connect
       failed_vias_;
 
   DbVia* makeSingleLayerVia(
+      odb::dbNet* net,
       odb::dbBlock* block,
       odb::dbTechLayer* lower,
       const std::set<odb::Rect>& lower_rects,
@@ -133,9 +142,10 @@ class Connect
                        odb::dbTechLayer* lower,
                        odb::dbTechLayer* upper) const;
 
-  int getSplitCut(odb::dbTechLayer* layer) const;
+  SplitCut getSplitCut(odb::dbTechLayer* layer) const;
 
   DbVia* generateDbVia(
+      odb::dbNet* net,
       const std::vector<std::shared_ptr<ViaGenerator>>& generators,
       odb::dbBlock* block) const;
 

src/pdn/src/pdn.tcl

@@ -545,14 +545,15 @@ sta::define_cmd_args "add_pdn_connect" {[-grid grid_name] \
                                         [-max_rows rows] \
                                         [-max_columns columns] \
                                         [-ongrid ongrid_layers] \
-                                        [-split_cuts split_cuts_mapping]
+                                        [-split_cuts split_cuts_mapping] \
+                                        [-split_cuts_staggered]
 }
 
 proc add_pdn_connect { args } {
   sta::parse_key_args "add_pdn_connect" args \
     keys {-grid -layers -cut_pitch -fixed_vias -max_rows -max_columns -ongrid -split_cuts \
       -dont_use_vias} \
-    flags {}
+    flags {-split_cuts_staggered}
 
   sta::check_argc_eq0 "add_pdn_connect" $args
 
@@ -616,11 +617,13 @@ proc add_pdn_connect { args } {
 
   set split_cuts_layers {}
   set split_cuts_pitches {}
+  set split_cuts_staggered false
   if { [info exists keys(-split_cuts)] } {
     foreach {l pitch} $keys(-split_cuts) {
       lappend split_cuts_layers [pdn::get_layer $l]
       lappend split_cuts_pitches [ord::microns_to_dbu $pitch]
     }
+    set split_cuts_staggered [info exists flags(-split_cuts_staggered)]
   }
 
   set dont_use ""
@@ -640,6 +643,7 @@ proc add_pdn_connect { args } {
     $ongrid \
     $split_cuts_layers \
     $split_cuts_pitches \
+    $split_cuts_staggered \
     $dont_use
 }