Merge pull request #7800 from The-OpenROAD-Project-staging/member-underscore-tidy

various: Add _ to class members; remove from struct members

Author: maliberty

src/cts/src/SinkClustering.h

@@ -25,14 +25,14 @@ using utl::Logger;
 class Matching
 {
  public:
-  Matching(unsigned p0, unsigned p1) : p_0(p0), p_1(p1) {}
+  Matching(unsigned p0, unsigned p1) : p0_(p0), p1_(p1) {}
 
-  unsigned getP0() const { return p_0; }
-  unsigned getP1() const { return p_1; }
+  unsigned getP0() const { return p0_; }
+  unsigned getP1() const { return p1_; }
 
  private:
-  const unsigned p_0;
-  const unsigned p_1;
+  const unsigned p0_;
+  const unsigned p1_;
 };
 
 class SinkClustering

src/dpl/include/dpl/OptMirror.h

@@ -24,11 +24,17 @@ class NetBox
 {
  public:
   NetBox() = default;
-  NetBox(dbNet* net, Rect box, bool ignore);
+  NetBox(dbNet* net, const Rect& box, bool ignore);
   int64_t hpwl();
   void saveBox();
   void restoreBox();
+  bool isIgnore() const { return ignore_; }
+  dbNet* getNet() const { return net_; }
+  const Rect& getBox() const { return box_; }
 
+  void setBox(const Rect& box) { box_ = box; }
+
+ private:
   dbNet* net_ = nullptr;
   Rect box_;
   Rect box_saved_;

src/dpl/src/OptMirror.cpp

@@ -24,7 +24,7 @@ using odb::dbOrientType;
 
 static dbOrientType orientMirrorY(const dbOrientType& orient);
 
-NetBox::NetBox(dbNet* net, Rect box, bool ignore)
+NetBox::NetBox(dbNet* net, const Rect& box, bool ignore)
     : net_(net), box_(box), ignore_(ignore)
 {
 }
@@ -118,9 +118,9 @@ std::vector<dbInst*> OptimizeMirroring::findMirrorCandidates(
   unordered_set<dbInst*> existing;
   // Find inst terms on the boundary of the net boxes.
   for (NetBox* net_box : net_boxes) {
-    if (!net_box->ignore_) {
-      dbNet* net = net_box->net_;
-      Rect& box = net_box->box_;
+    if (!net_box->isIgnore()) {
+      dbNet* net = net_box->getNet();
+      const Rect& box = net_box->getBox();
       for (dbITerm* iterm : net->getITerms()) {
         dbInst* inst = iterm->getInst();
         int x, y;
@@ -204,7 +204,7 @@ int64_t OptimizeMirroring::hpwl(dbInst* inst)
     dbNet* net = iterm->getNet();
     if (net) {
       NetBox& net_box = net_box_map_[net];
-      if (!net_box.ignore_) {
+      if (!net_box.isIgnore()) {
         inst_hpwl += net_box.hpwl();
       }
     }
@@ -218,8 +218,8 @@ void OptimizeMirroring::updateNetBoxes(dbInst* inst)
     dbNet* net = iterm->getNet();
     if (net) {
       NetBox& net_box = net_box_map_[net];
-      if (!net_box.ignore_) {
-        net_box_map_[net].box_ = net->getTermBBox();
+      if (!net_box.isIgnore()) {
+        net_box_map_[net].setBox(net->getTermBBox());
       }
     }
   }

src/dpl/src/Optdp.cpp

@@ -92,21 +92,21 @@ void Opendp::improvePlacement(const int seed,
   // Everything done through a script string.
 
   DetailedParams dtParams;
-  dtParams.script_ = "";
+  dtParams.script = "";
   // Maximum independent set matching.
-  dtParams.script_ += "mis -p 10 -t 0.005;";
+  dtParams.script += "mis -p 10 -t 0.005;";
   // Global swaps.
-  dtParams.script_ += "gs -p 10 -t 0.005;";
+  dtParams.script += "gs -p 10 -t 0.005;";
   // Vertical swaps.
-  dtParams.script_ += "vs -p 10 -t 0.005;";
+  dtParams.script += "vs -p 10 -t 0.005;";
   // Small reordering.
-  dtParams.script_ += "ro -p 10 -t 0.005;";
+  dtParams.script += "ro -p 10 -t 0.005;";
   // Random moves and swaps with hpwl as a cost function.  Use
   // random moves and hpwl objective right now.
-  dtParams.script_ += "default -p 5 -f 20 -gen rng -obj hpwl -cost (hpwl);";
+  dtParams.script += "default -p 5 -f 20 -gen rng -obj hpwl -cost (hpwl);";
 
   if (disallow_one_site_gaps) {
-    dtParams.script_ += "disallow_one_site_gaps;";
+    dtParams.script += "disallow_one_site_gaps;";
   }
 
   // Run the script.

src/dpl/src/PlacementDRC.cpp

@@ -156,7 +156,7 @@ bool PlacementDRC::checkBlockedLayers(const Node* cell,
   for (GridY y1 = y_begin; y1 < y_end; y1++) {
     for (GridX x1 = x_begin; x1 < x_end; x1++) {
       const Pixel* pixel = grid_->gridPixel(x1, y1);
-      if (pixel != nullptr && pixel->blocked_layers_ & cell->getUsedLayers()) {
+      if (pixel != nullptr && pixel->blocked_layers & cell->getUsedLayers()) {
         return false;
       }
     }
@@ -242,4 +242,4 @@ DbuX PlacementDRC::gridToDbu(const GridX grid_x, const DbuX site_width) const
   return DbuX(grid_x.v * site_width.v);
 }
 
-}  // namespace dpl
+}  // namespace dpl

src/dpl/src/infrastructure/Grid.cpp

@@ -73,7 +73,7 @@ void Grid::allocateGrid()
       pixel.util = 0.0;
       pixel.is_valid = false;
       pixel.is_hopeless = false;
-      pixel.blocked_layers_ = 0;
+      pixel.blocked_layers = 0;
     }
   }
 }
@@ -152,7 +152,7 @@ void Grid::markBlocked(dbBlock* block)
             for (GridX x = grid_rect.xlo; x < grid_rect.xhi; x++) {
               auto pixel1 = gridPixel(x, y);
               if (pixel1) {
-                pixel1->blocked_layers_ |= 1 << routing_level;
+                pixel1->blocked_layers |= 1 << routing_level;
               }
             }
           }

src/dpl/src/infrastructure/Grid.h

@@ -39,7 +39,7 @@ struct Pixel
   bool is_valid = false;     // false for dummy cells
   bool is_hopeless = false;  // too far from sites for diamond search
   std::map<dbSite*, dbOrientType> sites;
-  uint8_t blocked_layers_ = 0;
+  uint8_t blocked_layers = 0;
 };
 
 // Return value for grid searches.

src/dpl/src/infrastructure/network.h

@@ -46,6 +46,8 @@ class Network
     {
       return a->getEdge()->getId() < b->getEdge()->getId();
     }
+
+   private:
     Network* nw_ = nullptr;
   };
 
@@ -60,6 +62,8 @@ class Network
       }
       return a->getOffsetX() < b->getOffsetX();
     }
+
+   private:
     Network* nw_ = nullptr;
   };
 

src/dpl/src/legalize_shift.cxx

@@ -27,13 +27,13 @@ namespace dpl {
 
 struct ShiftLegalizer::Clump
 {
-  int id_ = 0;
-  double weight_ = 0.0;
-  double wposn_ = 0.0;
+  int id = 0;
+  double weight = 0.0;
+  double wposn = 0.0;
   // Left edge of clump should be integer, although
   // the computation can be double.
-  int posn_ = 0;
-  std::vector<Node*> nodes_;
+  int posn = 0;
+  std::vector<Node*> nodes;
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ -331,12 +331,12 @@ double ShiftLegalizer::clump(std::vector<Node*>& order)
 
     const double wt = 1.0e8;
 
-    r->id_ = clumpId;
-    r->nodes_.clear();
-    r->nodes_.push_back(ndi);
-    r->wposn_ = wt * ndi->getLeft().v;
-    r->weight_ = wt;  // Massive weight for segment start.
-    r->posn_ = ndi->getLeft().v;
+    r->id = clumpId;
+    r->nodes.clear();
+    r->nodes.push_back(ndi);
+    r->wposn = wt * ndi->getLeft().v;
+    r->weight = wt;  // Massive weight for segment start.
+    r->posn = ndi->getLeft().v;
 
     ++clumpId;
   }
@@ -351,12 +351,12 @@ double ShiftLegalizer::clump(std::vector<Node*>& order)
 
     const double wt = 1.0;
 
-    r->id_ = (int) i;
-    r->nodes_.clear();
-    r->nodes_.push_back(ndi);
-    r->wposn_ = wt * ndi->getLeft().v;
-    r->weight_ = wt;
-    r->posn_ = ndi->getLeft().v;
+    r->id = (int) i;
+    r->nodes.clear();
+    r->nodes.push_back(ndi);
+    r->wposn = wt * ndi->getLeft().v;
+    r->weight = wt;
+    r->posn = ndi->getLeft().v;
 
     // Always ensure the left edge is within the segments
     // in which the cell is assigned.
@@ -365,8 +365,7 @@ double ShiftLegalizer::clump(std::vector<Node*>& order)
       DbuX xmin = segPtr->getMinX();
       DbuX xmax = segPtr->getMaxX();
       // Left edge always within segment.
-      r->posn_
-          = std::min(std::max(r->posn_, xmin.v), xmax.v - ndi->getWidth().v);
+      r->posn = std::min(std::max(r->posn, xmin.v), xmax.v - ndi->getWidth().v);
     }
 
     ++clumpId;
@@ -381,12 +380,12 @@ double ShiftLegalizer::clump(std::vector<Node*>& order)
 
     const double wt = 1.0e8;
 
-    r->id_ = clumpId;
-    r->nodes_.clear();
-    r->nodes_.push_back(ndi);
-    r->wposn_ = wt * ndi->getLeft().v;
-    r->weight_ = wt;  // Massive weight for segment end.
-    r->posn_ = ndi->getLeft().v;
+    r->id = clumpId;
+    r->nodes.clear();
+    r->nodes.push_back(ndi);
+    r->wposn = wt * ndi->getLeft().v;
+    r->weight = wt;  // Massive weight for segment end.
+    r->posn = ndi->getLeft().v;
 
     ++clumpId;
   }
@@ -409,7 +408,7 @@ double ShiftLegalizer::clump(std::vector<Node*>& order)
 
     // Left edge.
     const DbuX oldX = ndi->getLeft();
-    const DbuX newX{r->posn_ + offset_[ndi->getId()]};
+    const DbuX newX{r->posn + offset_[ndi->getId()]};
 
     ndi->setLeft(newX);
 
@@ -436,20 +435,20 @@ void ShiftLegalizer::merge(Clump* r)
     // Merge clump r into clump l which, in turn, could result in more merges.
 
     // Move blocks from r to l and update offsets, etc.
-    for (const Node* ndi : r->nodes_) {
+    for (const Node* ndi : r->nodes) {
       offset_[ndi->getId()] += dist;
       ptr_[ndi->getId()] = l;
     }
-    l->nodes_.insert(l->nodes_.end(), r->nodes_.begin(), r->nodes_.end());
+    l->nodes.insert(l->nodes.end(), r->nodes.begin(), r->nodes.end());
 
     // Remove blocks from clump r.
-    r->nodes_.clear();
+    r->nodes.clear();
 
     // Update position of clump l.
-    l->wposn_ += r->wposn_ - dist * r->weight_;
-    l->weight_ += r->weight_;
+    l->wposn += r->wposn - dist * r->weight;
+    l->weight += r->weight;
     // Rounding down should always be fine since we merge to the left.
-    l->posn_ = (int) std::floor(l->wposn_ / l->weight_);
+    l->posn = (int) std::floor(l->wposn / l->weight);
 
     // Since clump l changed position, we need to make it the new right clump
     // and see if there are more merges to the left.
@@ -471,8 +470,8 @@ bool ShiftLegalizer::violated(Clump* r, Clump*& l, int& dist)
   int worst_diff = std::numeric_limits<int>::max();
   dist = std::numeric_limits<int>::max();
 
-  for (size_t i = 0; i < r->nodes_.size(); i++) {
-    const Node* ndr = r->nodes_[i];
+  for (size_t i = 0; i < r->nodes.size(); i++) {
+    const Node* ndr = r->nodes[i];
 
     // Look at each cell that must be left of current cell.
     for (size_t j = 0; j < incoming_[ndr->getId()].size(); j++) {
@@ -495,8 +494,8 @@ bool ShiftLegalizer::violated(Clump* r, Clump*& l, int& dist)
         continue;
       }
       // Get left edge of both cells.
-      const int pdst = r->posn_ + offset_[ndr->getId()];
-      const int psrc = t->posn_ + offset_[ndl->getId()];
+      const int pdst = r->posn + offset_[ndr->getId()];
+      const int psrc = t->posn + offset_[ndl->getId()];
       const int gap = ndl->getWidth().v;
       const int diff = pdst - (psrc + gap);
       if (diff < 0 && diff < worst_diff) {

src/dpl/src/optimization/detailed.cxx

@@ -39,7 +39,7 @@ bool Detailed::improve(DetailedMgr& mgr)
 
   // Parse the script string and run each command.
   boost::char_separator<char> separators(" \r\t\n", ";");
-  boost::tokenizer<boost::char_separator<char>> tokens(params_.script_,
+  boost::tokenizer<boost::char_separator<char>> tokens(params_.script,
                                                        separators);
   std::vector<std::string> args;
   for (auto temp : tokens) {