iterate over move type names

Author: soheilshahrouz

vpr/src/base/CheckSetup.cpp

@@ -31,7 +31,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,
             "This is allowed, but strange, and circuit speed will suffer.\n");
     }
 
-    if ((false == Timing.timing_analysis_enabled)
+    if (!Timing.timing_analysis_enabled
         && (PlacerOpts.place_algorithm.is_timing_driven())) {
         /* May work, not tested */
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
@@ -43,14 +43,20 @@ void CheckSetup(const t_packer_opts& PackerOpts,
                         "A block location file requires that placement is enabled.\n");
     }
 
-    if (PlacerOpts.place_static_move_prob.size() != NUM_PL_MOVE_TYPES) {
+    if (PlacerOpts.place_algorithm.is_timing_driven() &&
+        PlacerOpts.place_static_move_prob.size() > NUM_PL_MOVE_TYPES) {
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                        "The number of placer move probabilities should equal to the total number of supported moves. %d\n", PlacerOpts.place_static_move_prob.size());
+                        "The number of provided placer move probabilities (%d) should equal or less than the total number of supported moves (%d).\n",
+                        PlacerOpts.place_static_move_prob.size(),
+                        NUM_PL_MOVE_TYPES);
     }
 
-    if (PlacerOpts.place_static_notiming_move_prob.size() != NUM_PL_NONTIMING_MOVE_TYPES) {
+    if (!PlacerOpts.place_algorithm.is_timing_driven() &&
+        PlacerOpts.place_static_move_prob.size() > NUM_PL_NONTIMING_MOVE_TYPES) {
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                        "The number of placer non timing move probabilities should equal to the total number of supported moves. %d\n", PlacerOpts.place_static_notiming_move_prob.size());
+                        "The number of placer non timing move probabilities (%d) should equal to or less than the total number of supported moves (%d).\n",
+                        PlacerOpts.place_static_move_prob.size(),
+                        NUM_PL_MOVE_TYPES);
     }
 
     if (RouterOpts.doRouting) {

vpr/src/base/SetupVPR.cpp

@@ -661,8 +661,8 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->effort_scaling = Options.place_effort_scaling;
     PlacerOpts->timing_update_type = Options.timing_update_type;
     PlacerOpts->enable_analytic_placer = Options.enable_analytic_placer;
-    PlacerOpts->place_static_move_prob = Options.place_static_move_prob;
-    PlacerOpts->place_static_notiming_move_prob = Options.place_static_notiming_move_prob;
+    PlacerOpts->place_static_move_prob = vtr::vector<e_move_type, float>(Options.place_static_move_prob.value().begin(),
+                                                                         Options.place_static_move_prob.value().end());
     PlacerOpts->place_high_fanout_net = Options.place_high_fanout_net;
     PlacerOpts->place_bounding_box_mode = Options.place_bounding_box_mode;
     PlacerOpts->RL_agent_placement = Options.RL_agent_placement;

vpr/src/base/read_options.cpp

@@ -2032,24 +2032,17 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
 
     place_grp.add_argument(args.place_static_move_prob, "--place_static_move_prob")
         .help(
-            "The percentage probabilities of different moves in Simulated Annealing placement."
-            "This option is only effective for timing-driven placement."
-            "The numbers listed are interpreted as the percentage probabilities of {uniformMove, MedianMove, CentroidMove, "
+            "The percentage probabilities of different moves in Simulated Annealing placement. "
+            "For non-timing-driven placement, only the first 3 probabilities should be provided. "
+            "For timing-driven placement, all probabilities should be provided. "
+            "When the number of provided probabilities is less then the number of move types, zero probability "
+            "is assumed."
+            "The numbers listed are interpreted as the percentage probabilities of {UniformMove, MedianMove, CentroidMove, "
             "WeightedCentroid, WeightedMedian, Critical UniformMove, Timing feasible Region(TFR)}, in that order.")
         .nargs('+')
-        .default_value({"100", "0", "0", "0", "0", "0", "0"})
-
+        .default_value({"100"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    place_grp.add_argument(args.place_static_notiming_move_prob, "--place_static_notiming_move_prob")
-        .help(
-            "The Probability of different non timing move in Simulated Annealing."
-            "This option is only effective for nontiming driven placement."
-            " The numbers listed are interpreted as the percentage probabilities of {uniformMove, MedianMove, CentroidMove}, in that order.")
-        .nargs('+')
-        .default_value({"100", "0", "0"})
-
-        .show_in(argparse::ShowIn::HELP_ONLY);
 
     place_grp.add_argument(args.place_high_fanout_net, "--place_high_fanout_net")
         .help(

vpr/src/base/read_options.h

@@ -126,7 +126,6 @@ struct t_options {
     argparse::ArgValue<e_place_delta_delay_algorithm> place_delta_delay_matrix_calculation_method;
     argparse::ArgValue<bool> enable_analytic_placer;
     argparse::ArgValue<std::vector<float>> place_static_move_prob;
-    argparse::ArgValue<std::vector<float>> place_static_notiming_move_prob;
     argparse::ArgValue<int> place_high_fanout_net;
     argparse::ArgValue<e_place_bounding_box_mode> place_bounding_box_mode;
 

vpr/src/base/vpr_types.h

@@ -1150,6 +1150,8 @@ enum class e_place_delta_delay_algorithm {
     DIJKSTRA_EXPANSION,
 };
 
+enum class e_move_type;
+
 /**
  * @brief Various options for the placer.
  *
@@ -1248,8 +1250,7 @@ struct t_placer_opts {
 
     std::string write_placement_delay_lookup;
     std::string read_placement_delay_lookup;
-    std::vector<float> place_static_move_prob;
-    std::vector<float> place_static_notiming_move_prob;
+    vtr::vector<e_move_type, float> place_static_move_prob;
     bool RL_agent_placement;
     bool place_agent_multistate;
     bool place_checkpointing;

vpr/src/place/RL_agent_util.cpp

@@ -1,30 +1,25 @@
 #include "RL_agent_util.h"
+#include "static_move_generator.h"
 #include "manual_move_generator.h"
 
 void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator,
                             std::unique_ptr<MoveGenerator>& move_generator2,
                             const t_placer_opts& placer_opts,
                             int move_lim) {
     if (!placer_opts.RL_agent_placement) { // RL agent is disabled
-        if (placer_opts.place_algorithm.is_timing_driven()) {
-            VTR_LOG("Using static probabilities for choosing each move type\n");
-            VTR_LOG("Probability of Uniform_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::UNIFORM]);
-            VTR_LOG("Probability of Median_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::MEDIAN]);
-            VTR_LOG("Probability of Centroid_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::CENTROID]);
-            VTR_LOG("Probability of Weighted_centroid_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::W_CENTROID]);
-            VTR_LOG("Probability of Weighted_median_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::W_MEDIAN]);
-            VTR_LOG("Probability of Critical_uniform_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::CRIT_UNIFORM]);
-            VTR_LOG("Probability of Timing_feasible_region_move : %f \n", placer_opts.place_static_move_prob[(int)e_move_type::FEASIBLE_REGION]);
-            move_generator = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_move_prob);
-            move_generator2 = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_move_prob);
-        } else { //Non-timing driven placement
-            VTR_LOG("Using static probabilities for choosing each move type\n");
-            VTR_LOG("Probability of Uniform_move : %f \n", placer_opts.place_static_notiming_move_prob[(int)e_move_type::UNIFORM]);
-            VTR_LOG("Probability of Median_move : %f \n", placer_opts.place_static_notiming_move_prob[(int)e_move_type::MEDIAN]);
-            VTR_LOG("Probability of Centroid_move : %f \n", placer_opts.place_static_notiming_move_prob[(int)e_move_type::CENTROID]);
-            move_generator = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_notiming_move_prob);
-            move_generator2 = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_notiming_move_prob);
+        auto move_types = placer_opts.place_static_move_prob;
+        move_types.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES, 0.0f);
+
+        VTR_LOG("Using static probabilities for choosing each move type\n");
+        for (const auto move_type : placer_opts.place_static_move_prob.keys()) {
+            const std::string& move_name =  move_type_to_string(move_type);
+            VTR_LOG("Probability of %s : %f \n",
+                    move_name.c_str(),
+                    placer_opts.place_static_move_prob[move_type]);
         }
+
+        move_generator = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_move_prob);
+        move_generator2 = std::make_unique<StaticMoveGenerator>(placer_opts.place_static_move_prob);
     } else { //RL based placement
         /* For the non timing driven placement: the agent has a single state   *
          *     - Available moves are (Uniform / Median / Centroid)             *
@@ -113,7 +108,7 @@ void assign_current_move_generator(std::unique_ptr<MoveGenerator>& move_generato
         else
             current_move_generator = std::move(move_generator);
     } else {
-        if (agent_state == EARLY_IN_THE_ANNEAL || !placer_opts.place_agent_multistate)
+        if (agent_state == e_agent_state::EARLY_IN_THE_ANNEAL || !placer_opts.place_agent_multistate)
             current_move_generator = std::move(move_generator);
         else
             current_move_generator = std::move(move_generator2);
@@ -132,7 +127,7 @@ void update_move_generator(std::unique_ptr<MoveGenerator>& move_generator,
         else
             move_generator = std::move(current_move_generator);
     } else {
-        if (agent_state == EARLY_IN_THE_ANNEAL || !placer_opts.place_agent_multistate)
+        if (agent_state == e_agent_state::EARLY_IN_THE_ANNEAL || !placer_opts.place_agent_multistate)
             move_generator = std::move(current_move_generator);
         else
             move_generator2 = std::move(current_move_generator);

vpr/src/place/RL_agent_util.h

@@ -1,12 +1,11 @@
 #ifndef RL_AGENT_UTIL_H
 #define RL_AGENT_UTIL_H
 
-#include "static_move_generator.h"
-#include "simpleRL_move_generator.h"
-#include "manual_move_generator.h"
+#include "move_generator.h"
+
 
 //enum represents the available agent states
-enum e_agent_state {
+enum class e_agent_state {
     EARLY_IN_THE_ANNEAL,
     LATE_IN_THE_ANNEAL
 };
@@ -19,15 +18,28 @@ enum e_agent_state {
  * It returns a unique pointer for each move generator in move_generator and move_generator2
  * move_lim: represents the num of moves per temp.
  */
-void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator, std::unique_ptr<MoveGenerator>& move_generator2, const t_placer_opts& placer_opts, int move_lim);
+void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator,
+                            std::unique_ptr<MoveGenerator>& move_generator2,
+                            const t_placer_opts& placer_opts,
+                            int move_lim);
 
 /**
  * @brief copy one of the available move_generators to be the current move_generator that would be used in the placement based on the placer_options and the agent state
  */
-void assign_current_move_generator(std::unique_ptr<MoveGenerator>& move_generator, std::unique_ptr<MoveGenerator>& move_generator2, e_agent_state agent_state, const t_placer_opts& placer_opts, bool in_quench, std::unique_ptr<MoveGenerator>& current_move_generator);
+void assign_current_move_generator(std::unique_ptr<MoveGenerator>& move_generator,
+                                   std::unique_ptr<MoveGenerator>& move_generator2,
+                                   e_agent_state agent_state,
+                                   const t_placer_opts& placer_opts,
+                                   bool in_quench,
+                                   std::unique_ptr<MoveGenerator>& current_move_generator);
 
 /**
  * @ brief move the updated current_move_generator to its original move_Generator structure based on he placer_options and the agent state
  */
-void update_move_generator(std::unique_ptr<MoveGenerator>& move_generator, std::unique_ptr<MoveGenerator>& move_generator2, e_agent_state agent_state, const t_placer_opts& placer_opts, bool in_quench, std::unique_ptr<MoveGenerator>& current_move_generator);
+void update_move_generator(std::unique_ptr<MoveGenerator>& move_generator,
+                           std::unique_ptr<MoveGenerator>& move_generator2,
+                           e_agent_state agent_state,
+                           const t_placer_opts& placer_opts,
+                           bool in_quench,
+                           std::unique_ptr<MoveGenerator>& current_move_generator);
 #endif

vpr/src/place/place.cpp

@@ -981,7 +981,7 @@ void try_place(const Netlist<>& net_list,
 #endif /* ENABLE_ANALYTIC_PLACE */
 
     //RL agent state definition
-    e_agent_state agent_state = EARLY_IN_THE_ANNEAL;
+    e_agent_state agent_state = e_agent_state::EARLY_IN_THE_ANNEAL;
 
     std::unique_ptr<MoveGenerator> current_move_generator;
 
@@ -1011,7 +1011,7 @@ void try_place(const Netlist<>& net_list,
                 //see if we should save the current placement solution as a checkpoint
 
                 if (placer_opts.place_checkpointing
-                    && agent_state == LATE_IN_THE_ANNEAL) {
+                    && agent_state == e_agent_state::LATE_IN_THE_ANNEAL) {
                     save_placement_checkpoint_if_needed(placement_checkpoint,
                                                         timing_info, costs, critical_path.delay());
                 }
@@ -1045,9 +1045,9 @@ void try_place(const Netlist<>& net_list,
 
             if (placer_opts.place_algorithm.is_timing_driven()
                 && placer_opts.place_agent_multistate
-                && agent_state == EARLY_IN_THE_ANNEAL) {
+                && agent_state == e_agent_state::EARLY_IN_THE_ANNEAL) {
                 if (state.alpha < 0.85 && state.alpha > 0.6) {
-                    agent_state = LATE_IN_THE_ANNEAL;
+                    agent_state = e_agent_state::LATE_IN_THE_ANNEAL;
                     VTR_LOG("Agent's 2nd state: \n");
                 }
             }

vpr/src/place/static_move_generator.cpp

@@ -1,42 +1,61 @@
+
 #include "static_move_generator.h"
-#include "globals.h"
-#include <algorithm>
+
+#include "median_move_generator.h"
+#include "weighted_median_move_generator.h"
+#include "weighted_centroid_move_generator.h"
+#include "feasible_region_move_generator.h"
+#include "uniform_move_generator.h"
+#include "critical_uniform_move_generator.h"
+#include "centroid_move_generator.h"
 
 #include "vtr_random.h"
 #include "vtr_assert.h"
 
-StaticMoveGenerator::StaticMoveGenerator(const std::vector<float>& prob) {
-    avail_moves.emplace_back(std::make_unique<UniformMoveGenerator>());
-    avail_moves.emplace_back(std::make_unique<MedianMoveGenerator>());
-    avail_moves.emplace_back(std::make_unique<CentroidMoveGenerator>());
-    avail_moves.emplace_back(std::make_unique<WeightedCentroidMoveGenerator>());
-    avail_moves.emplace_back(std::make_unique<WeightedMedianMoveGenerator>());
-    avail_moves.emplace_back(std::make_unique<CriticalUniformMoveGenerator>());
-    avail_moves.emplace_back(std::make_unique<FeasibleRegionMoveGenerator>());
+StaticMoveGenerator::StaticMoveGenerator(const vtr::vector<e_move_type, float>& move_probs) {
+    all_moves.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES);
 
-    initialize_move_prob(prob);
+    all_moves[e_move_type::UNIFORM] = std::make_unique<UniformMoveGenerator>();
+    all_moves[e_move_type::MEDIAN] = std::make_unique<MedianMoveGenerator>();
+    all_moves[e_move_type::CENTROID] = std::make_unique<CentroidMoveGenerator>();
+    all_moves[e_move_type::W_CENTROID] = std::make_unique<WeightedCentroidMoveGenerator>();
+    all_moves[e_move_type::W_MEDIAN] = std::make_unique<WeightedMedianMoveGenerator>();
+    all_moves[e_move_type::CRIT_UNIFORM] = std::make_unique<CriticalUniformMoveGenerator>();
+    all_moves[e_move_type::FEASIBLE_REGION] = std::make_unique<FeasibleRegionMoveGenerator>();
+
+    initialize_move_prob(move_probs);
 }
 
-void StaticMoveGenerator::initialize_move_prob(const std::vector<float>& prob) {
-    cumm_move_probs.push_back(prob[0]);
-    for (size_t i = 1; i < prob.size(); i++) {
-        cumm_move_probs.push_back(prob[i] + cumm_move_probs[i - 1]);
+void StaticMoveGenerator::initialize_move_prob(const vtr::vector<e_move_type, float>& move_probs) {
+    cumm_move_probs.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES);
+    std::fill(cumm_move_probs.begin(), cumm_move_probs.end(), 0.0f);
+
+    for(auto move_type : move_probs.keys()) {
+        cumm_move_probs[move_type] = move_probs[move_type];
     }
 
-    total_prob = cumm_move_probs[cumm_move_probs.size() - 1];
+    std::partial_sum(cumm_move_probs.begin(), cumm_move_probs.end(), cumm_move_probs.begin());
+
+    total_prob = cumm_move_probs.back();
 }
 
-e_create_move StaticMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected, t_propose_action& proposed_action, float rlim, const t_placer_opts& placer_opts, const PlacerCriticalities* criticalities) {
+e_create_move StaticMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
+                                                t_propose_action& proposed_action,
+                                                float rlim,
+                                                const t_placer_opts& placer_opts,
+                                                const PlacerCriticalities* criticalities) {
     float rand_num = vtr::frand() * total_prob;
-    for (size_t i = 0; i < cumm_move_probs.size(); i++) {
-        if (rand_num <= cumm_move_probs[i]) {
-            proposed_action.move_type = (e_move_type)i;
-            return avail_moves[i]->propose_move(blocks_affected, proposed_action, rlim, placer_opts, criticalities);
+
+    for (auto move_type : cumm_move_probs.keys()) {
+        if (rand_num <= cumm_move_probs[move_type]) {
+            proposed_action.move_type = move_type;
+            return all_moves[move_type]->propose_move(blocks_affected, proposed_action, rlim, placer_opts, criticalities);
         }
     }
-    VTR_ASSERT_MSG(false, vtr::string_fmt("During static probability move selection, random number (%g) exceeded total expected probabaility (%g)", rand_num, total_prob).c_str());
+
+    VTR_ASSERT_MSG(false, vtr::string_fmt("During static probability move selection, random number (%g) exceeded total expected probability (%g)", rand_num, total_prob).c_str());
 
     //Unreachable
-    proposed_action.move_type = (e_move_type)(avail_moves.size() - 1);
-    return avail_moves[avail_moves.size() - 1]->propose_move(blocks_affected, proposed_action, rlim, placer_opts, criticalities);
+    proposed_action.move_type = e_move_type::INVALID_MOVE;
+    return e_create_move::ABORT;
 }