fixed incorrect pin side issue

Author: SamuelHo10

vpr/src/draw/draw_basic.cpp

@@ -683,8 +683,27 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
             continue;
         }
 
-        if (!inode_inter_cluster || !prev_node_inter_cluster) {
-            draw_intra_cluster_pin_to_pin(inode, prev_node, g);
+        // Default side for pin in case none can be found
+        e_side pin_side = e_side::TOP;
+        if (!prev_node_inter_cluster && inode_inter_cluster) {
+            // draw intra-cluster pin to inter-cluster pin
+            // node i + 1 is the channel node
+            if (i + 1 < rr_nodes_to_draw.size()) {
+                pin_side = get_pin_side(inode, rr_nodes_to_draw[i + 1]);
+            }
+
+            draw_intra_cluster_pin_to_pin(prev_node, inode, FROM_INTRA_CLUSTER_TO_INTER_CLUSTER, pin_side, g);
+            continue;
+        }
+
+        if (prev_node_inter_cluster && !inode_inter_cluster) {
+            // draw inter-cluster pin to intra-cluster pin
+            // node i - 2 is the channel node
+            if (i >= 2) {
+                pin_side = get_pin_side(prev_node, rr_nodes_to_draw[i - 2]);
+            }
+
+            draw_intra_cluster_pin_to_pin(inode, prev_node, FROM_INTER_CLUSTER_TO_INTRA_CLUSTER, pin_side, g);
             continue;
         }
 

vpr/src/draw/draw_rr_edges.cpp

@@ -205,7 +205,7 @@ void draw_chanx_to_chanx_edge(RRNodeId from_node, RRNodeId to_node, short switch
     }
 }
 
-void draw_chanx_to_chany_edge(RRNodeId chanx_node, RRNodeId chany_node, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer* g) {
+void draw_chanx_to_chany_edge(RRNodeId chanx_node, RRNodeId chany_node, enum e_chan_edge_dir edge_dir, short switch_type, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
@@ -300,44 +300,33 @@ void draw_intra_cluster_edge(RRNodeId inode, RRNodeId prev_node, ezgl::renderer*
     draw_triangle_along_line(g, triangle_coord_x, triangle_coord_y, prev_coord.x, icoord.x, prev_coord.y, icoord.y);
 }
 
-void draw_intra_cluster_pin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g) {
+void draw_intra_cluster_pin_to_pin(RRNodeId intra_cluster_node, RRNodeId inter_cluster_node, e_pin_edge_dir pin_edge_dir, e_side pin_side, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
 
     if (!draw_state->is_flat) {
         return;
     }
 
-    const auto& rr_graph = g_vpr_ctx.device().rr_graph;
+    // determine the location of the pins
+    float inter_cluster_x, inter_cluster_y;
+    ezgl::point2d intra_cluster_coord;
 
-    ezgl::point2d prev_coord, icoord;
-    float temp_x, temp_y; // temporary variables to hold coordinates to cast into ezgl::point2d
-
-    // 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)) {
+    draw_get_rr_pin_coords(inter_cluster_node, &inter_cluster_x, &inter_cluster_y, pin_side);
 
-        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);
+    auto [blk_id, pin_id] = get_rr_node_cluster_blk_id_pb_graph_pin(intra_cluster_node);
+    intra_cluster_coord = draw_coords->get_absolute_pin_location(blk_id, pin_id);
 
-        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};
-        }
+    // determine which coord is first based on the pin edge direction
+    ezgl::point2d prev_coord, icoord;
+    if (pin_edge_dir == FROM_INTRA_CLUSTER_TO_INTER_CLUSTER) {
+        prev_coord = intra_cluster_coord;
+        icoord = {inter_cluster_x, inter_cluster_y};
+    } else if (pin_edge_dir == FROM_INTER_CLUSTER_TO_INTRA_CLUSTER) {
+        prev_coord = {inter_cluster_x, inter_cluster_y};
+        icoord = intra_cluster_coord;
     } 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);
-
-        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};
-        }
+        VPR_ERROR(VPR_ERROR_DRAW, "Invalid pin edge direction: %d", pin_edge_dir);
     }
 
     g->draw_line(prev_coord, icoord);
@@ -433,14 +422,8 @@ void draw_source_to_pin(RRNodeId source_node, RRNodeId opin_node, ezgl::renderer
     }
 }
 
-void draw_pin_to_chan_edge(RRNodeId pin_node, RRNodeId chan_node, ezgl::renderer* g) {
-    /* This routine draws an edge from the pin_node to the chan_node (CHANX or   *
-     * CHANY).  The connection is made to the nearest end of the track instead   *
-     * of perpendicular to the track to symbolize a single-drive connection.     */
-
-    /* TODO: Fix this for global routing, currently for detailed only */
+e_side get_pin_side(RRNodeId pin_node, RRNodeId chan_node) {
 
-    t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
@@ -453,7 +436,6 @@ void draw_pin_to_chan_edge(RRNodeId pin_node, RRNodeId chan_node, ezgl::renderer
     int width_offset = device_ctx.grid.get_width_offset(tile_loc);
     int height_offset = device_ctx.grid.get_height_offset(tile_loc);
 
-    float x1 = 0, y1 = 0;
     /* If there is only one side, no need for the following inference!!!
      * When a node may have multiple sides,
      * we lack direct information about which side of the node drives the channel node
@@ -521,6 +503,30 @@ void draw_pin_to_chan_edge(RRNodeId pin_node, RRNodeId chan_node, ezgl::renderer
     /* Sanity check */
     VTR_ASSERT(NUM_2D_SIDES != pin_side);
 
+    return pin_side;
+}
+
+void draw_pin_to_chan_edge(RRNodeId pin_node, RRNodeId chan_node, ezgl::renderer* g) {
+    /* This routine draws an edge from the pin_node to the chan_node (CHANX or   *
+     * CHANY).  The connection is made to the nearest end of the track instead   *
+     * of perpendicular to the track to symbolize a single-drive connection.     */
+
+    /* TODO: Fix this for global routing, currently for detailed only */
+
+    t_draw_coords* draw_coords = get_draw_coords_vars();
+    auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
+
+    t_physical_tile_loc tile_loc = {
+        rr_graph.node_xlow(pin_node),
+        rr_graph.node_ylow(pin_node),
+        rr_graph.node_layer(pin_node)};
+
+    const auto& grid_type = device_ctx.grid.get_physical_type(tile_loc);
+    const e_rr_type channel_type = rr_graph.node_type(chan_node);
+    e_side pin_side = get_pin_side(pin_node, chan_node);
+
+    float x1 = 0, y1 = 0;
     /* Now we determine which side to be used, calculate the offset for the pin to be drawn
      * - For the pin locates above/right to the grid (at the top/right side),
      *   a positive offset (+ve) is required

vpr/src/draw/draw_rr_edges.h

@@ -35,15 +35,17 @@ void draw_chanx_to_chanx_edge(RRNodeId from_node, RRNodeId to_node, short switch
  * @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);
+void draw_chanx_to_chany_edge(RRNodeId chanx_node, RRNodeId chany_node, enum e_chan_edge_dir edge_dir, short switch_type, ezgl::renderer* g);
 
 /**
- * @brief Draws the edge between an intra-cluster pin and an inter-cluster 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
+ * @brief Draws the edge between an intra-cluster pin and an inter-cluster pin when flat routing is enabled.
+ * @param intra_cluster_node The intra-cluster pin node
+ * @param inter_cluster_node The inter-cluster pin node
+ * @param pin_edge_dir The direction of the edge, FROM_INTER_CLUSTER_TO_INTRA_CLUSTER or FROM_INTRA_CLUSTER_TO_INTER_CLUSTER
+ * @param pin_side The side of the inter-cluster pin (e.g. TOP, RIGHT, BOTTOM, LEFT)
  * @param g The ezgl renderer
  */
-void draw_intra_cluster_pin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g);
+void draw_intra_cluster_pin_to_pin(RRNodeId intra_cluster_node, RRNodeId inter_cluster_node, e_pin_edge_dir pin_edge_dir, e_side pin_side, 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
@@ -61,6 +63,13 @@ void draw_pin_to_pin(RRNodeId opin, RRNodeId ipin, ezgl::renderer* g);
 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 Determines the side of clb, the inter-cluster pin is located on based on the channel node.
+ * @param pin_node The inter-cluster pin node
+ * @param chan_node The channel node (CHANX or CHANY) that the pin is connected to
+ * @return The side of the clb that the pin is located on (e.g. TOP, RIGHT, BOTTOM, LEFT)
+ */
+e_side get_pin_side(RRNodeId pin_node, RRNodeId chan_node);
 /**
  * @brief Draws an edge from a inter-cluster pin node to a channel node (CHANX or CHANY).
  */

vpr/src/draw/draw_types.h

@@ -109,13 +109,18 @@ enum e_draw_net_type {
     ALL_NETS,
     HIGHLIGHTED
 };
-
-/* Chanx to chany or vice versa? */
-enum e_edge_dir {
+/// Chanx to chany or vice versa?
+enum e_chan_edge_dir {
     FROM_X_TO_Y,
     FROM_Y_TO_X
 };
 
+/// From inter-cluster pin to intra-cluster pin or vice versa?
+enum e_pin_edge_dir {
+    FROM_INTER_CLUSTER_TO_INTRA_CLUSTER,
+    FROM_INTRA_CLUSTER_TO_INTER_CLUSTER
+};
+
 /*
  * Defines the type of drawings that can be generated for the NoC.
  * DRAW_NO_NOC -> user did not select the option to draw the NoC

vpr/src/draw/intra_logic_block.cpp

@@ -253,7 +253,7 @@ static int draw_internal_find_max_lvl(const t_pb_type& pb_type) {
 static int get_num_child_blocks(const t_mode& mode) {
     // not all child_pb_types have the same number of physical blocks, so we have to manually loop through and count the physical blocks
     int num_blocks = 0;
-    for (int j=0;j<mode.num_pb_type_children;++j) {
+    for (int j = 0; j < mode.num_pb_type_children; ++j) {
         num_blocks += mode.pb_type_children[j].num_pb;
     }
     return num_blocks;
@@ -284,9 +284,9 @@ static void draw_internal_load_coords(int type_descrip_index, t_pb_graph_node* p
             // Find the number of instances for each child pb_type.
             int num_pb = mode.pb_type_children[j].num_pb;
 
-            // Determine how we want to arrange the sub-blocks in the parent block. 
-            // We want the blocks to be squarish, and not too wide or too tall. 
-            // In other words, we want the number of rows to be as close to the number of columns as possible such that 
+            // Determine how we want to arrange the sub-blocks in the parent block.
+            // We want the blocks to be squarish, and not too wide or too tall.
+            // In other words, we want the number of rows to be as close to the number of columns as possible such that
             // num_rows * num_columns =  num_blocks.
             // first, determine the "middle" factor for the number of columns
             int num_columns = 1;
@@ -317,7 +317,7 @@ static void draw_internal_load_coords(int type_descrip_index, t_pb_graph_node* p
                 draw_internal_load_coords(type_descrip_index,
                                           &pb_graph_node->child_pb_graph_nodes[i][j][k],
                                           blk_width, blk_height);
-                
+
                 blk_num++;
             }
         }