enum class e_reward_function

Author: soheilshahrouz

vpr/src/place/directed_moves_util.cpp

@@ -136,10 +136,10 @@ void calculate_centroid_loc(ClusterBlockId b_from,
 }
 
 static std::map<std::string, e_reward_function> available_reward_function = {
-    {"basic", BASIC},
-    {"nonPenalizing_basic", NON_PENALIZING_BASIC},
-    {"runtime_aware", RUNTIME_AWARE},
-    {"WLbiased_runtime_aware", WL_BIASED_RUNTIME_AWARE}};
+    {"basic", e_reward_function::BASIC},
+    {"nonPenalizing_basic", e_reward_function::NON_PENALIZING_BASIC},
+    {"runtime_aware", e_reward_function::RUNTIME_AWARE},
+    {"WLbiased_runtime_aware", e_reward_function::WL_BIASED_RUNTIME_AWARE}};
 
 e_reward_function string_to_reward(const std::string& st) {
     return available_reward_function[st];

vpr/src/place/directed_moves_util.h

@@ -7,7 +7,7 @@
 /**
  * @brief enum represents the different reward functions
  */
-enum e_reward_function {
+enum class e_reward_function {
     BASIC,                  ///@ directly uses the change of the annealing cost function
     NON_PENALIZING_BASIC,   ///@ same as basic reward function but with 0 reward if it's a hill-climbing one
     RUNTIME_AWARE,          ///@ same as NON_PENALIZING_BASIC but with normalizing with the runtime factor of each move type

vpr/src/place/place.cpp

@@ -319,12 +319,11 @@ static void generate_post_place_timing_reports(const t_placer_opts& placer_opts,
                                                bool is_flat);
 
 //calculate the agent's reward and the total process outcome
-static void calculate_reward_and_process_outcome(
-    const t_placer_opts& placer_opts,
-    const MoveOutcomeStats& move_outcome_stats,
-    const double& delta_c,
-    float timing_bb_factor,
-    MoveGenerator& move_generator);
+static void calculate_reward_and_process_outcome(const t_placer_opts& placer_opts,
+                                                 const MoveOutcomeStats& move_outcome_stats,
+                                                 double delta_c,
+                                                 float timing_bb_factor,
+                                                 MoveGenerator& move_generator);
 
 static void print_place_status_header(bool noc_enabled);
 
@@ -2023,7 +2022,7 @@ static int check_placement_costs(const t_placer_costs& costs,
     double bb_cost_check;
     double timing_cost_check;
 
-    const auto& cube_bb = g_vpr_ctx.placement().cube_bb;
+    const bool cube_bb = g_vpr_ctx.placement().cube_bb;
 
     if (cube_bb) {
         bb_cost_check = comp_bb_cost(CHECK);
@@ -2398,28 +2397,25 @@ static void print_placement_move_types_stats(const MoveTypeStat& move_type_stat)
     VTR_LOG("\n");
 }
 
-static void calculate_reward_and_process_outcome(
-    const t_placer_opts& placer_opts,
-    const MoveOutcomeStats& move_outcome_stats,
-    const double& delta_c,
-    float timing_bb_factor,
-    MoveGenerator& move_generator) {
-    std::string reward_fun_string = placer_opts.place_reward_fun;
+static void calculate_reward_and_process_outcome(const t_placer_opts& placer_opts,
+                                                 const MoveOutcomeStats& move_outcome_stats,
+                                                 double delta_c,
+                                                 float timing_bb_factor,
+                                                 MoveGenerator& move_generator) {
     static std::optional<e_reward_function> reward_fun;
     if (!reward_fun.has_value()) {
-        reward_fun = string_to_reward(reward_fun_string);
+        reward_fun = string_to_reward(placer_opts.place_reward_fun);
     }
 
-    if (reward_fun == BASIC) {
+    if (reward_fun == e_reward_function::BASIC) {
         move_generator.process_outcome(-1 * delta_c, reward_fun.value());
-    } else if (reward_fun == NON_PENALIZING_BASIC
-               || reward_fun == RUNTIME_AWARE) {
+    } else if (reward_fun == e_reward_function::NON_PENALIZING_BASIC || reward_fun == e_reward_function::RUNTIME_AWARE) {
         if (delta_c < 0) {
             move_generator.process_outcome(-1 * delta_c, reward_fun.value());
         } else {
             move_generator.process_outcome(0, reward_fun.value());
         }
-    } else if (reward_fun == WL_BIASED_RUNTIME_AWARE) {
+    } else if (reward_fun == e_reward_function::WL_BIASED_RUNTIME_AWARE) {
         if (delta_c < 0) {
             float reward = -1
                            * (move_outcome_stats.delta_cost_norm

vpr/src/place/simpleRL_move_generator.cpp

@@ -112,7 +112,7 @@ std::vector<int> KArmedBanditAgent::get_available_logical_blk_types_() {
 
 void KArmedBanditAgent::process_outcome(double reward, e_reward_function reward_fun) {
     ++num_action_chosen_[last_action_];
-    if (reward_fun == RUNTIME_AWARE || reward_fun == WL_BIASED_RUNTIME_AWARE) {
+    if (reward_fun == e_reward_function::RUNTIME_AWARE || reward_fun == e_reward_function::WL_BIASED_RUNTIME_AWARE) {
         e_move_type move_type = action_to_move_type_(last_action_);
         reward /= time_elapsed_[move_type];
     }