Merge pull request #3778 from verilog-to-routing/swap_evaluator

SwapEvaluator class

Author: AlexandreSinger

vpr/src/place/annealer.cpp

@@ -248,6 +248,7 @@ PlacementAnnealer::PlacementAnnealer(const t_placer_opts& placer_opts,
     , move_stats_file_(nullptr, vtr::fclose)
     , outer_crit_iter_count_(1)
     , blocks_affected_(placer_state.block_locs().size())
+    , swap_evaluator_(placer_opts, costs, placer_state, net_cost_handler, interposer_cost_handler, delay_model, criticalities)
     , quench_started_(false)
     , congestion_modeling_started_(false)
     , interposer_cong_modeling_started_(false) {
@@ -585,57 +586,14 @@ t_swap_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
     } else {
         VTR_ASSERT(create_move_outcome == e_create_move::VALID);
 
-        /* To make evaluating the move simpler (e.g. calculating changed bounding box),
-         * we first move the blocks to their new locations (apply the move to
-         * blk_loc_registry.block_locs) and then compute the change in cost. If the move
-         * is accepted, the inverse look-up in blk_loc_registry.grid_blocks is updated
-         * (committing the move). If the move is rejected, the blocks are returned to
-         * their original positions (reverting blk_loc_registry.block_locs to its original state).
-         *
-         * Note that the inverse look-up blk_loc_registry.grid_blocks is only updated after
-         * move acceptance is determined, so it should not be used when evaluating a move.
-         */
-
-        // Update the block positions
-        blk_loc_registry.apply_move_blocks(blocks_affected_);
-
-        // Find all the nets affected by this swap and update their wiring costs.
-        // This cost value doesn't depend on the timing info.
-        //
-        // Also find all the pins affected by the swap, and calculates new connection
-        // delays and timing costs.
-        net_cost_handler_.find_affected_nets_and_update_costs(delay_model_, criticalities_, blocks_affected_,
-                                                              cost_terms_delta, timing_delta_c);
-
-        const bool update_interposer_costs = interposer_cost_handler_.has_value() && interposer_cost_handler_->has_active_cost_terms();
-        if (update_interposer_costs) {
-            const auto [interposer_cost_delta, interposer_cong_cost_delta] = interposer_cost_handler_->total_proposed_cost(net_cost_handler_.affected_nets());
-            cost_terms_delta.interposer_cost = interposer_cost_delta;
-            cost_terms_delta.interposer_cong_cost = interposer_cong_cost_delta;
-        }
+        // Apply the move to block_locs and compute the resulting cost deltas.
+        t_swap_cost_deltas deltas = swap_evaluator_.apply_and_evaluate(blocks_affected_, place_algorithm);
+        cost_terms_delta = deltas.cost_terms_delta;
+        timing_delta_c = deltas.timing_delta_c;
+        delta_c = deltas.delta_c;
+        const bool update_interposer_costs = deltas.update_interposer_costs;
 
-        if (place_algorithm == e_place_algorithm::CRITICALITY_TIMING_PLACE) {
-            /* Take delta_c as a combination of timing and wiring cost. In
-             * addition to `timing_tradeoff`, we normalize the cost values.
-             * CRITICALITY_TIMING_PLACE algorithm works with somewhat stale
-             * timing information to save CPU time.
-             */
-            VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
-                           "\t\tMove bb_delta_c %e, bb_cost_norm %e, timing_tradeoff %f, "
-                           "timing_delta_c %e, timing_cost_norm %e\n",
-                           cost_terms_delta.bb_cost,
-                           costs_.bb_cost_norm,
-                           placer_opts_.timing_tradeoff,
-                           timing_delta_c,
-                           costs_.timing_cost_norm);
-            delta_c = (1 - placer_opts_.timing_tradeoff) * cost_terms_delta.bb_cost * costs_.bb_cost_norm
-                      + placer_opts_.timing_tradeoff * timing_delta_c * costs_.timing_cost_norm
-                      + placer_opts_.congestion_factor * cost_terms_delta.cong_cost * costs_.congestion_cost_norm;
-            if (update_interposer_costs) {
-                delta_c += placer_opts_.interposer_cost_params.net_cost_factor * cost_terms_delta.interposer_cost * costs_.interposer_cost_norm
-                           + placer_opts_.interposer_cost_params.cong_cost_factor * cost_terms_delta.interposer_cong_cost * costs_.interposer_cong_cost_norm;
-            }
-        } else if (place_algorithm == e_place_algorithm::SLACK_TIMING_PLACE) {
+        if (place_algorithm == e_place_algorithm::SLACK_TIMING_PLACE) {
             /* For setup slack analysis, we first do a timing analysis to get the newest
              * slack values resulted from the proposed block moves. If the move turns out
              * to be accepted, we keep the updated slack values and commit the block moves.
@@ -669,17 +627,6 @@ t_swap_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
             /* Get the setup slack analysis cost */
             //TODO: calculate a weighted average of the slack cost and wiring cost
             delta_c = analyze_setup_slack_cost(setup_slacks_, placer_state_) * costs_.timing_cost_norm;
-        } else {
-            VTR_ASSERT_SAFE(place_algorithm == e_place_algorithm::BOUNDING_BOX_PLACE);
-            VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
-                           "\t\tMove bb_delta_c %e, bb_cost_norm %e\n",
-                           cost_terms_delta.bb_cost,
-                           costs_.bb_cost_norm);
-            delta_c = cost_terms_delta.bb_cost * costs_.bb_cost_norm;
-            if (update_interposer_costs) {
-                delta_c += placer_opts_.interposer_cost_params.net_cost_factor * cost_terms_delta.interposer_cost * costs_.interposer_cost_norm
-                           + placer_opts_.interposer_cost_params.cong_cost_factor * cost_terms_delta.interposer_cong_cost * costs_.interposer_cong_cost_norm;
-            }
         }
 
         NocCostTerms noc_delta_c; // change in NoC cost
@@ -717,11 +664,6 @@ t_swap_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
                  * timing updates. These invalidations are accumulated for a
                  * big timing update in the outer loop. */
                 pin_timing_invalidator_->invalidate_affected_connections(blocks_affected_);
-
-                /* Update the connection_timing_cost and connection_delay
-                 * values from the temporary values. */
-                placer_state_.mutable_timing().commit_td_cost(blocks_affected_);
-
             } else if (place_algorithm == e_place_algorithm::SLACK_TIMING_PLACE) {
                 // Update the timing driven cost as usual
                 costs_.timing_cost += timing_delta_c;
@@ -731,14 +673,11 @@ t_swap_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
                 commit_setup_slacks(setup_slacks_, placer_state_);
             }
 
-            // Update net cost functions and reset flags.
-            net_cost_handler_.update_move_nets();
-            if (update_interposer_costs) {
-                interposer_cost_handler_->commit_costs(net_cost_handler_.affected_nets());
-            }
-
-            // Update clb data structures since we kept the move.
-            blk_loc_registry.commit_move_blocks(blocks_affected_);
+            // Make the move permanent. Connection delays and timing costs are committed
+            // only in CRITICALITY_TIMING_PLACE mode; SLACK_TIMING_PLACE already committed
+            // them before its timing analysis.
+            swap_evaluator_.commit(blocks_affected_, update_interposer_costs,
+                                   /*commit_td=*/place_algorithm == e_place_algorithm::CRITICALITY_TIMING_PLACE);
 
             if (noc_opts_.noc) {
                 noc_cost_handler_->commit_noc_costs();
@@ -755,16 +694,11 @@ t_swap_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
         } else {
             VTR_ASSERT_SAFE(move_outcome == e_move_result::REJECTED);
 
-            // Reset the net cost function flags first.
-            net_cost_handler_.reset_move_nets();
-
-            // Restore the blk_loc_registry.block_locs data structures to their state before the move.
-            blk_loc_registry.revert_move_blocks(blocks_affected_);
+            // Restore block_locs and reset the scratch/proposed state.
+            swap_evaluator_.revert(blocks_affected_,
+                                   /*revert_td=*/place_algorithm == e_place_algorithm::CRITICALITY_TIMING_PLACE);
 
-            if (place_algorithm == e_place_algorithm::CRITICALITY_TIMING_PLACE) {
-                // Un-stage the values stored in proposed_* data structures
-                placer_state_.mutable_timing().revert_td_cost(blocks_affected_);
-            } else if (place_algorithm == e_place_algorithm::SLACK_TIMING_PLACE) {
+            if (place_algorithm == e_place_algorithm::SLACK_TIMING_PLACE) {
                 /* Revert the timing delays and costs to pre-update values.
                  * These routines must be called after reverting the block moves.
                  */

vpr/src/place/annealer.h

@@ -5,8 +5,10 @@
 #include "move_generator.h" // movestats
 #include "net_cost_handler.h"
 #include "manual_move_generator.h"
+#include "swap_evaluator.h"
 #include "vtr_random.h"
 
+#include <memory>
 #include <optional>
 #include <tuple>
 
@@ -330,6 +332,9 @@ class PlacementAnnealer {
     /// Keep record of moved blocks and affected pins in a swap
     t_pl_blocks_to_be_moved blocks_affected_;
 
+    /// Evaluates/commits/reverts swaps
+    SwapEvaluator swap_evaluator_;
+
   private:
     /**
      * @brief The maximum number of swap attempts before invoking the

vpr/src/place/swap_evaluator.cpp

@@ -0,0 +1,124 @@
+#include "swap_evaluator.h"
+
+#include "globals.h"
+#include "interposer_cost_handler.h"
+#include "move_transactions.h"
+#include "placer_state.h"
+#include "vpr_types.h"
+
+SwapEvaluator::SwapEvaluator(const t_placer_opts& placer_opts,
+                             const t_placer_costs& costs,
+                             PlacerState& placer_state,
+                             NetCostHandler& net_cost_handler,
+                             std::optional<InterposerCostHandler>& interposer_cost_handler,
+                             const PlaceDelayModel* delay_model,
+                             const PlacerCriticalities* criticalities)
+    : placer_opts_(placer_opts)
+    , costs_(costs)
+    , placer_state_(placer_state)
+    , net_cost_handler_(net_cost_handler)
+    , interposer_cost_handler_(interposer_cost_handler)
+    , delay_model_(delay_model)
+    , criticalities_(criticalities) {}
+
+t_swap_cost_deltas SwapEvaluator::apply_and_evaluate(t_pl_blocks_to_be_moved& blocks_affected,
+                                                     const t_place_algorithm& place_algorithm) {
+    t_swap_cost_deltas deltas;
+
+    // To make evaluating the move simpler (e.g. calculating changed bounding box),
+    // we first move the blocks to their new locations (apply the move to
+    // blk_loc_registry.block_locs) and then compute the change in cost. If the move
+    // is accepted, the inverse look-up in blk_loc_registry.grid_blocks is updated
+    // (committing the move). If the move is rejected, the blocks are returned to their
+    // original positions (reverting blk_loc_registry.block_locs to its original state).
+    //
+    // Note that the inverse look-up blk_loc_registry.grid_blocks is only updated after
+    // move acceptance is determined, so it should not be used when evaluating a move.
+
+    // Update the block positions
+    placer_state_.mutable_blk_loc_registry().apply_move_blocks(blocks_affected);
+
+    // Find all the nets affected by this swap and update their costs.
+    // Also finds all the pins affected by the swap, and calculates new connection
+    // delays and timing costs.
+    net_cost_handler_.find_affected_nets_and_update_costs(delay_model_, criticalities_, blocks_affected,
+                                                          deltas.cost_terms_delta,
+                                                          deltas.timing_delta_c);
+
+    deltas.update_interposer_costs = interposer_cost_handler_.has_value() && interposer_cost_handler_->has_active_cost_terms();
+    if (deltas.update_interposer_costs) {
+        const auto [interposer_cost_delta, interposer_cong_cost_delta] = interposer_cost_handler_->total_proposed_cost(net_cost_handler_.affected_nets());
+        deltas.cost_terms_delta.interposer_cost = interposer_cost_delta;
+        deltas.cost_terms_delta.interposer_cong_cost = interposer_cong_cost_delta;
+    }
+
+    if (place_algorithm == e_place_algorithm::CRITICALITY_TIMING_PLACE) {
+        // Take delta_c as a combination of timing and wiring cost. In
+        // addition to `timing_tradeoff`, we normalize the cost values.
+        // CRITICALITY_TIMING_PLACE algorithm works with somewhat stale
+        // timing information to save CPU time.
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
+                       "\t\tMove bb_delta_c %e, bb_cost_norm %e, timing_tradeoff %f, "
+                       "timing_delta_c %e, timing_cost_norm %e\n",
+                       deltas.cost_terms_delta.bb_cost,
+                       costs_.bb_cost_norm,
+                       placer_opts_.timing_tradeoff,
+                       deltas.timing_delta_c,
+                       costs_.timing_cost_norm);
+        deltas.delta_c = (1 - placer_opts_.timing_tradeoff) * deltas.cost_terms_delta.bb_cost * costs_.bb_cost_norm
+                         + placer_opts_.timing_tradeoff * deltas.timing_delta_c * costs_.timing_cost_norm
+                         + placer_opts_.congestion_factor * deltas.cost_terms_delta.cong_cost * costs_.congestion_cost_norm;
+        if (deltas.update_interposer_costs) {
+            deltas.delta_c += placer_opts_.interposer_cost_params.net_cost_factor * deltas.cost_terms_delta.interposer_cost * costs_.interposer_cost_norm
+                              + placer_opts_.interposer_cost_params.cong_cost_factor * deltas.cost_terms_delta.interposer_cong_cost * costs_.interposer_cong_cost_norm;
+        }
+    } else if (place_algorithm == e_place_algorithm::SLACK_TIMING_PLACE) {
+        // delta_c is derived from a setup slack analysis performed by the caller;
+        // only the component deltas are computed here.
+    } else {
+        VTR_ASSERT_SAFE(place_algorithm == e_place_algorithm::BOUNDING_BOX_PLACE);
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
+                       "\t\tMove bb_delta_c %e, bb_cost_norm %e\n",
+                       deltas.cost_terms_delta.bb_cost,
+                       costs_.bb_cost_norm);
+        deltas.delta_c = deltas.cost_terms_delta.bb_cost * costs_.bb_cost_norm;
+        if (deltas.update_interposer_costs) {
+            deltas.delta_c += placer_opts_.interposer_cost_params.net_cost_factor * deltas.cost_terms_delta.interposer_cost * costs_.interposer_cost_norm
+                              + placer_opts_.interposer_cost_params.cong_cost_factor * deltas.cost_terms_delta.interposer_cong_cost * costs_.interposer_cong_cost_norm;
+        }
+    }
+
+    return deltas;
+}
+
+void SwapEvaluator::commit(t_pl_blocks_to_be_moved& blocks_affected,
+                           bool update_interposer_costs,
+                           bool commit_td) {
+    if (commit_td) {
+        // Update the connection_timing_cost and connection_delay
+        // values from the temporary values.
+        placer_state_.mutable_timing().commit_td_cost(blocks_affected);
+    }
+
+    // Update net cost functions and reset flags.
+    net_cost_handler_.update_move_nets();
+    if (update_interposer_costs) {
+        interposer_cost_handler_->commit_costs(net_cost_handler_.affected_nets());
+    }
+
+    // Update the grid_blocks inverse look-up now that the move is kept.
+    placer_state_.mutable_blk_loc_registry().commit_move_blocks(blocks_affected);
+}
+
+void SwapEvaluator::revert(t_pl_blocks_to_be_moved& blocks_affected, bool revert_td) {
+    // Reset the net cost function flags first.
+    net_cost_handler_.reset_move_nets();
+
+    // Restore the blk_loc_registry.block_locs data structures to their state before the move.
+    placer_state_.mutable_blk_loc_registry().revert_move_blocks(blocks_affected);
+
+    if (revert_td) {
+        // Un-stage the values stored in proposed_* data structures
+        placer_state_.mutable_timing().revert_td_cost(blocks_affected);
+    }
+}