[vpr][route] fix formatting issues in tileable rr graph

Author: amin1377

libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h

@@ -1846,14 +1846,14 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
     void process_rr_node_indices() {
         auto& rr_graph_builder = (*rr_graph_builder_);
 
-        /* Alloc the lookup table */
+        // Alloc the lookup table
         for (e_rr_type rr_type : RR_TYPES) {
             rr_graph_builder.node_lookup().resize_nodes(grid_.get_num_layers(), grid_.width(), grid_.height(), rr_type, NUM_2D_SIDES);
         }
 
-        /* Add the correct node into the vector */
+        // Add the correct node into the vector
         for (const t_rr_node& node : *rr_nodes_) {
-            /* Set track numbers as a node may have multiple ptc */
+            // Set track numbers as a node may have multiple ptc
             if (rr_graph_builder.node_contain_multiple_ptc(node.id())) {
                 if (rr_graph_->node_type(node.id()) == e_rr_type::CHANX || rr_graph_->node_type(node.id()) == e_rr_type::CHANY) {
                     rr_graph_builder.add_track_node_to_lookup(node.id());

vpr/src/base/read_blif.cpp

@@ -644,47 +644,47 @@ vtr::LogicValue to_vtr_logic_value(blifparse::LogicValue val) {
 }
 
 bool is_string_param(const std::string& param) {
-    /* Empty param is considered a string */
+    // Empty param is considered a string
     if (param.empty()) {
         return true;
     }
 
-    /* There have to be at least 2 characters (the quotes) */
+    // There have to be at least 2 characters (the quotes)
     if (param.length() < 2) {
         return false;
     }
 
-    /* The first and the last characters must be quotes */
+    // The first and the last characters must be quotes
     size_t len = param.length();
     if (param[0] != '"' || param[len - 1] != '"') {
         return false;
     }
 
-    /* There mustn't be any other quotes except for escaped ones */
+    // There mustn't be any other quotes except for escaped ones
     for (size_t i = 1; i < (len - 1); ++i) {
         if (param[i] == '"' && param[i - 1] != '\\') {
             return false;
         }
     }
 
-    /* This is a string param */
+    // This is a string param
     return true;
 }
 
 bool is_binary_param(const std::string& param) {
-    /* Must be non-empty */
+    // Must be non-empty
     if (param.empty()) {
         return false;
     }
 
-    /* The string must contain only '0' and '1' */
+    // The string must contain only '0' and '1'
     for (size_t i = 0; i < param.length(); ++i) {
         if (param[i] != '0' && param[i] != '1') {
             return false;
         }
     }
 
-    /* This is a binary word param */
+    // This is a binary word param
     return true;
 }
 
@@ -694,13 +694,13 @@ bool is_real_param(const std::string& param) {
         return false;
     }
 
-    /* The string must match the regular expression */
+    // The string must match the regular expression
     const std::regex real_number_expr("[+-]?([0-9]*\\.[0-9]+)|([0-9]+\\.[0-9]*)");
     if (!std::regex_match(param, real_number_expr)) {
         return false;
     }
 
-    /* This is a real number param */
+    // This is a real number param
     return true;
 }
 

vpr/src/base/vpr_context.h

@@ -254,9 +254,7 @@ struct DeviceContext : public Context {
                          rr_graph_builder.node_in_edge_storage(),
                          rr_graph_builder.node_ptc_storage()};
 
-    /* Track ids for each rr_node in the rr_graph.
-     * This is used by drawer for tileable routing resource graph
-     */
+    ///@brief Track ids for each rr_node in the rr_graph. This is used by drawer for tileable routing resource graph
     std::map<RRNodeId, std::vector<size_t>> rr_node_track_ids;
 
     std::vector<t_arch_switch_inf> arch_switch_inf; // [0..(num_arch_switches-1)]

vpr/src/draw/draw.cpp

@@ -1227,7 +1227,7 @@ static void run_graphics_commands(const std::string& commands) {
     t_draw_state backup_draw_state = *draw_state;
 
     std::vector<std::vector<std::string>> cmds;
-    for (std::string raw_cmd : vtr::StringToken(commands).split(";")) {
+    for (const std::string& raw_cmd : vtr::StringToken(commands).split(";")) {
         cmds.push_back(vtr::StringToken(raw_cmd).split(" \t\n"));
     }
 

vpr/src/route/rr_graph_generation/rr_graph.cpp

@@ -2,19 +2,19 @@
 #include "vtr_log.h"
 #include "vpr_utils.h"
 
-DeviceGridAnnotation::DeviceGridAnnotation(const DeviceGrid& grid, const bool& perimeter_cb) {
+DeviceGridAnnotation::DeviceGridAnnotation(const DeviceGrid& grid, const bool perimeter_cb) {
     alloc(grid);
     init(grid, perimeter_cb);
 }
 
 void DeviceGridAnnotation::alloc(const DeviceGrid& grid) {
-    /* Allocate */
+    // Allocate
     chanx_existence_.resize({grid.width(), grid.height()}, false);
     chany_existence_.resize({grid.width(), grid.height()}, false);
 }
 
-void DeviceGridAnnotation::init(const DeviceGrid& grid, const bool& perimeter_cb) {
-    /* If shrink is not considered, perimeters are the borderlines */
+void DeviceGridAnnotation::init(const DeviceGrid& grid, const bool perimeter_cb) {
+    // If shrink is not considered, perimeters are the borderlines
     size_t start_x = 1;
     size_t end_x = grid.width() - 1;
     if (perimeter_cb) {

vpr/src/route/rr_graph_generation/tileable_rr_graph/device_grid_annotation.cpp

@@ -1,8 +1,5 @@
 #pragma once
 
-/********************************************************************
- * Include header files required by the data structure definition
- *******************************************************************/
 #include <array>
 #include "vtr_geometry.h"
 #include "vtr_ndmatrix.h"
@@ -13,14 +10,14 @@
  * - Border of the device grid (check where the empty types cover the perimeters)
  */
 class DeviceGridAnnotation {
-  public: /* Constructor */
-    DeviceGridAnnotation(const DeviceGrid& grid, const bool& perimeter_cb);
+  public: // Constructor
+    DeviceGridAnnotation(const DeviceGrid& grid, const bool perimeter_cb);
 
-  private: /* Private mutators */
+  private: // Private mutators
     void alloc(const DeviceGrid& grid);
-    void init(const DeviceGrid& grid, const bool& perimeter_cb);
+    void init(const DeviceGrid& grid, const bool perimeter_cb);
 
-  public: /* Public accessors */
+  public: // Public accessors
     /** @brief Check if at a given coordinate, a X-direction routing channel should exist or not */
     bool is_chanx_exist(const vtr::Point<size_t>& coord) const;
     bool is_chanx_start(const vtr::Point<size_t>& coord) const;
@@ -30,10 +27,10 @@ class DeviceGridAnnotation {
     bool is_chany_start(const vtr::Point<size_t>& coord) const;
     bool is_chany_end(const vtr::Point<size_t>& coord) const;
 
-  private: /* Private validators */
+  private: // Private validators
     vtr::Point<size_t> get_neighbor_coord(const vtr::Point<size_t>& coord, const e_side& side) const;
 
-  private: /* Internal data */
+  private: // Internal data
     vtr::NdMatrix<bool, 2> chanx_existence_;
     vtr::NdMatrix<bool, 2> chany_existence_;
 };

vpr/src/route/rr_graph_generation/tileable_rr_graph/device_grid_annotation.h

@@ -28,7 +28,7 @@ size_t RRChan::get_chan_width() const {
 }
 
 /* get the track_id of a node */
-int RRChan::get_node_track_id(const RRNodeId& node) const {
+int RRChan::get_node_track_id(const RRNodeId node) const {
     /* if the given node is NULL, we return an invalid id */
     if (RRNodeId::INVALID() == node) {
         return -1;
@@ -42,15 +42,15 @@ int RRChan::get_node_track_id(const RRNodeId& node) const {
 }
 
 /* get the rr_node with the track_id */
-RRNodeId RRChan::get_node(const size_t& track_num) const {
+RRNodeId RRChan::get_node(const size_t track_num) const {
     if (false == valid_node_id(track_num)) {
         return RRNodeId::INVALID();
     }
     return nodes_[track_num];
 }
 
 /* get the segment id of a node */
-RRSegmentId RRChan::get_node_segment(const RRNodeId& node) const {
+RRSegmentId RRChan::get_node_segment(const RRNodeId node) const {
     int node_id = get_node_track_id(node);
     if (false == valid_node_id(node_id)) {
         return RRSegmentId::INVALID();
@@ -59,7 +59,7 @@ RRSegmentId RRChan::get_node_segment(const RRNodeId& node) const {
 }
 
 /* get the segment id of a node */
-RRSegmentId RRChan::get_node_segment(const size_t& track_num) const {
+RRSegmentId RRChan::get_node_segment(const size_t track_num) const {
     if (false == valid_node_id(track_num)) {
         return RRSegmentId::INVALID();
     }
@@ -70,14 +70,10 @@ RRSegmentId RRChan::get_node_segment(const size_t& track_num) const {
 std::vector<RRSegmentId> RRChan::get_segment_ids() const {
     std::vector<RRSegmentId> seg_list;
 
-    /* make sure a clean start */
-    seg_list.clear();
-
     /* Traverse node_segments */
     for (size_t inode = 0; inode < get_chan_width(); ++inode) {
-        std::vector<RRSegmentId>::iterator it;
         /* Try to find the node_segment id in the list */
-        it = find(seg_list.begin(), seg_list.end(), node_segments_[inode]);
+        auto it = find(seg_list.begin(), seg_list.end(), node_segments_[inode]);
         if (it == seg_list.end()) {
             /* Not found, add it to the list */
             seg_list.push_back(node_segments_[inode]);
@@ -88,15 +84,12 @@ std::vector<RRSegmentId> RRChan::get_segment_ids() const {
 }
 
 /* Get a list of nodes whose segment_id is specified  */
-std::vector<size_t> RRChan::get_node_ids_by_segment_ids(const RRSegmentId& seg_id) const {
+std::vector<size_t> RRChan::get_node_ids_by_segment_ids(const RRSegmentId seg_id) const {
     std::vector<size_t> node_list;
 
-    /* make sure a clean start */
-    node_list.clear();
-
-    /* Traverse node_segments */
+    // Traverse node_segments
     for (size_t inode = 0; inode < get_chan_width(); ++inode) {
-        /* Try to find the node_segment id in the list */
+        // Try to find the node_segment id in the list
         if (seg_id == node_segments_[inode]) {
             node_list.push_back(inode);
         }
@@ -109,35 +102,34 @@ std::vector<size_t> RRChan::get_node_ids_by_segment_ids(const RRSegmentId& seg_i
  * Mutators
  ***********************************************************************/
 void RRChan::set(const RRChan& rr_chan) {
-    /* Ensure a clean start */
-    this->clear();
-    /* Assign type of this routing channel */
-    this->type_ = rr_chan.get_type();
-    /* Copy node and node_segments */
-    this->nodes_.resize(rr_chan.get_chan_width());
-    this->node_segments_.resize(rr_chan.get_chan_width());
+    // Ensure a clean start
+    clear();
+    // Assign type of this routing channel
+    type_ = rr_chan.get_type();
+    // Copy node and node_segments
+    nodes_.resize(rr_chan.get_chan_width());
+    node_segments_.resize(rr_chan.get_chan_width());
     for (size_t inode = 0; inode < rr_chan.get_chan_width(); ++inode) {
-        this->nodes_[inode] = rr_chan.get_node(inode);
-        this->node_segments_[inode] = rr_chan.get_node_segment(inode);
+        nodes_[inode] = rr_chan.get_node(inode);
+        node_segments_[inode] = rr_chan.get_node_segment(inode);
     }
-    return;
 }
 
 /* modify type */
-void RRChan::set_type(const e_rr_type& type) {
-    VTR_ASSERT(valid_type(type));
+void RRChan::set_type(const e_rr_type type) {
+    VTR_ASSERT(is_rr_type_valid(type));
     type_ = type;
 }
 
 /* Reserve node list */
-void RRChan::reserve_node(const size_t& node_size) {
-    nodes_.reserve(node_size);         /* reserve to the maximum */
-    node_segments_.reserve(node_size); /* reserve to the maximum */
+void RRChan::reserve_node(const size_t node_size) {
+    nodes_.reserve(node_size);
+    node_segments_.reserve(node_size);
 }
 
 /* add a node to the array */
-void RRChan::add_node(const RRGraphView& rr_graph, const RRNodeId& node, const RRSegmentId& node_segment) {
-    /* fill the dedicated element in the vector */
+void RRChan::add_node(const RRGraphView& rr_graph, const RRNodeId node, const RRSegmentId node_segment) {
+    // fill the dedicated element in the vector
     nodes_.push_back(node);
     node_segments_.push_back(node_segment);
 
@@ -160,28 +152,28 @@ void RRChan::clear() {
  * Internal validators
  ***********************************************************************/
 /* for type, only valid type is CHANX and CHANY */
-bool RRChan::valid_type(const e_rr_type& type) const {
+bool RRChan::is_rr_type_valid(const e_rr_type type) const {
     if ((e_rr_type::CHANX == type) || (e_rr_type::CHANY == type)) {
         return true;
     }
     return false;
 }
 
 /* Check each node, see if the node type is consistent with the type */
-bool RRChan::valid_node_type(const RRGraphView& rr_graph, const RRNodeId& node) const {
-    valid_type(rr_graph.node_type(node));
+bool RRChan::valid_node_type(const RRGraphView& rr_graph, const RRNodeId node) const {
+    is_rr_type_valid(rr_graph.node_type(node));
     if (e_rr_type::NUM_RR_TYPES == type_) {
         return true;
     }
-    valid_type(type_);
+    is_rr_type_valid(type_);
     if (type_ != rr_graph.node_type(node)) {
         return false;
     }
     return true;
 }
 
 /* check if the node id is valid */
-bool RRChan::valid_node_id(const size_t& node_id) const {
+bool RRChan::valid_node_id(const size_t node_id) const {
     if (node_id < nodes_.size()) {
         return true;
     }