Slight refactor

Author: Nathan Shreve

libs/libarchfpga/src/device_grid.h

@@ -75,7 +75,7 @@ class DeviceGrid {
     }
 
     ///@brief Returns a rectangle which represents the bounding box of the tile at the given location.
-    inline vtr::Rect<int> get_tile_bb(t_physical_tile_loc tile_loc) const {
+    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);
 
         int tile_xlow = tile_loc.x - get_width_offset(tile_loc);

libs/librrgraph/src/base/check_rr_graph.cpp

@@ -406,7 +406,7 @@ void check_rr_node(const RRGraphView& rr_graph,
                                 "in check_rr_node: node %d (type %d) is at an illegal clb location (%d, %d).\n", inode, rr_type, xlow, ylow);
             }
 
-            auto tile_bb = grid.get_tile_bb({xlow, ylow, layer_num});
+            vtr::Rect<int> tile_bb = grid.get_tile_bb({xlow, ylow, layer_num});
             if (xlow < tile_bb.xmin() || ylow < tile_bb.ymin() || xhigh > tile_bb.xmax() || yhigh > tile_bb.ymax()) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_rr_node: node %d (type %d) has endpoints (%d,%d) and (%d,%d)\n", inode, rr_type, xlow, ylow, xhigh, yhigh);

libs/librrgraph/src/base/rr_graph_utils.cpp

@@ -21,7 +21,7 @@ static void walk_cluster_recursive(const RRGraphView& rr_graph,
     VTR_ASSERT_SAFE(rr_graph.node_type(origin) == e_rr_type::SINK);
 
     // We want to go "backward" to the cluster IPINs connected to the origin node
-    auto incoming_edges = fanins[curr];
+    const std::vector<RREdgeId>& incoming_edges = fanins[curr];
     for (RREdgeId edge : incoming_edges) {
         RRNodeId parent = rr_graph.edge_src_node(edge);
         VTR_ASSERT_SAFE(parent != RRNodeId::INVALID());
@@ -133,7 +133,7 @@ vtr::vector<RRNodeId, std::vector<RREdgeId>> get_fan_in_list(const RRGraphView&
 }
 
 void rr_set_sink_locs(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder, const DeviceGrid& grid) {
-    auto node_fanins = get_fan_in_list(rr_graph);
+    const vtr::vector<RRNodeId, std::vector<RREdgeId>> node_fanins = get_fan_in_list(rr_graph);
 
     // Keep track of offsets for SINKs for each tile type, to avoid repeated calculations
     std::unordered_map<t_physical_tile_type_ptr, std::unordered_map<int, vtr::Point<int>>> physical_type_offsets;
@@ -160,7 +160,7 @@ void rr_set_sink_locs(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_buil
 
         t_physical_tile_loc tile_loc = {node_xlow, node_ylow, node_layer};
         t_physical_tile_type_ptr tile_type = grid.get_physical_type(tile_loc);
-        auto tile_bb = grid.get_tile_bb(tile_loc);
+        vtr::Rect<int> tile_bb = grid.get_tile_bb(tile_loc);
 
         // See if we have encountered this tile type/ptc combo before, and used saved offset if so
         vtr::Point<int> new_loc(-1, -1);

libs/librrgraph/src/base/rr_spatial_lookup.cpp

@@ -260,7 +260,7 @@ void RRSpatialLookup::add_node(RRNodeId node,
                                t_rr_type type,
                                int ptc,
                                e_side side) {
-    VTR_ASSERT(node); /* Must have a valid node id to be added */
+    VTR_ASSERT(node.is_valid()); /* Must have a valid node id to be added */
     VTR_ASSERT_SAFE(4 == rr_node_indices_[type].ndims());
 
     /* For non-IPIN/OPIN nodes, the side should always be the TOP side which follows the convention in find_node() API! */
@@ -286,7 +286,7 @@ bool RRSpatialLookup::remove_node(RRNodeId node,
                                   t_rr_type type,
                                   int ptc,
                                   e_side side) {
-    VTR_ASSERT(node);
+    VTR_ASSERT(node.is_valid());
     VTR_ASSERT_SAFE(4 == rr_node_indices_[type].ndims());
     VTR_ASSERT_SAFE(layer >= 0);
     VTR_ASSERT_SAFE(x >= 0);

vpr/src/route/check_route.cpp

@@ -303,7 +303,7 @@ static bool check_adjacent(RRNodeId from_node, RRNodeId to_node, bool is_flat) {
 
     // If to_node is SINK, use its tile coordinates
     if (to_type == SINK) {
-        auto tile_bb = device_ctx.grid.get_tile_bb({to_xlow, to_ylow, to_layer});
+        vtr::Rect<int> tile_bb = device_ctx.grid.get_tile_bb({to_xlow, to_ylow, to_layer});
 
         to_xlow = tile_bb.xmin();
         to_ylow = tile_bb.ymin();

vpr/src/route/connection_router.cpp

@@ -382,8 +382,8 @@ void ConnectionRouter<Heap>::timing_driven_expand_neighbours(t_heap* current,
     t_bb target_bb;
     if (target_node != RRNodeId::INVALID()) {
         if (rr_graph_->node_type(target_node) == SINK) { // We need to get a bounding box for the sink's entire tile
-            auto tile_bb = grid_.get_tile_bb({rr_graph_->node_xlow(target_node),
-                                              rr_graph_->node_ylow(target_node),
+            vtr::Rect<int> tile_bb = grid_.get_tile_bb({rr_graph_->node_xlow(target_node),
+                                                        rr_graph_->node_ylow(target_node),
                                               rr_graph_->node_layer(target_node)});
 
             target_bb.xmin = tile_bb.xmin();

vpr/src/route/route_common.cpp

@@ -459,9 +459,9 @@ static vtr::vector<ParentNetId, std::vector<RRNodeId>> load_net_rr_terminals(con
                                                          SOURCE,
                                                          iclass);
             } else {
-                auto tile_bb = grid.get_tile_bb({blk_loc.loc.x,
-                                                 blk_loc.loc.y,
-                                                 blk_loc.loc.layer});
+                vtr::Rect<int> tile_bb = grid.get_tile_bb({blk_loc.loc.x,
+                                                           blk_loc.loc.y,
+                                                           blk_loc.loc.layer});
                 std::vector<RRNodeId> sink_nodes = rr_graph.node_lookup().find_nodes_in_range(blk_loc.loc.layer,
                                                                                               tile_bb.xmin(),
                                                                                               tile_bb.ymin(),
@@ -721,9 +721,9 @@ t_bb load_net_route_bb(const Netlist<>& net_list,
         VTR_ASSERT(rr_graph.node_layer(sink_rr) >= 0);
         VTR_ASSERT(rr_graph.node_layer(sink_rr) <= device_ctx.grid.get_num_layers() - 1);
 
-        auto tile_bb = device_ctx.grid.get_tile_bb({rr_graph.node_xlow(sink_rr),
-                                                    rr_graph.node_ylow(sink_rr),
-                                                    rr_graph.node_layer(sink_rr)});
+        vtr::Rect<int> tile_bb = device_ctx.grid.get_tile_bb({rr_graph.node_xlow(sink_rr),
+                                                              rr_graph.node_ylow(sink_rr),
+                                                              rr_graph.node_layer(sink_rr)});
 
         xmin = std::min<int>(xmin, tile_bb.xmin());
         xmax = std::max<int>(xmax, tile_bb.xmax());