[VPR] use constant reference to node_lookup to avoid long lines

Author: tangxifan

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,7 +153,7 @@ 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 */
-            RRNodeId rr_node = device_ctx.rr_graph.node_lookup().find_node(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 (!rr_node) {

vpr/src/place/timing_place_lookup.cpp

@@ -962,6 +962,7 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
 
     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,10 +980,10 @@ 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 {
-                (*scratch) = device_ctx.rr_graph.node_lookup().find_nodes_at_all_sides(from_x, from_y, OPIN, from_pin);
+                (*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;
@@ -996,10 +997,10 @@ 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 {
-                (*scratch) = device_ctx.rr_graph.node_lookup().find_nodes_at_all_sides(to_x, to_y, IPIN, to_pin);
+                (*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;
@@ -1037,13 +1038,13 @@ static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
     //
 
     {
-        (*scratch) = device_ctx.rr_graph.node_lookup().find_nodes_at_all_sides(from_x, from_y, SOURCE, from_pin_class);
+        (*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]);
     }
 
     {
-        (*scratch) = device_ctx.rr_graph.node_lookup().find_nodes_at_all_sides(to_x, to_y, SINK, to_pin_class);
+        (*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]);
     }

vpr/src/route/router_lookahead_map.cpp

@@ -546,6 +546,7 @@ static RRNodeId get_start_node(int start_x, int start_y, int target_x, int targe
     auto& device_ctx = g_vpr_ctx.device();
     const auto& temp_rr_graph = device_ctx.rr_graph; //TODO rename to rr_graph once the rr_graph below is unneeded
     auto& rr_graph = device_ctx.rr_nodes;
+    const auto& node_lookup = device_ctx.rr_graph.node_lookup();
 
     RRNodeId result = RRNodeId::INVALID();
 
@@ -563,7 +564,7 @@ static RRNodeId get_start_node(int start_x, int start_y, int target_x, int targe
     int start_lookup_y = start_y;
 
     /* find first node in channel that has specified segment index and goes in the desired direction */
-    for (const RRNodeId& node_id : device_ctx.rr_graph.node_lookup().find_channel_nodes(start_lookup_x, start_lookup_y, rr_type)) {
+    for (const RRNodeId& node_id : node_lookup.find_channel_nodes(start_lookup_x, start_lookup_y, rr_type)) {
         VTR_ASSERT(temp_rr_graph.node_type(node_id) == rr_type);
 
         e_direction node_direction = rr_graph.node_direction(node_id);

vpr/src/route/router_lookahead_map_utils.cpp

@@ -377,6 +377,7 @@ t_src_opin_delays compute_router_src_opin_lookahead() {
 t_chan_ipins_delays compute_router_chan_ipin_lookahead() {
     vtr::ScopedStartFinishTimer timer("Computing chan/ipin lookahead");
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& node_lookup = device_ctx.rr_graph.node_lookup();
 
     t_chan_ipins_delays chan_ipins_delays;
 
@@ -404,7 +405,7 @@ t_chan_ipins_delays compute_router_chan_ipin_lookahead() {
         for (int ix = min_x; ix < max_x; ix++) {
             for (int iy = min_y; iy < max_y; iy++) {
                 for (auto rr_type : {CHANX, CHANY}) {
-                    for (const RRNodeId& node_id : device_ctx.rr_graph.node_lookup().find_channel_nodes(ix, iy, rr_type)) {
+                    for (const RRNodeId& node_id : node_lookup.find_channel_nodes(ix, iy, rr_type)) {
                         //Find the IPINs which are reachable from the wires within the bounding box
                         //around the selected tile location
                         dijkstra_flood_to_ipins(node_id, chan_ipins_delays);