Merge branch 'improve_map_lookahead_exp0' into improve_map_lookahead

Author: Nathan Shreve

libs/librrgraph/src/base/rr_graph_utils.cpp

@@ -185,6 +185,16 @@ void set_sink_locs(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder
         auto x_avg = (short)round(std::accumulate(x_coords.begin(), x_coords.end(), 0.f) / (double)x_coords.size());
         auto y_avg = (short)round(std::accumulate(y_coords.begin(), y_coords.end(), 0.f) / (double)y_coords.size());
 
+        // Remove old indices from RRSpatialLookup
+        for (size_t x = tile_xlow; x <= tile_xhigh; ++x) {
+            for (size_t y = tile_ylow; y <= tile_yhigh; ++y) {
+                if (x == (size_t)x_avg && y == (size_t)y_avg)
+                    continue;
+
+                rr_graph_builder.node_lookup().remove_node(node_id, tile_layer, x, y, SINK, sink_ptc);
+            }
+        }
+
         // Save offset for this tile/ptc combo
         if (physical_type_offsets.find(tile_type) == physical_type_offsets.end())
             physical_type_offsets[tile_type] = {};

libs/librrgraph/src/base/rr_spatial_lookup.cpp

@@ -258,6 +258,33 @@ void RRSpatialLookup::add_node(RRNodeId node,
     rr_node_indices_[type][layer][x][y][side][ptc] = int(size_t(node));
 }
 
+void RRSpatialLookup::remove_node(RRNodeId node,
+                                  int layer,
+                                  int x,
+                                  int y,
+                                  t_rr_type type,
+                                  int ptc,
+                                  e_side side) {
+    VTR_ASSERT(node);
+    VTR_ASSERT_SAFE(4 == rr_node_indices_[type].ndims());
+    VTR_ASSERT_SAFE(layer >= 0);
+    VTR_ASSERT_SAFE(x >= 0);
+    VTR_ASSERT_SAFE(y >= 0);
+    VTR_ASSERT_SAFE(type != NUM_RR_TYPES);
+    VTR_ASSERT_SAFE(ptc >= 0);
+    VTR_ASSERT_SAFE(side != NUM_SIDES);
+
+    VTR_ASSERT_SAFE(!(type >= rr_node_indices_.size()));
+    VTR_ASSERT_SAFE(!((size_t)layer >= rr_node_indices_[type].dim_size(0)));
+    VTR_ASSERT_SAFE(!((size_t)x >= rr_node_indices_[type].dim_size(1)));
+    VTR_ASSERT_SAFE(!((size_t)y >= rr_node_indices_[type].dim_size(2)));
+    VTR_ASSERT_SAFE(!(side >= rr_node_indices_[type].dim_size(3)));
+    VTR_ASSERT_SAFE(!((size_t)ptc >= rr_node_indices_[type][layer][x][y][side].size()));
+    VTR_ASSERT_SAFE(!(rr_node_indices_[type][layer][x][y][side][ptc] == -1));
+
+    rr_node_indices_[type][layer][x][y][side][ptc] = -1;
+}
+
 void RRSpatialLookup::mirror_nodes(const int layer,
                                    const vtr::Point<int>& src_coord,
                                    const vtr::Point<int>& des_coord,

libs/librrgraph/src/base/rr_spatial_lookup.h

@@ -159,6 +159,14 @@ class RRSpatialLookup {
                   int ptc,
                   e_side side = SIDES[0]);
 
+    void remove_node(RRNodeId node,
+                     int layer,
+                     int x,
+                     int y,
+                     t_rr_type type,
+                     int ptc,
+                     e_side side = SIDES[0]);
+
     /**
      * @brief Mirror the last dimension of a look-up, i.e., a list of nodes, from a source coordinate to 
      * a destination coordinate.

vpr/src/route/route_common.cpp

@@ -7,6 +7,7 @@
 #include "route_common.h"
 #include "route_export.h"
 #include "rr_graph.h"
+#include "re_cluster_util.h"
 
 /*  The numbering relation between the channels and clbs is:				*
  *																	        *
@@ -452,7 +453,30 @@ static vtr::vector<ParentNetId, std::vector<RRNodeId>> load_net_rr_terminals(con
                                                               blk_loc.loc.y,
                                                               (pin_count == 0 ? SOURCE : SINK), /* First pin is driver */
                                                               iclass);
+
+            // 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);
+
+                        if (inode != RRNodeId::INVALID())
+                            break;
+                    }
+                }
+            }
+
             VTR_ASSERT(inode != RRNodeId::INVALID());
+
             net_rr_terminals[net_id][pin_count] = inode;
             pin_count++;
         }