enum class e_move_result

Author: soheilshahrouz

vpr/src/draw/manual_moves.cpp

@@ -254,16 +254,16 @@ void manual_move_cost_summary_dialog() {
     switch (result) {
         //If the user accepts the manual move
         case GTK_RESPONSE_ACCEPT:
-            draw_state->manual_moves_state.manual_move_info.user_move_outcome = ACCEPTED;
+            draw_state->manual_moves_state.manual_move_info.user_move_outcome = e_move_result::ACCEPTED;
             application.update_message(msg);
             break;
         //If the user rejects the manual move
         case GTK_RESPONSE_REJECT:
-            draw_state->manual_moves_state.manual_move_info.user_move_outcome = REJECTED;
+            draw_state->manual_moves_state.manual_move_info.user_move_outcome = e_move_result::REJECTED;
             application.update_message("Manual move was rejected");
             break;
         default:
-            draw_state->manual_moves_state.manual_move_info.user_move_outcome = ABORTED;
+            draw_state->manual_moves_state.manual_move_info.user_move_outcome = e_move_result::ABORTED;
             break;
     }
 

vpr/src/draw/manual_moves.h

@@ -56,8 +56,8 @@ struct ManualMovesInfo {
     double delta_bounding_box = 0;
     bool valid_input = true;
     t_pl_loc to_location;
-    e_move_result placer_move_outcome = ABORTED;
-    e_move_result user_move_outcome = ABORTED;
+    e_move_result placer_move_outcome = e_move_result::ABORTED;
+    e_move_result user_move_outcome = e_move_result::ABORTED;
 };
 
 /**

vpr/src/place/annealer.cpp

@@ -339,12 +339,12 @@ float PlacementAnnealer::estimate_starting_temperature() {
         e_move_result swap_result = try_swap(move_generator_1_, placer_opts_.place_algorithm,
                                              REWARD_BB_TIMING_RELATIVE_WEIGHT, manual_move_enabled);
 
-        if (swap_result == ACCEPTED) {
+        if (swap_result == e_move_result::ACCEPTED) {
             num_accepted++;
             av += costs_.cost;
             sum_of_squares += costs_.cost * costs_.cost;
             swap_stats_.num_swap_accepted++;
-        } else if (swap_result == ABORTED) {
+        } else if (swap_result == e_move_result::ABORTED) {
             swap_stats_.num_swap_aborted++;
         } else {
             swap_stats_.num_swap_rejected++;
@@ -455,7 +455,7 @@ e_move_result PlacementAnnealer::try_swap(MoveGenerator& move_generator,
                                    "illegal move");
         }
 
-        move_outcome = ABORTED;
+        move_outcome = e_move_result::ABORTED;
 
     } else {
         VTR_ASSERT(create_move_outcome == e_create_move::VALID);
@@ -553,7 +553,7 @@ e_move_result PlacementAnnealer::try_swap(MoveGenerator& move_generator,
         }
 #endif //NO_GRAPHICS
 
-        if (move_outcome == ACCEPTED) {
+        if (move_outcome == e_move_result::ACCEPTED) {
             costs_.cost += delta_c;
             costs_.bb_cost += bb_delta_c;
 
@@ -601,7 +601,7 @@ e_move_result PlacementAnnealer::try_swap(MoveGenerator& move_generator,
 #endif //NO_GRAPHICS
 
         } else {
-            VTR_ASSERT_SAFE(move_outcome == REJECTED);
+            VTR_ASSERT_SAFE(move_outcome == e_move_result::REJECTED);
 
             // Reset the net cost function flags first.
             net_cost_handler_.reset_move_nets();
@@ -652,7 +652,7 @@ e_move_result PlacementAnnealer::try_swap(MoveGenerator& move_generator,
         move_outcome_stats.delta_timing_cost_abs = timing_delta_c;
 
         if constexpr (VTR_ENABLE_DEBUG_LOGGING_CONST_EXPR) {
-            LOG_MOVE_STATS_OUTCOME(delta_c, bb_delta_c, timing_delta_c, (move_outcome ? "ACCEPTED" : "REJECTED"), "");
+            LOG_MOVE_STATS_OUTCOME(delta_c, bb_delta_c, timing_delta_c, (move_outcome == e_move_result::ACCEPTED ? "ACCEPTED" : "REJECTED"), "");
         }
     }
     move_outcome_stats.outcome = move_outcome;
@@ -721,11 +721,11 @@ void PlacementAnnealer::placement_inner_loop(MoveGenerator& move_generator,
         e_move_result swap_result = try_swap(move_generator, placer_opts_.place_algorithm,
                                              timing_bb_factor, manual_move_enabled);
 
-        if (swap_result == ACCEPTED) {
+        if (swap_result == e_move_result::ACCEPTED) {
             // Move was accepted.  Update statistics that are useful for the annealing schedule.
             placer_stats_.single_swap_update(costs_);
             swap_stats_.num_swap_accepted++;
-        } else if (swap_result == ABORTED) {
+        } else if (swap_result == e_move_result::ABORTED) {
             swap_stats_.num_swap_aborted++;
         } else { // swap_result == REJECTED
             swap_stats_.num_swap_rejected++;
@@ -879,20 +879,20 @@ e_move_result PlacementAnnealer::assess_swap_(double delta_c, double t) {
     VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\tTemperature is: %e delta_c is %e\n", t, delta_c);
     if (delta_c <= 0) {
         VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\tMove is accepted(delta_c < 0)\n");
-        return ACCEPTED;
+        return e_move_result::ACCEPTED;
     }
 
     if (t == 0.) {
         VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\tMove is rejected(t == 0)\n");
-        return REJECTED;
+        return e_move_result::REJECTED;
     }
 
     float fnum = rng_.frand();
     float prob_fac = std::exp(-delta_c / t);
     if (prob_fac > fnum) {
         VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\tMove is accepted(hill climbing)\n");
-        return ACCEPTED;
+        return e_move_result::ACCEPTED;
     }
     VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\tMove is rejected(hill climbing)\n");
-    return REJECTED;
+    return e_move_result::REJECTED;
 }

vpr/src/place/move_generator.h

@@ -17,7 +17,7 @@ struct MoveOutcomeStats {
     float delta_bb_cost_abs = std::numeric_limits<float>::quiet_NaN();
     float delta_timing_cost_abs = std::numeric_limits<float>::quiet_NaN();
 
-    e_move_result outcome = ABORTED;
+    e_move_result outcome = e_move_result::ABORTED;
     float elapsed_time = std::numeric_limits<float>::quiet_NaN();
 };
 

vpr/src/place/move_utils.cpp

@@ -1265,8 +1265,23 @@ bool intersect_range_limit_with_floorplan_constraints(ClusterBlockId b_from,
 }
 
 std::string e_move_result_to_string(e_move_result move_outcome) {
-    std::string move_result_to_string[] = {"Rejected", "Accepted", "Aborted"};
-    return move_result_to_string[move_outcome];
+    switch (move_outcome) {
+        case e_move_result::REJECTED:
+            return "Rejected";
+            break;
+
+        case e_move_result::ACCEPTED:
+            return "Accepted";
+            break;
+
+        case e_move_result::ABORTED:
+            return "Aborted";
+            break;
+
+        default:
+            return "Unsupported Move Outcome!";
+            break;
+    }
 }
 
 int find_free_layer(t_logical_block_type_ptr logical_block,

vpr/src/place/move_utils.h

@@ -19,7 +19,7 @@ constexpr size_t SMALL_NET = 4;
 /* This is for the placement swap routines. A swap attempt could be       *
  * rejected, accepted or aborted (due to the limitations placed on the    *
  * carry chain support at this point).                                    */
-enum e_move_result {
+enum class e_move_result {
     REJECTED,
     ACCEPTED,
     ABORTED

vpr/src/place/placer_breakpoint.cpp

@@ -11,10 +11,9 @@ void transform_blocks_affected(const t_pl_blocks_to_be_moved& blocksAffected) {
     BreakpointState* bp_state = get_bp_state_globals()->get_glob_breakpoint_state();
 
     bp_state->blocks_affected_by_move.clear();
-    for (size_t i = 0; i < blocksAffected.moved_blocks.size(); i++) {
+    for (const t_pl_moved_block& moved_block : blocksAffected.moved_blocks) {
         //size_t conversion is required since block_num is of type ClusterBlockId and can't be cast to an int. And this vector has to be of type int to be recognized in expr_eval class
-
-        bp_state->blocks_affected_by_move.push_back(size_t(blocksAffected.moved_blocks[i].block_num));
+        bp_state->blocks_affected_by_move.push_back(size_t(moved_block.block_num));
     }
 }
 
@@ -40,9 +39,9 @@ void stop_placement_and_check_breakpoints(t_pl_blocks_to_be_moved& blocks_affect
 
     if (placer_breakpoint_reached() && draw_state->show_graphics) {
         std::string msg = available_move_types[0];
-        if (move_outcome == 0) {
+        if (move_outcome == e_move_result::REJECTED) {
             msg += vtr::string_fmt(", Rejected");
-        } else if (move_outcome == 1) {
+        } else if (move_outcome == e_move_result::ACCEPTED) {
             msg += vtr::string_fmt(", Accepted");
         } else {
             msg += vtr::string_fmt(", Aborted");