avoid calling vtr::strdup() for t_logical_block_type.name and call c_str() when needed

Author: soheilshahrouz

libs/libarchfpga/src/arch_util.cpp

@@ -535,7 +535,7 @@ t_physical_tile_type get_empty_physical_type(const char* name /*= EMPTY_BLOCK_NA
 
 t_logical_block_type get_empty_logical_type(const char* name /*=EMPTY_BLOCK_NAME*/) {
     t_logical_block_type type;
-    type.name = vtr::strdup(name);
+    type.name = name;
     type.pb_type = nullptr;
 
     return type;

libs/libarchfpga/src/physical_types.cpp

@@ -141,7 +141,7 @@ bool t_physical_tile_type::is_empty() const {
  */
 
 bool t_logical_block_type::is_empty() const {
-    return std::string(name) == std::string(EMPTY_BLOCK_NAME);
+    return name == std::string(EMPTY_BLOCK_NAME);
 }
 
 /**

libs/libarchfpga/src/read_fpga_interchange_arch.cpp

@@ -1076,10 +1076,10 @@ struct ArchReader {
                 continue;
 
             // Check for duplicates
-            auto is_duplicate = [name](t_logical_block_type l) { return std::string(l.name) == name; };
+            auto is_duplicate = [name](const t_logical_block_type& l)-> bool { return l.name == name; };
             VTR_ASSERT(std::find_if(ltypes_.begin(), ltypes_.end(), is_duplicate) == ltypes_.end());
 
-            ltype.name = vtr::strdup(name.c_str());
+            ltype.name = name;
             ltype.index = ++index;
 
             auto pb_type = new t_pb_type;
@@ -2089,7 +2089,7 @@ struct ArchReader {
         // Create constant complex block
         t_logical_block_type block;
 
-        block.name = vtr::strdup(const_block_.c_str());
+        block.name = (const_block_;
         block.index = ltypes_.size();
 
         auto pb_type = new t_pb_type;

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -3613,7 +3613,7 @@ static void ProcessComplexBlocks(pugi::xml_node Node,
 
         /* Load type name */
         auto Prop = get_attribute(CurBlockType, "name", loc_data).value();
-        LogicalBlockType.name = vtr::strdup(Prop);
+        LogicalBlockType.name = Prop;
 
         auto [_, success] = pb_type_descriptors.insert(LogicalBlockType.name);
         if (!success) {

vpr/src/pack/cluster.cpp

@@ -250,7 +250,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             VTR_LOGV(verbosity > 2,
                      "Complex block %d: '%s' (%s) ", total_clb_num,
                      cluster_legalizer.get_cluster_pb(legalization_cluster_id)->name,
-                     cluster_legalizer.get_cluster_type(legalization_cluster_id)->name);
+                     cluster_legalizer.get_cluster_type(legalization_cluster_id)->name.c_str());
             VTR_LOGV(verbosity > 2, ".");
             //Progress dot for seed-block
             fflush(stdout);

vpr/src/pack/cluster_router.cpp

@@ -507,7 +507,7 @@ bool try_intra_lb_route(t_lb_router_data* router_data,
             --inet;
             auto& atom_ctx = g_vpr_ctx.atom();
             VTR_LOGV(verbosity > 3, "Net '%s' is impossible to route within proposed %s cluster\n",
-                     atom_ctx.nlist.net_name(lb_nets[inet].atom_net_id).c_str(), router_data->lb_type->name);
+                     atom_ctx.nlist.net_name(lb_nets[inet].atom_net_id).c_str(), router_data->lb_type->name.c_str());
             is_routed = false;
         }
         router_data->pres_con_fac *= router_data->params.pres_fac_mult;

vpr/src/pack/cluster_util.cpp

@@ -1061,13 +1061,13 @@ void start_new_cluster(ClusterLegalizer& cluster_legalizer,
         }
 
         if (success) {
-            VTR_LOGV(verbosity > 2, "\tPASSED_SEED: Block Type %s\n", type->name);
+            VTR_LOGV(verbosity > 2, "\tPASSED_SEED: Block Type %s\n", type->name.c_str());
             // If clustering succeeds return the new_cluster_id and type.
             legalization_cluster_id = new_cluster_id;
             block_type = type;
             break;
         } else {
-            VTR_LOGV(verbosity > 2, "\tFAILED_SEED: Block Type %s\n", type->name);
+            VTR_LOGV(verbosity > 2, "\tFAILED_SEED: Block Type %s\n", type->name.c_str());
         }
     }
 

vpr/src/pack/constraints_report.cpp

@@ -46,7 +46,7 @@ bool floorplan_constraints_regions_overfull(const ClusterLegalizer& cluster_lega
                 floorplanning_ctx.overfull_partition_regions.push_back(pr);
                 VTR_LOG("\n\nA partition including the following regions has been assigned %d blocks of type %s, "
                         "but only has %d tiles of that type\n",
-                        num_assigned_blocks, block_type.name, num_tiles);
+                        num_assigned_blocks, block_type.name.c_str(), num_tiles);
                 for (const Region& reg : regions) {
                     const vtr::Rect<int>& rect = reg.get_rect();
                     const auto [layer_low, layer_high] = reg.get_layer_range();

vpr/src/pack/pack.cpp

@@ -214,13 +214,13 @@ bool try_pack(t_packer_opts* packer_opts,
                     resource_avail += ", ";
                 }
 
-                resource_reqs += std::string(iter->first->name) + ": " + std::to_string(iter->second);
+                resource_reqs += iter->first->name + ": " + std::to_string(iter->second);
 
                 int num_instances = 0;
                 for (auto type : iter->first->equivalent_tiles)
                     num_instances += grid.num_instances(type, -1);
 
-                resource_avail += std::string(iter->first->name) + ": " + std::to_string(num_instances);
+                resource_avail += iter->first->name + ": " + std::to_string(num_instances);
             }
 
             VPR_FATAL_ERROR(VPR_ERROR_OTHER, "Failed to find device which satisfies resource requirements required: %s (available %s)", resource_reqs.c_str(), resource_avail.c_str());
@@ -352,7 +352,7 @@ static bool try_size_device_grid(const t_arch& arch,
         if (util > 1.) {
             fits_on_device = false;
         }
-        VTR_LOG("\tBlock Utilization: %.2f Type: %s\n", util, type.name);
+        VTR_LOG("\tBlock Utilization: %.2f Type: %s\n", util, type.name.c_str());
     }
     VTR_LOG("\n");
 

vpr/src/pack/pack_report.cpp

@@ -66,7 +66,7 @@ void report_packing_pin_usage(std::ostream& os, const VprContext& ctx) {
         if (total_input_pins[type] != 0) {
             os << "\t\tHistogram:\n";
             auto input_histogram = build_histogram(inputs_used[type], 10, 0, total_input_pins[type]);
-            for (auto line : format_histogram(input_histogram)) {
+            for (const std::string& line : format_histogram(input_histogram)) {
                 os << "\t\t" << line << "\n";
             }
         }

vpr/src/place/initial_placement.cpp

@@ -251,7 +251,7 @@ static void check_initial_placement_legality(const vtr::vector_map<ClusterBlockI
             VTR_LOG("Block %s (# %d) of type %s could not be placed during initial placement iteration %d\n",
                     cluster_ctx.clb_nlist.block_name(blk_id).c_str(),
                     blk_id,
-                    cluster_ctx.clb_nlist.block_type(blk_id)->name,
+                    cluster_ctx.clb_nlist.block_type(blk_id)->name.c_str(),
                     MAX_INIT_PLACE_ATTEMPTS - 1);
             unplaced_blocks++;
         }
@@ -275,13 +275,13 @@ static void check_initial_placement_legality(const vtr::vector_map<ClusterBlockI
         for (const auto& movable_blk_id : movable_blocks_of_type) {
             if (block_locs[movable_blk_id].is_fixed) {
                 VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Fixed block %d of logical type %s was mistakenly marked as movable during initial placement.\n",
-                                (size_t)movable_blk_id, logical_block_type.name);
+                                (size_t)movable_blk_id, logical_block_type.name.c_str());
             }
             if (cluster_ctx.clb_nlist.block_type(movable_blk_id)->index != logical_block_type.index) {
                 VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Clustered block %d of logical type %s was mistakenly marked as logical type %s.\n",
                                 (size_t)movable_blk_id,
-                                cluster_ctx.clb_nlist.block_type(movable_blk_id)->name,
-                                logical_block_type.name);
+                                cluster_ctx.clb_nlist.block_type(movable_blk_id)->name.c_str(),
+                                logical_block_type.name.c_str());
             }
         }
     }

vpr/src/place/move_generator.cpp

@@ -86,7 +86,7 @@ void MoveTypeStat::print_placement_move_types_stats() {
                 int rejected = rejected_moves[itype.index][imove];
                 int aborted = moves - (accepted + rejected);
                 if (count == 0) {
-                    VTR_LOG("%-18.20s", itype.name);
+                    VTR_LOG("%-18.20s", itype.name.c_str());
                 } else {
                     VTR_LOG("                  ");
                 }

vpr/src/place/place_macro.cpp

@@ -475,7 +475,7 @@ static void mark_direct_of_ports(int idirect,
                 int num_ports = ports.size();
                 for (int iport = 0; iport < num_ports; iport++) {
                     // Find ports with the same port_name
-                    if (port_name == ports[iport].name ) {
+                    if (port_name == ports[iport].name) {
                         int num_port_pins = ports[iport].num_pins;
 
                         // Check whether the end_pin_index is valid

vpr/test/test_interchange_device.cpp

@@ -94,10 +94,10 @@ TEST_CASE("read_interchange_luts", "[vpr]") {
             REQUIRE(lut_element.lut_bels.size() == 1);
 
             for (auto lut_bel : lut_element.lut_bels) {
-                CHECK(std::find(lut_bels.begin(), lut_bels.end(), lut_bel.name) != lut_bels.end());
+                CHECK(lut_bels.find(lut_bel.name) != lut_bels.end());
                 REQUIRE(lut_bel.output_pin == std::string("O"));
-                for (auto lut_pin : lut_bel.input_pins)
-                    CHECK(std::find(lut_bel_pins.begin(), lut_bel_pins.end(), lut_pin) != lut_bel_pins.end());
+                for (const std::string &lut_pin : lut_bel.input_pins)
+                    CHECK(lut_bel_pins.find(lut_pin) != lut_bel_pins.end());
             }
         }
     }