add get_compressed_noc_grid()

Author: soheilshahrouz

vpr/src/place/initial_noc_placement.cpp

@@ -51,6 +51,26 @@ static void place_noc_routers_randomly(std::vector<ClusterBlockId>& unfixed_rout
  */
 static void noc_routers_anneal(const t_noc_opts& noc_opts);
 
+/**
+ * @brief Returns the compressed grid of NoC.
+ * @return const t_compressed_block_grid& The compressed grid of NoC.
+ */
+static const t_compressed_block_grid& get_compressed_noc_grid();
+
+static const t_compressed_block_grid& get_compressed_noc_grid() {
+    auto& noc_ctx = g_vpr_ctx.noc();
+    auto& place_ctx = g_vpr_ctx.placement();
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+
+    // Get the logical block type for router
+    const t_logical_block_type_ptr router_block_type = cluster_ctx.clb_nlist.block_type(noc_ctx.noc_traffic_flows_storage.get_router_clusters_in_netlist()[0]);
+
+    // Get the compressed grid for NoC
+    const auto& compressed_noc_grid = place_ctx.compressed_block_grids[router_block_type->index];
+
+    return compressed_noc_grid;
+}
+
 static bool accept_noc_swap(double delta_cost, double prob) {
     if (delta_cost <= 0.0) {
         return true;
@@ -99,7 +119,6 @@ static void place_constrained_noc_router(ClusterBlockId router_blk_id) {
 static void place_noc_routers_randomly(std::vector<ClusterBlockId>& unfixed_routers, int seed) {
     auto& place_ctx = g_vpr_ctx.placement();
     auto& noc_ctx = g_vpr_ctx.noc();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
 
     /*
@@ -123,15 +142,12 @@ static void place_noc_routers_randomly(std::vector<ClusterBlockId>& unfixed_rout
     vtr::RandState rand_state = seed;
     vtr::shuffle(noc_phy_routers.begin(), noc_phy_routers.end(), rand_state);
 
-    // Get the logical block type for router
-    const auto router_block_type = cluster_ctx.clb_nlist.block_type(noc_ctx.noc_traffic_flows_storage.get_router_clusters_in_netlist()[0]);
-
     // Get the compressed grid for NoC
-    const auto& compressed_noc_grid = place_ctx.compressed_block_grids[router_block_type->index];
+    const auto& compressed_noc_grid = get_compressed_noc_grid();
 
     // Iterate over shuffled physical routers to place logical routers
     // Since physical routers are shuffled, router placement would be random
-    for (const auto& phy_router : noc_phy_routers) {
+    for (const NocRouter& phy_router : noc_phy_routers) {
         t_physical_tile_loc router_phy_loc = phy_router.get_router_physical_location();
 
         // Find a compatible sub-tile
@@ -143,7 +159,7 @@ static void place_noc_routers_randomly(std::vector<ClusterBlockId>& unfixed_rout
 
         if (place_ctx.grid_blocks.is_sub_tile_empty(router_phy_loc, sub_tile)) {
             // Pick one of the unplaced routers
-            auto logical_router_bid = unfixed_routers.back();
+            ClusterBlockId logical_router_bid = unfixed_routers.back();
             unfixed_routers.pop_back();
 
             // Create a macro with a single member
@@ -179,11 +195,16 @@ static void noc_routers_anneal(const t_noc_opts& noc_opts) {
     update_noc_normalization_factors(costs);
     costs.cost = calculate_noc_cost(costs.noc_cost_terms, costs.noc_cost_norm_factors, noc_opts);
 
-    // Maximum distance in each direction that a router can travel in a move
-    // It is assumed that NoC routers are organized in a square grid.
-    // Each router can initially move within the entire grid with a single swap.
+    const auto& compressed_noc_grid = get_compressed_noc_grid();
+    const size_t n_noc_layers = compressed_noc_grid.get_layer_nums().size();
+
+    /* Maximum distance in each direction that a router can travel in a move
+     * It is assumed that NoC routers are organized in a square grid.
+     * Each router can initially move within the entire grid with a single swap.
+     * For 3D NoCs, it is assumed that each layer has the same number of routers,
+     * and each layer NoC routers are laid out in a square grid. */
     const size_t n_physical_routers = noc_ctx.noc_model.get_noc_routers().size();
-    const float max_r_lim = ceilf(sqrtf((float)n_physical_routers));
+    const float max_r_lim = ceilf(sqrtf((float)n_physical_routers / (float)n_noc_layers));
 
     // At most, two routers are swapped
     t_pl_blocks_to_be_moved blocks_affected(2);
@@ -266,7 +287,7 @@ void initial_noc_placement(const t_noc_opts& noc_opts, const t_placer_opts& plac
     std::vector<ClusterBlockId> unfixed_routers;
 
     // Check for floorplanning constraints and place constrained NoC routers
-    for (auto router_blk_id : router_blk_ids) {
+    for (const ClusterBlockId router_blk_id : router_blk_ids) {
         // The block is fixed and was placed in mark_fixed_blocks()
         if (is_block_placed((router_blk_id))) {
             continue;

vpr/src/place/move_utils.cpp

@@ -743,7 +743,6 @@ bool find_to_loc_uniform(t_logical_block_type_ptr type,
     t_physical_tile_loc to_compressed_loc;
     bool legal = false;
 
-    //TODO: constraints should be adapted to 3D architecture
     if (is_cluster_constrained(b_from)) {
         bool intersect = intersect_range_limit_with_floorplan_constraints(b_from,
                                                                           search_range,
@@ -1137,7 +1136,7 @@ std::vector<t_physical_tile_loc> get_compressed_loc(const t_compressed_block_gri
 
     const auto& compatible_layers = compressed_block_grid.get_layer_nums();
 
-    for (const auto& layer_num : compatible_layers) {
+    for (const int layer_num : compatible_layers) {
         // This would cause a problem if two blocks of the same types are on different x/y locations of different layers
         compressed_locs[layer_num] = compressed_block_grid.grid_loc_to_compressed_loc({grid_loc.x, grid_loc.y, layer_num});
     }
@@ -1152,7 +1151,7 @@ std::vector<t_physical_tile_loc> get_compressed_loc_approx(const t_compressed_bl
 
     const auto& compatible_layers = compressed_block_grid.get_layer_nums();
 
-    for (const auto& layer_num : compatible_layers) {
+    for (const int layer_num : compatible_layers) {
         compressed_locs[layer_num] = compressed_block_grid.grid_loc_to_compressed_loc_approx({grid_loc.x, grid_loc.y, layer_num});
     }
 

vpr/src/place/noc_place_utils.cpp

@@ -804,7 +804,7 @@ static bool select_random_router_cluster(ClusterBlockId& b_from, t_pl_loc& from,
         return false;
     }
 
-    const int number_of_router_blocks = router_clusters.size();
+    const int number_of_router_blocks = static_cast<int>(router_clusters.size());
 
     //randomly choose a router block to move
     const int random_cluster_block_index = vtr::irand(number_of_router_blocks - 1);