est: adjust naming to Google-style (excluding method names)

src/cts/src/TritonCTS.cpp

@@ -2578,7 +2578,7 @@ void TritonCTS::setAllClocksPropagated()
     }
   }
 
-  estimate_parasitics_->estimateParasitics(est::ParasiticsSrc::placement);
+  estimate_parasitics_->estimateParasitics(est::ParasiticsSrc::kPlacement);
 }
 
 void TritonCTS::repairClockNets()

src/est/include/est/EstimateParasitics.h

@@ -49,10 +49,10 @@ class NetHash
 
 enum class ParasiticsSrc
 {
-  none,
-  placement,
-  global_routing,
-  detailed_routing
+  kNone,
+  kPlacement,
+  kGlobalRouting,
+  kDetailedRouting
 };
 
 struct ParasiticsResistance
@@ -134,7 +134,7 @@ class EstimateParasitics : public sta::dbStaState, public ParasiticsService
   double wireClkVCapacitance(const sta::Scene* scene) const;
   void estimateParasitics(ParasiticsSrc src);
   void estimateParasitics(ParasiticsSrc src,
-                          std::map<sta::Scene*, std::ostream*>& spef_streams_);
+                          std::map<sta::Scene*, std::ostream*>& spef_streams);
   void estimateWireParasitics(sta::SpefWriter* spef_writer = nullptr);
   void estimateWireParasitic(const sta::Net* net,
                              sta::SpefWriter* spef_writer = nullptr);
@@ -261,7 +261,7 @@ class EstimateParasitics : public sta::dbStaState, public ParasiticsService
   std::vector<ParasiticsResistance> wire_clk_res_;   // ohms/metre
   std::vector<ParasiticsCapacitance> wire_clk_cap_;  // Farads/meter
 
-  ParasiticsSrc parasitics_src_ = ParasiticsSrc::none;
+  ParasiticsSrc parasitics_src_ = ParasiticsSrc::kNone;
 
   std::unordered_set<const sta::Net*, NetHash> parasitics_invalid_;
 

src/est/include/est/SteinerTree.h

@@ -18,7 +18,7 @@
 #include "stt/flute.h"
 #include "utl/Logger.h"
 
-const int SteinerNull = -1;
+const int kSteinerNull = -1;
 
 namespace est {
 
@@ -106,7 +106,7 @@ class SteinerTree
   void locAddPin(const odb::Point& loc, const sta::Pin* pin);
   int getMaxIndex() const;
 
-  static constexpr SteinerPt null_pt = -1;
+  static constexpr SteinerPt kNullPt = -1;
 
  private:
   stt::Tree tree_;

src/est/src/EstimateParasitics.cpp

@@ -160,12 +160,12 @@ void EstimateParasitics::addSignalLayer(odb::dbTechLayer* layer)
 
 void EstimateParasitics::sortClkAndSignalLayers()
 {
-  auto sortLayers = [](const odb::dbTechLayer* a, const odb::dbTechLayer* b) {
+  auto sort_layers = [](const odb::dbTechLayer* a, const odb::dbTechLayer* b) {
     return a->getNumber() < b->getNumber();
   };
 
-  std::ranges::sort(clk_layers_, sortLayers);
-  std::ranges::sort(signal_layers_, sortLayers);
+  std::ranges::sort(clk_layers_, sort_layers);
+  std::ranges::sort(signal_layers_, sort_layers);
 }
 
 void EstimateParasitics::setHWireSignalRC(const sta::Scene* scene,
@@ -373,8 +373,8 @@ void EstimateParasitics::initBlock()
 void EstimateParasitics::ensureParasitics()
 {
   estimateParasitics(global_router_->haveRoutes()
-                         ? ParasiticsSrc::global_routing
-                         : ParasiticsSrc::placement);
+                         ? ParasiticsSrc::kGlobalRouting
+                         : ParasiticsSrc::kPlacement);
 }
 
 void EstimateParasitics::estimateParasitics(ParasiticsSrc src)
@@ -395,26 +395,26 @@ void EstimateParasitics::estimateParasitics(
   }
 
   switch (src) {
-    case ParasiticsSrc::placement:
+    case ParasiticsSrc::kPlacement:
       estimateWireParasitics(spef_writer.get());
-      parasitics_src_ = ParasiticsSrc::placement;
+      parasitics_src_ = ParasiticsSrc::kPlacement;
       break;
-    case ParasiticsSrc::global_routing:
+    case ParasiticsSrc::kGlobalRouting:
       estimateGlobalRouteRC(spef_writer.get());
-      parasitics_src_ = ParasiticsSrc::global_routing;
+      parasitics_src_ = ParasiticsSrc::kGlobalRouting;
       break;
-    case ParasiticsSrc::detailed_routing:
+    case ParasiticsSrc::kDetailedRouting:
       // TODO: call rcx to extract parasitics and load them to STA
-      parasitics_src_ = ParasiticsSrc::detailed_routing;
+      parasitics_src_ = ParasiticsSrc::kDetailedRouting;
       break;
-    case ParasiticsSrc::none:
+    case ParasiticsSrc::kNone:
       break;
   }
 }
 
 bool EstimateParasitics::haveEstimatedParasitics() const
 {
-  return parasitics_src_ != ParasiticsSrc::none;
+  return parasitics_src_ != ParasiticsSrc::kNone;
 }
 
 void EstimateParasitics::updateParasitics()
@@ -433,7 +433,7 @@ void EstimateParasitics::updateParasitics()
   network_->setDefaultLibertyLibrary(default_lib);
 
   switch (parasitics_src_) {
-    case ParasiticsSrc::placement:
+    case ParasiticsSrc::kPlacement:
       for (const sta::Net* net : parasitics_invalid_) {
         //
         // TODO: remove this check (we expect all to be flat net)
@@ -456,8 +456,8 @@ void EstimateParasitics::updateParasitics()
         estimateWireParasitic(net);
       }
       break;
-    case ParasiticsSrc::global_routing:
-    case ParasiticsSrc::detailed_routing: {
+    case ParasiticsSrc::kGlobalRouting:
+    case ParasiticsSrc::kDetailedRouting: {
       // TODO: update detailed route for modified nets
       incr_groute_->updateRoutes();
       for (const sta::Net* net : parasitics_invalid_) {
@@ -471,7 +471,7 @@ void EstimateParasitics::updateParasitics()
       }
       break;
     }
-    case ParasiticsSrc::none:
+    case ParasiticsSrc::kNone:
       break;
   }
 
@@ -480,7 +480,7 @@ void EstimateParasitics::updateParasitics()
   // annotations on the nets affected by a network edit. We need to explicitly
   // invalidate those delays. Do it in bulk instead of interleaving with each
   // groute call.
-  if (parasitics_src_ != ParasiticsSrc::none) {
+  if (parasitics_src_ != ParasiticsSrc::kNone) {
     for (const sta::Net* net : parasitics_invalid_) {
       debugPrint(logger_,
                  EST,
@@ -519,20 +519,20 @@ void EstimateParasitics::ensureWireParasitic(const sta::Pin* drvr_pin,
       || parasitics->findPiElmore(drvr_pin, sta::RiseFall::rise(), max_)
              == nullptr) {
     switch (parasitics_src_) {
-      case ParasiticsSrc::placement:
+      case ParasiticsSrc::kPlacement:
         estimateWireParasitic(drvr_pin, net);
         parasitics_invalid_.erase(net);
         break;
-      case ParasiticsSrc::global_routing: {
+      case ParasiticsSrc::kGlobalRouting: {
         incr_groute_->updateRoutes();
         estimateGlobalRouteRC(db_network_->staToDb(net));
         parasitics_invalid_.erase(net);
         break;
       }
-      case ParasiticsSrc::detailed_routing:
+      case ParasiticsSrc::kDetailedRouting:
         // TODO: call incremental drt for the modified net
         break;
-      case ParasiticsSrc::none:
+      case ParasiticsSrc::kNone:
         break;
     }
   }
@@ -631,7 +631,7 @@ void EstimateParasitics::estimateWireParasitics(sta::SpefWriter* spef_writer)
       sta::Net* cur_net = db_network_->dbToSta(db_net);
       estimateWireParasitic(cur_net, spef_writer);
     }
-    parasitics_src_ = ParasiticsSrc::placement;
+    parasitics_src_ = ParasiticsSrc::kPlacement;
     parasitics_invalid_.clear();
   }
 }
@@ -1331,18 +1331,18 @@ IncrementalParasiticsGuard::IncrementalParasiticsGuard(
     }
 
     switch (estimate_parasitics_->getParasiticsSrc()) {
-      case ParasiticsSrc::placement:
+      case ParasiticsSrc::kPlacement:
         break;
-      case ParasiticsSrc::global_routing:
-      case ParasiticsSrc::detailed_routing:
+      case ParasiticsSrc::kGlobalRouting:
+      case ParasiticsSrc::kDetailedRouting:
         // TODO: add IncrementalDRoute
         estimate_parasitics_->setIncrementalGRT(
             new grt::IncrementalGRoute(estimate_parasitics_->getGlobalRouter(),
                                        estimate_parasitics_->getBlock()));
         // Don't print verbose messages for incremental routing
         estimate_parasitics_->getGlobalRouter()->setVerbose(false);
         break;
-      case ParasiticsSrc::none:
+      case ParasiticsSrc::kNone:
         break;
     }
 
@@ -1374,15 +1374,15 @@ IncrementalParasiticsGuard::~IncrementalParasiticsGuard()
     }
 
     switch (estimate_parasitics_->getParasiticsSrc()) {
-      case ParasiticsSrc::placement:
+      case ParasiticsSrc::kPlacement:
         break;
-      case ParasiticsSrc::global_routing:
-      case ParasiticsSrc::detailed_routing:
+      case ParasiticsSrc::kGlobalRouting:
+      case ParasiticsSrc::kDetailedRouting:
         // TODO: add IncrementalDRoute
         delete estimate_parasitics_->getIncrementalGRT();
         estimate_parasitics_->setIncrementalGRT(nullptr);
         break;
-      case ParasiticsSrc::none:
+      case ParasiticsSrc::kNone:
         break;
     }
 

src/est/src/EstimateParasitics.i

@@ -90,11 +90,11 @@ using est::ParasiticsSrc;
   Tcl_Size length;
   const char *arg = Tcl_GetStringFromObj($input, &length);
   if (stringEq(arg, "placement"))
-    $1 = ParasiticsSrc::placement;
+    $1 = ParasiticsSrc::kPlacement;
   else if (stringEq(arg, "global_routing"))
-    $1 = ParasiticsSrc::global_routing;
+    $1 = ParasiticsSrc::kGlobalRouting;
   else if (stringEq(arg, "detailed_routing"))
-    $1 = ParasiticsSrc::detailed_routing;
+    $1 = ParasiticsSrc::kDetailedRouting;
   else {
     utl::Logger* logger = ord::getLogger();
     try {

src/est/src/MakeWireParasitics.cpp

@@ -86,6 +86,7 @@ void MakeWireParasitics::estimateParasitics(odb::dbNet* net,
     Parasitics* parasitics = corner->parasitics(min_max_);
     Parasitic* parasitic = parasitics->makeParasiticNetwork(sta_net, false);
 
+    resistor_id_ = 1;
     makeRouteParasitics(
         parasitics, net, route, sta_net, corner, parasitic, node_map);
     makeParasiticsToPins(
@@ -128,6 +129,7 @@ void MakeWireParasitics::estimateParasitics(odb::dbNet* net, grt::GRoute& route)
     Parasitics* parasitics = corner->parasitics(min_max_);
     Parasitic* parasitic = parasitics->makeParasiticNetwork(sta_net, false);
 
+    resistor_id_ = 1;
     makeRouteParasitics(
         parasitics, net, route, sta_net, corner, parasitic, node_map);
     makePartialParasiticsToPins(
@@ -168,7 +170,6 @@ void MakeWireParasitics::makeRouteParasitics(sta::Parasitics* parasitics,
 {
   const int min_routing_layer = global_router_->getMinRoutingLayer();
 
-  size_t resistor_id_ = 1;
   for (grt::GSegment& segment : route) {
     const int wire_length_dbu = segment.length();
 

src/est/src/SteinerTree.cpp

@@ -33,7 +33,7 @@ void SteinerTree::setTree(const stt::Tree& tree)
   tree_ = tree;
 
   // Find driver steiner point.
-  drvr_steiner_pt_ = null_pt;
+  drvr_steiner_pt_ = kNullPt;
   const odb::Point drvr_loc = drvr_location_;
   const int drvr_x = drvr_loc.getX();
   const int drvr_y = drvr_loc.getY();
@@ -133,7 +133,7 @@ void SteinerTree::report(utl::Logger* logger, const sta::Network* network)
 
 std::string SteinerTree::name(const SteinerPt pt, const sta::Network* network)
 {
-  if (pt == null_pt) {
+  if (pt == kNullPt) {
     return "NULL";
   }
   const sta::PinSeq* pt_pins = pins(pt);
@@ -179,7 +179,7 @@ SteinerPt SteinerTree::top() const
 {
   const SteinerPt driver = drvrPt();
   SteinerPt top = left(driver);
-  if (top == SteinerNull) {
+  if (top == kSteinerNull) {
     top = right(driver);
   }
   return top;
@@ -188,15 +188,15 @@ SteinerPt SteinerTree::top() const
 SteinerPt SteinerTree::left(const SteinerPt pt) const
 {
   if (pt >= (int) left_.size()) {
-    return SteinerNull;
+    return kSteinerNull;
   }
   return left_[pt];
 }
 
 SteinerPt SteinerTree::right(const SteinerPt pt) const
 {
   if (pt >= (int) right_.size()) {
-    return SteinerNull;
+    return kSteinerNull;
   }
   return right_[pt];
 }
@@ -216,26 +216,26 @@ void SteinerTree::validatePoint(const SteinerPt pt) const
 void SteinerTree::populateSides()
 {
   const int branch_count = branchCount();
-  left_.resize(branch_count, SteinerNull);
-  right_.resize(branch_count, SteinerNull);
-  std::vector<SteinerPt> adj1(branch_count, SteinerNull);
-  std::vector<SteinerPt> adj2(branch_count, SteinerNull);
-  std::vector<SteinerPt> adj3(branch_count, SteinerNull);
+  left_.resize(branch_count, kSteinerNull);
+  right_.resize(branch_count, kSteinerNull);
+  std::vector<SteinerPt> adj1(branch_count, kSteinerNull);
+  std::vector<SteinerPt> adj2(branch_count, kSteinerNull);
+  std::vector<SteinerPt> adj3(branch_count, kSteinerNull);
   for (int i = 0; i < branch_count; i++) {
     const stt::Branch& branch_pt = tree_.branch[i];
     const SteinerPt j = branch_pt.n;
     if (j != i) {
-      if (adj1[i] == SteinerNull) {
+      if (adj1[i] == kSteinerNull) {
         adj1[i] = j;
-      } else if (adj2[i] == SteinerNull) {
+      } else if (adj2[i] == kSteinerNull) {
         adj2[i] = j;
       } else {
         adj3[i] = j;
       }
 
-      if (adj1[j] == SteinerNull) {
+      if (adj1[j] == kSteinerNull) {
         adj1[j] = i;
-      } else if (adj2[j] == SteinerNull) {
+      } else if (adj2[j] == kSteinerNull) {
         adj2[j] = i;
       } else {
         adj3[j] = i;
@@ -273,14 +273,14 @@ void SteinerTree::populateSides(const SteinerPt from,
                                 const std::vector<SteinerPt>& adj2,
                                 const std::vector<SteinerPt>& adj3)
 {
-  if (adj != from && adj != SteinerNull) {
+  if (adj != from && adj != kSteinerNull) {
     if (adj == to) {
       logger_->error(EST, 92, "Steiner tree creation error.");
     }
-    if (left_[to] == SteinerNull) {
+    if (left_[to] == kSteinerNull) {
       left_[to] = adj;
       populateSides(to, adj, adj1, adj2, adj3);
-    } else if (right_[to] == SteinerNull) {
+    } else if (right_[to] == kSteinerNull) {
       right_[to] = adj;
       populateSides(to, adj, adj1, adj2, adj3);
     }

src/rsz/src/BaseMove.cc

@@ -641,9 +641,9 @@ bool BaseMove::replaceCell(sta::Instance* inst,
 
   // Legalize the position of the instance in case it leaves the die
   if (estimate_parasitics_->getParasiticsSrc()
-          == est::ParasiticsSrc::global_routing
+          == est::ParasiticsSrc::kGlobalRouting
       || estimate_parasitics_->getParasiticsSrc()
-             == est::ParasiticsSrc::detailed_routing) {
+             == est::ParasiticsSrc::kDetailedRouting) {
     opendp_->legalCellPos(db_network_->staToDb(inst));
   }