NetCostHandler class

libs/libvtrutil/src/vtr_memory.h

@@ -14,7 +14,7 @@ namespace vtr {
 /**
  * @brief This function will force the container to be cleared
  *
- * It release it's held memory.
+ * It release its held memory.
  * For efficiency, STL containers usually don't
  * release their actual heap-allocated memory until
  * destruction (even if Container::clear() is called).

vpr/src/base/vpr_types.h

@@ -618,19 +618,19 @@ struct t_bb {
  */
 struct t_2D_bb {
     t_2D_bb() = default;
-    t_2D_bb(int xmin_, int xmax_, int ymin_, int ymax_, int layer_num_)
+    t_2D_bb(int xmin_, int ymin_, int xmax_, int ymax_, int layer_num_)
         : xmin(xmin_)
-        , xmax(xmax_)
         , ymin(ymin_)
+        , xmax(xmax_)
         , ymax(ymax_)
         , layer_num(layer_num_) {
         VTR_ASSERT(xmax_ >= xmin_);
         VTR_ASSERT(ymax_ >= ymin_);
         VTR_ASSERT(layer_num_ >= 0);
     }
     int xmin = OPEN;
-    int xmax = OPEN;
     int ymin = OPEN;
+    int xmax = OPEN;
     int ymax = OPEN;
     int layer_num = OPEN;
 };

vpr/src/place/RL_agent_util.cpp

@@ -6,9 +6,10 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
                                                                                                  const t_placer_opts& placer_opts,
                                                                                                  int move_lim,
                                                                                                  double noc_attraction_weight) {
-
+    e_reward_function reward_fun = string_to_reward(placer_opts.place_reward_fun);
     std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> move_generators;
 
+
     if (!placer_opts.RL_agent_placement) { // RL agent is disabled
         auto move_types = placer_opts.place_static_move_prob;
         move_types.resize((int)e_move_type::NUMBER_OF_AUTO_MOVES, 0.0f);
@@ -20,8 +21,8 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
                     move_name.c_str(),
                     placer_opts.place_static_move_prob[move_type]);
         }
-        move_generators.first = std::make_unique<StaticMoveGenerator>(placer_state, placer_opts.place_static_move_prob);
-        move_generators.second = std::make_unique<StaticMoveGenerator>(placer_state, placer_opts.place_static_move_prob);
+        move_generators.first = std::make_unique<StaticMoveGenerator>(placer_state, reward_fun, placer_opts.place_static_move_prob);
+        move_generators.second = std::make_unique<StaticMoveGenerator>(placer_state, reward_fun, 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)             *
@@ -74,6 +75,7 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
             }
             karmed_bandit_agent1->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generators.first = std::make_unique<SimpleRLMoveGenerator>(placer_state,
+                                                                            reward_fun,
                                                                             karmed_bandit_agent1,
                                                                             noc_attraction_weight,
                                                                             placer_opts.place_high_fanout_net);
@@ -83,6 +85,7 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
                                                                         placer_opts.place_agent_epsilon);
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generators.second = std::make_unique<SimpleRLMoveGenerator>(placer_state,
+                                                                             reward_fun,
                                                                              karmed_bandit_agent2,
                                                                              noc_attraction_weight,
                                                                              placer_opts.place_high_fanout_net);
@@ -100,6 +103,7 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
             }
             karmed_bandit_agent1->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generators.first = std::make_unique<SimpleRLMoveGenerator>(placer_state,
+                                                                            reward_fun,
                                                                             karmed_bandit_agent1,
                                                                             noc_attraction_weight,
                                                                             placer_opts.place_high_fanout_net);
@@ -108,6 +112,7 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
                                                                   e_agent_space::MOVE_TYPE);
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generators.second = std::make_unique<SimpleRLMoveGenerator>(placer_state,
+                                                                             reward_fun,
                                                                              karmed_bandit_agent2,
                                                                              noc_attraction_weight,
                                                                              placer_opts.place_high_fanout_net);

vpr/src/place/centroid_move_generator.cpp

@@ -16,15 +16,17 @@ vtr::vector<ClusterBlockId, NocGroupId> CentroidMoveGenerator::cluster_to_noc_gr
 std::map<ClusterBlockId, NocGroupId> CentroidMoveGenerator::noc_router_to_noc_group_;
 
 
-CentroidMoveGenerator::CentroidMoveGenerator(PlacerState& placer_state)
-    : MoveGenerator(placer_state)
+CentroidMoveGenerator::CentroidMoveGenerator(PlacerState& placer_state,
+                                             e_reward_function reward_function)
+    : MoveGenerator(placer_state, reward_function)
     , noc_attraction_w_(0.0f)
     , noc_attraction_enabled_(false) {}
 
 CentroidMoveGenerator::CentroidMoveGenerator(PlacerState& placer_state,
+                                             e_reward_function reward_function,
                                              float noc_attraction_weight,
                                              size_t high_fanout_net)
-    : MoveGenerator(placer_state)
+    : MoveGenerator(placer_state, reward_function)
     , noc_attraction_w_(noc_attraction_weight)
     , noc_attraction_enabled_(true) {
     VTR_ASSERT(noc_attraction_weight > 0.0 && noc_attraction_weight <= 1.0);

vpr/src/place/centroid_move_generator.h

@@ -27,7 +27,8 @@ class CentroidMoveGenerator : public MoveGenerator {
      * @param placer_state A mutable reference to the placement state which will
      * be stored in this object.
      */
-    explicit CentroidMoveGenerator(PlacerState& placer_state);
+    CentroidMoveGenerator(PlacerState& placer_state,
+                          e_reward_function reward_function);
 
     /**
      * The move generator created by calling this constructor considers both
@@ -45,6 +46,7 @@ class CentroidMoveGenerator : public MoveGenerator {
      * ignored when forming NoC groups.
      */
     CentroidMoveGenerator(PlacerState& placer_state,
+                          e_reward_function reward_function,
                           float noc_attraction_weight,
                           size_t high_fanout_net);
 

vpr/src/place/critical_uniform_move_generator.cpp

@@ -4,8 +4,9 @@
 #include "placer_state.h"
 #include "move_utils.h"
 
-CriticalUniformMoveGenerator::CriticalUniformMoveGenerator(PlacerState& placer_state)
-    : MoveGenerator(placer_state) {}
+CriticalUniformMoveGenerator::CriticalUniformMoveGenerator(PlacerState& placer_state,
+                                                           e_reward_function reward_function)
+    : MoveGenerator(placer_state, reward_function) {}
 
 e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
                                                          t_propose_action& proposed_action,

vpr/src/place/critical_uniform_move_generator.h

@@ -17,7 +17,8 @@
 class CriticalUniformMoveGenerator : public MoveGenerator {
   public:
     CriticalUniformMoveGenerator() = delete;
-    explicit CriticalUniformMoveGenerator(PlacerState& placer_state);
+    CriticalUniformMoveGenerator(PlacerState& placer_state,
+                                 e_reward_function reward_function);
 
   private:
     e_create_move propose_move(t_pl_blocks_to_be_moved& blocks_affected,

vpr/src/place/directed_moves_util.h

@@ -8,10 +8,11 @@
  * @brief enum represents the different reward functions
  */
 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
-    WL_BIASED_RUNTIME_AWARE ///@ same as RUNTIME_AWARE but more biased to WL cost (the factor of the bias is REWARD_BB_TIMING_RELATIVE_WEIGHT)
+    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
+    WL_BIASED_RUNTIME_AWARE,    ///@ same as RUNTIME_AWARE but more biased to WL cost (the factor of the bias is REWARD_BB_TIMING_RELATIVE_WEIGHT)
+    UNDEFINED_REWARD            ///@ Used for manual moves
 };
 
 e_reward_function string_to_reward(const std::string& st);

vpr/src/place/feasible_region_move_generator.cpp

@@ -8,8 +8,9 @@
 #include <algorithm>
 #include <cmath>
 
-FeasibleRegionMoveGenerator::FeasibleRegionMoveGenerator(PlacerState& placer_state)
-    : MoveGenerator(placer_state) {}
+FeasibleRegionMoveGenerator::FeasibleRegionMoveGenerator(PlacerState& placer_state,
+                                                         e_reward_function reward_function)
+    : MoveGenerator(placer_state, reward_function) {}
 
 e_create_move FeasibleRegionMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
                                                         t_propose_action& proposed_action,

vpr/src/place/feasible_region_move_generator.h

@@ -21,7 +21,8 @@
 class FeasibleRegionMoveGenerator : public MoveGenerator {
   public:
     FeasibleRegionMoveGenerator() = delete;
-    explicit FeasibleRegionMoveGenerator(PlacerState& placer_state);
+    FeasibleRegionMoveGenerator(PlacerState& placer_state,
+                                e_reward_function reward_function);
 
   private:
     e_create_move propose_move(t_pl_blocks_to_be_moved& blocks_affected,

vpr/src/place/manual_move_generator.cpp

@@ -19,7 +19,7 @@
 #endif //NO_GRAPHICS
 
 ManualMoveGenerator::ManualMoveGenerator(PlacerState& placer_state)
-    : MoveGenerator(placer_state) {}
+    : MoveGenerator(placer_state, e_reward_function::UNDEFINED_REWARD) {}
 
 //Manual Move Generator function
 e_create_move ManualMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,

vpr/src/place/manual_move_generator.h

@@ -27,7 +27,7 @@
 class ManualMoveGenerator : public MoveGenerator {
   public:
     ManualMoveGenerator() = delete;
-    explicit ManualMoveGenerator(PlacerState& placer_state);
+    ManualMoveGenerator(PlacerState& placer_state);
 
     //Evaluates if move is successful and legal or unable to do.
     e_create_move propose_move(t_pl_blocks_to_be_moved& blocks_affected,

vpr/src/place/median_move_generator.cpp

@@ -7,8 +7,9 @@
 
 #include <algorithm>
 
-MedianMoveGenerator::MedianMoveGenerator(PlacerState& placer_state)
-    : MoveGenerator(placer_state) {}
+MedianMoveGenerator::MedianMoveGenerator(PlacerState& placer_state,
+                                         e_reward_function reward_function)
+    : MoveGenerator(placer_state, reward_function) {}
 
 e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
                                                 t_propose_action& proposed_action,

vpr/src/place/median_move_generator.h

@@ -18,7 +18,8 @@
 class MedianMoveGenerator : public MoveGenerator {
   public:
     MedianMoveGenerator() = delete;
-    explicit MedianMoveGenerator(PlacerState& placer_state);
+    MedianMoveGenerator(PlacerState& placer_state,
+                        e_reward_function reward_function);
 
   private:
     e_create_move propose_move(t_pl_blocks_to_be_moved& blocks_affected,

vpr/src/place/move_generator.cpp

@@ -0,0 +1,85 @@
+
+#include "move_generator.h"
+
+#include "vpr_error.h"
+
+void MoveGenerator::calculate_reward_and_process_outcome(const MoveOutcomeStats& move_outcome_stats,
+                                                         double delta_c,
+                                                         float timing_bb_factor) {
+    if (reward_func_ == e_reward_function::BASIC) {
+        process_outcome(-1 * delta_c, reward_func_);
+    } else if (reward_func_ == e_reward_function::NON_PENALIZING_BASIC || reward_func_ == e_reward_function::RUNTIME_AWARE) {
+        if (delta_c < 0) {
+            process_outcome(-1 * delta_c, reward_func_);
+        } else {
+            process_outcome(0, reward_func_);
+        }
+    } else if (reward_func_ == e_reward_function::WL_BIASED_RUNTIME_AWARE) {
+        if (delta_c < 0) {
+            float reward = -1
+                           * (move_outcome_stats.delta_cost_norm
+                              + (0.5 - timing_bb_factor)
+                                    * move_outcome_stats.delta_timing_cost_norm
+                              + timing_bb_factor
+                                    * move_outcome_stats.delta_bb_cost_norm);
+            process_outcome(reward, reward_func_);
+        } else {
+            process_outcome(0, reward_func_);
+        }
+    } else {
+        VTR_ASSERT_SAFE(reward_func_ == e_reward_function::UNDEFINED_REWARD);
+        VPR_ERROR(VPR_ERROR_PLACE, "Undefined reward function!\n");
+    }
+}
+
+void MoveTypeStat::print_placement_move_types_stats() {
+    VTR_LOG("\n\nPlacement perturbation distribution by block and move type: \n");
+
+    VTR_LOG(
+        "------------------ ----------------- ---------------- ---------------- --------------- ------------ \n");
+    VTR_LOG(
+        "    Block Type         Move Type       (%%) of Total      Accepted(%%)     Rejected(%%)    Aborted(%%)\n");
+    VTR_LOG(
+        "------------------ ----------------- ---------------- ---------------- --------------- ------------ \n");
+
+    int total_moves = 0;
+    for (size_t i = 0; i < blk_type_moves.size(); ++i) {
+        total_moves += blk_type_moves.get(i);
+    }
+
+    auto& device_ctx = g_vpr_ctx.device();
+    int count = 0;
+    int num_of_avail_moves = blk_type_moves.size() / device_ctx.logical_block_types.size();
+
+    //Print placement information for each block type
+    for (const auto& itype : device_ctx.logical_block_types) {
+        //Skip non-existing block types in the netlist
+        if (itype.index == 0 || movable_blocks_per_type(itype).empty()) {
+            continue;
+        }
+
+        count = 0;
+        for (int imove = 0; imove < num_of_avail_moves; imove++) {
+            const auto& move_name = move_type_to_string(e_move_type(imove));
+            int moves = blk_type_moves[itype.index][imove];
+            if (moves != 0) {
+                int accepted = accepted_moves[itype.index][imove];
+                int rejected = rejected_moves[itype.index][imove];
+                int aborted = moves - (accepted + rejected);
+                if (count == 0) {
+                    VTR_LOG("%-18.20s", itype.name);
+                } else {
+                    VTR_LOG("                  ");
+                }
+                VTR_LOG(
+                    " %-22.20s %-16.2f %-15.2f %-14.2f %-13.2f\n",
+                    move_name.c_str(), 100.0f * (float)moves / (float)total_moves,
+                    100.0f * (float)accepted / (float)moves, 100.0f * (float)rejected / (float)moves,
+                    100.0f * (float)aborted / (float)moves);
+            }
+            count++;
+        }
+        VTR_LOG("\n");
+    }
+    VTR_LOG("\n");
+}

vpr/src/place/move_generator.h

@@ -34,20 +34,27 @@ struct MoveTypeStat {
     vtr::NdMatrix<int, 2> blk_type_moves;
     vtr::NdMatrix<int, 2> accepted_moves;
     vtr::NdMatrix<int, 2> rejected_moves;
+
+    /**
+     * @brief Prints placement perturbation distribution by block and move type.
+     */
+    void print_placement_move_types_stats();
 };
 
 /**
  * @brief a base class for move generators
  *
  * This class represents the base class for all move generators.
- * All its functions are virtual functions.
  */
 class MoveGenerator {
   public:
-    MoveGenerator(PlacerState& placer_state)
-        : placer_state_(placer_state) {}
+    MoveGenerator(PlacerState& placer_state, e_reward_function reward_function)
+        : placer_state_(placer_state)
+        , reward_func_(reward_function) {}
 
     MoveGenerator() = delete;
+    MoveGenerator(const MoveGenerator&) = delete;
+    MoveGenerator& operator=(const MoveGenerator&) = delete;
     virtual ~MoveGenerator() = default;
 
     /**
@@ -81,8 +88,22 @@ class MoveGenerator {
      */
     virtual void process_outcome(double /*reward*/, e_reward_function /*reward_fun*/) {}
 
+    /**
+     * @brief Calculates the agent's reward and the total process outcome
+     *
+     * @param move_outcome_stats Contains information about how much each cost term
+     * changes by this move and whether the move is accepted.
+     * @param delta_c The total change in cost by this move.
+     * @param timing_bb_factor This factor controls the weight of bb cost
+     *  compared to the timing cost in the agent's reward function.
+     */
+    void calculate_reward_and_process_outcome(const MoveOutcomeStats& move_outcome_stats,
+                                              double delta_c,
+                                              float timing_bb_factor);
+
   protected:
     std::reference_wrapper<PlacerState> placer_state_;
+    e_reward_function reward_func_;
 };
 
 #endif

vpr/src/place/move_transactions.cpp

@@ -165,3 +165,19 @@ void t_pl_blocks_to_be_moved::clear_move_blocks() {
 
     affected_pins.clear();
 }
+
+bool t_pl_blocks_to_be_moved::driven_by_moved_block(const ClusterNetId net) const {
+    auto& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
+
+    bool is_driven_by_move_blk = false;
+    ClusterBlockId net_driver_block = clb_nlist.net_driver_block(net);
+
+    for (const t_pl_moved_block& block : moved_blocks) {
+        if (net_driver_block == block.block_num) {
+            is_driven_by_move_blk = true;
+            break;
+        }
+    }
+
+    return is_driven_by_move_blk;
+}