add get_root_location + pass t_physical_tile_loc instead of 3 integers

Author: soheilshahrouz

libs/libarchfpga/src/device_grid.h

@@ -53,7 +53,8 @@ class DeviceGrid {
     void clear();
 
     /**
-     * @brief Return the number of instances of the specified tile type on the specified layer. If the layer_num is -1, return the total number of instances of the specified tile type on all layers.
+     * @brief Return the number of instances of the specified tile type on the specified layer.
+     * If the layer_num is -1, return the total number of instances of the specified tile type on all layers.
      * @note This function should be used if count_instances() is called in the constructor.
      */
     size_t num_instances(t_physical_tile_type_ptr type, int layer_num) const;
@@ -83,6 +84,16 @@ class DeviceGrid {
         return get_width_offset(tile_loc) == 0 && get_height_offset(tile_loc) == 0;
     }
 
+    ///@brief Given a location, return the root location (bottom-left corner) of the tile instance
+    inline t_physical_tile_loc get_root_location(const t_physical_tile_loc& tile_loc) const {
+        t_physical_tile_loc root_loc;
+        root_loc.layer_num = tile_loc.layer_num;
+        root_loc.x = tile_loc.x - get_width_offset(tile_loc);
+        root_loc.y = tile_loc.y - get_height_offset(tile_loc);
+        return root_loc;
+    }
+
+
     ///@brief Returns a rectangle which represents the bounding box of the tile at the given location.
     inline vtr::Rect<int> get_tile_bb(const t_physical_tile_loc& tile_loc) const {
         t_physical_tile_type_ptr tile_type = get_physical_type(tile_loc);

libs/libarchfpga/src/physical_types_util.cpp

@@ -78,7 +78,6 @@ static std::vector<int> get_pb_pin_src_pins(t_physical_tile_type_ptr physical_ty
                                             const t_pb_graph_pin* pin);
 
 /**
- *
  * @param physical_type physical tile which pin belongs to
  * @param sub_tile  sub_tile in which physical tile located
  * @param logical_block logical block mapped to the sub_tile
@@ -108,20 +107,12 @@ static t_pb_graph_pin* get_mutable_tile_pin_pb_pin(t_physical_tile_type* physica
                                                    int pin_physical_num);
 
 /**
- *
- * @param physical_tile
- * @param class_physical_num
  * @return A vector containing all of the parent pb_graph_nodes and the pb_graph_node of the class_physical_num itself
  */
 static std::vector<const t_pb_graph_node*> get_sink_hierarchical_parents(t_physical_tile_type_ptr physical_tile,
                                                                          int class_physical_num);
 
 /**
- *
- * @param physical_tile
- * @param pin_physcial_num
- * @param ref_sink_num
- * @param sink_grp
  * @return Return zero if the ref_sink_num is not reachable by pin_physical_num, otherwise return the number sinks in sink_grp
  * reachable by pin_physical_num
  */
@@ -618,21 +609,21 @@ bool is_opin(int ipin, t_physical_tile_type_ptr type) {
         return false;
 }
 
-bool is_pin_conencted_to_layer(t_physical_tile_type_ptr type, int ipin, int from_layer, int to_layer, int num_of_avail_layer) {
-    if (type->is_empty()) { //if type is empty, there is no pins
+bool is_pin_conencted_to_layer(t_physical_tile_type_ptr type, int ipin, int from_layer, int to_layer, unsigned num_of_avail_layer) {
+    // if type is empty, there is no pins
+    if (type->is_empty()) {
         return false;
     }
-    //ipin should be a valid pin in physical type
+
+    // ipin should be a valid pin in physical type
     VTR_ASSERT(ipin < type->num_pins);
-    int pin_layer = from_layer + type->pin_layer_offset[ipin];
-    //if pin_offset specifies a layer that doesn't exist in arch file, we do a wrap around
+    unsigned pin_layer = from_layer + type->pin_layer_offset[ipin];
+    // if pin_offset specifies a layer that doesn't exist in arch file, we do a wrap around
     pin_layer = (pin_layer < num_of_avail_layer) ? pin_layer : pin_layer % num_of_avail_layer;
-    if (from_layer == to_layer || pin_layer == to_layer) {
+    if (from_layer == to_layer || int(pin_layer) == to_layer) {
         return true;
-    } else {
-        return false;
     }
-    //not reachable
+
     return false;
 }
 
@@ -643,7 +634,7 @@ std::string block_type_pin_index_to_name(t_physical_tile_type_ptr type, int pin_
     std::string pin_name = type->name;
 
     int sub_tile_index, inst_num, logical_num, pb_type_idx;
-    std::tie<int, int, int, int, int>(pin_index, sub_tile_index, inst_num, logical_num, pb_type_idx) = get_pin_index_for_inst(type, pin_physical_num, is_flat);
+    std::tie(pin_index, sub_tile_index, inst_num, logical_num, pb_type_idx) = get_pin_index_for_inst(type, pin_physical_num, is_flat);
     if (type->sub_tiles[sub_tile_index].capacity.total() > 1) {
         pin_name += "[" + std::to_string(inst_num) + "]";
     }

libs/libarchfpga/src/physical_types_util.h

@@ -116,7 +116,7 @@
 bool is_opin(int ipin, t_physical_tile_type_ptr type);
 
 ///@brief Returns true if the specified pin is located at "from_layer" and it is connected to "to_layer"
-bool is_pin_conencted_to_layer(t_physical_tile_type_ptr type, int ipin, int from_layer, int to_layer, int num_of_avail_layer);
+bool is_pin_conencted_to_layer(t_physical_tile_type_ptr type, int ipin, int from_layer, int to_layer, unsigned num_of_avail_layer);
 
 /**
  * @brief Returns the corresponding physical pin based on the input parameters:

vpr/src/route/overuse_report.cpp

@@ -43,17 +43,13 @@ static void log_single_overused_node_status(int overuse_index, RRNodeId inode);
  *
  * @param os The output stream to write the information to.
  * @param physical_type The physical type of the block.
- * @param layer The layer number of the block.
- * @param root_x The x coordinate of the root of the block.
- * @param root_y The y coordinate of the root of the block.
+ * @param root_loc The coordinates of the root of the block.
  * @param pin_physical_num The physical number of the pin.
  * @param rr_node_to_net_map A map of RR nodes to the nets that pass through them.
  */
 static void print_block_pins_nets(std::ostream& os,
                                   t_physical_tile_type_ptr physical_type,
-                                  int layer,
-                                  int root_x,
-                                  int root_y,
+                                  const t_physical_tile_loc& root_loc,
                                   int pin_physical_num,
                                   const std::map<RRNodeId, std::set<ParentNetId>>& rr_node_to_net_map);
 /**
@@ -231,31 +227,29 @@ static void report_overused_ipin_opin(std::ostream& os,
     const auto& rr_graph = device_ctx.rr_graph;
     const auto& place_ctx = g_vpr_ctx.placement();
 
-    auto grid_x = rr_graph.node_xlow(node_id);
-    auto grid_y = rr_graph.node_ylow(node_id);
-    auto grid_layer = rr_graph.node_layer(node_id);
+    t_physical_tile_loc grid_loc;
+    grid_loc.x = rr_graph.node_xlow(node_id);
+    grid_loc.y = rr_graph.node_ylow(node_id);
+    grid_loc.layer_num = rr_graph.node_layer(node_id);
+    const t_physical_tile_type_ptr physical_type = device_ctx.grid.get_physical_type(grid_loc);
 
-    VTR_ASSERT_MSG(
-        grid_x == rr_graph.node_xhigh(node_id) && grid_y == rr_graph.node_yhigh(node_id),
-        "Non-track RR node should not span across multiple grid blocks.");
+    VTR_ASSERT_MSG(grid_loc.x == rr_graph.node_xhigh(node_id) && grid_loc.y == rr_graph.node_yhigh(node_id),
+                   "Non-track RR node should not span across multiple grid blocks.");
 
     os << "Pin physical number = " << rr_graph.node_pin_num(node_id) << '\n';
     if (is_inter_cluster_node(rr_graph, node_id)) {
         os << "On Tile Pin"
            << "\n";
     } else {
-        auto pb_type_name = get_pb_graph_node_from_pin_physical_num(device_ctx.grid.get_physical_type({grid_x, grid_y, grid_layer}),
+        auto pb_type_name = get_pb_graph_node_from_pin_physical_num(device_ctx.grid.get_physical_type(grid_loc),
                                                                     rr_graph.node_ptc_num(node_id))
                                 ->pb_type->name;
-        auto pb_pin = get_pb_pin_from_pin_physical_num(device_ctx.grid.get_physical_type({grid_x, grid_y, grid_layer}),
-                                                       rr_graph.node_ptc_num(node_id));
+        auto pb_pin = get_pb_pin_from_pin_physical_num(physical_type, rr_graph.node_ptc_num(node_id));
         os << "Intra-Tile Pin - Port : " << pb_pin->port->name << " - PB Type : " << std::string(pb_type_name) << "\n";
     }
     print_block_pins_nets(os,
-                          device_ctx.grid.get_physical_type({grid_x, grid_y, grid_layer}),
-                          grid_layer,
-                          grid_x - device_ctx.grid.get_width_offset({grid_x, grid_y, grid_layer}),
-                          grid_y - device_ctx.grid.get_height_offset({grid_x, grid_y, grid_layer}),
+                          physical_type,
+                          device_ctx.grid.get_root_location(grid_loc),
                           rr_graph.node_ptc_num(node_id),
                           rr_node_to_net_map);
     os << "Side = " << rr_graph.node_side_string(node_id) << "\n\n";
@@ -264,19 +258,19 @@ static void report_overused_ipin_opin(std::ostream& os,
     const auto& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
     const auto& grid_info = place_ctx.grid_blocks();
 
-    os << "Grid location: X = " << grid_x << ", Y = " << grid_y << '\n';
-    os << "Number of blocks currently occupying this grid location = " << grid_info.get_usage({grid_x, grid_y, grid_layer}) << '\n';
+    os << "Grid location: X = " << grid_loc.x << ", Y = " << grid_loc.y << '\n';
+    os << "Number of blocks currently occupying this grid location = " << grid_info.get_usage(grid_loc) << '\n';
 
     size_t iblock = 0;
-    for (int isubtile = 0; isubtile < (int)grid_info.num_blocks_at_location({grid_x, grid_y, grid_layer}); ++isubtile) {
+    for (int isubtile = 0; isubtile < (int)grid_info.num_blocks_at_location(grid_loc); ++isubtile) {
         //Check if there is a valid block at this subtile location
-        if (grid_info.is_sub_tile_empty({grid_x, grid_y, grid_layer}, isubtile)) {
+        if (grid_info.is_sub_tile_empty(grid_loc, isubtile)) {
             continue;
         }
 
         //Print out the block index, name and type
         // TODO: Needs to be updated when RR Graph Nodes know their layer_num
-        ClusterBlockId block_id = grid_info.block_at_location({grid_x, grid_y, isubtile, grid_layer});
+        ClusterBlockId block_id = grid_info.block_at_location({grid_loc, isubtile});
         os << "Block #" << iblock << ": ";
         os << "Block name = " << clb_nlist.block_pb(block_id)->name << ", ";
         os << "Block type = " << clb_nlist.block_type(block_id)->name << '\n';
@@ -459,9 +453,7 @@ static void log_single_overused_node_status(int overuse_index, RRNodeId node_id)
 
 static void print_block_pins_nets(std::ostream& os,
                                   t_physical_tile_type_ptr physical_type,
-                                  int layer,
-                                  int root_x,
-                                  int root_y,
+                                  const t_physical_tile_loc& root_loc,
                                   int pin_physical_num,
                                   const std::map<RRNodeId, std::set<ParentNetId>>& rr_node_to_net_map) {
     const auto& rr_graph = g_vpr_ctx.device().rr_graph;
@@ -489,7 +481,7 @@ static void print_block_pins_nets(std::ostream& os,
 
     for (int pin = pin_num_range.low; pin <= pin_num_range.high; pin++) {
         e_rr_type rr_type = (get_pin_type_from_pin_physical_num(physical_type, pin) == e_pin_type::DRIVER) ? e_rr_type::OPIN : e_rr_type::IPIN;
-        RRNodeId node_id = get_pin_rr_node_id(rr_graph.node_lookup(), physical_type, layer, root_x, root_y, pin);
+        RRNodeId node_id = get_pin_rr_node_id(rr_graph.node_lookup(), physical_type, root_loc, pin);
         // When flat router is enabled, RR Node chains collapse into a single node. Thus, when
         // looking up the RR Node ID, it may return an invalid node ID. In this case, we skip
         // this pin.

vpr/src/route/route_utils.cpp

@@ -460,7 +460,12 @@ vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>> set_net
                 std::for_each(sink_grp.begin(), sink_grp.end(), [&rr_graph](int& sink_rr_num) {
                     sink_rr_num = rr_graph.node_ptc_num(RRNodeId(sink_rr_num));
                 });
-                auto physical_type = device_ctx.grid.get_physical_type({blk_loc.loc.x, blk_loc.loc.y, blk_loc.loc.layer});
+
+                t_physical_tile_loc grid_loc;
+                grid_loc.x = blk_loc.loc.x;
+                grid_loc.y = blk_loc.loc.y;
+                grid_loc.layer_num = blk_loc.loc.layer;
+                t_physical_tile_type_ptr physical_type = device_ctx.grid.get_physical_type(grid_loc);
                 // Get the choke points of the sink corresponds to pin_count given the sink group
                 auto sink_choking_spots = get_sink_choking_points(physical_type,
                                                                   rr_graph.node_ptc_num(RRNodeId(net_rr_terminal[net_id][pin_count])),
@@ -471,9 +476,7 @@ vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>> set_net
                     int num_reachable_sinks = choking_spot.second;
                     auto pin_rr_node_id = get_pin_rr_node_id(rr_graph.node_lookup(),
                                                              physical_type,
-                                                             blk_loc.loc.layer,
-                                                             blk_loc.loc.x,
-                                                             blk_loc.loc.y,
+                                                             grid_loc,
                                                              pin_physical_num);
                     if (pin_rr_node_id != RRNodeId::INVALID()) {
                         choking_spots[net_id][pin_count].insert(std::make_pair(pin_rr_node_id, num_reachable_sinks));