[draw ap] Now able to draw arbitrary things at AP stage

This will not break place and route drawing and it creates a initial world
of different dimension than place and route drawing

Author: robluo

vpr/src/analytical_place/global_placer.cpp

@@ -18,6 +18,7 @@
 #include "ap_netlist_fwd.h"
 #include "atom_netlist.h"
 #include "device_grid.h"
+#include "draw.h"
 #include "flat_placement_bins.h"
 #include "flat_placement_density_manager.h"
 #include "globals.h"
@@ -450,6 +451,7 @@ PartialPlacement SimPLGlobalPlacer::place() {
                           *density_manager_,
                           pre_cluster_timing_manager_);
 
+    update_screen(ScreenUpdatePriority::MAJOR, "Global Placement Complete", ANALYTICAL_PLACEMENT, nullptr);
     // Return the placement from the final iteration.
     return best_p_placement;
 }

vpr/src/base/vpr_types.h

@@ -386,6 +386,7 @@ enum class e_sched_type {
 enum pic_type {
     NO_PICTURE,
     PLACEMENT,
+    ANALYTICAL_PLACEMENT,
     ROUTING
 };
 /* What's on screen? */

vpr/src/draw/draw.cpp

@@ -20,6 +20,7 @@
 #include "physical_types.h"
 
 #include "move_utils.h"
+#include "vpr_types.h"
 
 #ifndef NO_GRAPHICS
 
@@ -174,63 +175,65 @@ static void draw_main_canvas(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
 
     g->set_font_size(14);
+    if (draw_state->pic_on_screen != ANALYTICAL_PLACEMENT) {
+        draw_block_pin_util();
+        drawplace(g);
+        draw_internal_draw_subblk(g);
 
-    draw_block_pin_util();
-    drawplace(g);
-    draw_internal_draw_subblk(g);
+        if (draw_state->pic_on_screen == ROUTING) { // ROUTING on screen
 
-    if (draw_state->pic_on_screen == ROUTING) { // ROUTING on screen
+            draw_rr(g);
 
-        draw_rr(g);
+            if (draw_state->show_nets && draw_state->draw_nets == DRAW_ROUTED_NETS) {
+                draw_route(ALL_NETS, g);
 
-        if (draw_state->show_nets && draw_state->draw_nets == DRAW_ROUTED_NETS) {
-            draw_route(ALL_NETS, g);
-
-            if (draw_state->highlight_fan_in_fan_out) {
-                draw_route(HIGHLIGHTED, g);
+                if (draw_state->highlight_fan_in_fan_out) {
+                    draw_route(HIGHLIGHTED, g);
+                }
             }
-        }
 
-        draw_congestion(g);
+            draw_congestion(g);
 
-        draw_routing_costs(g);
+            draw_routing_costs(g);
 
-        draw_router_expansion_costs(g);
+            draw_router_expansion_costs(g);
 
-        draw_routing_util(g);
+            draw_routing_util(g);
 
-        draw_routing_bb(g);
-    }
+            draw_routing_bb(g);
+        }
 
-    draw_placement_macros(g);
+        draw_placement_macros(g);
 
 #ifndef NO_SERVER
-    if (g_vpr_ctx.server().gate_io.is_running()) {
-        const ServerContext& server_ctx = g_vpr_ctx.server(); // shortcut
-        draw_crit_path_elements(server_ctx.crit_paths, server_ctx.crit_path_element_indexes, server_ctx.draw_crit_path_contour, g);
-    } else {
-        draw_crit_path(g);
-    }
+        if (g_vpr_ctx.server().gate_io.is_running()) {
+            const ServerContext& server_ctx = g_vpr_ctx.server(); // shortcut
+            draw_crit_path_elements(server_ctx.crit_paths, server_ctx.crit_path_element_indexes, server_ctx.draw_crit_path_contour, g);
+        } else {
+            draw_crit_path(g);
+        }
 #else
-    draw_crit_path(g);
+        draw_crit_path(g);
 #endif /* NO_SERVER */
 
-    draw_logical_connections(g);
+        draw_logical_connections(g);
 
-    draw_selected_pb_flylines(g);
+        draw_selected_pb_flylines(g);
 
-    draw_noc(g);
+        draw_noc(g);
 
-    if (draw_state->draw_partitions) {
-        highlight_all_regions(g);
-        draw_constrained_atoms(g);
-    }
+        if (draw_state->draw_partitions) {
+            highlight_all_regions(g);
+            draw_constrained_atoms(g);
+        }
 
-    if (draw_state->color_map) {
-        draw_color_map_legend(*draw_state->color_map, g);
-        draw_state->color_map.reset(); //Free color map in preparation for next redraw
+        if (draw_state->color_map) {
+            draw_color_map_legend(*draw_state->color_map, g);
+            draw_state->color_map.reset(); //Free color map in preparation for next redraw
+        }
+    } else {
+        draw_analytical_place(g);
     }
-
     if (draw_state->auto_proceed) {
         //Automatically exit the event loop, so user's don't need to manually click proceed
 
@@ -302,16 +305,28 @@ void update_screen(ScreenUpdatePriority priority, const char* msg, enum pic_type
 
         state_change = true;
 
+        if (pic_on_screen_val == ANALYTICAL_PLACEMENT) {
+            set_initial_world_ap();
+        } else {
+            set_initial_world();
+        }
+
         if (draw_state->pic_on_screen == NO_PICTURE) {
             // Only add the canvas the first time we open graphics
-            application.add_canvas("MainCanvas", draw_main_canvas,
-                                   initial_world);
+            application.add_canvas("MainCanvas", draw_main_canvas, initial_world);
+        } else {
+            // TODO: will this ever be null?
+            auto canvas = application.get_canvas(application.get_main_canvas_id());
+            if (canvas != nullptr) {
+                canvas->get_camera().set_world(initial_world);
+            }
         }
 
         draw_state->setup_timing_info = setup_timing_info;
         draw_state->pic_on_screen = pic_on_screen_val;
     }
 
+    // What is this? Always true!
     bool should_pause = int(priority) >= draw_state->gr_automode;
 
     //If there was a state change, we must call ezgl::application::run() to update the buttons.
@@ -481,7 +496,16 @@ void init_draw_coords(float clb_width, const BlkLocRegistry& blk_loc_registry) {
     //Margin beyond edge of the drawn device to extend the visible world
     //Setting this to > 0.0 means 'Zoom Fit' leave some fraction of white
     //space around the device edges
+#else
+    (void)clb_width;
+    (void)blk_loc_registry;
+#endif /* NO_GRAPHICS */
+}
+
+void set_initial_world() {
     constexpr float VISIBLE_MARGIN = 0.01;
+    t_draw_coords* draw_coords = get_draw_coords_vars();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
 
     float draw_width = draw_coords->tile_x[device_ctx.grid.width() - 1]
                        + draw_coords->get_tile_width();
@@ -491,11 +515,11 @@ void init_draw_coords(float clb_width, const BlkLocRegistry& blk_loc_registry) {
     initial_world = ezgl::rectangle(
         {-VISIBLE_MARGIN * draw_width, -VISIBLE_MARGIN * draw_height},
         {(1. + VISIBLE_MARGIN) * draw_width, (1. + VISIBLE_MARGIN)
-                                                 * draw_height});
-#else
-    (void)clb_width;
-    (void)blk_loc_registry;
-#endif /* NO_GRAPHICS */
+                                                 * draw_height});    
+}
+
+void set_initial_world_ap() {
+    initial_world = ezgl::rectangle({-1, -1}, {1, 1});
 }
 
 #ifndef NO_GRAPHICS

vpr/src/draw/draw.h

@@ -52,6 +52,9 @@ void update_screen(ScreenUpdatePriority priority, const char* msg, enum pic_type
  */
 void init_draw_coords(float clb_width, const BlkLocRegistry& blk_loc_registry);
 
+void set_initial_world_ap();
+void set_initial_world();
+
 /* Sets the static show_graphics and gr_automode variables to the    *
  * desired values.  They control if graphics are enabled and, if so, *
  * how often the user is prompted for input.                         */

vpr/src/draw/draw_basic.cpp

@@ -193,6 +193,15 @@ void drawplace(ezgl::renderer* g) {
     }
 }
 
+void draw_analytical_place(ezgl::renderer* g) {
+    // Fill the entire visible world with green
+    ezgl::rectangle vw = g->get_visible_world();
+    g->set_line_dash(ezgl::line_dash::none);
+    g->set_line_width(0);
+    g->set_color(ezgl::color(0, 180, 0)); // green fill
+    g->fill_rectangle(vw);
+}
+
 /* 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.        */

vpr/src/draw/draw_basic.h

@@ -29,6 +29,8 @@
  * Blocks are drawn in layer order (so that semi-transparent blocks/grids render well)*/
 void drawplace(ezgl::renderer* g);
 
+void draw_analytical_place(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.