replace some string& with string_view

Author: soheilshahrouz

libs/libvtrutil/src/vtr_util.cpp

@@ -26,7 +26,7 @@ static int cont;                 /* line continued? (used by strtok)*/
  *
  * The split strings (excluding the delimiters) are returned
  */
-std::vector<std::string> split(const char* text, const std::string& delims) {
+std::vector<std::string> split(const char* text, std::string_view delims) {
     if (text) {
         std::string text_str(text);
         return split(text_str, delims);
@@ -39,13 +39,13 @@ std::vector<std::string> split(const char* text, const std::string& delims) {
  *
  * The split strings (excluding the delimiters) are returned
  */
-std::vector<std::string> split(const std::string& text, const std::string& delims) {
+std::vector<std::string> split(std::string_view text, std::string_view delims) {
     std::vector<std::string> tokens;
 
     std::string curr_tok;
     for (char c : text) {
         if (delims.find(c) != std::string::npos) {
-            //Delimeter character
+            //Delimiter character
             if (!curr_tok.empty()) {
                 //At the end of the token
 
@@ -58,7 +58,7 @@ std::vector<std::string> split(const std::string& text, const std::string& delim
                 //Pass
             }
         } else {
-            //Non-delimeter append to token
+            //Non-delimiter append to token
             curr_tok += c;
         }
     }

libs/libvtrutil/src/vtr_util.h

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <vector>
 #include <string>
+#include <string_view>
 #include <cstdarg>
 #include <array>
 
@@ -14,8 +15,8 @@ namespace vtr {
  *
  * The split strings (excluding the delimiters) are returned
  */
-std::vector<std::string> split(const char* text, const std::string& delims = " \t\n");
-std::vector<std::string> split(const std::string& text, const std::string& delims = " \t\n");
+std::vector<std::string> split(const char* text, std::string_view string_view = " \t\n");
+std::vector<std::string> split(std::string_view text, std::string_view delims = " \t\n");
 
 ///@brief Returns 'input' with the first instance of 'search' replaced with 'replace'
 std::string replace_first(const std::string& input, const std::string& search, const std::string& replace);

utils/fasm/src/fasm.cpp

@@ -413,7 +413,7 @@ static LogicVec lut_outputs(const t_pb* atom_pb, size_t num_inputs, const t_pb_r
     return lut.table();
 }
 
-const t_metadata_dict *FasmWriterVisitor::get_fasm_type(const t_pb_graph_node* pb_graph_node, const std::string& target_type) const {
+const t_metadata_dict *FasmWriterVisitor::get_fasm_type(const t_pb_graph_node* pb_graph_node, std::string_view target_type) const {
   if(pb_graph_node == nullptr) {
     return nullptr;
   }
@@ -659,7 +659,7 @@ void FasmWriterVisitor::find_clb_prefix(const t_pb_graph_node *node,
     }
 }
 
-void FasmWriterVisitor::output_fasm_mux(const std::string& fasm_mux_str,
+void FasmWriterVisitor::output_fasm_mux(std::string_view fasm_mux_str,
                                         t_interconnect *interconnect,
                                         const t_pb_graph_pin *mux_input_pin) {
     auto *pb_name = mux_input_pin->parent_node->pb_type->name;
@@ -741,15 +741,15 @@ void FasmWriterVisitor::output_fasm_mux(const std::string& fasm_mux_str,
 
     vpr_throw(VPR_ERROR_OTHER, __FILE__, __LINE__,
         "fasm_mux %s[%d].%s[%d] found no matches in:\n%s\n",
-        pb_name, pb_index, port_name, pin_index, fasm_mux_str.c_str());
+        pb_name, pb_index, port_name, pin_index, fasm_mux_str.data());
 }
 
 void FasmWriterVisitor::output_fasm_features(const std::string& features) const {
   output_fasm_features(features, clb_prefix_, blk_prefix_);
 }
 
-void FasmWriterVisitor::output_fasm_features(const std::string& features, const std::string& clb_prefix, const std::string& blk_prefix) const {
-  std::stringstream os(features);
+void FasmWriterVisitor::output_fasm_features(const std::string& features, std::string_view clb_prefix, std::string_view blk_prefix) const {
+  std::istringstream os(features);
 
   while(os) {
     std::string feature;

utils/fasm/src/fasm.h

@@ -15,6 +15,7 @@
 #include <set>
 #include <sstream>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 #include <vector>
 
@@ -67,11 +68,11 @@ class FasmWriterVisitor : public NetlistVisitor {
 
   private:
       void output_fasm_features(const std::string& features) const;
-      void output_fasm_features(const std::string& features, const std::string& clb_prefix, const std::string& blk_prefix) const;
+      void output_fasm_features(const std::string& features, std::string_view clb_prefix, std::string_view blk_prefix) const;
       void check_features(const t_metadata_dict *meta) const;
       void check_interconnect(const t_pb_routes &pb_route, int inode);
       void check_for_lut(const t_pb* atom);
-      void output_fasm_mux(const std::string& fasm_mux, t_interconnect *interconnect, const t_pb_graph_pin *mux_input_pin);
+      void output_fasm_mux(std::string_view fasm_mux, t_interconnect *interconnect, const t_pb_graph_pin *mux_input_pin);
       void walk_routing();
       void walk_route_tree(const RRGraphBuilder& rr_graph_builder, const RouteTreeNode& root);
       std::string build_clb_prefix(const t_pb *pb, const t_pb_graph_node* pb_graph_node, bool* is_parent_pb_null) const;
@@ -83,7 +84,7 @@ class FasmWriterVisitor : public NetlistVisitor {
         bool *have_prefix, std::string *clb_prefix) const;
       std::string handle_fasm_prefix(const t_metadata_dict *meta,
         const t_pb_graph_node *pb_graph_node, const t_pb_type *pb_type) const;
-      const t_metadata_dict *get_fasm_type(const t_pb_graph_node* pb_graph_node, const std::string& target_type) const;
+      const t_metadata_dict *get_fasm_type(const t_pb_graph_node* pb_graph_node, std::string_view target_type) const;
 
       vtr::string_internment *strings_;
       std::ostream& os_;

utils/fasm/src/fasm_utils.cpp

@@ -5,7 +5,7 @@
 
 namespace fasm {
 
-void parse_name_with_optional_index(const std::string in, std::string *name, int *index) {
+void parse_name_with_optional_index(std::string_view in, std::string *name, int *index) {
   auto in_parts = vtr::split(in, "[]");
 
   if(in_parts.size() == 1) {
@@ -16,13 +16,13 @@ void parse_name_with_optional_index(const std::string in, std::string *name, int
     *index = vtr::atoi(in_parts[1]);
   } else {
     vpr_throw(VPR_ERROR_OTHER, __FILE__, __LINE__,
-              "Cannot parse %s.", in.c_str());
+              "Cannot parse %s.", in.data());
   }
 }
 
 std::vector<std::string> split_fasm_entry(std::string entry,
-                                                 std::string delims,
-                                                 std::string ignore) {
+                                          std::string_view delims,
+                                          std::string_view ignore) {
   for (size_t ii=0; ii<entry.length(); ii++) {
     while (ignore.find(entry[ii]) != std::string::npos) {
       entry.erase(ii, 1);
@@ -32,7 +32,7 @@ std::vector<std::string> split_fasm_entry(std::string entry,
   return vtr::split(entry, delims);
 }
 
-std::vector<std::string> find_tags_in_feature (const std::string& a_String) {
+std::vector<std::string> find_tags_in_feature (std::string_view a_String) {
     const std::regex regex ("(\\{[a-zA-Z0-9_]+\\})");
 
     std::vector<std::string> tags;
@@ -51,17 +51,17 @@ std::vector<std::string> find_tags_in_feature (const std::string& a_String) {
     return tags;
 }
 
-std::string substitute_tags (const std::string& a_Feature, const std::map<const std::string, std::string>& a_Tags) {
+std::string substitute_tags (std::string_view a_Feature, const std::map<const std::string, std::string>& a_Tags) {
 
     // First list tags that are given in the feature string
     auto tags = find_tags_in_feature(a_Feature);
     if (tags.empty()) {
-        return a_Feature;
+        return std::string{a_Feature};
     }
 
     // Check if those tags are defined, If not then throw an error
     bool have_errors = false;
-    for (auto tag: tags) {
+    for (const auto& tag: tags) {
         if (a_Tags.count(tag) == 0) {
             vtr::printf_error(__FILE__, __LINE__, "fasm placeholder '%s' not defined!", tag.c_str());
             have_errors = true;
@@ -71,13 +71,13 @@ std::string substitute_tags (const std::string& a_Feature, const std::map<const
     if (have_errors) {
         vpr_throw(VPR_ERROR_OTHER, __FILE__, __LINE__,
             "fasm feature '%s' contains placeholders that are not defined for the tile that it is used in!",
-            a_Feature.c_str()
+            a_Feature.data()
         );
     }
 
     // Substitute tags
     std::string feature(a_Feature);
-    for (auto tag: tags) {
+    for (const auto& tag: tags) {
         std::regex regex("\\{" + tag + "\\}");
         feature = std::regex_replace(feature, regex, a_Tags.at(tag));
     }

utils/fasm/src/fasm_utils.h

@@ -2,6 +2,7 @@
 #define UTILS_FASM_FASM_UTILS_H_
 
 #include <string>
+#include <string_view>
 #include <vector>
 #include <map>
 
@@ -13,27 +14,27 @@ namespace fasm {
 // in="A[5]" parts to *name="A", *index=5
 //
 // Throws vpr exception if parsing fails.
-void parse_name_with_optional_index(const std::string in, std::string *name, int *index);
+void parse_name_with_optional_index(std::string_view in, std::string *name, int *index);
 
 // Split FASM entry into parts.
 //
 // delims - Characters to split on.
 // ignore - Characters to ignore.
 std::vector<std::string> split_fasm_entry(std::string entry,
-                                                 std::string delims,
-                                                 std::string ignore);
+                                          std::string_view delims,
+                                          std::string_view ignore);
 
 // Searches for tags in given string, returns their names in a vector.
-std::vector<std::string> find_tags_in_feature (const std::string& a_String);
+std::vector<std::string> find_tags_in_feature(std::string_view a_String);
 
 // Substitutes tags found in a string with their values provided by the map.
-// Thorws an error if a tag is found in the string and its value is not present
+// Throws an error if a tag is found in the string and its value is not present
 // in the map.
 //
 // a_Feature - Fasm feature string (or any other string)
 // a_Tags    - Map with tags and their values
-std::string substitute_tags (const std::string& a_Feature,
-                             const std::map<const std::string, std::string>& a_Tags);
+std::string substitute_tags(std::string_view a_Feature,
+                            const std::map<const std::string, std::string>& a_Tags);
 
 } // namespace fasm
 

vpr/src/base/vpr_api.cpp

@@ -251,15 +251,15 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a
      * Initialize the functions names for which VPR_ERRORs
      * are demoted to VTR_LOG_WARNs
      */
-    for (const std::string& func_name : vtr::split(options->disable_errors, std::string(":"))) {
+    for (const std::string& func_name : vtr::split(options->disable_errors.value(), ":")) {
         map_error_activation_status(func_name);
     }
 
     /*
      * Initialize the functions names for which
      * warnings are being suppressed
      */
-    std::vector<std::string> split_warning_option = vtr::split(options->suppress_warnings, std::string(","));
+    std::vector<std::string> split_warning_option = vtr::split(options->suppress_warnings.value(), ",");
     std::string warn_log_file;
     std::string warn_functions;
     // If no log file name is provided, the specified warning
@@ -507,7 +507,7 @@ void vpr_create_device_grid(const t_vpr_setup& vpr_setup, const t_arch& Arch) {
     if (!device_ctx.grid.limiting_resources().empty()) {
         std::vector<std::string> limiting_block_names;
         for (auto blk_type : device_ctx.grid.limiting_resources()) {
-            limiting_block_names.push_back(blk_type->name);
+            limiting_block_names.emplace_back(blk_type->name);
         }
         VTR_LOG("FPGA size limited by block type(s): %s\n", vtr::join(limiting_block_names, " ").c_str());
         VTR_LOG("\n");
@@ -565,7 +565,6 @@ void vpr_setup_noc_routing_algorithm(const std::string& noc_routing_algorithm_na
     auto& noc_ctx = g_vpr_ctx.mutable_noc();
 
     noc_ctx.noc_flows_router = NocRoutingAlgorithmCreator::create_routing_algorithm(noc_routing_algorithm_name);
-    return;
 }
 
 bool vpr_pack_flow(t_vpr_setup& vpr_setup, const t_arch& arch) {
@@ -598,7 +597,7 @@ bool vpr_pack_flow(t_vpr_setup& vpr_setup, const t_arch& arch) {
         check_netlist(packer_opts.pack_verbosity);
 
         /* Output the netlist stats to console and optionally to file. */
-        writeClusteredNetlistStats(vpr_setup.FileNameOpts.write_block_usage.c_str());
+        writeClusteredNetlistStats(vpr_setup.FileNameOpts.write_block_usage);
 
         // print the total number of used physical blocks for each
         // physical block type after finishing the packing stage