Merge branch 'master' of https://github.com/The-OpenROAD-Project/OpenROAD into grt_real_capacity

Author: eder-matheus

src/gui/src/heatMap.cpp

@@ -97,7 +97,7 @@ void HeatMapDataSource::dumpToFile(const std::string& file)
 
   const double dbu_to_micron = block_->getDbUnitsPerMicron();
 
-  csv << "x0,y0,x1,y1,value" << std::endl;
+  csv << "x0,y0,x1,y1,value (" << getValueUnits() << ")" << '\n';
   for (const auto& map_col : map_) {
     for (const auto& map_value : map_col) {
       if (!map_value->has_value) {

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -263,62 +263,68 @@ void SimulatedAnnealingCore<T>::calOutlinePenalty()
 template <class T>
 void SimulatedAnnealingCore<T>::calWirelength()
 {
-  // Initialization
-  wirelength_ = 0.0;
   if (core_weights_.wirelength <= 0.0) {
     return;
   }
 
-  // calculate the total net weight
-  float tot_net_weight = 0.0;
-  for (const auto& net : nets_) {
-    tot_net_weight += net.weight;
-  }
+  wirelength_ = computeNetsWireLength(nets_);
 
-  if (tot_net_weight <= 0.0) {
-    return;
+  if (graphics_) {
+    graphics_->setWirelengthPenalty({.name = "Wire Length",
+                                     .weight = core_weights_.wirelength,
+                                     .value = wirelength_,
+                                     .normalization_factor = norm_wirelength_});
   }
+}
+
+template <class T>
+float SimulatedAnnealingCore<T>::computeNetsWireLength(
+    const std::vector<BundledNet>& nets) const
+{
+  float nets_wire_length = 0.0;
+  float nets_weight_sum = 0.0;
 
   for (const auto& net : nets_) {
-    T& source = macros_[net.terminals.first];
-    T& target = macros_[net.terminals.second];
+    nets_weight_sum += net.weight;
+  }
 
-    if (target.isClusterOfUnplacedIOPins()) {
-      computeWLForClusterOfUnplacedIOPins(source, target, net.weight);
-      continue;
-    }
+  if (nets_weight_sum != 0.0) {
+    for (const auto& net : nets) {
+      const T& source = macros_[net.terminals.first];
+      const T& target = macros_[net.terminals.second];
 
-    const float x1 = source.getPinX();
-    const float y1 = source.getPinY();
-    const float x2 = target.getPinX();
-    const float y2 = target.getPinY();
-    wirelength_ += net.weight * (std::abs(x2 - x1) + std::abs(y2 - y1));
-  }
+      if (target.isClusterOfUnplacedIOPins()) {
+        nets_wire_length
+            += computeWLForClusterOfUnplacedIOPins(source, target, net.weight);
+      } else {
+        const float x1 = source.getPinX();
+        const float y1 = source.getPinY();
+        const float x2 = target.getPinX();
+        const float y2 = target.getPinY();
 
-  // normalization
-  wirelength_ = wirelength_ / tot_net_weight
-                / (outline_.getHeight() + outline_.getWidth());
+        nets_wire_length
+            += net.weight * (std::abs(x2 - x1) + std::abs(y2 - y1));
+      }
+    }
 
-  if (graphics_) {
-    graphics_->setWirelengthPenalty({"Wire Length",
-                                     core_weights_.wirelength,
-                                     wirelength_,
-                                     norm_wirelength_});
+    nets_wire_length = nets_wire_length / nets_weight_sum
+                       / (outline_.getHeight() + outline_.getWidth());
   }
+
+  return nets_wire_length;
 }
 
 template <class T>
-void SimulatedAnnealingCore<T>::computeWLForClusterOfUnplacedIOPins(
+double SimulatedAnnealingCore<T>::computeWLForClusterOfUnplacedIOPins(
     const T& macro,
     const T& unplaced_ios,
-    const float net_weight)
+    const float net_weight) const
 {
   // To generate maximum cost.
   const float max_dist = die_area_.getPerimeter() / 2;
 
   if (isOutsideTheOutline(macro)) {
-    wirelength_ += net_weight * max_dist;
-    return;
+    return net_weight * max_dist;
   }
 
   const odb::Point macro_location(block_->micronsToDbu(macro.getPinX()),
@@ -341,7 +347,7 @@ void SimulatedAnnealingCore<T>::computeWLForClusterOfUnplacedIOPins(
         = computeDistToNearestRegion(macro_location, {constraint}, nullptr);
   }
 
-  wirelength_ += net_weight * block_->dbuToMicrons(smallest_distance);
+  return net_weight * block_->dbuToMicrons(smallest_distance);
 }
 
 // We consider the macro outside the outline based on the location of

src/mpl/src/SimulatedAnnealingCore.h

@@ -116,9 +116,10 @@ class SimulatedAnnealingCore
   virtual void calPenalty() = 0;
   void calOutlinePenalty();
   void calWirelength();
-  void computeWLForClusterOfUnplacedIOPins(const T& macro,
-                                           const T& unplaced_ios,
-                                           float net_weight);
+  float computeNetsWireLength(const std::vector<BundledNet>& nets) const;
+  double computeWLForClusterOfUnplacedIOPins(const T& macro,
+                                             const T& unplaced_ios,
+                                             float net_weight) const;
   bool isOutsideTheOutline(const T& macro) const;
   void calGuidancePenalty();
   void calFencePenalty();

src/psm/README.md

@@ -145,6 +145,7 @@ set_pdnsim_source_settings
     [-bump_size size]
     [-bump_interval interval]
     [-strap_track_pitch pitch]
+    [-external_resistance resistance]
 ```
 
 #### Options
@@ -154,7 +155,8 @@ set_pdnsim_source_settings
 | `-bump_dx`,`-bump_dy` | Set the bump pitch to decide the voltage source location. The default bump pitch is 140um. |
 | `-bump_size` | Set the bump size. The default bump size is 70um. |
 | `-bump_interval` | Set the bump population interval, this is used to depopulate the bump grid to emulate signals and other power connections. The default bump pitch is 3. |
-| `-strap_track_pitch` | Sets the track pitck to use for moduling voltage sources as straps. The default is 10x. |
+| `-strap_track_pitch` | Sets the track pitch to use for modeling voltage sources as straps. The default is 10x. |
+| `-external_resistance` | Set to model the resistance of the package or power network outside the chip/block. The default value is 0.0. |
 
 ### Insert Decap Cells
 The `insert_decap` command inserts decap cells in the areas with the highest

src/psm/include/psm/pdnsim.h

@@ -56,6 +56,9 @@ class PDNSim : public odb::dbBlockCallBackObj
 
     // Straps
     int strap_track_pitch = 10;
+
+    // Source resistance
+    float resistance = 0.0;  // Ohms
   };
 
   using IRDropByPoint = std::map<odb::Point, double>;

src/psm/src/connection.cpp

@@ -204,15 +204,23 @@ TermConnection::TermConnection(Node* node0, Node* node1)
 {
 }
 
-Connection::Resistance TermConnection::getResistance(
-    const ResistanceMap& res_map) const
+std::string TermConnection::describe() const
 {
-  return kResistance;
+  return "Terminal Connection";
 }
 
-std::string TermConnection::describe() const
+/////////////////////////////
+
+FixedResistanceConnection::FixedResistanceConnection(Node* node0,
+                                                     Node* node1,
+                                                     Resistance resistance)
+    : Connection(node0, node1), res_(resistance)
 {
-  return "Terminal Connection";
+}
+
+std::string FixedResistanceConnection::describe() const
+{
+  return "Fixed Resistance Connection";
 }
 
 }  // namespace psm

src/psm/src/connection.h

@@ -131,7 +131,10 @@ class TermConnection : public Connection
  public:
   TermConnection(Node* node0, Node* node1);
 
-  Resistance getResistance(const ResistanceMap& res_map) const override;
+  Resistance getResistance(const ResistanceMap& res_map) const override
+  {
+    return kResistance;
+  }
   bool isValid() const override { return true; }
 
   void mergeWith(const Connection* other) override {}
@@ -142,4 +145,23 @@ class TermConnection : public Connection
   static constexpr Resistance kResistance = 0.001;
 };
 
+class FixedResistanceConnection : public Connection
+{
+ public:
+  FixedResistanceConnection(Node* node0, Node* node1, Resistance resistance);
+
+  Resistance getResistance(const ResistanceMap& res_map) const override
+  {
+    return res_;
+  };
+  bool isValid() const override { return true; }
+
+  void mergeWith(const Connection* other) override {}
+
+  std::string describe() const override;
+
+ private:
+  Resistance res_;
+};
+
 }  // namespace psm

src/psm/src/ir_solver.cpp

@@ -431,15 +431,17 @@ Connection::ResistanceMap IRSolver::getResistanceMap(sta::Corner* corner) const
 }
 
 Connection::ConnectionMap<Connection::Conductance>
-IRSolver::generateConductanceMap(sta::Corner* corner) const
+IRSolver::generateConductanceMap(
+    sta::Corner* corner,
+    const std::vector<std::unique_ptr<Connection>>& connections) const
 {
   const utl::DebugScopedTimer timer(
       logger_, utl::PSM, "timer", 1, "Generate conductance map: {}");
 
   const Connection::ResistanceMap resistance = getResistanceMap(corner);
 
   Connection::ConnectionMap<Connection::Conductance> conductance;
-  for (const auto& conn : network_->getConnections()) {
+  for (const auto& conn : connections) {
     const auto res = conn->getResistance(resistance);
     conductance[conn.get()] = 1.0 / res;
   }
@@ -985,7 +987,33 @@ void IRSolver::solve(sta::Corner* corner,
   voltages.clear();
   currents.clear();
 
-  const auto conductance = generateConductanceMap(corner);
+  // Build source map
+  std::vector<std::unique_ptr<SourceNode>> real_src_nodes;
+  Voltage src_voltage
+      = generateSourceNodes(source_type, source_file, corner, real_src_nodes);
+
+  std::vector<std::unique_ptr<SourceNode>> src_nodes;
+  std::vector<std::unique_ptr<Connection>> src_conns;
+  // If resistance is set, add connection from source nodes to new source and
+  // connect
+  if (generated_source_settings_.resistance > 0) {
+    src_nodes.reserve(real_src_nodes.size());
+    src_conns.reserve(real_src_nodes.size());
+    for (const auto& real_src_node : real_src_nodes) {
+      src_conns.push_back(std::make_unique<FixedResistanceConnection>(
+          real_src_node->getSource(),
+          real_src_node.get(),
+          generated_source_settings_.resistance));
+      src_nodes.push_back(std::make_unique<SourceNode>(real_src_node.get()));
+    }
+  } else {
+    src_nodes = std::move(real_src_nodes);
+    real_src_nodes.clear();
+  }
+
+  // Build conductance map
+  Connection::ConnectionMap<Connection::Conductance> conductance
+      = generateConductanceMap(corner, network_->getConnections());
   debugPrint(logger_,
              utl::PSM,
              "stats",
@@ -997,23 +1025,34 @@ void IRSolver::solve(sta::Corner* corner,
     dumpConductance(conductance, "cond");
   }
 
-  const auto node_connections = getNodeConnectionMap(conductance);
+  std::map<Node*, Connection::ConnectionSet> node_connections
+      = getNodeConnectionMap(conductance);
   Node::NodeSet all_nodes;
   for (const auto& [node, conns] : node_connections) {
     all_nodes.insert(node);
   }
 
-  const Power total_power = buildNodeCurrentMap(corner, currents);
+  // Add source conductance
+  if (!src_conns.empty()) {
+    const auto src_conductance = generateConductanceMap(corner, src_conns);
+    for (const auto& [conn, cond] : src_conductance) {
+      conductance[conn] = cond;
+    }
+    for (const auto& [node, conns] : getNodeConnectionMap(src_conductance)) {
+      node_connections[node].insert(conns.begin(), conns.end());
+    }
+  }
 
-  // Build source map
-  std::vector<std::unique_ptr<SourceNode>> src_nodes;
-  Voltage src_voltage
-      = generateSourceNodes(source_type, source_file, corner, src_nodes);
+  const Power total_power = buildNodeCurrentMap(corner, currents);
 
   // Solve
   // create vector of nodes
   std::map<Node*, std::size_t> node_index = assignNodeIDs(all_nodes);
   const std::map<Node*, std::size_t> real_node_index = node_index;
+  for (const auto& [node, id] :
+       assignNodeIDs(real_src_nodes, node_index.size())) {
+    node_index[node] = id;
+  }
   for (const auto& [node, id] : assignNodeIDs(src_nodes, node_index.size())) {
     node_index[node] = id;
   }
@@ -1052,6 +1091,7 @@ void IRSolver::solve(sta::Corner* corner,
     if (logger_->debugCheck(utl::PSM, "dump", 1)) {
       network_->dumpNodes(node_index);
       dumpMatrix(g_matrix, "G");
+      dumpVector(j_vector, "J");
     }
     logger_->error(
         utl::PSM,
@@ -1576,7 +1616,8 @@ Connection::ConnectionMap<IRSolver::Current> IRSolver::generateCurrentMap(
 {
   const auto& voltages = voltages_.at(corner);
   Connection::ConnectionMap<IRSolver::Current> currents;
-  for (const auto& [connection, cond] : generateConductanceMap(corner)) {
+  for (const auto& [connection, cond] :
+       generateConductanceMap(corner, network_->getConnections())) {
     if (connection->hasITermNode() || connection->hasBPinNode()) {
       continue;
     }

src/psm/src/ir_solver.h

@@ -143,7 +143,8 @@ class IRSolver
       sta::Corner* corner) const;
 
   Connection::ConnectionMap<Connection::Conductance> generateConductanceMap(
-      sta::Corner* corner) const;
+      sta::Corner* corner,
+      const std::vector<std::unique_ptr<Connection>>& connections) const;
   Voltage generateSourceNodes(
       GeneratedSourceType source_type,
       const std::string& source_file,

src/psm/src/pdnsim.cpp

@@ -205,6 +205,9 @@ void PDNSim::setGeneratedSourceSettings(const GeneratedSourceSettings& settings)
   if (settings.strap_track_pitch > 0) {
     generated_source_settings_.strap_track_pitch = settings.strap_track_pitch;
   }
+  if (settings.resistance > 0) {
+    generated_source_settings_.resistance = settings.resistance;
+  }
 }
 
 void PDNSim::clearSolvers()