Ipa end user doc

vpr/src/place/centroid_move_generator.cpp

@@ -76,9 +76,9 @@ e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
     /* Calculate the centroid location*/
     calculate_centroid_loc(b_from, false, centroid, nullptr, noc_attraction_enabled_, noc_attraction_w_);
 
-    // Centroid location is not necessarily a valid location, and the downstream location expect a valid
-    // layer for "to" location. So if the layer is not valid, we set it to the same layer as from loc.
-    to.layer = (centroid.layer < 0) ? from.layer : centroid.layer;
+    // Centroid location is not necessarily a valid location, and the downstream location expects a valid
+    // 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)) {
         return e_create_move::ABORT;

vpr/src/place/median_move_generator.cpp

@@ -5,7 +5,14 @@
 #include "placer_globals.h"
 #include "move_utils.h"
 
-static bool get_bb_incrementally(ClusterNetId net_id, t_bb& bb_coord_new, int xold, int yold, int xnew, int ynew);
+static bool get_bb_incrementally(ClusterNetId net_id,
+                                 t_bb& bb_coord_new,
+                                 int xold,
+                                 int yold,
+                                 int layer_old,
+                                 int xnew,
+                                 int ynew,
+                                 int layer_new);
 
 static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_coord_new, ClusterBlockId block_id, bool& skip_net);
 
@@ -29,7 +36,7 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
     auto& place_move_ctx = g_placer_ctx.mutable_move();
 
     const int num_layers = device_ctx.grid.get_num_layers();
-    bool is_multi_layer = (num_layers > 1);
+
 
     t_pl_loc from = place_ctx.block_locs[b_from].loc;
     int from_layer = from.layer;
@@ -43,12 +50,13 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
     t_bb coords(OPEN, OPEN, OPEN, OPEN, OPEN, OPEN);
     t_bb limit_coords;
     ClusterBlockId bnum;
-    int pnum, xnew, xold, ynew, yold;
+    int pnum, xnew, xold, ynew, yold, layer_new, layer_old;
 
     //clear the vectors that saves X & Y coords
     //reused to save allocation time
     place_move_ctx.X_coord.clear();
     place_move_ctx.Y_coord.clear();
+    place_move_ctx.layer_coord.clear();
     std::vector<int> layer_blk_cnt(num_layers, 0);
 
     //true if the net is a feedback from the block to itself
@@ -84,8 +92,11 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
             VTR_ASSERT(pnum >= 0);
             xold = place_ctx.block_locs[bnum].loc.x + physical_tile_type(bnum)->pin_width_offset[pnum];
             yold = place_ctx.block_locs[bnum].loc.y + physical_tile_type(bnum)->pin_height_offset[pnum];
+            layer_old = place_ctx.block_locs[bnum].loc.layer;
+
             xold = std::max(std::min(xold, (int)device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
             yold = std::max(std::min(yold, (int)device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+            layer_old = std::max(std::min(layer_old, (int)device_ctx.grid.get_num_layers() - 1), 0);
 
             //To calulate the bb incrementally while excluding the moving block
             //assume that the moving block is moved to a non-critical coord of the bb
@@ -101,7 +112,23 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
                 ynew = net_bb_coords.ymin;
             }
 
-            if (!get_bb_incrementally(net_id, coords, xold, yold, xnew, ynew)) {
+            if (net_bb_coords.layer_min == layer_old) {
+                layer_new = net_bb_coords.layer_max;
+            } else {
+                layer_new = net_bb_coords.layer_min;
+            }
+
+            // If the mvoing block is on the border of the bounding box, we cannot get
+            // the bounding box incrementatlly. In that case, bounding box should be calculated 
+            // from scratch.
+            if (!get_bb_incrementally(net_id,
+                                      coords,
+                                      xold,
+                                      yold,
+                                      layer_old,
+                                      xnew,
+                                      ynew,
+                                      layer_new)) {
                 get_bb_from_scratch_excluding_block(net_id, coords, b_from, skip_net);
                 if (skip_net)
                     continue;
@@ -112,34 +139,29 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
         place_move_ctx.X_coord.push_back(coords.xmax);
         place_move_ctx.Y_coord.push_back(coords.ymin);
         place_move_ctx.Y_coord.push_back(coords.ymax);
-        if (is_multi_layer) {
-            for (int layer_num = 0; layer_num < num_layers; layer_num++) {
-                layer_blk_cnt[layer_num] += place_move_ctx.num_sink_pin_layer[size_t(net_id)][layer_num];
-            }
-            // If the pin under consideration is of type sink, it shouldn't be added to layer_blk_cnt since the block
-            // is moving
-            if (cluster_ctx.clb_nlist.pin_type(pin_id) == PinType::SINK) {
-                VTR_ASSERT_SAFE(layer_blk_cnt[from_layer] > 0);
-                layer_blk_cnt[from_layer]--;
-            }
-        }
+        place_move_ctx.layer_coord.push_back(coords.layer_min);
+        place_move_ctx.layer_coord.push_back(coords.layer_max);
     }
 
-    if ((place_move_ctx.X_coord.empty()) || (place_move_ctx.Y_coord.empty())) {
-        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\tMove aborted - X_coord and y_coord are empty\n");
+    if ((place_move_ctx.X_coord.empty()) || (place_move_ctx.Y_coord.empty()) || (place_move_ctx.layer_coord.empty())) {
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\tMove aborted - X_coord or y_coord or layer_coord are empty\n");
         return e_create_move::ABORT;
     }
 
     //calculate the median region
     std::stable_sort(place_move_ctx.X_coord.begin(), place_move_ctx.X_coord.end());
     std::stable_sort(place_move_ctx.Y_coord.begin(), place_move_ctx.Y_coord.end());
+    std::stable_sort(place_move_ctx.layer_coord.begin(), place_move_ctx.layer_coord.end());
 
     limit_coords.xmin = place_move_ctx.X_coord[floor((place_move_ctx.X_coord.size() - 1) / 2)];
     limit_coords.xmax = place_move_ctx.X_coord[floor((place_move_ctx.X_coord.size() - 1) / 2) + 1];
 
     limit_coords.ymin = place_move_ctx.Y_coord[floor((place_move_ctx.Y_coord.size() - 1) / 2)];
     limit_coords.ymax = place_move_ctx.Y_coord[floor((place_move_ctx.Y_coord.size() - 1) / 2) + 1];
 
+    limit_coords.layer_min = place_move_ctx.layer_coord[floor((place_move_ctx.layer_coord.size() - 1) / 2)];
+    limit_coords.layer_max = place_move_ctx.layer_coord[floor((place_move_ctx.layer_coord.size() - 1) / 2) + 1];
+
     //arrange the different range limiters
     t_range_limiters range_limiters{rlim,
                                     place_move_ctx.first_rlim,
@@ -149,17 +171,8 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
     t_pl_loc median_point;
     median_point.x = (limit_coords.xmin + limit_coords.xmax) / 2;
     median_point.y = (limit_coords.ymin + limit_coords.ymax) / 2;
+    median_point.layer = (limit_coords.layer_min + limit_coords.layer_max) / 2;
 
-    // Before calling find_to_loc_centroid a valid layer should be assigned to "to" location. If there are multiple layers, the layer
-    // with highest number of sinks will be used. Otherwise, the same layer as "from" loc is assigned.
-    if (is_multi_layer) {
-        int layer_num = std::distance(layer_blk_cnt.begin(), std::max_element(layer_blk_cnt.begin(), layer_blk_cnt.end()));
-        median_point.layer = layer_num;
-        to.layer = layer_num;
-    } else {
-        median_point.layer = from.layer;
-        to.layer = from.layer;
-    }
     if (!find_to_loc_centroid(cluster_from_type, from, median_point, range_limiters, to, b_from)) {
         return e_create_move::ABORT;
     }
@@ -194,6 +207,9 @@ static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_co
     int ymin = OPEN;
     int ymax = OPEN;
 
+    int layer_min = OPEN;
+    int layer_max = OPEN;
+
     int pnum;
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -208,11 +224,14 @@ static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_co
         pnum = net_pin_to_tile_pin_index(net_id, 0);
         int src_x = place_ctx.block_locs[bnum].loc.x + physical_tile_type(bnum)->pin_width_offset[pnum];
         int src_y = place_ctx.block_locs[bnum].loc.y + physical_tile_type(bnum)->pin_height_offset[pnum];
+        int src_layer = place_ctx.block_locs[bnum].loc.layer;
 
         xmin = src_x;
         ymin = src_y;
         xmax = src_x;
         ymax = src_y;
+        layer_min = src_layer;
+        layer_max = src_layer;
         first_block = true;
     }
 
@@ -225,12 +244,15 @@ static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_co
         const auto& block_loc = place_ctx.block_locs[bnum].loc;
         int x = block_loc.x + physical_tile_type(bnum)->pin_width_offset[pnum];
         int y = block_loc.y + physical_tile_type(bnum)->pin_height_offset[pnum];
+        int layer = block_loc.layer;
 
         if (!first_block) {
             xmin = x;
             ymin = y;
             xmax = x;
             ymax = y;
+            layer_max = layer;
+            layer_min = layer;
             first_block = true;
             continue;
         }
@@ -245,6 +267,12 @@ static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_co
         } else if (y > ymax) {
             ymax = y;
         }
+
+        if (layer < layer_min) {
+            layer_min = layer;
+        } else if (layer > layer_max) {
+            layer_max = layer;
+        }
     }
 
     /* Now I've found the coordinates of the bounding box.  There are no *
@@ -256,8 +284,10 @@ static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_co
      * is 0).  See route_common.cpp for a channel diagram.               */
     bb_coord_new.xmin = std::max(std::min<int>(xmin, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
     bb_coord_new.ymin = std::max(std::min<int>(ymin, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+    bb_coord_new.layer_min = std::max(std::min<int>(layer_min, device_ctx.grid.get_num_layers() - 1), 0);
     bb_coord_new.xmax = std::max(std::min<int>(xmax, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
     bb_coord_new.ymax = std::max(std::min<int>(ymax, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+    bb_coord_new.layer_max = std::max(std::min<int>(layer_max, device_ctx.grid.get_num_layers() - 1), 0);
 }
 
 /*
@@ -273,20 +303,36 @@ static void get_bb_from_scratch_excluding_block(ClusterNetId net_id, t_bb& bb_co
  * the pins always lie on the outside of the bounding box.            *
  * The x and y coordinates are the pin's x and y coordinates.         */
 /* IO blocks are considered to be one cell in for simplicity.         */
-static bool get_bb_incrementally(ClusterNetId net_id, t_bb& bb_coord_new, int xold, int yold, int xnew, int ynew) {
+static bool get_bb_incrementally(ClusterNetId net_id,
+                                 t_bb& bb_coord_new,
+                                 int xold,
+                                 int yold,
+                                 int layer_old,
+                                 int xnew,
+                                 int ynew,
+                                 int layer_new) {
     //TODO: account for multiple physical pin instances per logical pin
 
     auto& device_ctx = g_vpr_ctx.device();
     auto& place_move_ctx = g_placer_ctx.move();
 
     xnew = std::max(std::min<int>(xnew, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
     ynew = std::max(std::min<int>(ynew, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+    layer_new = std::max(std::min<int>(layer_new, device_ctx.grid.get_num_layers() - 1), 0);
+
     xold = std::max(std::min<int>(xold, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
     yold = std::max(std::min<int>(yold, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+    layer_old = std::max(std::min<int>(layer_old, device_ctx.grid.get_num_layers() - 1), 0);
 
     t_bb union_bb_edge;
     t_bb union_bb;
     const bool& cube_bb = g_vpr_ctx.placement().cube_bb;
+    /* Calculating per-layer bounding box is more time consuming compared to cube bounding box. To speed up
+    * this move, the bounding box used for this move is of the type cube bounding box even if the per-layer
+    * bounding box is used by placement SA engine. 
+    * If per-layer bounding box is used, we take a union of boundinx boxes on each layer to make a cube bounding box.
+    * For example, the xmax of this cube boundix box is determined by the maximim x coordinate across all blocks on all layers.
+    */
     if (!cube_bb) {
         std::tie(union_bb_edge, union_bb) = union_2d_bb_incr(place_move_ctx.layer_bb_num_on_edges[net_id],
                                                              place_move_ctx.layer_bb_coords[net_id]);
@@ -410,5 +456,47 @@ static bool get_bb_incrementally(ClusterNetId net_id, t_bb& bb_coord_new, int xo
         bb_coord_new.ymin = curr_bb_coord.ymin;
         bb_coord_new.ymax = curr_bb_coord.ymax;
     }
+
+    if (layer_new < layer_old) {
+        if (layer_old == curr_bb_coord.layer_max) {
+            if (curr_bb_edge.layer_max == 1) {
+                return false;
+            } else {
+                bb_coord_new.layer_max = curr_bb_coord.layer_max;
+            }
+        } else {
+            bb_coord_new.layer_max = curr_bb_coord.layer_max;
+        }
+
+        if (layer_new < curr_bb_coord.layer_min) {
+            bb_coord_new.layer_min = layer_new;
+        } else if (layer_new == curr_bb_coord.layer_min) {
+            bb_coord_new.layer_min = layer_new;
+        } else {
+            bb_coord_new.layer_min = curr_bb_coord.layer_min;
+        }
+
+    } else if (layer_new > layer_old) {
+        if (layer_old == curr_bb_coord.layer_min) {
+            if (curr_bb_edge.layer_min == 1) {
+                return false;
+            } else {
+                bb_coord_new.layer_min = curr_bb_coord.layer_min;
+            }
+        } else {
+            bb_coord_new.layer_min = curr_bb_coord.layer_min;
+        }
+
+        if (layer_new > curr_bb_coord.layer_max) {
+            bb_coord_new.layer_max = layer_new;
+        } else if (layer_new == curr_bb_coord.layer_max) {
+            bb_coord_new.layer_max = layer_new;
+        } else {
+            bb_coord_new.layer_max = curr_bb_coord.layer_max;
+        }
+    } else {
+        bb_coord_new.layer_min = curr_bb_coord.layer_min;
+        bb_coord_new.layer_max = curr_bb_coord.layer_max;
+    }
     return true;
 }

vpr/src/place/move_utils.cpp

@@ -928,7 +928,7 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
                           ClusterBlockId b_from) {
     //Retrieve the compressed block grid for this block type
     const auto& compressed_block_grid = g_vpr_ctx.placement().compressed_block_grids[blk_type->index];
-    const int to_layer_num = to_loc.layer;
+    const int to_layer_num = centroid.layer;
     VTR_ASSERT(to_layer_num >= 0);
     const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
 

vpr/src/place/move_utils.h

@@ -70,6 +70,8 @@ struct t_bb_cost {
     t_edge_cost xmax = {0, 0.0};
     t_edge_cost ymin = {0, 0.0};
     t_edge_cost ymax = {0, 0.0};
+    t_edge_cost layer_min = {0, 0.};
+    t_edge_cost layer_max = {0, 0.};
 };
 
 /**