Merge pull request #8703 from arthurjolo/est_remove_wrong_dead_code

EST: Remove dead code

Author: maliberty

src/est/include/est/EstimateParasitics.h

@@ -247,10 +247,6 @@ class EstimateParasitics : public dbStaState
   bool isPadPin(const Pin* pin) const;
   bool isPad(const Instance* inst) const;
   float pinCapacitance(const Pin* pin, const DcalcAnalysisPt* dcalc_ap) const;
-  float totalLoad(SteinerTree* tree) const;
-  float subtreeLoad(SteinerTree* tree,
-                    float cap_per_micron,
-                    SteinerPt pt) const;
   odb::dbTechLayer* getPinLayer(const Pin* pin);
   double computeAverageCutResistance(Corner* corner);
   void parasiticNodeConnectPins(Parasitic* parasitic,

src/est/include/est/SteinerTree.h

@@ -103,7 +103,6 @@ class SteinerTree
                      const std::vector<SteinerPt>& adj1,
                      const std::vector<SteinerPt>& adj2,
                      const std::vector<SteinerPt>& adj3);
-  int distance(SteinerPt from, SteinerPt to) const;
 
   // "Accessors" for SteinerPts.
   const char* name(SteinerPt pt, const Network* network);

src/est/src/EstimateParasitics.cpp

@@ -775,72 +775,6 @@ float EstimateParasitics::pinCapacitance(const Pin* pin,
   return 0.0;
 }
 
-float EstimateParasitics::totalLoad(SteinerTree* tree) const
-{
-  if (!tree) {
-    return 0;
-  }
-
-  SteinerPt top_pt = tree->top();
-  SteinerPt drvr_pt = tree->drvrPt();
-
-  if (top_pt == SteinerNull) {
-    return 0;
-  }
-
-  auto top_loc = tree->location(top_pt);
-  auto drvr_loc = tree->location(drvr_pt);
-  int length = tree->distance(drvr_pt, top_pt);
-  double dx
-      = dbuToMeters(std::abs(top_loc.x() - drvr_loc.x())) / dbuToMeters(length);
-  double dy
-      = dbuToMeters(std::abs(top_loc.y() - drvr_loc.y())) / dbuToMeters(length);
-
-  float load = 0.0, max_load = 0.0;
-
-  debugPrint(logger_, EST, "estimate_parasitics", 1, "Steiner totalLoad ");
-  // For now we will just look at the worst corner for totalLoad
-  for (Corner* corner : *sta_->corners()) {
-    double wire_cap = dx * wireSignalHCapacitance(corner)
-                      + dy * wireSignalVCapacitance(corner);
-    float top_length = dbuToMeters(tree->distance(drvr_pt, top_pt));
-    float subtree_load = subtreeLoad(tree, wire_cap, top_pt);
-    load = top_length * wire_cap + subtree_load;
-    max_load = std::max(max_load, load);
-  }
-  return max_load;
-}
-
-float EstimateParasitics::subtreeLoad(SteinerTree* tree,
-                                      float cap_per_micron,
-                                      SteinerPt pt) const
-{
-  if (pt == SteinerNull) {
-    return 0;
-  }
-  SteinerPt left_pt = tree->left(pt);
-  SteinerPt right_pt = tree->right(pt);
-
-  if ((left_pt == SteinerNull) && (right_pt == SteinerNull)) {
-    return (this->pinCapacitance(tree->pin(pt), tgt_slew_dcalc_ap_));
-  }
-
-  float left_cap = 0;
-  float right_cap = 0;
-
-  if (left_pt != SteinerNull) {
-    const float left_length = dbuToMeters(tree->distance(pt, left_pt));
-    left_cap = subtreeLoad(tree, cap_per_micron, left_pt)
-               + (left_length * cap_per_micron);
-  }
-  if (right_pt != SteinerNull) {
-    const float right_length = dbuToMeters(tree->distance(pt, right_pt));
-    right_cap = subtreeLoad(tree, cap_per_micron, right_pt)
-                + (right_length * cap_per_micron);
-  }
-  return left_cap + right_cap;
-}
-
 odb::dbTechLayer* EstimateParasitics::getPinLayer(const Pin* pin)
 {
   odb::dbITerm* iterm;

src/est/src/SteinerTree.cpp

@@ -271,39 +271,6 @@ void SteinerTree::populateSides(const SteinerPt from,
   }
 }
 
-int SteinerTree::distance(const SteinerPt from, const SteinerPt to) const
-{
-  if (from == SteinerNull || to == SteinerNull) {
-    return -1;
-  }
-  if (from == to) {
-    return 0;
-  }
-  const odb::Point from_pt = location(from);
-  const odb::Point to_pt = location(to);
-  const SteinerPt left_from = left(from);
-  const SteinerPt right_from = right(from);
-  if (left_from == to || right_from == to) {
-    return abs(from_pt.x() - to_pt.x()) + abs(from_pt.y() - to_pt.y());
-  }
-  if (left_from == SteinerNull && right_from == SteinerNull) {
-    return -1;
-  }
-
-  const int find_left = distance(left_from, to);
-  if (find_left >= 0) {
-    return find_left + abs(from_pt.x() - to_pt.x())
-           + abs(from_pt.y() - to_pt.y());
-  }
-
-  const int find_right = distance(right_from, to);
-  if (find_right >= 0) {
-    return find_right + abs(from_pt.x() - to_pt.x())
-           + abs(from_pt.y() - to_pt.y());
-  }
-  return -1;
-}
-
 const Pin* SteinerTree::pin(const SteinerPt pt) const
 {
   validatePoint(pt);