rr_nodes replacing by rr_graph

Author: umariqbal-rs

utils/route_diag/src/main.cpp

@@ -101,7 +101,7 @@ static void do_one_route(int source_node, int sink_node,
     ConnectionRouter<BinaryHeap> router(
             device_ctx.grid,
             *router_lookahead,
-            device_ctx.rr_nodes,
+            device_ctx.rr_graph.rr_nodes(),
             &device_ctx.rr_graph,
             device_ctx.rr_rc_data,
             device_ctx.rr_graph.rr_switch(),

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_graph_builder.size());
+    OveruseInfo overuse_info(device_ctx.rr_graph.num_nodes());
     pathfinder_update_acc_cost_and_overuse_info(router_opts.acc_fac, overuse_info);
 
     reserve_locally_used_opins(&small_heap, router_opts.initial_pres_fac,
@@ -505,9 +505,9 @@ static bool check_rr_graph_connectivity(RRNodeId prev_node, RRNodeId node) {
     if (prev_node == node) return false;
 
     auto& device_ctx = g_vpr_ctx.device();
-    const auto& rr_graph = device_ctx.rr_nodes;
+    const auto& rr_graph = device_ctx.rr_graph;
     /*TODO We need to remove temp_rr_graph once rr_graph is resolved*/
-    const auto& temp_rr_graph = device_ctx.rr_graph;
+    // const auto& temp_rr_graph = device_ctx.rr_graph;
     // If it's starting a new sub branch this is ok
     if (device_ctx.rr_graph.node_type(prev_node) == SINK) return true;
 
@@ -519,7 +519,7 @@ static bool check_rr_graph_connectivity(RRNodeId prev_node, RRNodeId node) {
 
         // If there are any non-configurable branches return true
         short edge_switch = rr_graph.edge_switch(edge);
-        if (!(temp_rr_graph.rr_switch_inf(RRSwitchId(edge_switch)).configurable())) return true;
+        if (!(rr_graph.rr_switch_inf(RRSwitchId(edge_switch)).configurable())) return true;
     }
 
     // If it's part of a non configurable node list, return true

vpr/src/device/rr_graph_builder.cpp

@@ -14,7 +14,7 @@ RRGraphBuilder::RRGraphBuilder(
     , rr_edge_metadata_(*rr_edge_metadata) {
 }
 
-t_rr_graph_storage& RRGraphBuilder::node_storage() {
+t_rr_graph_storage& RRGraphBuilder::rr_nodes() {
     return node_storage_;
 }
 

vpr/src/device/rr_graph_builder.h

@@ -37,7 +37,7 @@ class RRGraphBuilder {
     /* -- Mutators -- */
   public:
     /** @brief Return a writable object for rr_nodes */
-    t_rr_graph_storage& node_storage();
+    t_rr_graph_storage& rr_nodes();
     /** @brief Return a writable object for update the fast look-up of rr_node */
     RRSpatialLookup& node_lookup();
 
@@ -274,9 +274,12 @@ class RRGraphBuilder {
         node_storage_.init_fan_in();
     }
     /** @brief Return number of nodes. This function is inlined for runtime optimization. */
-    inline size_t size() const {
+    inline size_t num_nodes() const {
         return node_storage_.size();
     }
+    inline bool empty() const {
+        return node_storage_.empty();
+    }
 
     /* -- Internal data storage -- */
   private:

vpr/src/device/rr_graph_view.h

@@ -67,13 +67,17 @@ class RRGraphView {
      *      } 
      */
     inline vtr::StrongIdRange<RRNodeId> nodes() const {
-        return vtr::StrongIdRange<RRNodeId>(RRNodeId(0), RRNodeId(size()));
+        return vtr::StrongIdRange<RRNodeId>(RRNodeId(0), RRNodeId(num_nodes()));
     }
 
     /** @brief Return number of nodes. This function is inlined for runtime optimization. */
-    inline size_t size() const {
+    inline size_t num_nodes() const {
         return node_storage_.size();
     }
+    // Is the RR graph currently empty?
+    inline bool empty() const {
+        return node_storage_.empty();
+    }
 
     /** @brief Get the type of a routing resource node. This function is inlined for runtime optimization. */
     inline t_rr_type node_type(RRNodeId node) const {
@@ -154,6 +158,12 @@ class RRGraphView {
     inline RREdgeId node_last_edge(RRNodeId node) const {
         return node_storage_.last_edge(node);
     }
+    // Returns a range of RREdgeId's belonging to RRNodeId id.
+    //
+    // If this range is empty, then RRNodeId id has no edges.
+    inline vtr::StrongIdRange<RREdgeId> edge_range(const RRNodeId id) const {
+        return vtr::StrongIdRange<RREdgeId>(node_storage_.first_edge(id), node_storage_.last_edge(id));
+    }
 
     /** @brief Get the length (number of grid tile units spanned by the wire, including the endpoints) of a routing resource node.
      * node_length() only applies to CHANX or CHANY and is always a positive number
@@ -285,12 +295,19 @@ class RRGraphView {
     inline short edge_switch(RRNodeId id, t_edge_size iedge) const {
         return node_storage_.edge_switch(id, iedge);
     }
+    inline short edge_switch(const RREdgeId& edge) const {
+        return edge_switch_[edge];
+    }
+
     /** @brief Get the destination node for the iedge'th edge from specified RRNodeId.
      *  This method should generally not be used, and instead first_edge and
      *  last_edge should be used.*/
     inline RRNodeId edge_sink_node(RRNodeId id, t_edge_size iedge) const {
         return node_storage_.edge_sink_node(id, iedge);
     }
+    inline RRNodeId edge_sink_node(RREdgeId edge) const {
+        return edge_dest_node_[edge];
+    }
 
     /** @brief Get the number of configurable edges. This function is inlined for runtime optimization. */
     inline t_edge_size num_configurable_edges(RRNodeId node) const {
@@ -372,6 +389,7 @@ class RRGraphView {
     RRIndexedDataId node_cost_index(RRNodeId node) const {
         return node_storage_.node_cost_index(node);
     }
+
     /** @brief Return detailed routing segment information with a given id* @note The routing segments here may not be exactly same as those defined in architecture file. They have been
      * adapted to fit the context of routing resource graphs.
      */
@@ -419,15 +437,18 @@ class RRGraphView {
     const RRSpatialLookup& node_lookup() const {
         return node_lookup_;
     }
-
+    const t_rr_graph_storage& rr_nodes() const {
+        return node_storage_;
+    }
     /* -- Internal data storage -- */
     /* Note: only read-only object or data structures are allowed!!! */
   private:
     /* node-level storage including edge storages */
     const t_rr_graph_storage& node_storage_;
     /* Fast look-up for rr nodes */
     const RRSpatialLookup& node_lookup_;
-
+    const vtr::vector<RREdgeId, RRNodeId> edge_dest_node_;
+    const vtr::vector<RREdgeId, short> edge_switch_;
     /* rr_indexed_data_ and rr_segments_ are needed to lookup the segment information in  node_coordinate_to_string() */
     const vtr::vector<RRIndexedDataId, t_rr_indexed_data>& rr_indexed_data_;
 

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_graph_builder.size() * sizeof(t_draw_rr_node));
+        device_ctx.rr_graph.num_nodes() * sizeof(t_draw_rr_node));
 
     draw_state->arch_info = arch;
 
@@ -980,10 +980,10 @@ 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_graph_builder.size() != 0) {
+    if (rr_graph.num_nodes() != 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));
+            (rr_graph.num_nodes()) * sizeof(t_draw_rr_node));
         /*FIXME: the type cast should be eliminated by making draw_rr_node adapt RRNodeId */
         for (const RRNodeId& rr_id : rr_graph.nodes()) {
             draw_state->draw_rr_node[(size_t)rr_id].color = DEFAULT_RR_NODE_COLOR;
@@ -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_graph_builder.size(), 0.);
+    std::vector<float> rr_node_costs(device_ctx.rr_graph.num_nodes(), 0.);
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         float cost = 0.;
@@ -1694,7 +1694,7 @@ static void draw_rr_edges(int inode, ezgl::renderer* g) {
         to_node = size_t(rr_graph.edge_sink_node(rr_node, iedge));
         to_type = rr_graph.node_type(RRNodeId(to_node));
         to_ptc_num = rr_graph.node_ptc_num(RRNodeId(to_node));
-        bool edge_configurable = device_ctx.rr_nodes[inode].edge_is_configurable(iedge);
+        bool edge_configurable = rr_graph.rr_nodes()[inode].edge_is_configurable(iedge);
 
         switch (from_type) {
             case OPIN:
@@ -2288,7 +2288,7 @@ static void draw_rr_pin(int inode, const ezgl::color& color, ezgl::renderer* g)
  * the physical pin is on.                                                  */
 void draw_get_rr_pin_coords(int inode, float* xcen, float* ycen, const e_side& pin_side) {
     auto& device_ctx = g_vpr_ctx.device();
-    draw_get_rr_pin_coords(device_ctx.rr_nodes[inode], xcen, ycen, pin_side);
+    draw_get_rr_pin_coords(device_ctx.rr_graph.rr_nodes()[inode], xcen, ycen, pin_side);
 }
 
 void draw_get_rr_pin_coords(const t_rr_node& node, float* xcen, float* ycen, const e_side& pin_side) {
@@ -2357,7 +2357,7 @@ static void draw_rr_src_sink(int inode, ezgl::color color, ezgl::renderer* g) {
     const auto& rr_graph = device_ctx.rr_graph;
 
     float xcen, ycen;
-    draw_get_rr_src_sink_coords(device_ctx.rr_nodes[inode], &xcen, &ycen);
+    draw_get_rr_src_sink_coords(rr_graph.rr_nodes()[inode], &xcen, &ycen);
 
     g->set_color(color);
 
@@ -2786,7 +2786,7 @@ static int draw_check_rr_node_hit(float click_x, float click_y) {
             case SOURCE:
             case SINK: {
                 float xcen, ycen;
-                draw_get_rr_src_sink_coords(device_ctx.rr_nodes[inode], &xcen, &ycen);
+                draw_get_rr_src_sink_coords(device_ctx.rr_graph.rr_nodes()[inode], &xcen, &ycen);
 
                 // Now check if we clicked on this pin
                 if (click_x >= xcen - draw_coords->pin_size && click_x <= xcen + draw_coords->pin_size && click_y >= ycen - draw_coords->pin_size && click_y <= ycen + draw_coords->pin_size) {
@@ -2829,7 +2829,7 @@ void draw_expand_non_configurable_rr_nodes_recurr(int from_node,
 
     for (t_edge_size iedge = 0;
          iedge < rr_graph.num_edges(RRNodeId(from_node)); ++iedge) {
-        bool edge_configurable = device_ctx.rr_nodes[from_node].edge_is_configurable(iedge);
+        bool edge_configurable = rr_graph.rr_nodes()[from_node].edge_is_configurable(iedge);
         int to_node = size_t(rr_graph.edge_sink_node(RRNodeId(from_node), iedge));
 
         if (!edge_configurable && !expanded_nodes.count(to_node)) {
@@ -3355,7 +3355,7 @@ static void draw_pin_to_sink(int ipin_node, int sink_node, ezgl::renderer* g) {
         draw_get_rr_pin_coords(ipin_node, &x1, &y1, pin_side);
 
         float x2 = 0, y2 = 0;
-        draw_get_rr_src_sink_coords(device_ctx.rr_nodes[sink_node], &x2, &y2);
+        draw_get_rr_src_sink_coords(rr_graph.rr_nodes()[sink_node], &x2, &y2);
 
         g->draw_line({x1, y1}, {x2, y2});
 
@@ -3370,7 +3370,7 @@ static void draw_source_to_pin(int source_node, int opin_node, ezgl::renderer* g
     const auto& rr_graph = device_ctx.rr_graph;
 
     float x1 = 0, y1 = 0;
-    draw_get_rr_src_sink_coords(device_ctx.rr_nodes[source_node], &x1, &y1);
+    draw_get_rr_src_sink_coords(rr_graph.rr_nodes()[source_node], &x1, &y1);
 
     /* Draw the line for each ipin on different sides */
     for (const e_side& pin_side : SIDES) {
@@ -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_graph_builder.size());
+    std::vector<float> rr_costs(device_ctx.rr_graph.num_nodes());
 
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         float cost = get_router_expansion_cost(
@@ -4198,11 +4198,11 @@ 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_graph_builder.size());
+    VTR_ASSERT(rr_costs.size() == rr_graph.num_nodes());
 
     float min_cost = std::numeric_limits<float>::infinity();
     float max_cost = -min_cost;
-    for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
+    for (const RRNodeId& rr_id : rr_graph.nodes()) {
         if (std::isnan(rr_costs[(size_t)rr_id])) continue;
 
         min_cost = std::min(min_cost, rr_costs[(size_t)rr_id]);
@@ -4214,7 +4214,7 @@ static void draw_rr_costs(ezgl::renderer* g, const std::vector<float>& rr_costs,
 
     //Draw the nodes in ascending order of value, this ensures high valued nodes
     //are not overdrawn by lower value ones (e.g-> when zoomed-out far)
-    std::vector<int> nodes(device_ctx.rr_nodes.size());
+    std::vector<int> nodes(rr_graph.num_nodes());
     std::iota(nodes.begin(), nodes.end(), 0);
     auto cmp_ascending_cost = [&](int lhs_node, int rhs_node) {
         if (lowest_cost_first) {

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_graph_builder.size())) {
+        if (rr_node_id < 0 || rr_node_id >= int(device_ctx.rr_graph.num_nodes())) {
             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_graph_builder.size());
+            VTR_ASSERT((size_t)rr_node < device_ctx.rr_graph.num_nodes());
 
             /* 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,9 +1192,9 @@ 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_graph_builder.size(),
+    rr_node_power = (t_rr_node_power*)vtr::calloc(rr_graph.num_nodes(),
                                                   sizeof(t_rr_node_power));
-    for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
+    for (const RRNodeId& rr_id : rr_graph.nodes()) {
         rr_node_power[(size_t)rr_id].driver_switch_type = OPEN;
     }
 
@@ -1203,7 +1203,7 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
     max_IPIN_fanin = 0;
     max_seg_to_seg_fanout = 0;
     max_seg_to_IPIN_fanout = 0;
-    for (const RRNodeId& rr_node_idx : device_ctx.rr_graph.nodes()) {
+    for (const RRNodeId& rr_node_idx : rr_graph.nodes()) {
         t_edge_size fanout_to_IPIN = 0;
         t_edge_size fanout_to_seg = 0;
         t_rr_node_power* node_power = &rr_node_power[size_t(rr_node_idx)];
@@ -1253,7 +1253,7 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
 #endif
 
     /* Populate driver switch type */
-    for (const RRNodeId& rr_node_idx : device_ctx.rr_graph.nodes()) {
+    for (const RRNodeId& rr_node_idx : rr_graph.nodes()) {
         for (t_edge_size edge_idx = 0; edge_idx < rr_graph.num_edges(rr_node_idx); edge_idx++) {
             if (size_t(rr_graph.edge_sink_node(rr_node_idx, edge_idx))) {
                 if (rr_node_power[size_t(rr_graph.edge_sink_node(rr_node_idx, edge_idx))].driver_switch_type == OPEN) {
@@ -1355,7 +1355,7 @@ bool power_uninit() {
     auto& power_ctx = g_vpr_ctx.power();
     bool error = false;
 
-    for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
+    for (const RRNodeId& rr_id : rr_graph.nodes()) {
         t_rr_node_power* node_power = &rr_node_power[(size_t)rr_id];
 
         switch (rr_graph.node_type(rr_id)) {

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_graph_builder.size(), ClusterNetId::INVALID());
+    rr_node_nets.resize(rr_graph.num_nodes(), ClusterNetId::INVALID());
 
     for (auto net_id : clustering_ctx.clb_nlist.nets()) {
         if (clustering_ctx.clb_nlist.net_is_ignored(net_id)) {
@@ -52,7 +52,7 @@ vtr::vector<RRNodeId, ClusterNetId> annotate_rr_node_nets(const DeviceContext& d
                  * whose capacity is 1 
                  */
                 if ((rr_node_nets[rr_node])
-                    && (1 == device_ctx.rr_nodes.node_capacity(rr_node))
+                    && (1 == device_ctx.rr_graph.node_capacity(rr_node))
                     && (net_id != rr_node_nets[rr_node])) {
                     VPR_FATAL_ERROR(VPR_ERROR_ANALYSIS,
                                     "Detect two nets '%s' and '%s' that are mapped to the same rr_node '%ld'!\n%s\n",

vpr/src/route/check_route.cpp

@@ -74,8 +74,8 @@ 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_graph_builder.size());
-    std::fill_n(connected_to_route.get(), device_ctx.rr_nodes.size(), false);
+    auto connected_to_route = std::make_unique<bool[]>(device_ctx.rr_graph.num_nodes());
+    std::fill_n(connected_to_route.get(), device_ctx.rr_graph.num_nodes(), false);
 
     max_pins = 0;
     for (auto net_id : cluster_ctx.clb_nlist.nets())
@@ -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_graph_builder.size());
+                VTR_ASSERT(inode >= 0 && inode < (ssize_t)device_ctx.rr_graph.num_nodes());
                 route_ctx.rr_node_route_inf[inode].set_occ(route_ctx.rr_node_route_inf[inode].occ() + 1);
             }
         }
@@ -592,9 +592,9 @@ 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_graph_builder.size()) {
+    if (inode < 0 || inode >= (int)device_ctx.rr_graph.num_nodes()) {
         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);
+                        "in check_node_and_range: rr_node #%d is out of legal, range (0 to %d).\n", inode, device_ctx.rr_graph.num_nodes() - 1);
     }
     check_rr_node(inode, route_type, device_ctx);
 }