Fixed bug in add_classes_spatial_lookup()

Author: Nathan Shreve

libs/librrgraph/src/base/rr_graph_utils.cpp

@@ -142,10 +142,6 @@ void set_sink_locs(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder
 
     // Helper fn. to remove old sink locations from RRSpatialLookup
     auto remove_sink_locs_from_lookup = [&](Offset bottom_left, Offset top_right, Offset new_sink_loc, RRNodeId node, size_t layer, size_t ptc) {
-        if (rr_graph_builder.node_lookup().find_node((int)layer, (int)new_sink_loc.x(), (int)new_sink_loc.y(), SINK, (int)ptc) == RRNodeId::INVALID()) {
-            rr_graph_builder.node_lookup().add_node(node, (int)layer, (int)new_sink_loc.x(), (int)new_sink_loc.y(), SINK, ptc);
-        }
-
         for (size_t x = bottom_left.x(); x <= top_right.x(); ++x) {
             for (size_t y = bottom_left.y(); y <= top_right.y(); ++y) {
                 if (x == new_sink_loc.x() && y == new_sink_loc.y()) /* The new sink location */

vpr/src/route/route_common.cpp

@@ -456,18 +456,15 @@ static vtr::vector<ParentNetId, std::vector<RRNodeId>> load_net_rr_terminals(con
 
             // SINK nodes do not cover their whole tile, so we need to check all coordinates in the tile.
             if (pin_count != 0 && inode == RRNodeId::INVALID()) {
-                ClusterBlockId cluster_block_id;
-
-                if (is_flat)
-                    cluster_block_id = atom_to_cluster(AtomBlockId(size_t(block_id)));
-                else
-                    cluster_block_id = ClusterBlockId(size_t(block_id));
-
-                auto tile_type = physical_tile_type(cluster_block_id);
-
-                for (int x = blk_loc.loc.x; x < blk_loc.loc.x + tile_type->width; ++x) {
-                    for (int y = blk_loc.loc.y; y < blk_loc.loc.y + tile_type->height; ++y) {
-                        inode = rr_graph.node_lookup().find_node(blk_loc.loc.layer, x, y, SINK, iclass);
+                auto tile_type = g_vpr_ctx.device().grid.get_physical_type({blk_loc.loc.x, blk_loc.loc.y, blk_loc.loc.layer});
+                size_t tile_xlow = blk_loc.loc.x - g_vpr_ctx.device().grid.get_width_offset({blk_loc.loc.x, blk_loc.loc.y, blk_loc.loc.layer});
+                size_t tile_ylow = blk_loc.loc.y - g_vpr_ctx.device().grid.get_height_offset({blk_loc.loc.x, blk_loc.loc.y, blk_loc.loc.layer});
+                size_t tile_xhigh = tile_xlow + tile_type->width - 1;
+                size_t tile_yhigh = tile_ylow + tile_type->height - 1;
+
+                for (size_t x = tile_xlow; x <= tile_xhigh; ++x) {
+                    for (size_t y = tile_ylow; y <= tile_yhigh; ++y) {
+                        inode = rr_graph.node_lookup().find_node(blk_loc.loc.layer, (int)x, (int)y, SINK, iclass);
 
                         if (inode != RRNodeId::INVALID())
                             break;

vpr/src/route/rr_graph.cpp

@@ -1502,7 +1502,7 @@ static void build_intra_cluster_rr_graph(const t_graph_type graph_type,
 
     rr_graph_builder.partition_edges();
 
-    set_sink_locs(rr_graph, rr_graph_builder, grid);
+    //set_sink_locs(rr_graph, rr_graph_builder, grid);
 
     rr_graph_builder.clear_temp_storage();
 

vpr/src/route/rr_graph2.cpp

@@ -1295,35 +1295,23 @@ static void add_classes_spatial_lookup(RRGraphBuilder& rr_graph_builder,
 
     for (auto class_num : class_num_vec) {
         auto class_type = get_class_type_from_class_physical_num(physical_type_ptr, class_num);
+        e_rr_type node_type = SINK;
         if (class_type == DRIVER) {
-            rr_graph_builder.node_lookup().add_node(RRNodeId(*index), layer, root_x, root_y, SOURCE, class_num);
+            node_type = SOURCE;
         } else {
             VTR_ASSERT(class_type == RECEIVER);
-
-            rr_graph_builder.node_lookup().add_node(RRNodeId(*index), layer, root_x, root_y, SINK, class_num);
         }
-        ++(*index);
-    }
 
-    //Copy the SOURCE/SINK nodes to all offset positions for blocks with width > 1 and/or height > 1
-    // This ensures that look-ups on non-root locations will still find the correct SOURCE/SINK
-    for (int x_offset = 0; x_offset < block_width; x_offset++) {
-        for (int y_offset = 0; y_offset < block_height; y_offset++) {
-            if (x_offset == 0 && y_offset == 0) {
-                // Node is already added
-                continue;
+        for (int x_offset = 0; x_offset < block_width; x_offset++) {
+            for (int y_offset = 0; y_offset < block_height; y_offset++) {
+                int curr_x = root_x + x_offset;
+                int curr_y = root_y + y_offset;
+
+                rr_graph_builder.node_lookup().add_node(RRNodeId(*index), layer, curr_x, curr_y, node_type, class_num);
             }
-            int curr_x = root_x + x_offset;
-            int curr_y = root_y + y_offset;
-            rr_graph_builder.node_lookup().mirror_nodes(layer, vtr::Point<int>(root_x, root_y),
-                                                        vtr::Point<int>(curr_x, curr_y),
-                                                        SOURCE,
-                                                        SIDES[0]);
-            rr_graph_builder.node_lookup().mirror_nodes(layer, vtr::Point<int>(root_x, root_y),
-                                                        vtr::Point<int>(curr_x, curr_y),
-                                                        SINK,
-                                                        SIDES[0]);
         }
+
+        ++(*index);
     }
 }