Changed type of pad_loc_type back to enum instead of string

Author: sfkhalid

vpr/src/base/ShowSetup.cpp

@@ -511,12 +511,15 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
         }
 
         VTR_LOG("PlacerOpts.pad_loc_type: ");
-        if (PlacerOpts.pad_loc_type == "free") {
-            VTR_LOG("FREE\n");
-        } else if (PlacerOpts.pad_loc_type == "random") {
-            VTR_LOG("RANDOM\n");
-        } else {
-            VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "Unknown I/O pad location type\n");
+        switch (PlacerOpts.pad_loc_type) {
+        	case FREE:
+        		VTR_LOG("FREE\n");
+        		break;
+        	case RANDOM:
+        		VTR_LOG("RANDOM\n");
+        		break;
+        	default:
+        		VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "Unknown I/O pad location type\n");
         }
 
         VTR_LOG("PlacerOpts.constraints_file: ");

vpr/src/base/read_options.cpp

@@ -343,6 +343,37 @@ struct ParsePlaceAlgorithm {
     }
 };
 
+struct ParseFixPins {
+    ConvertedValue<e_pad_loc_type> from_str(std::string str) {
+        ConvertedValue<e_pad_loc_type> conv_value;
+        if (str == "free")
+            conv_value.set_value(FREE);
+        else if (str == "random")
+            conv_value.set_value(RANDOM);
+        else {
+            std::stringstream msg;
+            msg << "Invalid conversion from '" << str << "' to e_router_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
+            conv_value.set_error(msg.str());
+        }
+        return conv_value;
+    }
+
+    ConvertedValue<std::string> to_str(e_pad_loc_type val) {
+        ConvertedValue<std::string> conv_value;
+        if (val == FREE)
+            conv_value.set_value("free");
+        else {
+            VTR_ASSERT(val == RANDOM);
+            conv_value.set_value("random");
+        }
+        return conv_value;
+    }
+
+    std::vector<std::string> default_choices() {
+        return {"free", "random"};
+    }
+};
+
 struct ParseClusterSeed {
     ConvertedValue<e_cluster_seed> from_str(std::string str) {
         ConvertedValue<e_cluster_seed> conv_value;
@@ -1596,12 +1627,13 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("0.25")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    place_grp.add_argument(args.pad_loc_type, "--fix_pins")
+    place_grp.add_argument<e_pad_loc_type, ParseFixPins>(args.pad_loc_type, "--fix_pins")
         .help(
             "Fixes I/O pad locations randomly during placement. Valid options:\n"
             " * 'free' allows placement to optimize pad locations\n"
             " * 'random' fixes pad locations to arbitrary locations\n.")
         .default_value("free")
+		.choices({"free", "random"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     place_grp.add_argument(args.constraints_file, "--fix_clusters")

vpr/src/base/read_options.h

@@ -104,7 +104,7 @@ struct t_options {
     argparse::ArgValue<float> PlaceSuccessTarget;
     argparse::ArgValue<sched_type> anneal_sched_type;
     argparse::ArgValue<e_place_algorithm> PlaceAlgorithm;
-    argparse::ArgValue<std::string> pad_loc_type;
+    argparse::ArgValue<e_pad_loc_type> pad_loc_type;
     argparse::ArgValue<int> PlaceChanWidth;
     argparse::ArgValue<float> place_rlim_escape_fraction;
     argparse::ArgValue<std::string> place_move_stats_file;

vpr/src/base/vpr_types.h

@@ -837,6 +837,11 @@ enum e_place_algorithm {
     PATH_TIMING_DRIVEN_PLACE
 };
 
+enum e_pad_loc_type {
+	FREE,
+	RANDOM
+};
+
 enum e_place_effort_scaling {
     CIRCUIT,       ///<Effort scales based on circuit size only
     DEVICE_CIRCUIT ///<Effort scales based on both circuit and device size
@@ -872,7 +877,7 @@ struct t_placer_opts {
     float timing_tradeoff;
     float place_cost_exp;
     int place_chan_width;
-    std::string pad_loc_type;
+    enum e_pad_loc_type pad_loc_type;
     std::string constraints_file;
     enum pfreq place_freq;
     int recompute_crit_iter;

vpr/src/place/initial_placement.cpp

@@ -23,7 +23,7 @@ static int check_macro_can_be_placed(t_pl_macro pl_macro, int itype, t_pl_loc he
 static int try_place_macro(int itype, int ipos, int isub_tile, t_pl_macro pl_macro);
 static void initial_placement_pl_macros(int macros_max_num_tries, std::vector<std::vector<int>>& free_locations);
 
-static void initial_placement_blocks(std::vector<std::vector<int>>& free_locations, std::string pad_loc_type);
+static void initial_placement_blocks(std::vector<std::vector<int>>& free_locations, enum e_pad_loc_type pad_loc_type);
 
 static t_physical_tile_type_ptr pick_placement_type(t_logical_block_type_ptr logical_block,
                                                     int num_needed_types,
@@ -296,7 +296,7 @@ static void initial_placement_pl_macros(int macros_max_num_tries, std::vector<st
 
 /* Place blocks that are NOT a part of any macro.
  * We'll randomly place each block in the clustered netlist, one by one. */
-static void initial_placement_blocks(std::vector<std::vector<int>>& free_locations, std::string pad_loc_type) {
+static void initial_placement_blocks(std::vector<std::vector<int>>& free_locations, enum e_pad_loc_type pad_loc_type) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
     auto& place_ctx = g_vpr_ctx.mutable_placement();
@@ -368,7 +368,7 @@ static void initial_placement_blocks(std::vector<std::vector<int>>& free_locatio
         place_ctx.block_locs[blk_id].loc = to;
 
         //Mark IOs as fixed if specifying a (fixed) random placement
-        if (is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == "random") {
+        if (is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == RANDOM) {
             place_ctx.block_locs[blk_id].is_fixed = true;
         }
 
@@ -396,7 +396,7 @@ static t_physical_tile_type_ptr pick_placement_type(t_logical_block_type_ptr log
     return nullptr;
 }
 
-void initial_placement(std::string pad_loc_type, const char* constraints_file) {
+void initial_placement(enum e_pad_loc_type pad_loc_type, const char* constraints_file) {
     vtr::ScopedStartFinishTimer timer("Initial Placement");
 
     /* Randomly places the blocks to create an initial placement. We rely on

vpr/src/place/initial_placement.h

@@ -3,6 +3,6 @@
 
 #include "vpr_types.h"
 
-void initial_placement(std::string pad_loc_type, const char* constraints_file);
+void initial_placement(enum e_pad_loc_type pad_loc_type, const char* constraints_file);
 
 #endif