size in rr_graph_builder

Author: umariqbal-rs

vpr/src/base/read_route.cpp

@@ -126,7 +126,7 @@ bool read_route(const char* route_file, const t_router_opts& router_opts, bool v
     recompute_occupancy_from_scratch();
 
     /* Note: This pres_fac is not necessarily correct since it isn't the first routing iteration*/
-    OveruseInfo overuse_info(device_ctx.rr_nodes.size());
+    OveruseInfo overuse_info(device_ctx.rr_graph_builder.size());
     pathfinder_update_acc_cost_and_overuse_info(router_opts.acc_fac, overuse_info);
 
     reserve_locally_used_opins(&small_heap, router_opts.initial_pres_fac,

vpr/src/base/vpr_context.h

@@ -163,7 +163,7 @@ struct DeviceContext : public Context {
     /* A writeable view of routing resource graph to be the ONLY database 
      * for routing resource graph builder functions.
      */
-    RRGraphBuilder rr_graph_builder{&rr_nodes, &rr_node_metadata, &rr_edge_metadata};
+    RRGraphBuilder rr_graph_builder{&rr_node_metadata, &rr_edge_metadata};
 
     /* A read-only view of routing resource graph to be the ONLY database 
      * for client functions: GUI, placer, router, timing analyzer etc.

vpr/src/device/rr_graph_builder.cpp

@@ -7,11 +7,10 @@
 
 //#include "globals.h"
 
-RRGraphBuilder::RRGraphBuilder(t_rr_graph_storage* node_storage,
-                               MetadataStorage<int>* rr_node_metadata,
-                               MetadataStorage<std::tuple<int, int, short>>* rr_edge_metadata)
-    : node_storage_(*node_storage)
-    , rr_node_metadata_(*rr_node_metadata)
+RRGraphBuilder::RRGraphBuilder(
+    MetadataStorage<int>* rr_node_metadata,
+    MetadataStorage<std::tuple<int, int, short>>* rr_edge_metadata)
+    : rr_node_metadata_(*rr_node_metadata)
     , rr_edge_metadata_(*rr_edge_metadata) {
 }
 

vpr/src/device/rr_graph_builder.h

@@ -21,9 +21,9 @@ class RRGraphBuilder {
     /* -- Constructors -- */
   public:
     /* See detailed comments about the data structures in the internal data storage section of this file */
-    RRGraphBuilder(t_rr_graph_storage* node_storage,
-                   MetadataStorage<int>* rr_node_metadata,
-                   MetadataStorage<std::tuple<int, int, short>>* rr_edge_metadata);
+    RRGraphBuilder(
+        MetadataStorage<int>* rr_node_metadata,
+        MetadataStorage<std::tuple<int, int, short>>* rr_edge_metadata);
 
     /* Disable copy constructors and copy assignment operator
      * This is to avoid accidental copy because it could be an expensive operation considering that the 
@@ -273,6 +273,10 @@ class RRGraphBuilder {
     inline void init_fan_in() {
         node_storage_.init_fan_in();
     }
+    /** @brief Return number of nodes. This function is inlined for runtime optimization. */
+    inline size_t size() const {
+        return node_storage_.size();
+    }
 
     /* -- Internal data storage -- */
   private:
@@ -286,7 +290,7 @@ class RRGraphBuilder {
      * That explains why the reference is used here temporarily
      */
     /* node-level storage including edge storages */
-    t_rr_graph_storage& node_storage_;
+    t_rr_graph_storage node_storage_;
     /* Fast look-up for rr nodes */
     RRSpatialLookup node_lookup_;
 

vpr/src/draw/draw.cpp

@@ -929,7 +929,7 @@ void alloc_draw_structs(const t_arch* arch) {
     /* Space is allocated for draw_rr_node but not initialized because we do *
      * not yet know information about the routing resources.				  */
     draw_state->draw_rr_node = (t_draw_rr_node*)vtr::malloc(
-        device_ctx.rr_nodes.size() * sizeof(t_draw_rr_node));
+        device_ctx.rr_graph_builder.size() * sizeof(t_draw_rr_node));
 
     draw_state->arch_info = arch;
 
@@ -980,7 +980,7 @@ void init_draw_coords(float width_val) {
         return; //do not initialize only if --disp off and --save_graphics off
     /* Each time routing is on screen, need to reallocate the color of each *
      * rr_node, as the number of rr_nodes may change.						*/
-    if (device_ctx.rr_nodes.size() != 0) {
+    if (device_ctx.rr_graph_builder.size() != 0) {
         draw_state->draw_rr_node = (t_draw_rr_node*)vtr::realloc(
             draw_state->draw_rr_node,
             (device_ctx.rr_nodes.size()) * sizeof(t_draw_rr_node));
@@ -1310,7 +1310,7 @@ static void draw_routing_costs(ezgl::renderer* g) {
 
     float min_cost = std::numeric_limits<float>::infinity();
     float max_cost = -min_cost;
-    std::vector<float> rr_node_costs(device_ctx.rr_nodes.size(), 0.);
+    std::vector<float> rr_node_costs(device_ctx.rr_graph_builder.size(), 0.);
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         float cost = 0.;
@@ -4141,7 +4141,7 @@ static void draw_router_expansion_costs(ezgl::renderer* g) {
     auto& device_ctx = g_vpr_ctx.device();
     auto& routing_ctx = g_vpr_ctx.routing();
 
-    std::vector<float> rr_costs(device_ctx.rr_nodes.size());
+    std::vector<float> rr_costs(device_ctx.rr_graph_builder.size());
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         float cost = get_router_expansion_cost(
@@ -4198,7 +4198,7 @@ static void draw_rr_costs(ezgl::renderer* g, const std::vector<float>& rr_costs,
                        || draw_state->show_router_expansion_cost == DRAW_ROUTER_EXPANSION_COST_KNOWN_WITH_EDGES
                        || draw_state->show_router_expansion_cost == DRAW_ROUTER_EXPANSION_COST_EXPECTED_WITH_EDGES);
 
-    VTR_ASSERT(rr_costs.size() == device_ctx.rr_nodes.size());
+    VTR_ASSERT(rr_costs.size() == device_ctx.rr_graph_builder.size());
 
     float min_cost = std::numeric_limits<float>::infinity();
     float max_cost = -min_cost;

vpr/src/draw/search_bar.cpp

@@ -68,7 +68,7 @@ void search_and_highlight(GtkWidget* /*widget*/, ezgl::application* app) {
         ss >> rr_node_id;
 
         // valid rr node id check
-        if (rr_node_id < 0 || rr_node_id >= int(device_ctx.rr_nodes.size())) {
+        if (rr_node_id < 0 || rr_node_id >= int(device_ctx.rr_graph_builder.size())) {
             warning_dialog_box("Invalid RR Node ID");
             app->refresh_drawing();
             return;

vpr/src/pack/post_routing_pb_pin_fixup.cpp

@@ -159,7 +159,7 @@ static void update_cluster_pin_with_post_routing_results(const DeviceContext& de
             if (!rr_node) {
                 continue;
             }
-            VTR_ASSERT((size_t)rr_node < device_ctx.rr_nodes.size());
+            VTR_ASSERT((size_t)rr_node < device_ctx.rr_graph_builder.size());
 
             /* If the node has been visited on the other side, we just skip it */
             if (visited_rr_nodes.end() != std::find(visited_rr_nodes.begin(), visited_rr_nodes.end(), RRNodeId(rr_node))) {

vpr/src/power/power.cpp

@@ -1192,7 +1192,7 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
     }
 
     /* Initialize RR Graph Structures */
-    rr_node_power = (t_rr_node_power*)vtr::calloc(device_ctx.rr_nodes.size(),
+    rr_node_power = (t_rr_node_power*)vtr::calloc(device_ctx.rr_graph_builder.size(),
                                                   sizeof(t_rr_node_power));
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         rr_node_power[(size_t)rr_id].driver_switch_type = OPEN;

vpr/src/route/annotate_routing.cpp

@@ -28,7 +28,7 @@ vtr::vector<RRNodeId, ClusterNetId> annotate_rr_node_nets(const DeviceContext& d
     const auto& rr_graph = device_ctx.rr_graph;
 
     vtr::vector<RRNodeId, ClusterNetId> rr_node_nets;
-    rr_node_nets.resize(device_ctx.rr_nodes.size(), ClusterNetId::INVALID());
+    rr_node_nets.resize(device_ctx.rr_graph_builder.size(), ClusterNetId::INVALID());
 
     for (auto net_id : clustering_ctx.clb_nlist.nets()) {
         if (clustering_ctx.clb_nlist.net_is_ignored(net_id)) {

vpr/src/route/check_route.cpp

@@ -74,7 +74,7 @@ void check_route(enum e_route_type route_type, e_check_route_option check_route_
 
     check_locally_used_clb_opins(route_ctx.clb_opins_used_locally, route_type);
 
-    auto connected_to_route = std::make_unique<bool[]>(device_ctx.rr_nodes.size());
+    auto connected_to_route = std::make_unique<bool[]>(device_ctx.rr_graph_builder.size());
     std::fill_n(connected_to_route.get(), device_ctx.rr_nodes.size(), false);
 
     max_pins = 0;
@@ -536,7 +536,7 @@ void recompute_occupancy_from_scratch() {
             /* Will always be 0 for pads or SINK classes. */
             for (ipin = 0; ipin < num_local_opins; ipin++) {
                 inode = route_ctx.clb_opins_used_locally[blk_id][iclass][ipin];
-                VTR_ASSERT(inode >= 0 && inode < (ssize_t)device_ctx.rr_nodes.size());
+                VTR_ASSERT(inode >= 0 && inode < (ssize_t)device_ctx.rr_graph_builder.size());
                 route_ctx.rr_node_route_inf[inode].set_occ(route_ctx.rr_node_route_inf[inode].occ() + 1);
             }
         }
@@ -592,7 +592,7 @@ static void check_node_and_range(int inode, enum e_route_type route_type) {
 
     auto& device_ctx = g_vpr_ctx.device();
 
-    if (inode < 0 || inode >= (int)device_ctx.rr_nodes.size()) {
+    if (inode < 0 || inode >= (int)device_ctx.rr_graph_builder.size()) {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                         "in check_node_and_range: rr_node #%d is out of legal, range (0 to %d).\n", inode, device_ctx.rr_nodes.size() - 1);
     }

vpr/src/route/check_rr_graph.cpp

@@ -50,7 +50,7 @@ void check_rr_graph(const t_graph_type graph_type,
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
-    auto total_edges_to_node = std::vector<int>(device_ctx.rr_nodes.size());
+    auto total_edges_to_node = std::vector<int>(device_ctx.rr_graph_builder.size());
     auto switch_types_from_current_to_node = std::vector<unsigned char>(device_ctx.rr_nodes.size());
     const int num_rr_switches = rr_graph.num_rr_switches();
 

vpr/src/route/route_breadth_first.cpp

@@ -72,7 +72,7 @@ bool try_breadth_first_route(const t_router_opts& router_opts) {
     BinaryHeap heap;
     heap.init_heap(device_ctx.grid);
 
-    OveruseInfo overuse_info(device_ctx.rr_nodes.size());
+    OveruseInfo overuse_info(device_ctx.rr_graph_builder.size());
 
     for (itry = 1; itry <= router_opts.max_router_iterations; itry++) {
         VTR_LOG("Routing Iteration %d\n", itry);

vpr/src/route/route_common.cpp

@@ -369,7 +369,7 @@ std::vector<std::set<ClusterNetId>> collect_rr_node_nets() {
     auto& route_ctx = g_vpr_ctx.routing();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
-    std::vector<std::set<ClusterNetId>> rr_node_nets(device_ctx.rr_nodes.size());
+    std::vector<std::set<ClusterNetId>> rr_node_nets(device_ctx.rr_graph_builder.size());
     for (ClusterNetId inet : cluster_ctx.clb_nlist.nets()) {
         t_trace* trace_elem = route_ctx.trace[inet].head;
         while (trace_elem) {
@@ -941,7 +941,7 @@ void alloc_and_load_rr_node_route_structs() {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     auto& device_ctx = g_vpr_ctx.device();
 
-    route_ctx.rr_node_route_inf.resize(device_ctx.rr_nodes.size());
+    route_ctx.rr_node_route_inf.resize(device_ctx.rr_graph_builder.size());
     route_ctx.non_configurable_bitset.resize(device_ctx.rr_nodes.size());
     route_ctx.non_configurable_bitset.fill(false);
 
@@ -959,7 +959,7 @@ void reset_rr_node_route_structs() {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     auto& device_ctx = g_vpr_ctx.device();
 
-    VTR_ASSERT(route_ctx.rr_node_route_inf.size() == size_t(device_ctx.rr_nodes.size()));
+    VTR_ASSERT(route_ctx.rr_node_route_inf.size() == size_t(device_ctx.rr_graph_builder.size()));
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         auto& node_inf = route_ctx.rr_node_route_inf[(size_t)rr_id];
@@ -1401,7 +1401,7 @@ void reserve_locally_used_opins(HeapInterface* heap, float pres_fac, float acc_f
                 /* Always 0 for pads and for RECEIVER (IPIN) classes */
                 for (ipin = 0; ipin < num_local_opin; ipin++) {
                     inode = route_ctx.clb_opins_used_locally[blk_id][iclass][ipin];
-                    VTR_ASSERT(inode >= 0 && inode < (ssize_t)device_ctx.rr_nodes.size());
+                    VTR_ASSERT(inode >= 0 && inode < (ssize_t)device_ctx.rr_graph_builder.size());
                     adjust_one_rr_occ_and_acc_cost(inode, -1, acc_fac);
                 }
             }

vpr/src/route/route_timing.cpp

@@ -322,7 +322,7 @@ bool try_timing_driven_route_tmpl(const t_router_opts& router_opts,
      */
     bool routing_is_successful = false;
     WirelengthInfo wirelength_info;
-    OveruseInfo overuse_info(device_ctx.rr_nodes.size());
+    OveruseInfo overuse_info(device_ctx.rr_graph_builder.size());
     tatum::TimingPathInfo critical_path;
     int itry; //Routing iteration number
     int itry_conflicted_mode = 0;

vpr/src/route/route_tree_timing.cpp

@@ -80,7 +80,7 @@ bool alloc_route_tree_timing_structs(bool exists_ok) {
     /* Allocates any structures needed to build the routing trees. */
 
     auto& device_ctx = g_vpr_ctx.device();
-    bool route_tree_structs_are_allocated = (rr_node_to_rt_node.size() == size_t(device_ctx.rr_nodes.size())
+    bool route_tree_structs_are_allocated = (rr_node_to_rt_node.size() == size_t(device_ctx.rr_graph_builder.size())
                                              || rt_node_free_list != nullptr);
     if (route_tree_structs_are_allocated) {
         if (exists_ok) {

vpr/src/route/router_delay_profiling.cpp

@@ -100,7 +100,7 @@ std::vector<float> calculate_all_path_delays_from_rr_node(int src_rr_node, const
     auto& device_ctx = g_vpr_ctx.device();
     auto& routing_ctx = g_vpr_ctx.mutable_routing();
 
-    std::vector<float> path_delays_to(device_ctx.rr_nodes.size(), std::numeric_limits<float>::quiet_NaN());
+    std::vector<float> path_delays_to(device_ctx.rr_graph_builder.size(), std::numeric_limits<float>::quiet_NaN());
 
     t_rt_node* rt_root = setup_routing_resources_no_net(src_rr_node);
 

vpr/src/route/router_lookahead_extended_map.cpp

@@ -438,8 +438,8 @@ void ExtendedMapLookahead::compute(const std::vector<t_segment_inf>& segment_inf
         util::RoutingCosts delay_costs;
         util::RoutingCosts base_costs;
         int total_path_count = 0;
-        std::vector<bool> node_expanded(device_ctx.rr_nodes.size());
-        std::vector<util::Search_Path> paths(device_ctx.rr_nodes.size());
+        std::vector<bool> node_expanded(device_ctx.rr_graph_builder.size());
+        std::vector<util::Search_Path> paths(device_ctx.rr_graph_builder.size());
 
         // Each point in a sample region contains a set of nodes. Each node becomes a starting node
         // for the dijkstra expansions, and different paths are explored to reach different locations.

vpr/src/route/router_lookahead_map.cpp

@@ -588,7 +588,7 @@ static void run_dijkstra(RRNodeId start_node, int start_x, int start_y, t_routin
     const auto& rr_graph = device_ctx.rr_graph;
 
     auto& node_expanded = data->node_expanded;
-    node_expanded.resize(device_ctx.rr_nodes.size());
+    node_expanded.resize(device_ctx.rr_graph_builder.size());
     std::fill(node_expanded.begin(), node_expanded.end(), false);
 
     auto& node_visited_costs = data->node_visited_costs;

vpr/src/route/rr_graph_area.cpp

@@ -145,7 +145,7 @@ void count_bidir_routing_transistors(int num_switch, int wire_to_ipin_switch, fl
         trans_track_to_cblock_buf = 0;
     }
 
-    num_inputs_to_cblock = (int*)vtr::calloc(device_ctx.rr_nodes.size(), sizeof(int));
+    num_inputs_to_cblock = (int*)vtr::calloc(device_ctx.rr_graph_builder.size(), sizeof(int));
 
     maxlen = std::max(device_ctx.grid.width(), device_ctx.grid.height());
     cblock_counted = (bool*)vtr::calloc(maxlen, sizeof(bool));
@@ -319,7 +319,7 @@ void count_unidir_routing_transistors(std::vector<t_segment_inf>& /*segment_inf*
      * switches of all rr nodes. Thus we keep track of which muxes we have already
      * counted via the variable below. */
     bool* chan_node_switch_done;
-    chan_node_switch_done = (bool*)vtr::calloc(device_ctx.rr_nodes.size(), sizeof(bool));
+    chan_node_switch_done = (bool*)vtr::calloc(device_ctx.rr_graph_builder.size(), sizeof(bool));
 
     /* The variable below is an accumulator variable that will add up all the   *
      * transistors in the routing.  Make double so that it doesn't stop         *

vpr/src/route/rr_graph_timing_params.cpp

@@ -45,7 +45,7 @@ void add_rr_graph_C_from_switches(float C_ipin_cblock) {
     cblock_counted = (bool*)vtr::calloc(maxlen, sizeof(bool));
     buffer_Cin = (float*)vtr::calloc(maxlen, sizeof(float));
 
-    std::vector<float> rr_node_C(device_ctx.rr_nodes.size(), 0.); //Stores the final C
+    std::vector<float> rr_node_C(device_ctx.rr_graph_builder.size(), 0.); //Stores the final C
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         size_t inode = (size_t)rr_id;
@@ -172,7 +172,7 @@ void add_rr_graph_C_from_switches(float C_ipin_cblock) {
      * Current structures only keep switch information from a node to the next node and
      * not the reverse.  Therefore I need to go through all the possible edges to figure
      * out what the Cout's should be */
-    Couts_to_add = (float*)vtr::calloc(device_ctx.rr_nodes.size(), sizeof(float));
+    Couts_to_add = (float*)vtr::calloc(device_ctx.rr_graph_builder.size(), sizeof(float));
     for (const RRNodeId& inode : device_ctx.rr_graph.nodes()) {
         for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(inode); iedge++) {
             switch_index = rr_graph.edge_switch(inode, iedge);

vpr/src/util/vpr_utils.cpp

@@ -1799,7 +1799,7 @@ void print_switch_usage() {
     switch_fanin_delay = new std::map<int, float>[device_ctx.num_arch_switches];
     // a node can have multiple inward switches, so
     // map key: switch index; map value: count (fanin)
-    std::map<int, int>* inward_switch_inf = new std::map<int, int>[device_ctx.rr_nodes.size()];
+    std::map<int, int>* inward_switch_inf = new std::map<int, int>[device_ctx.rr_graph_builder.size()];
     for (const RRNodeId& inode : device_ctx.rr_graph.nodes()) {
         int num_edges = rr_graph.num_edges(inode);
         for (int iedge = 0; iedge < num_edges; iedge++) {

vpr/test/test_vpr.cpp

@@ -183,8 +183,8 @@ TEST_CASE("read_rr_graph_metadata", "[vpr]") {
     const auto& device_ctx = g_vpr_ctx.device();
 
     // recompute ordering from 'random_shuffle'
-    std::vector<int> src_order(device_ctx.rr_nodes.size()); // new id -> old id
-    std::iota(src_order.begin(), src_order.end(), 0);       // Initialize to [0, 1, 2 ...]
+    std::vector<int> src_order(device_ctx.rr_graph_builder.size()); // new id -> old id
+    std::iota(src_order.begin(), src_order.end(), 0);               // Initialize to [0, 1, 2 ...]
     std::mt19937 g(1);
     std::shuffle(src_order.begin(), src_order.end(), g);