improved comments and code structure

Author: SamuelHo10

vpr/src/draw/draw_basic.cpp

@@ -612,7 +612,7 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
-    // Draw Pins
+    // Draw RR Nodes
     for (size_t i = 1; i < rr_nodes_to_draw.size(); ++i) {
         RRNodeId inode = rr_nodes_to_draw[i];
         auto rr_type = rr_graph.node_type(inode);
@@ -637,7 +637,7 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
             continue;
         }
 
-        // Draw IO Pins
+        // Draw cluster-level IO Pins
         if (rr_type == e_rr_type::OPIN || rr_type == e_rr_type::IPIN) {
             draw_rr_pin(inode, color, g);
             continue;
@@ -671,7 +671,7 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
             continue;
         }
 
-        // Skip drawing sources and sinks
+        // Skip drawing edges to or from sources and sinks
         if (rr_type == e_rr_type::SINK || rr_type == e_rr_type::SOURCE || prev_type == e_rr_type::SINK || prev_type == e_rr_type::SOURCE) {
             continue;
         }
@@ -688,71 +688,78 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
             continue;
         }
 
-        auto iedge = find_edge(prev_node, inode);
-        auto switch_type = rr_graph.edge_switch(RRNodeId(prev_node), iedge);
+        draw_inter_cluster_rr_edge(inode, prev_node, rr_type, prev_type, rr_graph, g);
 
-        switch (rr_type) {
-            case e_rr_type::IPIN: {
-                if (rr_graph.node_type(prev_node) == e_rr_type::OPIN) {
-                    draw_pin_to_pin(prev_node, inode, g);
-                } else {
-                    draw_pin_to_chan_edge(inode, prev_node, g);
-                }
-                break;
+    }
+}
+
+void draw_inter_cluster_rr_edge(RRNodeId inode, RRNodeId prev_node, e_rr_type rr_type, e_rr_type prev_type, const RRGraphView& rr_graph, ezgl::renderer* g) {
+
+    auto iedge = find_edge(prev_node, inode);
+    auto switch_type = rr_graph.edge_switch(RRNodeId(prev_node), iedge);
+
+    switch (rr_type) {
+        case e_rr_type::IPIN: {
+            if (prev_type == e_rr_type::OPIN) {
+                draw_pin_to_pin(prev_node, inode, g);
+            } else {
+                draw_pin_to_chan_edge(inode, prev_node, g);
             }
-            case e_rr_type::CHANX: {
-                switch (prev_type) {
-                    case e_rr_type::CHANX: {
-                        draw_chanx_to_chanx_edge(prev_node, inode, switch_type, g);
-                        break;
-                    }
-                    case e_rr_type::CHANY: {
-                        draw_chanx_to_chany_edge(inode, prev_node, FROM_Y_TO_X, switch_type, g);
-                        break;
-                    }
-                    case e_rr_type::OPIN: {
-                        draw_pin_to_chan_edge(prev_node, inode, g);
-                        break;
-                    }
-                    default: {
-                        VPR_ERROR(VPR_ERROR_OTHER,
-                                  "Unexpected connection from an rr_node of type %d to one of type %d.\n",
-                                  prev_type, rr_type);
-                    }
+            break;
+        }
+        case e_rr_type::CHANX: {
+            switch (prev_type) {
+                case e_rr_type::CHANX: {
+                    draw_chanx_to_chanx_edge(prev_node, inode, switch_type, g);
+                    break;
+                }
+                case e_rr_type::CHANY: {
+                    draw_chanx_to_chany_edge(inode, prev_node, FROM_Y_TO_X, switch_type, g);
+                    break;
+                }
+                case e_rr_type::OPIN: {
+                    draw_pin_to_chan_edge(prev_node, inode, g);
+                    break;
+                }
+                default: {
+                    VPR_ERROR(VPR_ERROR_OTHER,
+                                "Unexpected connection from an rr_node of type %d to one of type %d.\n",
+                                prev_type, rr_type);
                 }
-                break;
             }
-            case e_rr_type::CHANY: {
-                switch (prev_type) {
-                    case e_rr_type::CHANX: {
-                        draw_chanx_to_chany_edge(prev_node, inode,
-                                                 FROM_X_TO_Y, switch_type, g);
-                        break;
-                    }
-                    case e_rr_type::CHANY: {
-                        draw_chany_to_chany_edge(RRNodeId(prev_node), RRNodeId(inode),
-                                                 switch_type, g);
-                        break;
-                    }
-                    case e_rr_type::OPIN: {
-                        draw_pin_to_chan_edge(prev_node, inode, g);
+            break;
+        }
+        case e_rr_type::CHANY: {
+            switch (prev_type) {
+                case e_rr_type::CHANX: {
+                    draw_chanx_to_chany_edge(prev_node, inode,
+                                                FROM_X_TO_Y, switch_type, g);
+                    break;
+                }
+                case e_rr_type::CHANY: {
+                    draw_chany_to_chany_edge(RRNodeId(prev_node), RRNodeId(inode),
+                                                switch_type, g);
+                    break;
+                }
+                case e_rr_type::OPIN: {
+                    draw_pin_to_chan_edge(prev_node, inode, g);
 
-                        break;
-                    }
-                    default: {
-                        VPR_ERROR(VPR_ERROR_OTHER,
-                                  "Unexpected connection from an rr_node of type %d to one of type %d.\n",
-                                  prev_type, rr_type);
-                    }
+                    break;
+                }
+                default: {
+                    VPR_ERROR(VPR_ERROR_OTHER,
+                                "Unexpected connection from an rr_node of type %d to one of type %d.\n",
+                                prev_type, rr_type);
                 }
-                break;
-            }
-            default: {
-                break;
             }
+            break;
+        }
+        default: {
+            break;
         }
     }
 }
+    
 
 /* Helper function that checks whether the edges between the current and previous nodes can be drawn
  * based on whether the cross-layer connections option is enabled and whether the layer on which the

vpr/src/draw/draw_basic.h

@@ -57,6 +57,12 @@ void draw_routed_net(ParentNetId net, ezgl::renderer* g);
 void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw,
                         ezgl::renderer* g);
 
+/** @brief Draws an edge between two rr_nodes, which are both intra-cluster nodes.
+ * @param inode The current rr_node id
+ * @param prev_node The previous rr_node id
+ * @param g The ezgl renderer
+ */
+void draw_inter_cluster_rr_edge(RRNodeId inode, RRNodeId prev_node, e_rr_type rr_type, e_rr_type prev_type, const RRGraphView& rr_graph, ezgl::renderer* g);
 /**
  * @brief Returns the layer number of a timing path node
  * @param node

vpr/src/draw/draw_rr.cpp

@@ -727,6 +727,8 @@ RRNodeId draw_check_rr_node_hit(float click_x, float click_y) {
 
             continue;
         }
+
+        // Check for inter cluster nodes
         switch (rr_graph.node_type(inode)) {
             case e_rr_type::IPIN:
             case e_rr_type::OPIN: {

vpr/src/draw/draw_rr.h

@@ -27,6 +27,9 @@ void draw_rr_edges(RRNodeId from_node, ezgl::renderer* g);
 
 void draw_rr_chan(RRNodeId inode, const ezgl::color color, ezgl::renderer* g);
 
+/**
+ * @brief Draws the intra-cluster pin for a given RRNodeId when flat routing is enabled.
+ */
 void draw_rr_intrapin(RRNodeId inode, const ezgl::color& color, ezgl::renderer* g);
 /* Draws an IPIN or OPIN rr_node.  Note that the pin can appear on more
  * than one side of a clb.  Also note that this routine can change the

vpr/src/draw/draw_rr_edges.cpp

@@ -287,17 +287,17 @@ void draw_intrapin_to_intrapin(RRNodeId inode, RRNodeId prev_node, ezgl::rendere
         return;
     }
 
-    auto blk_id_pin_id1 = get_rr_node_cluster_blk_id_pb_graph_pin(inode);
-    auto blk_id_pin_id2 = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
+    auto [blk_id, pin_id] = get_rr_node_cluster_blk_id_pb_graph_pin(inode);
+    auto [prev_blk_id, prev_pin_id] = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
 
-    ezgl::point2d p2 = draw_coords->get_absolute_pin_location(blk_id_pin_id1.first, blk_id_pin_id1.second);
-    ezgl::point2d p1 = draw_coords->get_absolute_pin_location(blk_id_pin_id2.first, blk_id_pin_id2.second);
+    ezgl::point2d icoord = draw_coords->get_absolute_pin_location(blk_id, pin_id);
+    ezgl::point2d prev_coord = draw_coords->get_absolute_pin_location(prev_blk_id, prev_pin_id);
 
-    g->draw_line(p1, p2);
+    g->draw_line(prev_coord, icoord);
 
-    float xend = p2.x + (p1.x - p2.x) / 10.;
-    float yend = p2.y + (p1.y - p2.y) / 10.;
-    draw_triangle_along_line(g, xend, yend, p1.x, p2.x, p1.y, p2.y);
+    float triangle_coord_x = icoord.x + (prev_coord.x - icoord.x) / 10.;
+    float triangle_coord_y = icoord.y + (prev_coord.y - icoord.y) / 10.;
+    draw_triangle_along_line(g, triangle_coord_x, triangle_coord_y, prev_coord.x, icoord.x, prev_coord.y, icoord.y);
 }
 
 void draw_intrapin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g) {
@@ -307,35 +307,44 @@ void draw_intrapin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g)
     if (!draw_state->is_flat) {
         return;
     }
+
     const auto& rr_graph = g_vpr_ctx.device().rr_graph;
 
-    bool swapped = false;
-    if (!is_inter_cluster_node(rr_graph, inode) && is_inter_cluster_node(rr_graph, prev_node)) {
-        //Swap the nodes so that the inter-cluster node is always the current node
-        std::swap(inode, prev_node);
-        swapped = true;
-    }
+    ezgl::point2d prev_coord, icoord;
+    float temp_x, temp_y; // temporary variables to hold coordinates to cast into ezgl::point2d
 
-    auto blk_id_pin_id = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
-    float x1, y1;
-    ezgl::point2d p2 = draw_coords->get_absolute_pin_location(blk_id_pin_id.first, blk_id_pin_id.second);
+    // get the location of the nodes based on whether inode is an inter-cluster or intra-cluster pin.
+    if (!is_inter_cluster_node(rr_graph, inode)) {
 
-    for (const e_side& pin_side : TOTAL_2D_SIDES) {
-        if (!rr_graph.is_node_on_specific_side(RRNodeId(inode), pin_side)) {
-            continue;
-        }
-        draw_get_rr_pin_coords(inode, &x1, &y1, pin_side);
-        ezgl::point2d p1 = {x1, y1};
+        auto [blk_id, pin_id] = get_rr_node_cluster_blk_id_pb_graph_pin(inode);
+        icoord = draw_coords->get_absolute_pin_location(blk_id, pin_id);
 
-        if (!swapped) {
-            std::swap(p1, p2);
+        for (const e_side& pin_side : TOTAL_2D_SIDES) {
+            if (!rr_graph.is_node_on_specific_side(RRNodeId(prev_node), pin_side)) {
+                continue;
+            }
+            draw_get_rr_pin_coords(prev_node, &temp_x, &temp_y, pin_side);
+            prev_coord = {temp_x, temp_y};
         }
+    } else {
+
+        auto [prev_blk_id, prev_pin_id] = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
+        prev_coord = draw_coords->get_absolute_pin_location(prev_blk_id, prev_pin_id);
 
-        g->draw_line(p1, p2);
-        float xend = p2.x + (p1.x - p2.x) / 10.;
-        float yend = p2.y + (p1.y - p2.y) / 10.;
-        draw_triangle_along_line(g, xend, yend, p1.x, p2.x, p1.y, p2.y);
+        for (const e_side& pin_side : TOTAL_2D_SIDES) {
+            if (!rr_graph.is_node_on_specific_side(RRNodeId(inode), pin_side)) {
+                continue;
+            }
+            draw_get_rr_pin_coords(inode, &temp_x, &temp_y, pin_side);
+            icoord = {temp_x, temp_y};
+        }
     }
+
+    g->draw_line(prev_coord, icoord);
+    float triangle_coord_x = icoord.x + (prev_coord.x - icoord.x) / 10.;
+    float triangle_coord_y = icoord.y + (prev_coord.y - icoord.y) / 10.;
+    draw_triangle_along_line(g, triangle_coord_x, triangle_coord_y, prev_coord.x, icoord.x, prev_coord.y, icoord.y);
+    
 }
 
 void draw_pin_to_pin(RRNodeId opin_node, RRNodeId ipin_node, ezgl::renderer* g) {

vpr/src/draw/draw_rr_edges.h

@@ -17,14 +17,53 @@
 
 #include "ezgl/graphics.hpp"
 
+/**
+ * @brief Draws the edge between two vertical channel nodes
+ */
 void draw_chany_to_chany_edge(RRNodeId from_node, RRNodeId to_node, short switch_type, ezgl::renderer* g);
+
+/**
+ * @brief Draws the edge between two horizontal channel nodes
+ */
 void draw_chanx_to_chanx_edge(RRNodeId from_node, RRNodeId to_node, short switch_type, ezgl::renderer* g);
+
+/**
+ * @brief Draws the edge between a horizontal channel node and a vertical channel node
+ * @param chanx_node The horizontal channel node
+ * @param chany_node The vertical channel node
+ * @param edge_dir The direction of the edge, FROM_X_TO_Y or FROM_Y_TO_X
+ * @param switch_type The type of switch used for the connection
+ * @param g The ezgl renderer 
+ */
 void draw_chanx_to_chany_edge(RRNodeId chanx_node, RRNodeId chany_node, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer* g);
+
+/**
+ * @brief Draws the edge between an intra-cluster pin and a pin when flat routing is enabled. It does not matter whether prev_node is the intra-cluster pin or whether inode is the intra-cluster pin.
+ * @param inode The current node to draw to
+ * @param prev_node The previous node to draw from
+ * @param g The ezgl renderer
+ */
 void draw_intrapin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g);
+/**
+ * @brief Draws the edge between two intra-cluster pins when flat routing is enabled.
+ * @param inode The current node to draw to
+ * @param prev_node The previous node to draw from
+ * @param g The ezgl renderer
+ */
 void draw_intrapin_to_intrapin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g);
+
+/**
+ * @brief This routine directly draws an edge from an inter-cluster output pin to an inter-cluster input pin.
+ */
 void draw_pin_to_pin(RRNodeId opin, RRNodeId ipin, ezgl::renderer* g);
+
+//TODO: These two functions currently do not draw correctly after rearranging the block locations. They need an update.
 void draw_pin_to_sink(RRNodeId ipin_node, RRNodeId sink_node, ezgl::renderer* g);
 void draw_source_to_pin(RRNodeId source_node, RRNodeId opin_node, ezgl::renderer* g);
+
+/**
+ * @brief Draws an edge from a inter-cluster pin node to a channel node (CHANX or CHANY).
+ */
 void draw_pin_to_chan_edge(RRNodeId pin_node, RRNodeId chan_node, ezgl::renderer* g);
 
 #endif /* NO_GRAPHICS */

vpr/src/draw/draw_searchbar.cpp

@@ -131,7 +131,7 @@ void draw_highlight_blocks_color(t_logical_block_type_ptr type,
 /* If an rr_node has been clicked on, it will be highlighted in MAGENTA.
  * If so, and toggle nets is selected, highlight the whole net in that colour.
  */
-void highlight_net(char* message, RRNodeId hit_node) {
+void highlight_nets(char* message, RRNodeId hit_node) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& route_ctx = g_vpr_ctx.routing();
@@ -154,33 +154,35 @@ void highlight_net(char* message, RRNodeId hit_node) {
     application.update_message(message);
 }
 
-void check_node_highlight_net(char* message, ParentNetId parent_id, RRNodeId hit_node) {
+std::string draw_get_net_name(ParentNetId parent_id) {
+    if (!g_vpr_ctx.routing().is_flat) {
+        return g_vpr_ctx.clustering().clb_nlist.net_name(convert_to_cluster_net_id(parent_id));
+    } else {
+        return g_vpr_ctx.atom().netlist().net_name(convert_to_atom_net_id(parent_id));
+    }
+}
+
+void check_node_highlight_net(char* message, ParentNetId parent_net_id, RRNodeId hit_node) {
     auto& route_ctx = g_vpr_ctx.routing();
     t_draw_state* draw_state = get_draw_state_vars();
 
-    if (!route_ctx.route_trees[parent_id])
+    if (!route_ctx.route_trees[parent_net_id])
         return;
 
-    for (auto& rt_node : route_ctx.route_trees[parent_id].value().all_nodes()) {
+    for (auto& rt_node : route_ctx.route_trees[parent_net_id].value().all_nodes()) {
         RRNodeId inode = rt_node.inode;
         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
-            draw_state->net_color[parent_id] = draw_state->draw_rr_node[inode].color;
+            draw_state->net_color[parent_net_id] = draw_state->draw_rr_node[inode].color;
             if (inode == hit_node) {
                 std::string orig_msg(message);
-                std::string net_name;
-                if (!route_ctx.is_flat) {
-                    net_name = g_vpr_ctx.clustering().clb_nlist.net_name(convert_to_cluster_net_id(parent_id));
-                } else {
-                    net_name = g_vpr_ctx.atom().netlist().net_name(convert_to_atom_net_id(parent_id));
-                }
                 sprintf(message, "%s  ||  Net: %zu (%s)", orig_msg.c_str(),
-                        size_t(parent_id),
-                        net_name.c_str());
+                        size_t(parent_net_id),
+                        draw_get_net_name(parent_net_id).c_str());
             }
         } else if (draw_state->draw_rr_node[inode].color
                    == ezgl::WHITE) {
             // If node is de-selected.
-            draw_state->net_color[parent_id] = ezgl::BLACK;
+            draw_state->net_color[parent_net_id] = ezgl::BLACK;
             break;
         }
     }