add underline to private members vars of ClockRib

soheilshahrouz · soheilshahrouz · commit 221fafeeb97e · 2025-11-24T20:03:12.000-05:00
diff --git a/vpr/src/route/rr_graph_generation/clock_network_builders.cpp b/vpr/src/route/rr_graph_generation/clock_network_builders.cpp
@@ -96,12 +96,12 @@ ClockType ClockRib::get_network_type() const {
  */
 
 void ClockRib::set_metal_layer(float r_metal, float c_metal) {
-    x_chan_wire.layer.r_metal = r_metal;
-    x_chan_wire.layer.c_metal = c_metal;
+    x_chan_wire_.layer.r_metal = r_metal;
+    x_chan_wire_.layer.c_metal = c_metal;
 }
 
 void ClockRib::set_metal_layer(MetalLayer metal_layer) {
-    x_chan_wire.layer = metal_layer;
+    x_chan_wire_.layer = metal_layer;
 }
 
 void ClockRib::set_initial_wire_location(int start_x, int end_x, int y) {
@@ -112,9 +112,9 @@ void ClockRib::set_initial_wire_location(int start_x, int end_x, int y) {
                         end_x, start_x);
     }
 
-    x_chan_wire.start = start_x;
-    x_chan_wire.length = end_x - start_x;
-    x_chan_wire.position = y;
+    x_chan_wire_.start = start_x;
+    x_chan_wire_.length = end_x - start_x;
+    x_chan_wire_.position = y;
 }
 
 void ClockRib::set_wire_repeat(int repeat_x, int repeat_y) {
@@ -124,29 +124,29 @@ void ClockRib::set_wire_repeat(int repeat_x, int repeat_y) {
                         repeat_x, repeat_y);
     }
 
-    repeat.x = repeat_x;
-    repeat.y = repeat_y;
+    repeat_.x = repeat_x;
+    repeat_.y = repeat_y;
 }
 
 void ClockRib::set_drive_location(int offset_x) {
-    drive.offset = offset_x;
+    drive_.offset = offset_x;
 }
 
 void ClockRib::set_drive_switch(int switch_idx) {
-    drive.switch_idx = switch_idx;
+    drive_.switch_idx = switch_idx;
 }
 
 void ClockRib::set_drive_name(std::string name) {
-    drive.name = name;
+    drive_.name = name;
 }
 
 void ClockRib::set_tap_locations(int offset_x, int increment_x) {
-    tap.offset = offset_x;
-    tap.increment = increment_x;
+    tap_.offset = offset_x;
+    tap_.increment = increment_x;
 }
 
 void ClockRib::set_tap_name(std::string name) {
-    tap.name = name;
+    tap_.name = name;
 }
 
 /*
@@ -160,52 +160,52 @@ void ClockRib::create_segments(std::vector<t_segment_inf>& segment_inf) {
 
     // Drive point segment
     segment_inf.emplace_back();
-    drive_seg_idx = segment_inf.size() - 1;
+    drive_seg_idx_ = segment_inf.size() - 1;
 
-    index = drive_seg_idx;
+    index = drive_seg_idx_;
     name = clock_name_ + "_drive";
     length = 1; // Since drive segment has one length, the left and right segments have length - 1
 
     /*AA: ClockRibs are assumed to be horizontal currently. */
 
-    populate_segment_values(index, name, length, x_chan_wire.layer, segment_inf, e_parallel_axis::X_AXIS);
+    populate_segment_values(index, name, length, x_chan_wire_.layer, segment_inf, e_parallel_axis::X_AXIS);
 
     // Segment to the right of the drive point
     segment_inf.emplace_back();
-    right_seg_idx = segment_inf.size() - 1;
+    right_seg_idx_ = segment_inf.size() - 1;
 
-    index = right_seg_idx;
+    index = right_seg_idx_;
     name = clock_name_ + "_right";
-    length = (x_chan_wire.length - drive.offset) - 1;
+    length = (x_chan_wire_.length - drive_.offset) - 1;
 
-    populate_segment_values(index, name, length, x_chan_wire.layer, segment_inf, e_parallel_axis::X_AXIS);
+    populate_segment_values(index, name, length, x_chan_wire_.layer, segment_inf, e_parallel_axis::X_AXIS);
 
     // Segment to the left of the drive point
     segment_inf.emplace_back();
-    left_seg_idx = segment_inf.size() - 1;
+    left_seg_idx_ = segment_inf.size() - 1;
 
-    index = left_seg_idx;
+    index = left_seg_idx_;
     name = clock_name_ + "_left";
-    length = drive.offset - 1;
+    length = drive_.offset - 1;
 
-    populate_segment_values(index, name, length, x_chan_wire.layer, segment_inf, e_parallel_axis::X_AXIS);
+    populate_segment_values(index, name, length, x_chan_wire_.layer, segment_inf, e_parallel_axis::X_AXIS);
 }
 
 size_t ClockRib::estimate_additional_nodes(const DeviceGrid& grid) {
     // Avoid an infinite loop
-    VTR_ASSERT(repeat.y > 0);
-    VTR_ASSERT(repeat.x > 0);
+    VTR_ASSERT(repeat_.y > 0);
+    VTR_ASSERT(repeat_.x > 0);
 
     size_t num_additional_nodes = 0;
-    for (unsigned y = x_chan_wire.position; y < grid.height() - 1; y += repeat.y) {
-        for (unsigned x_start = x_chan_wire.start; x_start < grid.width() - 1; x_start += repeat.x) {
-            unsigned drive_x = x_start + drive.offset;
-            unsigned x_end = x_start + x_chan_wire.length;
+    for (unsigned y = x_chan_wire_.position; y < grid.height() - 1; y += repeat_.y) {
+        for (unsigned x_start = x_chan_wire_.start; x_start < grid.width() - 1; x_start += repeat_.x) {
+            unsigned drive_x = x_start + drive_.offset;
+            unsigned x_end = x_start + x_chan_wire_.length;
 
             // Adjust for boundry conditions
             int x_offset = 0;
             if ((x_start == 0) ||              // CHANX wires left boundry
-                (x_start + repeat.x == x_end)) // Avoid overlap
+                (x_start + repeat_.x == x_end)) // Avoid overlap
             {
                 x_offset = 1;
             }
@@ -244,22 +244,22 @@ void ClockRib::create_rr_nodes_and_internal_edges_for_one_instance(ClockRRGraphB
     int ptc_num = clock_graph.get_and_increment_chanx_ptc_num(); // used for drawing
 
     // Avoid an infinite loop
-    VTR_ASSERT(repeat.y > 0);
-    VTR_ASSERT(repeat.x > 0);
+    VTR_ASSERT(repeat_.y > 0);
+    VTR_ASSERT(repeat_.x > 0);
 
     // TODO: This function is not adapted to the multi-layer grid
     VTR_ASSERT(g_vpr_ctx.device().grid.get_num_layers() == 1);
     int layer_num = 0;
 
-    for (unsigned y = x_chan_wire.position; y < grid.height() - 1; y += repeat.y) {
-        for (unsigned x_start = x_chan_wire.start; x_start < grid.width() - 1; x_start += repeat.x) {
-            unsigned drive_x = x_start + drive.offset;
-            unsigned x_end = x_start + x_chan_wire.length;
+    for (unsigned y = x_chan_wire_.position; y < grid.height() - 1; y += repeat_.y) {
+        for (unsigned x_start = x_chan_wire_.start; x_start < grid.width() - 1; x_start += repeat_.x) {
+            unsigned drive_x = x_start + drive_.offset;
+            unsigned x_end = x_start + x_chan_wire_.length;
 
             // Adjust for boundry conditions
             int x_offset = 0;
             if ((x_start == 0) ||              // CHANX wires left boundry
-                (x_start + repeat.x == x_end)) // Avoid overlap
+                (x_start + repeat_.x == x_end)) // Avoid overlap
             {
                 x_offset = 1;
             }
@@ -296,7 +296,7 @@ void ClockRib::create_rr_nodes_and_internal_edges_for_one_instance(ClockRRGraphB
                                                     Direction::BIDIR,
                                                     rr_nodes,
                                                     rr_graph_builder);
-            clock_graph.add_switch_location(get_name(), drive.name, drive_x, y, drive_node_idx);
+            clock_graph.add_switch_location(get_name(), drive_.name, drive_x, y, drive_node_idx);
 
             // create rib wire to the right and left of the drive point
             auto left_node_idx = create_chanx_wire(layer_num,
@@ -323,8 +323,8 @@ void ClockRib::create_rr_nodes_and_internal_edges_for_one_instance(ClockRRGraphB
                                  clock_graph);
 
             // connect drive point to each half rib using a directed switch
-            clock_graph.add_edge(rr_edges_to_create, RRNodeId(drive_node_idx), RRNodeId(left_node_idx), drive.switch_idx, false);
-            clock_graph.add_edge(rr_edges_to_create, RRNodeId(drive_node_idx), RRNodeId(right_node_idx), drive.switch_idx, false);
+            clock_graph.add_edge(rr_edges_to_create, RRNodeId(drive_node_idx), RRNodeId(left_node_idx), drive_.switch_idx, false);
+            clock_graph.add_edge(rr_edges_to_create, RRNodeId(drive_node_idx), RRNodeId(right_node_idx), drive_.switch_idx, false);
         }
     }
 }
@@ -346,20 +346,20 @@ int ClockRib::create_chanx_wire(int layer,
     rr_graph_builder.set_node_layer(chanx_node, layer, layer);
     rr_graph_builder.set_node_capacity(chanx_node, 1);
     rr_graph_builder.set_node_track_num(chanx_node, ptc_num);
-    const NodeRCIndex rc_index = find_create_rr_rc_data(x_chan_wire.layer.r_metal, x_chan_wire.layer.c_metal, g_vpr_ctx.mutable_device().rr_rc_data);
+    const NodeRCIndex rc_index = find_create_rr_rc_data(x_chan_wire_.layer.r_metal, x_chan_wire_.layer.c_metal, g_vpr_ctx.mutable_device().rr_rc_data);
     rr_graph_builder.set_node_rc_index(chanx_node, rc_index);
     rr_graph_builder.set_node_direction(chanx_node, direction);
 
     short seg_index = 0;
     switch (direction) {
         case Direction::BIDIR:
-            seg_index = drive_seg_idx;
+            seg_index = drive_seg_idx_;
             break;
         case Direction::DEC:
-            seg_index = left_seg_idx;
+            seg_index = left_seg_idx_;
             break;
         case Direction::INC:
-            seg_index = right_seg_idx;
+            seg_index = right_seg_idx_;
             break;
         default:
             VTR_ASSERT_MSG(false, "Unidentified direction type for clock rib");
@@ -386,11 +386,11 @@ void ClockRib::record_tap_locations(unsigned x_start,
                                     int left_rr_node_idx,
                                     int right_rr_node_idx,
                                     ClockRRGraphBuilder& clock_graph) {
-    for (unsigned x = x_start + tap.offset; x <= x_end; x += tap.increment) {
-        if (x < (x_start + drive.offset - 1)) {
-            clock_graph.add_switch_location(get_name(), tap.name, x, y, left_rr_node_idx);
+    for (unsigned x = x_start + tap_.offset; x <= x_end; x += tap_.increment) {
+        if (x < (x_start + drive_.offset - 1)) {
+            clock_graph.add_switch_location(get_name(), tap_.name, x, y, left_rr_node_idx);
         } else {
-            clock_graph.add_switch_location(get_name(), tap.name, x, y, right_rr_node_idx);
+            clock_graph.add_switch_location(get_name(), tap_.name, x, y, right_rr_node_idx);
         }
     }
 }
@@ -401,14 +401,14 @@ void ClockRib::map_relative_seg_indices(const t_unified_to_parallel_seg_index& i
 
     int seg_idx;
 
-    seg_idx = get_parallel_seg_index(drive_seg_idx, indices_map, e_parallel_axis::X_AXIS);
-    drive_seg_idx = (seg_idx >= 0) ? seg_idx : drive_seg_idx;
+    seg_idx = get_parallel_seg_index(drive_seg_idx_, indices_map, e_parallel_axis::X_AXIS);
+    drive_seg_idx_ = (seg_idx >= 0) ? seg_idx : drive_seg_idx_;
 
-    seg_idx = get_parallel_seg_index(left_seg_idx, indices_map, e_parallel_axis::X_AXIS);
-    left_seg_idx = (seg_idx >= 0) ? seg_idx : left_seg_idx;
+    seg_idx = get_parallel_seg_index(left_seg_idx_, indices_map, e_parallel_axis::X_AXIS);
+    left_seg_idx_ = (seg_idx >= 0) ? seg_idx : left_seg_idx_;
 
-    seg_idx = get_parallel_seg_index(right_seg_idx, indices_map, e_parallel_axis::X_AXIS);
-    right_seg_idx = (seg_idx >= 0) ? seg_idx : right_seg_idx;
+    seg_idx = get_parallel_seg_index(right_seg_idx_, indices_map, e_parallel_axis::X_AXIS);
+    right_seg_idx_ = (seg_idx >= 0) ? seg_idx : right_seg_idx_;
 }
 
 /*********************************************************************************
diff --git a/vpr/src/route/rr_graph_generation/clock_network_builders.h b/vpr/src/route/rr_graph_generation/clock_network_builders.h
@@ -119,28 +119,28 @@ class ClockNetwork {
 class ClockRib : public ClockNetwork {
   private:
     // start and end x and position in the y
-    Wire x_chan_wire;
-    WireRepeat repeat;
+    Wire x_chan_wire_;
+    WireRepeat repeat_;
 
     // offset in the x
-    RibDrive drive;
+    RibDrive drive_;
 
     // offset and incr in the x
-    RibTaps tap;
+    RibTaps tap_;
 
     // segment indices
-    int right_seg_idx = UNDEFINED;
-    int left_seg_idx = UNDEFINED;
-    int drive_seg_idx = UNDEFINED;
+    int right_seg_idx_ = UNDEFINED;
+    int left_seg_idx_ = UNDEFINED;
+    int drive_seg_idx_ = UNDEFINED;
 
   public:
     /** Constructor**/
     ClockRib() {} // default
     ClockRib(Wire wire1, WireRepeat repeat1, RibDrive drive1, RibTaps tap1)
-        : x_chan_wire(wire1)
-        , repeat(repeat1)
-        , drive(drive1)
-        , tap(tap1) {}
+        : x_chan_wire_(wire1)
+        , repeat_(repeat1)
+        , drive_(drive1)
+        , tap_(tap1) {}
     /*
      * Getters
      */
