Merge pull request #3236 from verilog-to-routing/gui_update

Updated Route and Net UI Elements

Author: SamuelHo10

vpr/main.ui

@@ -76,8 +76,8 @@ const std::vector<ezgl::color> kelly_max_contrast_colors = {
 void drawplace(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
-    const auto& device_ctx = g_vpr_ctx.device();
-    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
     const auto& grid_blocks = draw_state->get_graphics_blk_loc_registry_ref().grid_blocks();
 
     ClusterBlockId bnum;
@@ -196,14 +196,12 @@ void drawplace(ezgl::renderer* g) {
 /* This routine draws the nets on the placement.  The nets have not *
  * yet been routed, so we just draw a chain showing a possible path *
  * for each net.  This gives some idea of future congestion.        */
-void drawnets(ezgl::renderer* g) {
+void draw_flylines_placement(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
-    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
     const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
-    float NET_ALPHA = draw_state->net_alpha;
-
     g->set_line_dash(ezgl::line_dash::none);
     g->set_line_width(0);
 
@@ -244,11 +242,12 @@ void drawnets(ezgl::renderer* g) {
             if (!element_visibility.visible) {
                 continue; /* Don't Draw */
             }
-            float transparency_factor = element_visibility.alpha;
 
-            //Take the highest of the 2 transparency values that the user can select from the UI
+            // Take the highest of the 2 transparency values that the user can select from the UI
             // Compare the current cross layer transparency to the overall Net transparency set by the user.
-            g->set_color(draw_state->net_color[net_id], fmin(transparency_factor, draw_state->net_color[net_id].alpha * NET_ALPHA));
+            int transparency = std::min(element_visibility.alpha, draw_state->net_color[net_id].alpha * draw_state->net_alpha / 255);
+
+            g->set_color(draw_state->net_color[net_id], transparency);
 
             ezgl::point2d sink_center = draw_coords->get_absolute_clb_bbox(b2, cluster_ctx.clb_nlist.block_type(b2)).center();
             g->draw_line(driver_center, sink_center);
@@ -266,9 +265,9 @@ void draw_congestion(ezgl::renderer* g) {
         return;
     }
 
-    auto& device_ctx = g_vpr_ctx.device();
-    const auto& rr_graph = device_ctx.rr_graph;
-    auto& route_ctx = g_vpr_ctx.routing();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+    const RRGraphView& rr_graph = device_ctx.rr_graph;
+    const RoutingContext& route_ctx = g_vpr_ctx.routing();
 
     //Record min/max congestion
     float min_congestion_ratio = 1.;
@@ -320,7 +319,7 @@ void draw_congestion(ezgl::renderer* g) {
             }
         }
         g->set_line_width(0);
-        drawroute(HIGHLIGHTED, g);
+        draw_route(HIGHLIGHTED, g);
 
         //Reset colors
         for (RRNodeId inode : congested_rr_nodes) {
@@ -379,8 +378,8 @@ void draw_routing_costs(ezgl::renderer* g) {
         return;
     }
 
-    auto& device_ctx = g_vpr_ctx.device();
-    auto& route_ctx = g_vpr_ctx.routing();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+    const RoutingContext& route_ctx = g_vpr_ctx.routing();
     g->set_line_width(0);
 
     VTR_ASSERT(!route_ctx.rr_node_route_inf.empty());
@@ -472,8 +471,8 @@ void draw_routing_bb(ezgl::renderer* g) {
         return;
     }
 
-    auto& route_ctx = g_vpr_ctx.routing();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    const RoutingContext& route_ctx = g_vpr_ctx.routing();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
 
     VTR_ASSERT(draw_state->show_routing_bb != OPEN);
     VTR_ASSERT(draw_state->show_routing_bb < (int)route_ctx.route_bb.size());
@@ -534,18 +533,16 @@ void draw_x(float x, float y, float size, ezgl::renderer* g) {
 /* Draws the nets in the positions fixed by the router.  If draw_net_type is *
  * ALL_NETS, draw all the nets.  If it is HIGHLIGHTED, draw only the nets    *
  * that are not coloured black (useful for drawing over the rr_graph).       */
-void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer* g) {
+void draw_route(enum e_draw_net_type draw_net_type, ezgl::renderer* g) {
     /* Next free track in each channel segment if routing is GLOBAL */
 
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
     const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     t_draw_state* draw_state = get_draw_state_vars();
 
-    float NET_ALPHA = draw_state->net_alpha;
-
     g->set_line_dash(ezgl::line_dash::none);
-    g->set_color(ezgl::BLACK, ezgl::BLACK.alpha * NET_ALPHA);
+    g->set_color(ezgl::BLACK, draw_state->net_alpha);
 
     /* Now draw each net, one by one.      */
     if (draw_state->is_flat) {
@@ -568,7 +565,7 @@ void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer* g) {
 }
 
 void draw_routed_net(ParentNetId net_id, ezgl::renderer* g) {
-    auto& route_ctx = g_vpr_ctx.routing();
+    const RoutingContext& route_ctx = g_vpr_ctx.routing();
 
     t_draw_state* draw_state = get_draw_state_vars();
 
@@ -579,13 +576,12 @@ void draw_routed_net(ParentNetId net_id, ezgl::renderer* g) {
     for (auto& rt_node : route_ctx.route_trees[net_id].value().all_nodes()) {
         RRNodeId inode = rt_node.inode;
 
+        // If a net has been highlighted, highlight all the nodes in the net the same color.
         if (draw_if_net_highlighted(net_id)) {
-            /* If a net has been highlighted, highlight the whole net in *
-             * the same color.											 */
             draw_state->draw_rr_node[inode].color = draw_state->net_color[net_id];
             draw_state->draw_rr_node[inode].node_highlighted = true;
         } else {
-            /* If not highlighted, draw the node in default color. */
+            // If not highlighted, draw the node in default color.
             draw_state->draw_rr_node[inode].color = DEFAULT_RR_NODE_COLOR;
         }
 
@@ -609,21 +605,53 @@ void draw_routed_net(ParentNetId net_id, ezgl::renderer* g) {
 //Draws the set of rr_nodes specified, using the colors set in draw_state
 void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
+    const RRGraphView& rr_graph = g_vpr_ctx.device().rr_graph;
 
     // Draw RR Nodes
     for (size_t i = 1; i < rr_nodes_to_draw.size(); ++i) {
         RRNodeId inode = rr_nodes_to_draw[i];
         ezgl::color color = draw_state->draw_rr_node[inode].color;
 
+        bool inter_cluster_node = is_inter_cluster_node(rr_graph, inode);
+
+        if (!(draw_state->draw_rr_node[inode].node_highlighted && draw_state->highlight_fan_in_fan_out)) {
+            // skip drawing INTER-cluster nets if the user has disabled them
+            if (inter_cluster_node && !draw_state->draw_inter_cluster_nets) {
+                continue;
+            }
+
+            // skip drawing INTRA-cluster nets if the user has disabled them
+            if (!inter_cluster_node && !draw_state->draw_intra_cluster_nets) {
+                continue;
+            }
+        }
+
         draw_rr_node(inode, color, g);
     }
 
     // Draw Edges
     for (size_t i = 1; i < rr_nodes_to_draw.size(); ++i) {
         RRNodeId inode = rr_nodes_to_draw[i];
         RRNodeId prev_node = rr_nodes_to_draw[i - 1];
+        bool inter_cluster_node = is_inter_cluster_node(rr_graph, inode);
+        bool prev_inter_cluster_node = is_inter_cluster_node(rr_graph, prev_node);
 
-        draw_rr_edge(inode, prev_node, draw_state->draw_rr_node[inode].color, g);
+        if (!(draw_state->draw_rr_node[inode].node_highlighted && draw_state->highlight_fan_in_fan_out)) {
+            // If this is an edge between two inter-cluster nodes, draw only if the user has enabled inter-cluster nets
+            if ((inter_cluster_node && prev_inter_cluster_node) && !draw_state->draw_inter_cluster_nets) {
+                continue;
+            }
+
+            // If this is an edge containing an intra-cluster node, draw only if the user has enabled intra-cluster nets
+            if ((!inter_cluster_node || !prev_inter_cluster_node) && !draw_state->draw_intra_cluster_nets) {
+                continue;
+            }
+        }
+
+        // avoid highlighting edge unless both nodes are highlighted
+        ezgl::color color = draw_state->draw_rr_node[prev_node].node_highlighted ? draw_state->draw_rr_node[inode].color : DEFAULT_RR_NODE_COLOR;
+
+        draw_rr_edge(inode, prev_node, color, g);
     }
 }
 
@@ -633,7 +661,7 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
  */
 bool is_edge_valid_to_draw(RRNodeId current_node, RRNodeId prev_node) {
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& rr_graph = g_vpr_ctx.device().rr_graph;
+    const RRGraphView& rr_graph = g_vpr_ctx.device().rr_graph;
 
     int current_node_layer = rr_graph.node_layer(current_node);
     int prev_node_layer = rr_graph.node_layer(prev_node);
@@ -726,7 +754,7 @@ void draw_routing_util(ezgl::renderer* g) {
     }
 
     t_draw_coords* draw_coords = get_draw_coords_vars();
-    auto& device_ctx = g_vpr_ctx.device();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
 
     auto chanx_usage = calculate_routing_usage(e_rr_type::CHANX, draw_state->is_flat, false);
     auto chany_usage = calculate_routing_usage(e_rr_type::CHANY, draw_state->is_flat, false);
@@ -896,7 +924,7 @@ void draw_crit_path(ezgl::renderer* g) {
     tatum::TimingPathCollector path_collector;
 
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& timing_ctx = g_vpr_ctx.timing();
+    const TimingContext& timing_ctx = g_vpr_ctx.timing();
 
     if (draw_state->show_crit_path == DRAW_NO_CRIT_PATH) {
         return;
@@ -1054,7 +1082,7 @@ void draw_crit_path_elements(const std::vector<tatum::TimingPath>& paths, const
 int get_timing_path_node_layer_num(tatum::NodeId node) {
     t_draw_state* draw_state = get_draw_state_vars();
     const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
-    const auto& atom_ctx = g_vpr_ctx.atom();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     AtomPinId atom_pin = atom_ctx.lookup().tnode_atom_pin(node);
     AtomBlockId atom_block = atom_ctx.netlist().pin_block(atom_pin);
@@ -1152,9 +1180,9 @@ void draw_routed_timing_edge_connection(tatum::NodeId src_tnode,
                                         tatum::NodeId sink_tnode,
                                         ezgl::color color,
                                         ezgl::renderer* g) {
-    auto& atom_ctx = g_vpr_ctx.atom();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& timing_ctx = g_vpr_ctx.timing();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
+    const TimingContext& timing_ctx = g_vpr_ctx.timing();
 
     AtomPinId atom_src_pin = atom_ctx.lookup().tnode_atom_pin(src_tnode);
     AtomPinId atom_sink_pin = atom_ctx.lookup().tnode_atom_pin(sink_tnode);
@@ -1211,6 +1239,7 @@ void draw_routed_timing_edge_connection(tatum::NodeId src_tnode,
 
             for (RRNodeId inode : routed_rr_nodes) {
                 draw_state->draw_rr_node[inode].color = color;
+                draw_state->draw_rr_node[inode].node_highlighted = true;
             }
 
             //draw_partial_route() takes care of layer visibility and cross-layer settings
@@ -1284,8 +1313,8 @@ void draw_block_pin_util() {
     if (draw_state->show_blk_pin_util == DRAW_NO_BLOCK_PIN_UTIL)
         return;
 
-    const auto& device_ctx = g_vpr_ctx.device();
-    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
     const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
     std::map<t_physical_tile_type_ptr, size_t> total_input_pins;
@@ -1344,7 +1373,7 @@ void draw_block_pin_util() {
 }
 
 void draw_reset_blk_colors() {
-    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
     for (auto blk : cluster_ctx.clb_nlist.blocks()) {
         draw_reset_blk_color(blk);
     }

vpr/src/draw/b.png

@@ -29,10 +29,11 @@
  * Blocks are drawn in layer order (so that semi-transparent blocks/grids render well)*/
 void drawplace(ezgl::renderer* g);
 
-/* This routine draws the nets on the placement.  The nets have not *
- * yet been routed, so we just draw a chain showing a possible path *
- * for each net.  This gives some idea of future congestion.        */
-void drawnets(ezgl::renderer* g);
+/** This routine draws the nets on the placement.  The nets have not
+ * yet been routed, so we just draw a chain showing a possible path
+ * for each net.  This gives some idea of future congestion. 
+ * This function may be deprecated. draw_logical_connections() is preferred. */
+void draw_flylines_placement(ezgl::renderer* g);
 
 /* Draws all the overused routing resources (i.e. congestion) in various contrasting colors showing congestion ratio.  */
 void draw_congestion(ezgl::renderer* g);
@@ -49,7 +50,7 @@ void draw_x(float x, float y, float size, ezgl::renderer* g);
 /* Draws the nets in the positions fixed by the router.  If draw_net_type is *
  * ALL_NETS, draw all the nets.  If it is HIGHLIGHTED, draw only the nets    *
  * that are not coloured black (useful for drawing over the rr_graph).       */
-void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer* g);
+void draw_route(enum e_draw_net_type draw_net_type, ezgl::renderer* g);
 
 void draw_routed_net(ParentNetId net, ezgl::renderer* g);
 

vpr/src/draw/draw.cpp

@@ -56,7 +56,7 @@ static std::vector<int> highlight_alpha;
 
 //Helper function to highlight a partition
 static void highlight_partition(ezgl::renderer* g, int partitionID, int alpha) {
-    auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
+    const FloorplanningContext& floorplanning_ctx = g_vpr_ctx.floorplanning();
     auto constraints = floorplanning_ctx.constraints;
     t_draw_coords* draw_coords = get_draw_coords_vars();
     t_draw_state* draw_state = get_draw_state_vars();
@@ -116,7 +116,7 @@ static void highlight_partition(ezgl::renderer* g, int partitionID, int alpha) {
 
 //Iterates through all partitions and draws each region of each partition
 void highlight_all_regions(ezgl::renderer* g) {
-    auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
+    const FloorplanningContext& floorplanning_ctx = g_vpr_ctx.floorplanning();
     const auto& constraints = floorplanning_ctx.constraints;
     auto num_partitions = constraints.get_num_partitions();
 
@@ -135,11 +135,11 @@ void highlight_all_regions(ezgl::renderer* g) {
 
 // Draws atoms that are constrained to a partition in the colour of their respective partition.
 void draw_constrained_atoms(ezgl::renderer* g) {
-    auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
+    const FloorplanningContext& floorplanning_ctx = g_vpr_ctx.floorplanning();
     const auto& constraints = floorplanning_ctx.constraints;
     int num_partitions = constraints.get_num_partitions();
-    auto& atom_ctx = g_vpr_ctx.atom();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
 
     for (int partitionID = 0; partitionID < num_partitions; partitionID++) {
         auto atoms = constraints.get_part_atoms((PartitionId)partitionID);
@@ -237,7 +237,7 @@ enum {
 
 //Highlights partition clicked on in the legend.
 void highlight_selected_partition(GtkWidget* widget) {
-    auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
+    const FloorplanningContext& floorplanning_ctx = g_vpr_ctx.floorplanning();
     auto constraints = floorplanning_ctx.constraints;
     auto num_partitions = constraints.get_num_partitions();
 
@@ -282,8 +282,8 @@ void highlight_selected_partition(GtkWidget* widget) {
 
 //Fills in the legend
 static GtkTreeModel* create_and_fill_model() {
-    auto& atom_ctx = g_vpr_ctx.atom();
-    auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+    const FloorplanningContext& floorplanning_ctx = g_vpr_ctx.floorplanning();
     const auto& constraints = floorplanning_ctx.constraints;
     int num_partitions = constraints.get_num_partitions();
 

vpr/src/draw/draw_basic.cpp

@@ -12,8 +12,8 @@
 
 void draw_noc(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& noc_ctx = g_vpr_ctx.noc();
-    auto& device_ctx = g_vpr_ctx.device();
+    const NocContext& noc_ctx = g_vpr_ctx.noc();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
 
     // vector of routers in the NoC
     const vtr::vector<NocRouterId, NocRouter>& router_list = noc_ctx.noc_model.get_noc_routers();
@@ -76,7 +76,7 @@ void draw_noc(ezgl::renderer* g) {
  */
 void draw_noc_usage(vtr::vector<NocLinkId, ezgl::color>& noc_link_colors) {
     t_draw_state* draw_state = get_draw_state_vars();
-    const auto& noc_ctx = g_vpr_ctx.noc();
+    const NocContext& noc_ctx = g_vpr_ctx.noc();
     const auto& noc_link_bandwidth_usages = draw_state->get_noc_link_bandwidth_usages_ref();
 
     // check to see if a color map was already created previously
@@ -210,7 +210,7 @@ void draw_noc_links(ezgl::renderer* g,
                     ezgl::rectangle noc_connection_marker_bbox,
                     const vtr::vector<NocLinkId, NocLinkShift>& list_of_noc_link_shift_directions) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
-    auto& noc_ctx = g_vpr_ctx.noc();
+    const NocContext& noc_ctx = g_vpr_ctx.noc();
 
     // vector of routers in the NoC
     const vtr::vector<NocRouterId, NocRouter>& router_list = noc_ctx.noc_model.get_noc_routers();
@@ -296,7 +296,7 @@ void draw_noc_links(ezgl::renderer* g,
 }
 
 void determine_direction_to_shift_noc_links(vtr::vector<NocLinkId, NocLinkShift>& list_of_noc_link_shift_directions) {
-    auto& noc_ctx = g_vpr_ctx.noc();
+    const NocContext& noc_ctx = g_vpr_ctx.noc();
 
     int number_of_links = list_of_noc_link_shift_directions.size();