make format

Author: amin1377

vpr/src/base/read_options.cpp

@@ -3316,7 +3316,7 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help("Whether the generated CRR should remove CHANX and CHANY nodes that have no fan-in")
         .default_value("off")
         .show_in(argparse::ShowIn::HELP_ONLY);
-    
+
     crr_grp.add_argument(args.sb_count_dir, "--sb_count_dir")
         .help("Directory to store csv files showing how many times each switch specified in the switch block templates is used")
         .default_value("")

vpr/src/base/stats.cpp

@@ -42,35 +42,35 @@ struct SBKeyParts {
 // Parse the key to extract filename, row, and column
 static SBKeyParts parse_sb_key(const std::string& key) {
     SBKeyParts parts;
-    
+
     // Find the last two underscores
     size_t last_underscore = key.rfind('_');
     size_t second_last_underscore = key.rfind('_', last_underscore - 1);
-    
+
     parts.filename = key.substr(0, second_last_underscore);
     parts.row = std::stoi(key.substr(second_last_underscore + 1, last_underscore - second_last_underscore - 1));
     parts.col = std::stoi(key.substr(last_underscore + 1));
-    
+
     return parts;
 }
 
 // Read CSV file and keep first NUM_EMPTY_ROWS rows completely and first NUM_EMPTY_COLS columns of all other rows
 static std::vector<std::vector<std::string>> read_and_trim_csv(const std::string& filepath) {
     std::vector<std::vector<std::string>> data;
     std::ifstream file(filepath);
-    
+
     if (!file.is_open()) {
         return data;
     }
-    
+
     std::string line;
     int row_count = 0;
     while (std::getline(file, line)) {
         std::vector<std::string> row;
         std::stringstream ss(line);
         std::string cell;
         int col_count = 0;
-        
+
         if (row_count < crrgenerator::NUM_EMPTY_ROWS) {
             // Keep entire row for first NUM_EMPTY_ROWS rows
             while (std::getline(ss, cell, ',')) {
@@ -83,19 +83,19 @@ static std::vector<std::vector<std::string>> read_and_trim_csv(const std::string
                 col_count++;
             }
         }
-        
+
         data.push_back(row);
         row_count++;
     }
-    
+
     file.close();
     return data;
 }
 
 // Write 2D vector to CSV file
 static void write_csv(const std::string& filepath, const std::vector<std::vector<std::string>>& data) {
     std::ofstream file(filepath);
-    
+
     for (size_t i = 0; i < data.size(); ++i) {
         for (size_t j = 0; j < data[i].size(); ++j) {
             file << data[i][j];
@@ -105,7 +105,7 @@ static void write_csv(const std::string& filepath, const std::vector<std::vector
         }
         file << "\n";
     }
-    
+
     file.close();
 }
 
@@ -252,22 +252,22 @@ void write_sb_count_stats(const Netlist<>& net_list,
     // Write the sb_count to a file
     // First, read all CSV files from directory and trim them
     std::unordered_map<std::string, std::vector<std::vector<std::string>>> csv_data;
-    
+
     for (const auto& entry : fs::directory_iterator(sb_map_dir)) {
         if (entry.is_regular_file() && entry.path().extension() == ".csv") {
             std::string filename = entry.path().filename().string();
             csv_data[filename] = read_and_trim_csv(entry.path().string());
         }
     }
-    
+
     // Group sb_count entries by filename
     std::unordered_map<std::string, std::vector<std::pair<int, std::pair<int, int>>>> file_groups;
-    
+
     for (const auto& [sb_id, count] : sb_count) {
         SBKeyParts parts = parse_sb_key(sb_id);
         file_groups[parts.filename].push_back({parts.row, {parts.col, count}});
     }
-    
+
     // Process each file
     for (auto& [filename, data] : csv_data) {
         // Check if this file has updates from sb_count
@@ -278,35 +278,35 @@ void write_sb_count_stats(const Netlist<>& net_list,
             VTR_LOG("Written trimmed CSV: %s\n", filename.c_str());
             continue;
         }
-        
+
         const auto& entries = file_groups[filename];
-        
+
         // Find maximum row and column needed
         int max_row = 0, max_col = 0;
         for (const auto& entry : entries) {
             max_row = std::max(max_row, entry.first);
             max_col = std::max(max_col, entry.second.first);
         }
-        
+
         // Expand data structure if needed
         while (data.size() <= static_cast<size_t>(max_row)) {
             data.push_back(std::vector<std::string>());
         }
-        
+
         for (auto& row : data) {
             while (row.size() <= static_cast<size_t>(max_col)) {
                 row.push_back("");
             }
         }
-        
+
         // Update values from sb_count
         for (const auto& entry : entries) {
             int row = entry.first;
             int col = entry.second.first;
             int count = entry.second.second;
             data[row][col] = std::to_string(count);
         }
-        
+
         // Write updated file
         std::string output_path = sb_count_dir + "/" + filename;
         write_csv(output_path, data);

vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h

@@ -149,31 +149,31 @@ struct Sizing {
  * It is used to store the connection information and to compare connections.
  */
 class Connection {
-    public:
-        Connection(RRNodeId sink_node, RRNodeId src_node, int delay_ps, std::string crr_id) noexcept
-            : sink_node_(sink_node)
-            , src_node_(src_node)
-            , delay_ps_(delay_ps)
-            , crr_id_(std::move(crr_id)) {}
-
-        RRNodeId sink_node() const { return sink_node_; }
-        RRNodeId src_node() const { return src_node_; }
-        int delay_ps() const { return delay_ps_; }
-        std::string crr_id() const { return crr_id_; }
-
-        bool operator<(const Connection& other) const {
-            return std::tie(sink_node_, src_node_, delay_ps_) < std::tie(other.sink_node_, other.src_node_, other.delay_ps_);
-        }
+  public:
+    Connection(RRNodeId sink_node, RRNodeId src_node, int delay_ps, std::string crr_id) noexcept
+        : sink_node_(sink_node)
+        , src_node_(src_node)
+        , delay_ps_(delay_ps)
+        , crr_id_(std::move(crr_id)) {}
+
+    RRNodeId sink_node() const { return sink_node_; }
+    RRNodeId src_node() const { return src_node_; }
+    int delay_ps() const { return delay_ps_; }
+    std::string crr_id() const { return crr_id_; }
+
+    bool operator<(const Connection& other) const {
+        return std::tie(sink_node_, src_node_, delay_ps_) < std::tie(other.sink_node_, other.src_node_, other.delay_ps_);
+    }
 
-        bool operator==(const Connection& other) const {
-            return sink_node_ == other.sink_node_ && src_node_ == other.src_node_ && delay_ps_ == other.delay_ps_;
-        }
+    bool operator==(const Connection& other) const {
+        return sink_node_ == other.sink_node_ && src_node_ == other.src_node_ && delay_ps_ == other.delay_ps_;
+    }
 
-    private:
-        RRNodeId sink_node_;
-        RRNodeId src_node_;
-        int delay_ps_;
-        std::string crr_id_;
+  private:
+    RRNodeId sink_node_;
+    RRNodeId src_node_;
+    int delay_ps_;
+    std::string crr_id_;
 };
 
 // Node hash type for lookups