Merge pull request #1779 from verilog-to-routing/rr_spatial_lookup_client_functions

vaughnbetz · web-flow · commit e73e8894028b · 2021-06-26T09:51:35.000-04:00
Deploy ``RRGraphBuilder`` in Client Functions to replace the use of ``rr_node_indices``
diff --git a/vpr/src/device/rr_spatial_lookup.cpp b/vpr/src/device/rr_spatial_lookup.cpp
@@ -29,7 +29,7 @@ RRNodeId RRSpatialLookup::find_node(int x,
     }
 
     /* Pre-check: the x, y, side and ptc should be non negative numbers! Otherwise, return an invalid id */
-    if ((0 > x) || (0 > y) || (NUM_SIDES == node_side) || (0 > ptc)) {
+    if ((x < 0) || (y < 0) || (node_side == NUM_SIDES) || (ptc < 0)) {
         return RRNodeId::INVALID();
     }
 
@@ -41,7 +41,7 @@ RRNodeId RRSpatialLookup::find_node(int x,
      */
     size_t node_x = x;
     size_t node_y = y;
-    if (CHANX == type) {
+    if (type == CHANX) {
         std::swap(node_x, node_y);
     }
 
@@ -74,6 +74,90 @@ RRNodeId RRSpatialLookup::find_node(int x,
     return RRNodeId(rr_node_indices_[type][node_x][node_y][node_side][ptc]);
 }
 
+std::vector<RRNodeId> RRSpatialLookup::find_channel_nodes(int x,
+                                                          int y,
+                                                          t_rr_type type) const {
+    /* TODO: The implementation of this API should be worked 
+     * when rr_node_indices adapts RRNodeId natively!
+     */
+    std::vector<RRNodeId> channel_nodes;
+
+    /* Pre-check: the x, y, type are valid! Otherwise, return an empty vector */
+    if ((x < 0 || y < 0) && (type == CHANX || type == CHANY)) {
+        return channel_nodes;
+    }
+
+    /* Currently need to swap x and y for CHANX because of chan, seg convention 
+     * This is due to that the fast look-up builders uses (y, x) coordinate when
+     * registering a CHANX node in the look-up
+     * TODO: Once the builders is reworked for use consistent (x, y) convention,
+     * the following swapping can be removed
+     */
+    size_t node_x = x;
+    size_t node_y = y;
+    if (type == CHANX) {
+        std::swap(node_x, node_y);
+    }
+
+    VTR_ASSERT_SAFE(3 == rr_node_indices_[type].ndims());
+
+    /* Sanity check to ensure the x, y, side are in range 
+     * - Return a list of valid ids by searching in look-up when all the parameters are in range
+     * - Return an empty list if any out-of-range is detected
+     */
+    if (size_t(type) >= rr_node_indices_.size()) {
+        return channel_nodes;
+    }
+
+    if (node_x >= rr_node_indices_[type].dim_size(0)) {
+        return channel_nodes;
+    }
+
+    if (node_y >= rr_node_indices_[type].dim_size(1)) {
+        return channel_nodes;
+    }
+
+    /* By default, we always added the channel nodes to the TOP side (to save memory) */
+    e_side node_side = TOP;
+    if (node_side >= rr_node_indices_[type].dim_size(2)) {
+        return channel_nodes;
+    }
+
+    for (const auto& node : rr_node_indices_[type][node_x][node_y][node_side]) {
+        if (RRNodeId(node)) {
+            channel_nodes.push_back(RRNodeId(node));
+        }
+    }
+
+    return channel_nodes;
+}
+
+std::vector<RRNodeId> RRSpatialLookup::find_nodes_at_all_sides(int x,
+                                                               int y,
+                                                               t_rr_type rr_type,
+                                                               int ptc) const {
+    std::vector<RRNodeId> indices;
+
+    /* TODO: Consider to access the raw data like find_node() rather than calling find_node() many times, which hurts runtime */
+    if (rr_type == IPIN || rr_type == OPIN) {
+        //For pins we need to look at all the sides of the current grid tile
+        for (e_side side : SIDES) {
+            RRNodeId rr_node_index = find_node(x, y, rr_type, ptc, side);
+            if (rr_node_index) {
+                indices.push_back(rr_node_index);
+            }
+        }
+    } else {
+        //Sides do not effect non-pins so there should only be one per ptc
+        RRNodeId rr_node_index = find_node(x, y, rr_type, ptc);
+        if (rr_node_index) {
+            indices.push_back(rr_node_index);
+        }
+    }
+
+    return indices;
+}
+
 void RRSpatialLookup::add_node(RRNodeId node,
                                int x,
                                int y,
@@ -112,8 +196,8 @@ void RRSpatialLookup::resize_nodes(int x,
      * should ensure the fast look-up well organized  
      */
     VTR_ASSERT(type < rr_node_indices_.size());
-    VTR_ASSERT(0 <= x);
-    VTR_ASSERT(0 <= y);
+    VTR_ASSERT(x >= 0);
+    VTR_ASSERT(y >= 0);
 
     if ((x >= int(rr_node_indices_[type].dim_size(0)))
         || (y >= int(rr_node_indices_[type].dim_size(1)))
diff --git a/vpr/src/device/rr_spatial_lookup.h b/vpr/src/device/rr_spatial_lookup.h
@@ -63,6 +63,34 @@ class RRSpatialLookup {
                        int ptc,
                        e_side side = NUM_SIDES) const;
 
+    /**
+     * Returns the indices of the specified routing resource nodes,
+     * representing routing tracks in a channel.  
+     * - (x, y) are the coordinate of the routing channel within the FPGA
+     * - rr_type specifies the type of routing channel, either x-direction or y-direction
+     *
+     * Note: 
+     * - Return an empty list if there are no routing channel at the given (x, y) location
+     * - The node list returned only contain valid ids
+     *   For example, if the 2nd routing track does not exist in a routing channel at (x, y) location,
+     *   while the 3rd routing track does exist in a routing channel at (x, y) location,
+     *   the node list will not contain the node for the 2nd routing track, but the 2nd element in the list
+     *   will be the node for the 3rd routing track
+     */
+    std::vector<RRNodeId> find_channel_nodes(int x,
+                                             int y,
+                                             t_rr_type type) const;
+
+    /**
+     * Like find_node() but returns all matching nodes on all the sides.
+     * This is particularly useful for getting all instances
+     * of a specific IPIN/OPIN at a specific gird tile (x,y) location.
+     */
+    std::vector<RRNodeId> find_nodes_at_all_sides(int x,
+                                                  int y,
+                                                  t_rr_type rr_type,
+                                                  int ptc) const;
+
     /* -- Mutators -- */
   public:
     /**
diff --git a/vpr/src/pack/post_routing_pb_pin_fixup.cpp b/vpr/src/pack/post_routing_pb_pin_fixup.cpp
@@ -55,6 +55,7 @@ static void update_cluster_pin_with_post_routing_results(const DeviceContext& de
                                                          const int& sub_tile_z,
                                                          size_t& num_mismatches,
                                                          const bool& verbose) {
+    const auto& node_lookup = device_ctx.rr_graph.node_lookup();
     /* Handle each pin */
     auto logical_block = clustering_ctx.clb_nlist.block_type(blk_id);
     auto physical_tile = device_ctx.grid[grid_coord.x()][grid_coord.y()].type;
@@ -152,12 +153,10 @@ static void update_cluster_pin_with_post_routing_results(const DeviceContext& de
         short valid_routing_net_cnt = 0;
         for (const e_side& pin_side : pin_sides) {
             /* Find the net mapped to this pin in routing results */
-            const int& rr_node = get_rr_node_index(device_ctx.rr_node_indices,
-                                                   grid_coord.x(), grid_coord.y(),
-                                                   rr_node_type, physical_pin, pin_side);
+            RRNodeId rr_node = node_lookup.find_node(grid_coord.x(), grid_coord.y(), rr_node_type, physical_pin, pin_side);
 
             /* Bypass invalid nodes, after that we must have a valid rr_node id */
-            if (OPEN == rr_node) {
+            if (!rr_node) {
                 continue;
             }
             VTR_ASSERT((size_t)rr_node < device_ctx.rr_nodes.size());
@@ -179,19 +178,19 @@ static void update_cluster_pin_with_post_routing_results(const DeviceContext& de
              * - A invalid net id (others should be all invalid as well)
              *   assume that this pin is not used by router
              */
-            if (rr_node_nets[RRNodeId(rr_node)]) {
+            if (rr_node_nets[rr_node]) {
                 if (routing_net_id) {
-                    if (routing_net_id != rr_node_nets[RRNodeId(rr_node)]) {
+                    if (routing_net_id != rr_node_nets[rr_node]) {
                         VTR_LOG_ERROR("Pin '%s' is mapped to two nets: '%s' and '%s'\n",
                                       pb_graph_pin->to_string().c_str(),
                                       clustering_ctx.clb_nlist.net_name(routing_net_id).c_str(),
-                                      clustering_ctx.clb_nlist.net_name(rr_node_nets[RRNodeId(rr_node)]).c_str());
+                                      clustering_ctx.clb_nlist.net_name(rr_node_nets[rr_node]).c_str());
                     }
-                    VTR_ASSERT(routing_net_id == rr_node_nets[RRNodeId(rr_node)]);
+                    VTR_ASSERT(routing_net_id == rr_node_nets[rr_node]);
                 }
-                routing_net_id = rr_node_nets[RRNodeId(rr_node)];
+                routing_net_id = rr_node_nets[rr_node];
                 valid_routing_net_cnt++;
-                visited_rr_nodes.push_back(RRNodeId(rr_node));
+                visited_rr_nodes.push_back(rr_node);
             }
         }
 
diff --git a/vpr/src/place/timing_place_lookup.cpp b/vpr/src/place/timing_place_lookup.cpp
@@ -143,7 +143,7 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
                                                  int to_pin_class,
                                                  int* src_rr,
                                                  int* sink_rr,
-                                                 std::vector<int>* scratch);
+                                                 std::vector<RRNodeId>* scratch);
 
 static bool verify_delta_delays(const vtr::Matrix<float>& delta_delays);
 
@@ -956,12 +956,13 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
                                                  int to_pin_class,
                                                  int* src_rr,
                                                  int* sink_rr,
-                                                 std::vector<int>* scratch) {
+                                                 std::vector<RRNodeId>* scratch) {
     VTR_ASSERT(from_type != nullptr);
     VTR_ASSERT(to_type != nullptr);
 
     auto& device_ctx = g_vpr_ctx.device();
     auto& grid = device_ctx.grid;
+    const auto& node_lookup = device_ctx.rr_graph.node_lookup();
 
     //Search the grid for an instance of from/to blocks which satisfy this direct connect offsets,
     //and which has the appropriate pins
@@ -979,12 +980,11 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
             //(with multi-width/height blocks pins may not exist at all locations)
             bool from_pin_found = false;
             if (direct->from_side != NUM_SIDES) {
-                RRNodeId from_pin_rr = device_ctx.rr_graph.node_lookup().find_node(from_x, from_y, OPIN, from_pin, direct->from_side);
+                RRNodeId from_pin_rr = node_lookup.find_node(from_x, from_y, OPIN, from_pin, direct->from_side);
                 from_pin_found = (from_pin_rr != RRNodeId::INVALID());
             } else {
-                std::vector<int>& from_pin_rrs = *scratch;
-                get_rr_node_indices(device_ctx.rr_node_indices, from_x, from_y, OPIN, from_pin, &from_pin_rrs);
-                from_pin_found = !from_pin_rrs.empty();
+                (*scratch) = node_lookup.find_nodes_at_all_sides(from_x, from_y, OPIN, from_pin);
+                from_pin_found = !(*scratch).empty();
             }
             if (!from_pin_found) continue;
 
@@ -997,12 +997,11 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
             //(with multi-width/height blocks pins may not exist at all locations)
             bool to_pin_found = false;
             if (direct->to_side != NUM_SIDES) {
-                RRNodeId to_pin_rr = device_ctx.rr_graph.node_lookup().find_node(to_x, to_y, IPIN, to_pin, direct->to_side);
+                RRNodeId to_pin_rr = node_lookup.find_node(to_x, to_y, IPIN, to_pin, direct->to_side);
                 to_pin_found = (to_pin_rr != RRNodeId::INVALID());
             } else {
-                std::vector<int>& to_pin_rrs = *scratch;
-                get_rr_node_indices(device_ctx.rr_node_indices, to_x, to_y, IPIN, to_pin, &to_pin_rrs);
-                to_pin_found = !to_pin_rrs.empty();
+                (*scratch) = node_lookup.find_nodes_at_all_sides(to_x, to_y, IPIN, to_pin);
+                to_pin_found = !(*scratch).empty();
             }
             if (!to_pin_found) continue;
 
@@ -1039,17 +1038,15 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
     //
 
     {
-        std::vector<int>& source_rr_nodes = *scratch;
-        get_rr_node_indices(device_ctx.rr_node_indices, from_x, from_y, SOURCE, from_pin_class, &source_rr_nodes);
-        VTR_ASSERT(source_rr_nodes.size() > 0);
-        *src_rr = source_rr_nodes[0];
+        (*scratch) = node_lookup.find_nodes_at_all_sides(from_x, from_y, SOURCE, from_pin_class);
+        VTR_ASSERT((*scratch).size() > 0);
+        *src_rr = size_t((*scratch)[0]);
     }
 
     {
-        std::vector<int>& sink_rr_nodes = *scratch;
-        get_rr_node_indices(device_ctx.rr_node_indices, to_x, to_y, SINK, to_pin_class, &sink_rr_nodes);
-        VTR_ASSERT(sink_rr_nodes.size() > 0);
-        *sink_rr = sink_rr_nodes[0];
+        (*scratch) = node_lookup.find_nodes_at_all_sides(to_x, to_y, SINK, to_pin_class);
+        VTR_ASSERT((*scratch).size() > 0);
+        *sink_rr = size_t((*scratch)[0]);
     }
 
     return true;
@@ -1082,7 +1079,7 @@ void OverrideDelayModel::compute_override_delay_model(
 
     //Look at all the direct connections that exist, and add overrides to delay model
     auto& device_ctx = g_vpr_ctx.device();
-    std::vector<int> scratch;
+    std::vector<RRNodeId> scratch;
     for (int idirect = 0; idirect < device_ctx.arch->num_directs; ++idirect) {
         const t_direct_inf* direct = &device_ctx.arch->Directs[idirect];
 
diff --git a/vpr/src/route/route_common.cpp b/vpr/src/route/route_common.cpp
@@ -90,8 +90,8 @@ static t_trace_branch traceback_branch(int node, int target_net_pin_index, std::
 static std::pair<t_trace*, t_trace*> add_trace_non_configurable(t_trace* head, t_trace* tail, int node, std::unordered_set<int>& visited);
 static std::pair<t_trace*, t_trace*> add_trace_non_configurable_recurr(int node, std::unordered_set<int>& visited, int depth = 0);
 
-static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t_rr_node_indices& L_rr_node_indices);
-static vtr::vector<ClusterBlockId, std::vector<int>> load_rr_clb_sources(const t_rr_node_indices& L_rr_node_indices);
+static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const RRGraphView& rr_graph);
+static vtr::vector<ClusterBlockId, std::vector<int>> load_rr_clb_sources(const RRGraphView& rr_graph);
 
 static t_clb_opins_used alloc_and_load_clb_opins_used_locally();
 static void adjust_one_rr_occ_and_acc_cost(int inode, int add_or_sub, float acc_fac);
@@ -480,10 +480,10 @@ void init_route_structs(int bb_factor) {
     route_ctx.trace_nodes.resize(cluster_ctx.clb_nlist.nets().size());
 
     //Various look-ups
-    route_ctx.net_rr_terminals = load_net_rr_terminals(device_ctx.rr_node_indices);
+    route_ctx.net_rr_terminals = load_net_rr_terminals(device_ctx.rr_graph);
     route_ctx.is_clock_net = load_is_clock_net();
     route_ctx.route_bb = load_route_bb(bb_factor);
-    route_ctx.rr_blk_source = load_rr_clb_sources(device_ctx.rr_node_indices);
+    route_ctx.rr_blk_source = load_rr_clb_sources(device_ctx.rr_graph);
     route_ctx.clb_opins_used_locally = alloc_and_load_clb_opins_used_locally();
     route_ctx.net_status.resize(cluster_ctx.clb_nlist.nets().size());
 }
@@ -969,7 +969,7 @@ void reset_rr_node_route_structs() {
 /* Allocates and loads the route_ctx.net_rr_terminals data structure. For each net it stores the rr_node   *
  * index of the SOURCE of the net and all the SINKs of the net [clb_nlist.nets()][clb_nlist.net_pins()].    *
  * Entry [inet][pnum] stores the rr index corresponding to the SOURCE (opin) or SINK (ipin) of the pin.     */
-static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t_rr_node_indices& L_rr_node_indices) {
+static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const RRGraphView& rr_graph) {
     vtr::vector<ClusterNetId, std::vector<int>> net_rr_terminals;
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -996,9 +996,9 @@ static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t
 
             int iclass = type->pin_class[phys_pin];
 
-            int inode = get_rr_node_index(L_rr_node_indices, i, j, (pin_count == 0 ? SOURCE : SINK), /* First pin is driver */
-                                          iclass);
-            net_rr_terminals[net_id][pin_count] = inode;
+            RRNodeId inode = rr_graph.node_lookup().find_node(i, j, (pin_count == 0 ? SOURCE : SINK), /* First pin is driver */
+                                                              iclass);
+            net_rr_terminals[net_id][pin_count] = size_t(inode);
             pin_count++;
         }
     }
@@ -1011,10 +1011,10 @@ static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t
  * they are used only to reserve pins for locally used OPINs in the router. *
  * [0..cluster_ctx.clb_nlist.blocks().size()-1][0..num_class-1].            *
  * The values for blocks that are padsare NOT valid.                        */
-static vtr::vector<ClusterBlockId, std::vector<int>> load_rr_clb_sources(const t_rr_node_indices& L_rr_node_indices) {
+static vtr::vector<ClusterBlockId, std::vector<int>> load_rr_clb_sources(const RRGraphView& rr_graph) {
     vtr::vector<ClusterBlockId, std::vector<int>> rr_blk_source;
 
-    int i, j, iclass, inode;
+    int i, j, iclass;
     t_rr_type rr_type;
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -1039,8 +1039,8 @@ static vtr::vector<ClusterBlockId, std::vector<int>> load_rr_clb_sources(const t
                 else
                     rr_type = SINK;
 
-                inode = get_rr_node_index(L_rr_node_indices, i, j, rr_type, iclass);
-                rr_blk_source[blk_id][iclass] = inode;
+                RRNodeId inode = rr_graph.node_lookup().find_node(i, j, rr_type, iclass);
+                rr_blk_source[blk_id][iclass] = size_t(inode);
             } else {
                 rr_blk_source[blk_id][iclass] = OPEN;
             }
diff --git a/vpr/src/route/router_lookahead_map.cpp b/vpr/src/route/router_lookahead_map.cpp
diff --git a/vpr/src/route/router_lookahead_map_utils.cpp b/vpr/src/route/router_lookahead_map_utils.cpp
