move NoC-biased member vars from PlacementContext to CentroidMoveGenerator

Author: soheilshahrouz

vpr/src/base/vpr_context.h

@@ -413,15 +413,6 @@ struct PlacementContext : public Context {
      * it would mean that per-layer bounding box is used. For the 2D architecture, the cube bounding box would be used.
      */
     bool cube_bb = false;
-
-
-    vtr::vector<NocGroupId, std::vector<ClusterBlockId>> noc_group_clusters;
-
-    vtr::vector<NocGroupId, std::vector<ClusterBlockId>> noc_group_routers;
-
-    vtr::vector<ClusterBlockId, NocGroupId> cluster_to_noc_grp;
-
-    std::map<ClusterBlockId, NocGroupId> noc_router_to_noc_group;
 };
 
 /**

vpr/src/place/RL_agent_util.cpp

@@ -77,13 +77,17 @@ void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator,
                                                                             placer_opts.place_agent_epsilon);
             }
             karmed_bandit_agent1->set_step(placer_opts.place_agent_gamma, move_lim);
-            move_generator = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent1, noc_attraction_weight);
+            move_generator = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent1,
+                                                                     noc_attraction_weight,
+                                                                     placer_opts.place_high_fanout_net);
             //agent's 2nd state
             karmed_bandit_agent2 = std::make_unique<EpsilonGreedyAgent>(second_state_avail_moves,
                                                                         e_agent_space::MOVE_TYPE,
                                                                         placer_opts.place_agent_epsilon);
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
-            move_generator2 = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent2, noc_attraction_weight);
+            move_generator2 = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent2,
+                                                                      noc_attraction_weight,
+                                                                      placer_opts.place_high_fanout_net);
         } else {
             std::unique_ptr<SoftmaxAgent> karmed_bandit_agent1, karmed_bandit_agent2;
             //agent's 1st state
@@ -97,12 +101,16 @@ void create_move_generators(std::unique_ptr<MoveGenerator>& move_generator,
                                                                       e_agent_space::MOVE_TYPE);
             }
             karmed_bandit_agent1->set_step(placer_opts.place_agent_gamma, move_lim);
-            move_generator = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent1, noc_attraction_weight);
+            move_generator = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent1,
+                                                                     noc_attraction_weight,
+                                                                     placer_opts.place_high_fanout_net);
             //agent's 2nd state
             karmed_bandit_agent2 = std::make_unique<SoftmaxAgent>(second_state_avail_moves,
                                                                   e_agent_space::MOVE_TYPE);
             karmed_bandit_agent2->set_step(placer_opts.place_agent_gamma, move_lim);
-            move_generator2 = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent2, noc_attraction_weight);
+            move_generator2 = std::make_unique<SimpleRLMoveGenerator>(karmed_bandit_agent2,
+                                                                      noc_attraction_weight,
+                                                                      placer_opts.place_high_fanout_net);
         }
     }
 }

vpr/src/place/centroid_move_generator.cpp

@@ -5,14 +5,127 @@
 #include "place_constraints.h"
 #include "move_utils.h"
 
+#include <queue>
+
+
+// Static member variable definitions
+vtr::vector<NocGroupId, std::vector<ClusterBlockId>> CentroidMoveGenerator::noc_group_clusters_;
+vtr::vector<NocGroupId, std::vector<ClusterBlockId>> CentroidMoveGenerator::noc_group_routers_;
+vtr::vector<ClusterBlockId, NocGroupId> CentroidMoveGenerator::cluster_to_noc_grp_;
+std::map<ClusterBlockId, NocGroupId> CentroidMoveGenerator::noc_router_to_noc_group_;
+
+
 CentroidMoveGenerator::CentroidMoveGenerator()
     : noc_attraction_w_(0.0f)
     , noc_attraction_enabled_(false) {}
 
-CentroidMoveGenerator::CentroidMoveGenerator(float noc_attraction_weight)
+CentroidMoveGenerator::CentroidMoveGenerator(float noc_attraction_weight, size_t high_fanout_net)
     : noc_attraction_w_(noc_attraction_weight)
     , noc_attraction_enabled_(true) {
     VTR_ASSERT(noc_attraction_weight > 0.0 && noc_attraction_weight <= 1.0);
+
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& noc_ctx = g_vpr_ctx.noc();
+
+    // check if static member variables are already initialized
+    if (!noc_group_clusters_.empty() && !noc_group_routers_.empty() &&
+        !cluster_to_noc_grp_.empty() && !noc_router_to_noc_group_.empty()) {
+        return;
+    }
+
+    noc_group_clusters_.clear();
+    noc_group_routers_.clear();
+    cluster_to_noc_grp_.clear();
+    noc_router_to_noc_group_.clear();
+
+    /*
+     * Assume the clustered netlist is an undirected graph where nodes
+     * represent clustered blocks, and edges are low fanout connections.
+     * To determine NoC groups, we need to find components that include
+     * at least one NoC router. To do this, we start a BFS traversal from
+     * unvisited NoC routers and assign the starting NoC router and all the
+     * blocks that are visited during the traversal to a NoC group.
+     */
+
+    // determines whether a block is visited
+    vtr::vector<ClusterBlockId, bool> block_visited(cluster_ctx.clb_nlist.blocks().size(), false);
+
+    // NoCGroupIDs are sequential and start from zero. This counter specifies the value to be assigned to a new NoCGroupID
+    int noc_group_cnt = 0;
+
+    // Initialize the associated NoC group for all blocks to INVALID. If a block is not visited during traversal,
+    // it does not belong to any NoC groups. For other blocks, the associated NoC group is updated once they are visited.
+    cluster_to_noc_grp_.resize(cluster_ctx.clb_nlist.blocks().size(), NocGroupId ::INVALID());
+
+    // Get all the router clusters and the NoC router logical block type
+    const auto& router_blk_ids = noc_ctx.noc_traffic_flows_storage.get_router_clusters_in_netlist();
+    const auto router_block_type = cluster_ctx.clb_nlist.block_type(router_blk_ids[0]);
+
+    // iterate over logical NoC routers and start a BFS
+    for (auto router_blk_id : router_blk_ids) {
+
+        if (block_visited[router_blk_id]) {
+            continue;
+        }
+
+        NocGroupId noc_group_id(noc_group_cnt);
+        noc_group_cnt++;
+        noc_group_routers_.emplace_back();
+        noc_group_clusters_.emplace_back();
+
+        // BFS frontier
+        std::queue<ClusterBlockId> q;
+
+        // initialize the frontier with the NoC router
+        q.push(router_blk_id);
+        block_visited[router_blk_id] = true;
+
+        while (!q.empty()) {
+            ClusterBlockId current_block_id = q.front();
+            q.pop();
+
+            // get the logical block type for the block extracted from the frontier queue
+            auto block_type = cluster_ctx.clb_nlist.block_type(current_block_id);
+
+            if (block_type->index == router_block_type->index) {
+                noc_group_routers_[noc_group_id].push_back(current_block_id);
+                noc_router_to_noc_group_[current_block_id] = noc_group_id;
+            } else {
+                noc_group_clusters_[noc_group_id].push_back(current_block_id);
+                cluster_to_noc_grp_[current_block_id] = noc_group_id;
+            }
+
+            // iterate over all low fanout nets of the current block to find its unvisited neighbors
+            for (ClusterPinId pin_id : cluster_ctx.clb_nlist.block_pins(current_block_id)) {
+                ClusterNetId net_id = cluster_ctx.clb_nlist.pin_net(pin_id);
+
+                if (cluster_ctx.clb_nlist.net_is_ignored(net_id)) {
+                    continue;
+                }
+
+                if (cluster_ctx.clb_nlist.net_sinks(net_id).size() >= high_fanout_net) {
+                    continue;
+                }
+
+                if (cluster_ctx.clb_nlist.pin_type(pin_id) == PinType::DRIVER) {
+                    for (auto sink_pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
+                        ClusterBlockId sink_block_id = cluster_ctx.clb_nlist.pin_block(sink_pin_id);
+                        if (!block_visited[sink_block_id]) {
+                            block_visited[sink_block_id] = true;
+                            q.push(sink_block_id);
+                        }
+                    }
+                } else { //else the pin is sink --> only care about its driver
+                    ClusterPinId source_pin = cluster_ctx.clb_nlist.net_driver(net_id);
+                    ClusterBlockId source_blk_id = cluster_ctx.clb_nlist.pin_block(source_pin);
+                    if (!block_visited[source_blk_id]) {
+                        block_visited[source_blk_id] = true;
+                        q.push(source_blk_id);
+                    }
+                }
+            }
+        }
+    }
 }
 
 e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected,
@@ -74,3 +187,11 @@ e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
 
     return create_move;
 }
+
+const std::vector<ClusterBlockId>& CentroidMoveGenerator::get_noc_group_routers(NocGroupId noc_grp_id) {
+    return CentroidMoveGenerator::noc_group_routers_[noc_grp_id];
+}
+
+NocGroupId CentroidMoveGenerator::get_cluster_noc_group(ClusterBlockId blk_id) {
+    return CentroidMoveGenerator::cluster_to_noc_grp_[blk_id];
+}

vpr/src/place/centroid_move_generator.h

@@ -1,5 +1,6 @@
 #ifndef VPR_CENTROID_MOVE_GEN_H
 #define VPR_CENTROID_MOVE_GEN_H
+
 #include "move_generator.h"
 
 /**
@@ -10,12 +11,22 @@
  * This move picks a random block and moves it (swapping with what's there if necessary) to the zero force location
  * It calculates forces/weighs acting on the block based on its connections to other blocks.
  *
+ * The computed centroid location can be optionally biased towards the location of NoC routers
+ * that are reachable from the selected block. A NoC router is reachable from a block if one can
+ * start from the block and reach the NoC router only by traversing low fanout nets. All the blocks
+ * (including NoC routers) that can reach a NoC router form a NoC group.
+ *
  * Returns its choices by filling in affected_blocks.
  */
 class CentroidMoveGenerator : public MoveGenerator {
   public:
     CentroidMoveGenerator();
-    CentroidMoveGenerator(float noc_attraction_weight);
+    CentroidMoveGenerator(float noc_attraction_weight, size_t high_fanout_net);
+
+
+    static const std::vector<ClusterBlockId>& get_noc_group_routers(NocGroupId noc_grp_id);
+
+    static NocGroupId get_cluster_noc_group(ClusterBlockId blk_id);
 
   private:
     e_create_move propose_move(t_pl_blocks_to_be_moved& blocks_affected,
@@ -25,8 +36,28 @@ class CentroidMoveGenerator : public MoveGenerator {
                                const PlacerCriticalities* /*criticalities*/) override;
 
   private:
+    /** A value in range [0, 1] that specifies how much the centroid location
+     * computation is biased towards the associated NoC routers*/
     float noc_attraction_w_;
+
+    /** Indicates whether the centroid calculation is NoC-biased.*/
     bool noc_attraction_enabled_;
+
+    /** Stores all non-router blocks for each NoC group*/
+    static vtr::vector<NocGroupId, std::vector<ClusterBlockId>> noc_group_clusters_;
+
+    /** Stores NoC routers in each NoC group*/
+    static vtr::vector<NocGroupId, std::vector<ClusterBlockId>> noc_group_routers_;
+
+    /** Specifies the NoC group that each block belongs to. A block cannot belong to more
+     * than one NoC because this means those NoC groups can reach each other and form
+     * a single NoC group. We use NocGroupId::INVALID to show that a block does not belong
+     * to any NoC groups. This happens when a block is not reachable from any NoC router.
+     * */
+    static vtr::vector<ClusterBlockId, NocGroupId> cluster_to_noc_grp_;
+
+    /** Specifies the NoC group for each NoC router*/
+    static std::map<ClusterBlockId, NocGroupId> noc_router_to_noc_group_;
 };
 
 #endif

vpr/src/place/directed_moves_util.cpp

@@ -1,4 +1,6 @@
+
 #include "directed_moves_util.h"
+#include "centroid_move_generator.h"
 
 void get_coordinate_of_pin(ClusterPinId pin, t_physical_tile_loc& tile_loc) {
     auto& device_ctx = g_vpr_ctx.device();
@@ -98,16 +100,19 @@ void calculate_centroid_loc(ClusterBlockId b_from,
     }
 
     if (noc_attraction_enabled) {
-        if (place_ctx.cluster_to_noc_grp[b_from] != NocGroupId::INVALID()) {
+        NocGroupId noc_grp_id = CentroidMoveGenerator::get_cluster_noc_group(b_from);
 
-            NocGroupId noc_grp_id = place_ctx.cluster_to_noc_grp[b_from];
-            float single_noc_weight = (acc_weight * noc_attraction_weight) / place_ctx.noc_group_routers[noc_grp_id].size();
+        // check if the block belongs to a NoC group
+        if (noc_grp_id != NocGroupId::INVALID()) {
+            // get the routers in the associated NoC group
+            const auto& noc_routers = CentroidMoveGenerator::get_noc_group_routers(noc_grp_id);
+            float single_noc_weight = (acc_weight * noc_attraction_weight) / (float)noc_routers.size();
 
             acc_x *= (1.0f - noc_attraction_weight);
             acc_y *= (1.0f - noc_attraction_weight);
             acc_weight *= (1.0f - noc_attraction_weight);
 
-            for (ClusterBlockId router_blk_id : place_ctx.noc_group_routers[noc_grp_id]) {
+            for (ClusterBlockId router_blk_id : noc_routers) {
                 t_block_loc router_loc = place_ctx.block_locs[router_blk_id];
                 acc_x += router_loc.loc.x * single_noc_weight;
                 acc_y += router_loc.loc.y * single_noc_weight;

vpr/src/place/initial_noc_placement.cpp

@@ -255,11 +255,9 @@ static void noc_routers_anneal(const t_noc_opts& noc_opts) {
 
 void initial_noc_placement(const t_noc_opts& noc_opts, const t_placer_opts& placer_opts) {
     auto& noc_ctx = g_vpr_ctx.noc();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
 
     // Get all the router clusters
     const std::vector<ClusterBlockId>& router_blk_ids = noc_ctx.noc_traffic_flows_storage.get_router_clusters_in_netlist();
-    const auto router_block_type = cluster_ctx.clb_nlist.block_type(router_blk_ids[0]);
 
     // Holds all the routers that are not fixed into a specific location by constraints
     std::vector<ClusterBlockId> unfixed_routers;
@@ -294,72 +292,4 @@ void initial_noc_placement(const t_noc_opts& noc_opts, const t_placer_opts& plac
                         "At least one cycle was found in NoC channel dependency graph. This may cause a deadlock "
                         "when packets wait on each other in a cycle.\n");
     }
-
-    vtr::vector<ClusterBlockId, bool> block_visited(cluster_ctx.clb_nlist.blocks().size(), false);
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
-    int noc_group_cnt = 0;
-    place_ctx.cluster_to_noc_grp.resize(cluster_ctx.clb_nlist.blocks().size(), NocGroupId ::INVALID());
-
-    for (auto router_blk_id : router_blk_ids) {
-
-        if (block_visited[router_blk_id]) {
-            continue;
-        }
-
-        NocGroupId noc_group_id(noc_group_cnt);
-        noc_group_cnt++;
-        place_ctx.noc_group_routers.emplace_back();
-        place_ctx.noc_group_clusters.emplace_back();
-
-        std::queue<ClusterBlockId> q;
-        q.push(router_blk_id);
-        block_visited[router_blk_id] = true;
-
-        while (!q.empty()) {
-            ClusterBlockId current_block_id = q.front();
-            q.pop();
-
-            auto block_type = cluster_ctx.clb_nlist.block_type(current_block_id);
-            if (block_type->index == router_block_type->index) {
-                place_ctx.noc_group_routers[noc_group_id].push_back(current_block_id);
-                place_ctx.noc_router_to_noc_group[current_block_id] = noc_group_id;
-            } else {
-                place_ctx.noc_group_clusters[noc_group_id].push_back(current_block_id);
-                place_ctx.cluster_to_noc_grp[current_block_id] = noc_group_id;
-            }
-
-
-            for (ClusterPinId pin_id : cluster_ctx.clb_nlist.block_pins(current_block_id)) {
-                ClusterNetId net_id = cluster_ctx.clb_nlist.pin_net(pin_id);
-
-                if (cluster_ctx.clb_nlist.net_is_ignored(net_id)) {
-                    continue;
-                }
-
-                if (cluster_ctx.clb_nlist.net_sinks(net_id).size() >= placer_opts.place_high_fanout_net) {
-                    continue;
-                }
-
-                if (cluster_ctx.clb_nlist.pin_type(pin_id) == PinType::DRIVER) {
-                    //ignore nets that are globally routed
-
-                    for (auto sink_pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
-                        auto sink_block_id = cluster_ctx.clb_nlist.pin_block(sink_pin_id);
-                        if (!block_visited[sink_block_id]) {
-                            block_visited[sink_block_id] = true;
-                            q.push(sink_block_id);
-                        }
-                    }
-                } else { //else the pin is sink --> only care about its driver
-                    ClusterPinId source_pin = cluster_ctx.clb_nlist.net_driver(net_id);
-                    auto source_blk_id = cluster_ctx.clb_nlist.pin_block(source_pin);
-                    if (!block_visited[source_blk_id]) {
-                        block_visited[source_blk_id] = true;
-                        q.push(source_blk_id);
-                    }
-                }
-            }
-        }
-
-    }
 }