Merge pull request #1799 from ethanroj23/rr_graph_node_fan_in

RRGraphView::node_fan_in() Implementation

Author: vaughnbetz

vpr/src/device/rr_graph_view.h

@@ -77,6 +77,11 @@ class RRGraphView {
         return node_storage_.node_direction_string(node);
     }
 
+    /* Get the fan in of a routing resource node. This function is inlined for runtime optimization. */
+    inline t_edge_size node_fan_in(RRNodeId node) const {
+        return node_storage_.fan_in(node);
+    }
+
     /* Return the fast look-up data structure for queries from client functions */
     const RRSpatialLookup& node_lookup() const {
         return node_lookup_;

vpr/src/draw/draw.cpp

@@ -1503,7 +1503,7 @@ static void draw_rr_chan(int inode, const ezgl::color color, ezgl::renderer* g)
         if (switchpoint_min == 0) {
             if (dir != Direction::BIDIR) {
                 //Draw a mux at the start of each wire, labelled with it's size (#inputs)
-                draw_mux_with_size(start, mux_dir, WIRE_DRAWING_WIDTH, device_ctx.rr_nodes[inode].fan_in(), g);
+                draw_mux_with_size(start, mux_dir, WIRE_DRAWING_WIDTH, rr_graph.node_fan_in(RRNodeId(inode)), g);
             }
         } else {
             //Draw arrows and label with switch point
@@ -1529,7 +1529,7 @@ static void draw_rr_chan(int inode, const ezgl::color color, ezgl::renderer* g)
         if (switchpoint_max == 0) {
             if (dir != Direction::BIDIR) {
                 //Draw a mux at the start of each wire, labelled with it's size (#inputs)
-                draw_mux_with_size(start, mux_dir, WIRE_DRAWING_WIDTH, device_ctx.rr_nodes[inode].fan_in(), g);
+                draw_mux_with_size(start, mux_dir, WIRE_DRAWING_WIDTH, rr_graph.node_fan_in(RRNodeId(inode)), g);
             }
         } else {
             //Draw arrows and label with switch point

vpr/src/power/power.cpp

@@ -824,26 +824,26 @@ static void power_usage_routing(t_power_usage* power_usage,
             for (t_edge_size edge_idx = 0; edge_idx < node.num_edges(); edge_idx++) {
                 const auto& next_node_id = node.edge_sink_node(edge_idx);
                 if (next_node_id != OPEN) {
-                    auto next_node = device_ctx.rr_nodes[next_node_id];
                     t_rr_node_power* next_node_power = &rr_node_power[next_node_id];
 
                     switch (rr_graph.node_type(RRNodeId(next_node_id))) {
                         case CHANX:
                         case CHANY:
-                        case IPIN:
+                        case IPIN: {
                             if (next_node_power->net_num == node_power->net_num) {
                                 next_node_power->selected_input = next_node_power->num_inputs;
                             }
                             next_node_power->in_dens[next_node_power->num_inputs] = clb_net_density(node_power->net_num);
                             next_node_power->in_prob[next_node_power->num_inputs] = clb_net_prob(node_power->net_num);
                             next_node_power->num_inputs++;
-                            if (next_node_power->num_inputs > next_node.fan_in()) {
+                            const t_edge_size next_node_fan_in = rr_graph.node_fan_in(RRNodeId(next_node_id));
+                            if (next_node_power->num_inputs > next_node_fan_in) {
                                 VTR_LOG("%d %d\n", next_node_power->num_inputs,
-                                        next_node.fan_in());
+                                        next_node_fan_in);
                                 fflush(nullptr);
                                 VTR_ASSERT(0);
                             }
-                            break;
+                        } break;
                         default:
                             /* Do nothing */
                             break;
@@ -865,6 +865,7 @@ static void power_usage_routing(t_power_usage* power_usage,
         int switchbox_fanout;
         //float C_per_seg_split;
         int wire_length;
+        const t_edge_size node_fan_in = rr_graph.node_fan_in(RRNodeId(rr_node_idx));
 
         switch (rr_graph.node_type(RRNodeId(rr_node_idx))) {
             case SOURCE:
@@ -877,13 +878,13 @@ static void power_usage_routing(t_power_usage* power_usage,
                  *  - Driver (accounted for at end of CHANX/Y - see below)
                  *  - Multiplexor */
 
-                if (node.fan_in()) {
+                if (node_fan_in) {
                     VTR_ASSERT(node_power->in_dens);
                     VTR_ASSERT(node_power->in_prob);
 
                     /* Multiplexor */
                     power_usage_mux_multilevel(&sub_power_usage,
-                                               power_get_mux_arch(node.fan_in(),
+                                               power_get_mux_arch(node_fan_in,
                                                                   power_ctx.arch->mux_transistor_size),
                                                node_power->in_prob, node_power->in_dens,
                                                node_power->selected_input, true,
@@ -912,11 +913,11 @@ static void power_usage_routing(t_power_usage* power_usage,
                 int seg_index = device_ctx.rr_indexed_data[node.cost_index()].seg_index;
                 C_wire = wire_length * device_ctx.rr_segments[seg_index].Cmetal;
                 //(double)power_ctx.commonly_used->tile_length);
-                VTR_ASSERT(node_power->selected_input < node.fan_in());
+                VTR_ASSERT(node_power->selected_input < node_fan_in);
 
                 /* Multiplexor */
                 power_usage_mux_multilevel(&sub_power_usage,
-                                           power_get_mux_arch(node.fan_in(),
+                                           power_get_mux_arch(node_fan_in,
                                                               power_ctx.arch->mux_transistor_size),
                                            node_power->in_prob, node_power->in_dens,
                                            node_power->selected_input, true, power_ctx.solution_inf.T_crit);
@@ -1173,10 +1174,10 @@ void power_pb_pins_uninit() {
 }
 
 void power_routing_init(const t_det_routing_arch* routing_arch) {
-    int max_fanin;
-    int max_IPIN_fanin;
-    int max_seg_to_IPIN_fanout;
-    int max_seg_to_seg_fanout;
+    t_edge_size max_fanin;
+    t_edge_size max_IPIN_fanin;
+    t_edge_size max_seg_to_IPIN_fanout;
+    t_edge_size max_seg_to_seg_fanout;
     auto& power_ctx = g_vpr_ctx.mutable_power();
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
@@ -1205,20 +1206,20 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
     max_seg_to_seg_fanout = 0;
     max_seg_to_IPIN_fanout = 0;
     for (size_t rr_node_idx = 0; rr_node_idx < device_ctx.rr_nodes.size(); rr_node_idx++) {
-        int fanout_to_IPIN = 0;
-        int fanout_to_seg = 0;
+        t_edge_size fanout_to_IPIN = 0;
+        t_edge_size fanout_to_seg = 0;
         auto node = device_ctx.rr_nodes[rr_node_idx];
         t_rr_node_power* node_power = &rr_node_power[rr_node_idx];
+        const t_edge_size node_fan_in = rr_graph.node_fan_in(RRNodeId(rr_node_idx));
 
         switch (rr_graph.node_type(RRNodeId(rr_node_idx))) {
             case IPIN:
-                max_IPIN_fanin = std::max(max_IPIN_fanin,
-                                          static_cast<int>(node.fan_in()));
-                max_fanin = std::max(max_fanin, static_cast<int>(node.fan_in()));
+                max_IPIN_fanin = std::max(max_IPIN_fanin, node_fan_in);
+                max_fanin = std::max(max_fanin, node_fan_in);
 
-                node_power->in_dens = (float*)vtr::calloc(node.fan_in(),
+                node_power->in_dens = (float*)vtr::calloc(node_fan_in,
                                                           sizeof(float));
-                node_power->in_prob = (float*)vtr::calloc(node.fan_in(),
+                node_power->in_prob = (float*)vtr::calloc(node_fan_in,
                                                           sizeof(float));
                 break;
             case CHANX:
@@ -1233,11 +1234,11 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
                 max_seg_to_IPIN_fanout = std::max(max_seg_to_IPIN_fanout,
                                                   fanout_to_IPIN);
                 max_seg_to_seg_fanout = std::max(max_seg_to_seg_fanout, fanout_to_seg);
-                max_fanin = std::max(max_fanin, static_cast<int>(node.fan_in()));
+                max_fanin = std::max(max_fanin, node_fan_in);
 
-                node_power->in_dens = (float*)vtr::calloc(node.fan_in(),
+                node_power->in_dens = (float*)vtr::calloc(node_fan_in,
                                                           sizeof(float));
-                node_power->in_prob = (float*)vtr::calloc(node.fan_in(),
+                node_power->in_prob = (float*)vtr::calloc(node_fan_in,
                                                           sizeof(float));
                 break;
             default:
@@ -1361,14 +1362,13 @@ bool power_uninit() {
     bool error = false;
 
     for (size_t rr_node_idx = 0; rr_node_idx < device_ctx.rr_nodes.size(); rr_node_idx++) {
-        auto node = device_ctx.rr_nodes[rr_node_idx];
         t_rr_node_power* node_power = &rr_node_power[rr_node_idx];
 
         switch (rr_graph.node_type(RRNodeId(rr_node_idx))) {
             case CHANX:
             case CHANY:
             case IPIN:
-                if (node.fan_in()) {
+                if (rr_graph.node_fan_in(RRNodeId(rr_node_idx))) {
                     free(node_power->in_dens);
                     free(node_power->in_prob);
                 }

vpr/src/route/check_rr_graph.cpp

@@ -601,12 +601,13 @@ static bool has_adjacent_channel(const t_rr_node& node, const DeviceGrid& grid)
 
 static void check_rr_edge(int from_node, int iedge, int to_node) {
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
 
     //Check that to to_node's fan-in is correct, given the switch type
     int iswitch = device_ctx.rr_nodes[from_node].edge_switch(iedge);
     auto switch_type = device_ctx.rr_switch_inf[iswitch].type();
 
-    int to_fanin = device_ctx.rr_nodes[to_node].fan_in();
+    int to_fanin = rr_graph.node_fan_in(RRNodeId(to_node));
     switch (switch_type) {
         case SwitchType::BUFFER:
             //Buffer switches are non-configurable, and uni-directional -- they must have only one driver

vpr/src/route/rr_graph.cpp

@@ -2496,7 +2496,7 @@ std::string describe_rr_node(int inode) {
     }
 
     msg += vtr::string_fmt(" capacity: %d", rr_graph.node_capacity(RRNodeId(inode)));
-    msg += vtr::string_fmt(" fan-in: %d", rr_node.fan_in());
+    msg += vtr::string_fmt(" fan-in: %d", rr_graph.node_fan_in(RRNodeId(inode)));
     msg += vtr::string_fmt(" fan-out: %d", rr_node.num_edges());
 
     return msg;

vpr/src/route/rr_graph_area.cpp

@@ -382,7 +382,7 @@ void count_unidir_routing_transistors(std::vector<t_segment_inf>& /*segment_inf*
                                 int switch_index = device_ctx.rr_nodes[from_node].edge_switch(iedge);
                                 auto switch_type = device_ctx.rr_switch_inf[switch_index].type();
 
-                                int fan_in = device_ctx.rr_nodes[to_node].fan_in();
+                                int fan_in = rr_graph.node_fan_in(RRNodeId(to_node));
 
                                 if (device_ctx.rr_switch_inf[switch_index].type() == SwitchType::MUX) {
                                     /* Each wire segment begins with a multipexer followed by a driver for unidirectional */

vpr/src/route/rr_node.h

@@ -92,7 +92,6 @@ class t_rr_node {
     short edge_switch(t_edge_size iedge) const;
 
     bool edge_is_configurable(t_edge_size iedge) const;
-    t_edge_size fan_in() const;
 
     short xlow() const;
     short ylow() const;

vpr/src/route/rr_node_impl.h

@@ -102,10 +102,6 @@ inline short t_rr_node::edge_switch(t_edge_size iedge) const {
     return storage_->edge_switch(id_, iedge);
 }
 
-inline t_edge_size t_rr_node::fan_in() const {
-    return storage_->fan_in(id_);
-}
-
 inline short t_rr_node::xlow() const {
     return storage_->node_xlow(id_);
 }