update move generators with argument of vtr::RngContainer

Author: soheilshahrouz

vpr/src/base/SetupVPR.cpp

@@ -1,13 +1,9 @@
-#include <cstring>
 #include <vector>
-#include <sstream>
 #include <list>
 
 #include "vtr_assert.h"
 #include "vtr_util.h"
-#include "vtr_random.h"
 #include "vtr_log.h"
-#include "vtr_memory.h"
 #include "vtr_time.h"
 
 #include "vpr_types.h"
@@ -21,7 +17,6 @@
 #include "pb_type_graph.h"
 #include "pack_types.h"
 #include "lb_type_rr_graph.h"
-#include "rr_graph_area.h"
 #include "echo_arch.h"
 #include "read_options.h"
 #include "echo_files.h"
@@ -117,7 +112,7 @@ void SetupVPR(const t_options* options,
 
     auto& device_ctx = g_vpr_ctx.mutable_device();
 
-    if (options->CircuitName.value() == "") {
+    if (options->CircuitName.value().empty()) {
         VPR_FATAL_ERROR(VPR_ERROR_BLIF_F,
                         "No blif file found in arguments (did you specify an architecture file?)\n");
     }
@@ -156,7 +151,7 @@ void SetupVPR(const t_options* options,
     //save the device layout, which is required to parse the architecture file
     arch->device_layout = options->device_layout;
 
-    if (readArchFile == true) {
+    if (readArchFile) {
         vtr::ScopedStartFinishTimer t("Loading Architecture Description");
         switch (options->arch_format) {
             case e_arch_format::VTR:
@@ -305,9 +300,6 @@ void SetupVPR(const t_options* options,
     /* init global variables */
     vtr::out_file_prefix = options->out_file_prefix;
 
-    /* Set seed for pseudo-random placement, default seed to 1 */
-    vtr::srandom(placerOpts->seed);
-
     {
         vtr::ScopedStartFinishTimer t("Building complex block graph");
         alloc_and_load_all_pb_graphs(powerOpts->do_power, routerOpts->flat_routing);
@@ -348,7 +340,7 @@ void SetupVPR(const t_options* options,
 
 static void SetupTiming(const t_options& Options, const bool TimingEnabled, t_timing_inf* Timing) {
     /* Don't do anything if they don't want timing */
-    if (false == TimingEnabled) {
+    if (!TimingEnabled) {
         Timing->timing_analysis_enabled = false;
         return;
     }
@@ -570,7 +562,7 @@ static void SetupAnnealSched(const t_options& Options,
 }
 
 /**
- * @brief Sets up the s_packer_opts structure baesd on users inputs and
+ * @brief Sets up the s_packer_opts structure based on users inputs and
  *        on the architecture specified.
  *
  * Error checking, such as checking for conflicting params is assumed

vpr/src/place/RL_agent_util.cpp

@@ -22,8 +22,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, 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);
+        move_generators.first = std::make_unique<StaticMoveGenerator>(placer_state, reward_fun, rng, placer_opts.place_static_move_prob);
+        move_generators.second = std::make_unique<StaticMoveGenerator>(placer_state, reward_fun, rng, 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)             *
@@ -79,6 +79,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,
+                                                                            rng,
                                                                             karmed_bandit_agent1,
                                                                             noc_attraction_weight,
                                                                             placer_opts.place_high_fanout_net);
@@ -90,6 +91,7 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generators.second = std::make_unique<SimpleRLMoveGenerator>(placer_state,
                                                                              reward_fun,
+                                                                             rng,
                                                                              karmed_bandit_agent2,
                                                                              noc_attraction_weight,
                                                                              placer_opts.place_high_fanout_net);
@@ -110,6 +112,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,
+                                                                            rng,
                                                                             karmed_bandit_agent1,
                                                                             noc_attraction_weight,
                                                                             placer_opts.place_high_fanout_net);
@@ -120,6 +123,7 @@ std::pair<std::unique_ptr<MoveGenerator>, std::unique_ptr<MoveGenerator>> create
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
             move_generators.second = std::make_unique<SimpleRLMoveGenerator>(placer_state,
                                                                              reward_fun,
+                                                                             rng,
                                                                              karmed_bandit_agent2,
                                                                              noc_attraction_weight,
                                                                              placer_opts.place_high_fanout_net);

vpr/src/place/centroid_move_generator.cpp

@@ -17,16 +17,18 @@ std::map<ClusterBlockId, NocGroupId> CentroidMoveGenerator::noc_router_to_noc_gr
 
 
 CentroidMoveGenerator::CentroidMoveGenerator(PlacerState& placer_state,
-                                             e_reward_function reward_function)
-    : MoveGenerator(placer_state, reward_function)
+                                             e_reward_function reward_function,
+                                             vtr::RngContainer& rng)
+    : MoveGenerator(placer_state, reward_function, rng)
     , noc_attraction_w_(0.0f)
     , noc_attraction_enabled_(false) {}
 
 CentroidMoveGenerator::CentroidMoveGenerator(PlacerState& placer_state,
                                              e_reward_function reward_function,
+                                             vtr::RngContainer& rng,
                                              float noc_attraction_weight,
                                              size_t high_fanout_net)
-    : MoveGenerator(placer_state, reward_function)
+    : MoveGenerator(placer_state, reward_function, rng)
     , noc_attraction_w_(noc_attraction_weight)
     , noc_attraction_enabled_(true) {
     VTR_ASSERT(noc_attraction_weight > 0.0 && noc_attraction_weight <= 1.0);
@@ -59,7 +61,8 @@ e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
                                                   /*highly_crit_block=*/false,
                                                   /*net_from=*/nullptr,
                                                   /*pin_from=*/nullptr,
-                                                  placer_state);
+                                                  placer_state,
+                                                  rng_);
 
     VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
                    "Centroid Move Choose Block %d - rlim %f\n",
@@ -92,7 +95,7 @@ e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
     // layer for the centroid location. So if the layer is not valid, we set it to the same layer as from loc.
     centroid.layer = (centroid.layer < 0) ? from.layer : centroid.layer;
     /* Find a location near the weighted centroid_loc */
-    if (!find_to_loc_centroid(cluster_from_type, from, centroid, range_limiters, to, b_from, blk_loc_registry)) {
+    if (!find_to_loc_centroid(cluster_from_type, from, centroid, range_limiters, to, b_from, blk_loc_registry, rng_)) {
         return e_create_move::ABORT;
     }
 

vpr/src/place/centroid_move_generator.h

@@ -30,7 +30,8 @@ class CentroidMoveGenerator : public MoveGenerator {
      * of the RL agent.
      */
     CentroidMoveGenerator(PlacerState& placer_state,
-                          e_reward_function reward_function);
+                          e_reward_function reward_function,
+                          vtr::RngContainer& rng);
 
     /**
      * The move generator created by calling this constructor considers both
@@ -49,6 +50,7 @@ class CentroidMoveGenerator : public MoveGenerator {
      */
     CentroidMoveGenerator(PlacerState& placer_state,
                           e_reward_function reward_function,
+                          vtr::RngContainer& rng,
                           float noc_attraction_weight,
                           size_t high_fanout_net);
 

vpr/src/place/critical_uniform_move_generator.cpp

@@ -5,8 +5,9 @@
 #include "move_utils.h"
 
 CriticalUniformMoveGenerator::CriticalUniformMoveGenerator(PlacerState& placer_state,
-                                                           e_reward_function reward_function)
-    : MoveGenerator(placer_state, reward_function) {}
+                                                           e_reward_function reward_function,
+                                                           vtr::RngContainer& rng)
+    : MoveGenerator(placer_state, reward_function, rng) {}
 
 e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
                                                          t_propose_action& proposed_action,
@@ -26,7 +27,8 @@ e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved
                                                   /*highly_crit_block=*/true,
                                                   &net_from,
                                                   &pin_from,
-                                                  placer_state);
+                                                  placer_state,
+                                                  rng_);
 
     VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Critical Uniform Move Choose Block %d - rlim %f\n", size_t(b_from), rlim);
 
@@ -42,7 +44,7 @@ e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved
 
     t_pl_loc to;
     to.layer = from.layer;
-    if (!find_to_loc_uniform(cluster_from_type, rlim, from, to, b_from, blk_loc_registry)) {
+    if (!find_to_loc_uniform(cluster_from_type, rlim, from, to, b_from, blk_loc_registry, rng_)) {
         return e_create_move::ABORT;
     }
 

vpr/src/place/critical_uniform_move_generator.h

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

vpr/src/place/feasible_region_move_generator.cpp

@@ -9,8 +9,9 @@
 #include <cmath>
 
 FeasibleRegionMoveGenerator::FeasibleRegionMoveGenerator(PlacerState& placer_state,
-                                                         e_reward_function reward_function)
-    : MoveGenerator(placer_state, reward_function) {}
+                                                         e_reward_function reward_function,
+                                                         vtr::RngContainer& rng)
+    : MoveGenerator(placer_state, reward_function, rng) {}
 
 e_create_move FeasibleRegionMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
                                                         t_propose_action& proposed_action,
@@ -31,7 +32,8 @@ e_create_move FeasibleRegionMoveGenerator::propose_move(t_pl_blocks_to_be_moved&
                                                   /*highly_crit_block=*/true,
                                                   &net_from,
                                                   &pin_from,
-                                                  placer_state);
+                                                  placer_state,
+                                                  rng_);
 
     VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Feasible Region Move Choose Block %di - rlim %f\n", size_t(b_from), rlim);
 
@@ -126,7 +128,7 @@ e_create_move FeasibleRegionMoveGenerator::propose_move(t_pl_blocks_to_be_moved&
                                     placer_opts.place_dm_rlim};
 
     // Try to find a legal location inside the feasible region
-    if (!find_to_loc_median(cluster_from_type, from, &FR_coords, to, b_from, blk_loc_registry)) {
+    if (!find_to_loc_median(cluster_from_type, from, &FR_coords, to, b_from, blk_loc_registry, rng_)) {
         /** If there is no legal location in the feasible region, calculate the center of the FR and try to find a legal location 
          *  in a range around this center.
          */
@@ -135,7 +137,7 @@ e_create_move FeasibleRegionMoveGenerator::propose_move(t_pl_blocks_to_be_moved&
         center.y = (FR_coords.ymin + FR_coords.ymax) / 2;
         // TODO: Currently, we don't move blocks between different types of layers
         center.layer = from.layer;
-        if (!find_to_loc_centroid(cluster_from_type, from, center, range_limiters, to, b_from, blk_loc_registry))
+        if (!find_to_loc_centroid(cluster_from_type, from, center, range_limiters, to, b_from, blk_loc_registry, rng_))
             return e_create_move::ABORT;
     }
 

vpr/src/place/feasible_region_move_generator.h

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

vpr/src/place/initial_placement.cpp

@@ -171,7 +171,8 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
 static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
-                                   const BlkLocRegistry& blk_loc_registry);
+                                   const BlkLocRegistry& blk_loc_registry,
+                                   vtr::RngContainer& rng);
 
 /**
  * @brief  tries to place a macro at a centroid location of its placed connections.
@@ -335,7 +336,8 @@ static bool is_loc_legal(const t_pl_loc& loc,
 static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
-                                   const BlkLocRegistry& blk_loc_registry) {
+                                   const BlkLocRegistry& blk_loc_registry,
+                                   vtr::RngContainer& rng) {
     const auto& compressed_block_grid = g_vpr_ctx.placement().compressed_block_grids[block_type->index];
     const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
     const int centroid_loc_layer_num = centroid_loc.layer;
@@ -370,13 +372,14 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                                          /*is_median=*/false,
                                                          centroid_loc_layer_num,
                                                          search_for_empty,
-                                                         blk_loc_registry);
+                                                         blk_loc_registry,
+                                                         rng);
 
     if (!legal) {
         return false;
     }
 
-    compressed_grid_to_loc(block_type, to_compressed_loc, centroid_loc);
+    compressed_grid_to_loc(block_type, to_compressed_loc, centroid_loc, rng);
 
     return legal;
 }
@@ -504,7 +507,7 @@ static bool try_centroid_placement(const t_pl_macro& pl_macro,
     //try to find a near location that meet these requirements
     bool neighbor_legal_loc = false;
     if (!is_loc_legal(centroid_loc, pr, block_type)) {
-        neighbor_legal_loc = find_centroid_neighbor(centroid_loc, block_type, false, blk_loc_registry);
+        neighbor_legal_loc = find_centroid_neighbor(centroid_loc, block_type, false, blk_loc_registry, rng);
         if (!neighbor_legal_loc) { //no neighbor candidate found
             return false;
         }
@@ -698,7 +701,8 @@ bool try_place_macro_randomly(const t_pl_macro& pl_macro,
                                                     /*is_median=*/false,
                                                     selected_layer,
                                                     /*search_for_empty=*/false,
-                                                    blk_loc_registry);
+                                                    blk_loc_registry,
+                                                    rng);
 
 
     if (!legal) {
@@ -707,7 +711,7 @@ bool try_place_macro_randomly(const t_pl_macro& pl_macro,
     }
 
     t_pl_loc loc;
-    compressed_grid_to_loc(block_type, to_compressed_loc, loc);
+    compressed_grid_to_loc(block_type, to_compressed_loc, loc, rng);
 
     auto& device_ctx = g_vpr_ctx.device();
 

vpr/src/place/manual_move_generator.cpp

@@ -18,8 +18,8 @@
 #    include "draw.h"
 #endif //NO_GRAPHICS
 
-ManualMoveGenerator::ManualMoveGenerator(PlacerState& placer_state)
-    : MoveGenerator(placer_state, e_reward_function::UNDEFINED_REWARD) {}
+ManualMoveGenerator::ManualMoveGenerator(PlacerState& placer_state, vtr::RngContainer& rng)
+    : MoveGenerator(placer_state, e_reward_function::UNDEFINED_REWARD, rng) {}
 
 //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;
-    ManualMoveGenerator(PlacerState& placer_state);
+    ManualMoveGenerator(PlacerState& placer_state, vtr::RngContainer& rng);
 
     //Evaluates if move is successful and legal or unable to do.
     e_create_move propose_move(t_pl_blocks_to_be_moved& blocks_affected,