pdn: add ability to connect to straps from pads and attempt rebuild when no shapes were created

Signed-off-by: Peter Gadfort <[email protected]>

Author: gadfort

src/pdn/README.md

@@ -64,6 +64,8 @@ set_voltage_domain
     [-region region_name]
     [-secondary_power secondary_power_net]
     [-switched_power switched_power_net]
+    [-connect_to_pad_layers layers]
+    [-connect_to_pads]
 ```
 
 #### Options
@@ -76,6 +78,8 @@ set_voltage_domain
 | `[-region]` | Specifies a region of the design occupied by this voltage domain. |
 | `[-secondary_power]` | Specifies the name of the secondary power net for this voltage domain. |
 | `[-switched_power]` | Specifies the name of the switched power net for switched power domains. |
+| `[-connect_to_pad_layers]` | Restrict the pad pins layers to this list. |
+| `[-connect_to_pads]` | The core side of the pad pins will be connected to the grid. |
 
 ### Define Power Grids
 

src/pdn/include/pdn/PdnGen.hh

@@ -98,7 +98,8 @@ class PdnGen
                     const std::vector<odb::dbTechLayer*>& generate_obstructions,
                     PowerCell* powercell,
                     odb::dbNet* powercontrol,
-                    const char* powercontrolnetwork);
+                    const char* powercontrolnetwork,
+                    const std::vector<odb::dbTechLayer*>& pad_pin_layers);
   void makeInstanceGrid(
       VoltageDomain* domain,
       const std::string& name,

src/pdn/src/PdnGen.cc

@@ -421,7 +421,8 @@ void PdnGen::makeCoreGrid(
     const std::vector<odb::dbTechLayer*>& generate_obstructions,
     PowerCell* powercell,
     odb::dbNet* powercontrol,
-    const char* powercontrolnetwork)
+    const char* powercontrolnetwork,
+    const std::vector<odb::dbTechLayer*>& pad_pin_layers)
 {
   auto grid = std::make_unique<CoreGrid>(
       domain, name, starts_with == POWER, generate_obstructions);
@@ -450,6 +451,9 @@ void PdnGen::makeCoreGrid(
           GridSwitchedPower::fromString(powercontrolnetwork, logger_)));
     }
   }
+  if (!pad_pin_layers.empty()) {
+    grid->setupDirectConnect(pad_pin_layers);
+  }
   domain->addGrid(std::move(grid));
 }
 
@@ -574,6 +578,13 @@ void PdnGen::makeRing(Grid* grid,
   if (!pad_pin_layers.empty() && grid->type() == Grid::Core) {
     auto* core_grid = static_cast<CoreGrid*>(grid);
     core_grid->setupDirectConnect(pad_pin_layers);
+    for (const auto& comp : core_grid->getStraps()) {
+      PadDirectConnectionStraps* straps
+          = dynamic_cast<PadDirectConnectionStraps*>(comp.get());
+      if (straps) {
+        straps->setTargetType(odb::dbWireShapeType::RING);
+      }
+    }
   }
 }
 

src/pdn/src/PdnGen.i

@@ -81,7 +81,8 @@ void make_core_grid(pdn::VoltageDomain* domain,
                     const std::vector<odb::dbTechLayer*>& generate_obstructions,
                     pdn::PowerCell* powercell,
                     odb::dbNet* powercontrol,
-                    const char* powercontrolnetwork)
+                    const char* powercontrolnetwork,
+                    const std::vector<odb::dbTechLayer*>& pad_pin_layers)
 {
   PdnGen* pdngen = ord::getPdnGen();
   StartsWith starts_with = POWER;
@@ -95,7 +96,8 @@ void make_core_grid(pdn::VoltageDomain* domain,
                        generate_obstructions, 
                        powercell, 
                        powercontrol, 
-                       powercontrolnetwork);
+                       powercontrolnetwork,
+                       pad_pin_layers);
 }
 
 void make_instance_grid(pdn::VoltageDomain* domain,

src/pdn/src/grid.cpp

@@ -121,15 +121,21 @@ void Grid::makeShapes(const Shape::ShapeTreeMap& global_shapes,
 
   Shape::ShapeTreeMap local_shapes = global_shapes;
   // make shapes
+  std::vector<GridComponent*> deferred;
   for (auto* component : getGridComponents()) {
-    // make initial shapes
-    component->makeShapes(local_shapes);
-    // cut shapes to avoid obstructions
-    component->cutShapes(local_obstructions);
-    // add shapes and obstructions to they are accounted for in future
-    // components
-    component->getObstructions(local_obstructions);
-    component->getShapes(local_shapes);
+    if (!component->make(local_shapes, local_obstructions)) {
+      debugPrint(logger,
+                 utl::PDN,
+                 "Make",
+                 2,
+                 "Deferring shape creation for component in \"{}\".",
+                 getName());
+      deferred.push_back(component);
+    }
+  }
+  // make deferred components
+  for (auto* component : deferred) {
+    component->make(local_shapes, local_obstructions);
   }
 
   // refine shapes

src/pdn/src/grid.h

@@ -27,6 +27,7 @@ class Straps;
 class Connect;
 class GridComponent;
 class GridSwitchedPower;
+class PadDirectConnectionStraps;
 
 class PdnGen;
 

src/pdn/src/grid_component.cpp

@@ -62,6 +62,23 @@ std::string GridComponent::typeToString(Type type)
   return "Unknown";
 }
 
+bool GridComponent::make(Shape::ShapeTreeMap& shapes,
+                         Shape::ObstructionTreeMap& obstructions)
+{
+  const int shape_count = getShapeCount();
+
+  // make initial shapes
+  makeShapes(shapes);
+  // cut shapes to avoid obstructions
+  cutShapes(obstructions);
+  // add shapes and obstructions to they are accounted for in future
+  // components
+  getObstructions(obstructions);
+  getShapes(shapes);
+
+  return shape_count != getShapeCount();
+}
+
 ShapePtr GridComponent::addShape(std::unique_ptr<Shape> shape)
 {
   debugPrint(getLogger(),

src/pdn/src/grid_component.h

@@ -46,6 +46,9 @@ class GridComponent
   Grid* getGrid() const { return grid_; }
   VoltageDomain* getDomain() const;
 
+  bool make(Shape::ShapeTreeMap& shapes,
+            Shape::ObstructionTreeMap& obstructions);
+
   virtual void makeShapes(const Shape::ShapeTreeMap& other_shapes) = 0;
   virtual bool refineShapes(Shape::ShapeTreeMap& all_shapes,
                             Shape::ObstructionTreeMap& all_obstructions)

src/pdn/src/pdn.tcl

@@ -169,7 +169,9 @@ sta::define_cmd_args "define_pdn_grid" {[-name <name>] \
                                         [-obstructions <list_of_layers>] \
                                         [-power_switch_cell <name>] \
                                         [-power_control <signal_name>] \
-                                        [-power_control_network (STAR|DAISY)]
+                                        [-power_control_network (STAR|DAISY)] \
+                                        [-connect_to_pads] \
+                                        [-connect_to_pad_layers layers]
 } ;#checker off
 
 proc define_pdn_grid { args } {
@@ -840,8 +842,8 @@ proc deprecated { args_var key { use "." } } {
 proc define_pdn_grid { args } {
   sta::parse_key_args "define_pdn_grid" args \
     keys {-name -voltage_domains -pins -starts_with -obstructions -power_switch_cell \
-      -power_control -power_control_network} \
-    flags {} ;# checker off
+      -power_control -power_control_network -connect_to_pad_layers} \
+    flags {-connect_to_pads} ;# checker off
 
   sta::check_argc_eq0 "define_pdn_grid" $args
   pdn::check_design_state "define_pdn_grid"
@@ -900,6 +902,21 @@ proc define_pdn_grid { args } {
     set power_control_network $keys(-power_control_network)
   }
 
+  set connect_to_pad_layers {}
+  if { [info exists flags(-connect_to_pads)] } {
+    if { ![info exists keys(-connect_to_pad_layers)] } {
+      foreach layer [[ord::get_db_tech] getLayers] {
+        if { [$layer getType] == "ROUTING" } {
+          lappend connect_to_pad_layers $layer
+        }
+      }
+    } else {
+      foreach layer $keys(-connect_to_pad_layers) {
+        lappend connect_to_pad_layers [get_layer $layer]
+      }
+    }
+  }
+
   foreach domain $domains {
     pdn::make_core_grid \
       $domain \
@@ -909,7 +926,8 @@ proc define_pdn_grid { args } {
       $obstructions \
       $power_cell \
       $power_control \
-      $power_control_network
+      $power_control_network \
+      $connect_to_pad_layers
   }
 }
 

src/pdn/src/straps.cpp

@@ -952,8 +952,7 @@ ShapePtr PadDirectConnectionStraps::getClosestShape(
   for (auto it = search_shapes.qbegin(bgi::intersects(search_rect)
                                       && bgi::satisfies([&](const auto& other) {
                                            return other->getNet() == net
-                                                  && other->getType()
-                                                         == target_shapes_type_;
+                                                  && isTargetShape(other.get());
                                          }));
        it != search_shapes.qend();
        it++) {
@@ -1016,7 +1015,7 @@ void PadDirectConnectionStraps::makeShapesFacingCore(
   std::map<odb::dbTechLayer*, std::set<odb::dbTechLayer*>> connectable_layers;
   for (const auto& [layer, shapes] : other_shapes) {
     for (const auto& shape : shapes) {
-      if (shape->getType() == target_shapes_type_) {
+      if (isTargetShape(shape.get())) {
         const auto layers = getGrid()->connectableLayers(layer);
         pin_layers.insert(layers.begin(), layers.end());
         for (auto* clayer : layers) {
@@ -1571,6 +1570,32 @@ bool PadDirectConnectionStraps::refineShape(
   return false;
 }
 
+bool PadDirectConnectionStraps::isTargetShape(const Shape* shape) const
+{
+  if (target_shapes_type_) {
+    return shape->getType() == target_shapes_type_.value();
+  }
+
+  switch (shape->getType()) {
+    case odb::dbWireShapeType::STRIPE:
+    case odb::dbWireShapeType::RING:
+      return true;
+    case odb::dbWireShapeType::NONE:
+    case odb::dbWireShapeType::PADRING:
+    case odb::dbWireShapeType::BLOCKRING:
+    case odb::dbWireShapeType::FOLLOWPIN:
+    case odb::dbWireShapeType::IOWIRE:
+    case odb::dbWireShapeType::COREWIRE:
+    case odb::dbWireShapeType::BLOCKWIRE:
+    case odb::dbWireShapeType::BLOCKAGEWIRE:
+    case odb::dbWireShapeType::FILLWIRE:
+    case odb::dbWireShapeType::DRCFILL:
+      return false;
+  }
+
+  return false;
+}
+
 ////////
 
 RepairChannelStraps::RepairChannelStraps(